This is the first commit of the hicn projectv19.01

Change-Id: I6f2544ad9b9f8891c88cc4bcce3cf19bd3cc863f
Signed-off-by: Luca Muscariello <lumuscar+fdio@cisco.com>

29 files changed, 6907 insertions, 0 deletions

diff --git a/lib/src/CMakeLists.txt b/lib/src/CMakeLists.txt
new file mode 100755
index 000000000..0137a16c7
--- /dev/null
+++ b/lib/src/CMakeLists.txt
@@ -0,0 +1,81 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
+
+list(APPEND LIBHICN_HEADER_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/base.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/common.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/compat.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/error.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/header.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/name.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/ops.h
+)
+
+list(APPEND LIBHICN_HEADER_FILES_PROTOCOL
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ah.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/icmp.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/icmprd.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ipv4.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ipv6.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/tcp.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/udp.h
+)
+
+list(APPEND LIBHICN_SOURCE_FILES
+  ${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}/common.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
+)
+
+set (COMPILER_DEFINITIONS "-DWITH_MAPME -DWITH_MAPME_FIXES")
+
+include(BuildMacros)
+build_library(${LIBHICN}
+  SHARED STATIC
+  SOURCES ${LIBHICN_SOURCE_FILES}
+  COMPONENT libhicn
+  INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..
+  DEFINITIONS ${COMPILER_DEFINITIONS}
+  INSTALL_ROOT_DIR hicn
+  INSTALL_HEADERS ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL}
+)
+
+add_custom_command(TARGET hicn PRE_BUILD
+  COMMAND ${CMAKE_COMMAND} -E remove_directory ${PROJECT_BINARY_DIR}/hicn
+)
+
+add_custom_command(TARGET hicn POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/hicn/
+  COMMAND ${CMAKE_COMMAND} -E copy ${LIBHICN_HEADER_FILES} ${PROJECT_BINARY_DIR}/hicn/
+)
+
+add_custom_command(TARGET hicn POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/hicn/protocol
+  COMMAND ${CMAKE_COMMAND} -E copy ${LIBHICN_HEADER_FILES_PROTOCOL} ${PROJECT_BINARY_DIR}/hicn/protocol
+)
+
+# install(FILES ${LIBHICN_HEADER_FILES} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/hicn COMPONENT libhicn)
+# install(FILES ${LIBHICN_HEADER_FILES_PROTOCOL} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/hicn/protocol COMPONENT libhicn)
diff --git a/lib/src/base.h b/lib/src/base.h
new file mode 100755
index 000000000..c1bd23aeb
--- /dev/null
+++ b/lib/src/base.h
@@ -0,0 +1,136 @@
+/*
+ * 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 base.h
+ * @brief Base hICN definitions.
+ */
+
+#ifndef HICN_BASE_H
+#define HICN_BASE_H
+
+#include "common.h"
+
+/* Default header fields */
+#define HICN_DEFAULT_TTL 254
+
+typedef u32 hicn_faceid_t;
+typedef u8 hicn_pathlabel_t;
+typedef u32 hicn_lifetime_t;
+
+#define HICN_MAX_LIFETIME HICN_MAX_LIFETIME_SCALED << HICN_MAX_LIFETIME_MULTIPLIER
+#define HICN_MAX_LIFETIME_SCALED 0xFFFF
+#define HICN_MAX_LIFETIME_MULTIPLIER 0xF	/* 4 bits */
+
+/**
+ * @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
+ * faciliate decapsulation of packet header by simple shift/mask operations.
+ *
+ * For instance, an IPv6/TCP packet will be identified as :
+ * [IPPROTO_NONE, IPPROTO_NONE, IPPROTO_TCP, IPPROTO_IPV6]
+ *
+ * We expect four elements to be sufficient for most uses, the max being
+ * currently used by an hypothetical signed MAP-Me update :
+ * [IPPROTO_ICMPRD, IPPROTO_AH, IPPROTO_ICMP, IPPROTO_IPV6]
+ */
+typedef union
+{
+    /** 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 */
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    u8 l4;     /**< Fourth layer */
+    u8 l3;     /**< Third layer */
+    u8 l2;     /**< Second layer */
+    u8 l1;     /**< First layer */
+#else
+#error "Unsupported endianness"
+#endif
+  };
+    /** u32 representation */
+  u32 as_u32;
+} hicn_type_t;
+
+/* Common protocol layers */
+#define HICN_TYPE_IPV4_TCP   (hicn_type_t) {{ .l4 = IPPROTO_NONE, .l3 = IPPROTO_NONE, .l2 = IPPROTO_TCP,    .l1 = IPPROTO_IP }}
+#define HICN_TYPE_IPV4_ICMP  (hicn_type_t) {{ .l4 = IPPROTO_NONE, .l3 = IPPROTO_NONE, .l2 = IPPROTO_ICMP,   .l1 = IPPROTO_IP }}
+#define HICN_TYPE_IPV6_TCP   (hicn_type_t) {{ .l4 = IPPROTO_NONE, .l3 = IPPROTO_NONE, .l2 = IPPROTO_TCP,    .l1 = IPPROTO_IPV6 }}
+#define HICN_TYPE_IPV6_ICMP  (hicn_type_t) {{ .l4 = IPPROTO_NONE, .l3 = IPPROTO_NONE, .l2 = IPPROTO_ICMPV6, .l1 = IPPROTO_IPV6 }}
+
+
+/**
+ * @brief hICN Payload type
+ *
+ * This type distinguishes several types of data packet, which can either carry
+ * content data, or Manifest
+ */
+typedef enum
+{
+  HPT_DATA = 0,
+  HPT_MANIFEST = 1,
+  HPT_UNSPEC = 999
+} hicn_payload_type_t;
+
+/**
+ * @brief Path label computations
+ *
+ * Path label is computed by accumulating the identifiers of successive output
+ * faces as a Data packet is traveling from its producer back to the consumer
+ * originating the Interest.
+ *
+ * NOTE: this computation is not (yet) part of the hICN specification.
+ */
+
+#define HICN_PATH_LABEL_MASK 0xF000	/* 1000 0000 0000 0000 */
+#define HICN_PATH_LABEL_SIZE 8
+
+/**
+ * @brief Path label update
+ * @param [in] current_label Current pathlabel
+ * @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
+ */
+always_inline void
+update_pathlabel (hicn_pathlabel_t current_label, hicn_faceid_t face_id,
+		  hicn_pathlabel_t * new_label)
+{
+  hicn_pathlabel_t pl_face_id =
+    (hicn_pathlabel_t) ((face_id & HICN_PATH_LABEL_MASK) >>
+			(16 - HICN_PATH_LABEL_SIZE));
+  *new_label =
+    ((current_label << 1) | (current_label >> (HICN_PATH_LABEL_SIZE - 1))) ^
+    pl_face_id;
+}
+
+#endif /* HICN_BASE_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/common.c b/lib/src/common.c
new file mode 100755
index 000000000..4b7c4a2a7
--- /dev/null
+++ b/lib/src/common.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file common.c
+ * @brief Implementation of common interfaces abstracting low-level platform.
+ * details.
+ */
+
+#include <stdlib.h>
+#include <string.h>		// memset
+#include <sys/types.h>		// getaddrinfo
+#include <sys/socket.h>		// ''
+#include <netdb.h>		// ''
+#include <stdio.h>
+
+#include "common.h"
+
+
+int
+get_addr_family (const char *ip_address)
+{
+  struct addrinfo hint, *res = NULL;
+  int rc;
+
+  memset (&hint, '\0', sizeof hint);
+
+  hint.ai_family = PF_UNSPEC;
+  hint.ai_flags = AI_NUMERICHOST;
+
+  rc = getaddrinfo (ip_address, NULL, &hint, &res);
+  if (rc)
+    {
+      return -1;
+    }
+  rc = res->ai_family;
+  freeaddrinfo (res);
+  return rc;
+}
+
+/* hashes */
+
+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
+  const u32 fnv1a_prime = 0x01000193;
+  u32 hash = lastValue;
+  size_t i;
+
+  const char *chardata = data;
+
+  for (i = 0; i < len; i++)
+    {
+      hash = hash ^ chardata[i];
+      hash = hash * fnv1a_prime;
+    }
+
+  return hash;
+}
+
+u32
+hash32 (const void *data, size_t len)
+{
+  // 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);
+}
+
+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
+  const u64 fnv1a_prime = 0x00000100000001B3ULL;
+  u64 hash = lastValue;
+  const char *chardata = data;
+  size_t i;
+
+  for (i = 0; i < len; i++)
+    {
+      hash = hash ^ chardata[i];
+      hash = hash * fnv1a_prime;
+    }
+
+  return hash;
+}
+
+u64
+hash64 (const void *data, size_t len)
+{
+  // 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 (uint8_t * buffer, size_t len)
+{
+  int i;
+  unsigned char buff[17];
+  unsigned char *pc = (unsigned char *) buffer;
+
+  // Output description if given.
+  if (len == 0)
+    {
+      printf ("  ZERO LENGTH\n");
+      return;
+    }
+
+  // Process every byte in the data.
+  for (i = 0; i < len; i++)
+    {
+      // Multiple of 16 means new line (with line offset).
+
+      if ((i % 16) == 0)
+	{
+	  // Just don't print ASCII for the zeroth line.
+	  if (i != 0)
+	    printf ("  %s\n", buff);
+
+	  // Output the offset.
+	  printf ("  %04x ", i);
+	}
+
+      // Now the hex code for the specific character.
+      printf (" %02x", pc[i]);
+
+      // And store a printable ASCII character for later.
+      if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+	buff[i % 16] = '.';
+      else
+	buff[i % 16] = pc[i];
+      buff[(i % 16) + 1] = '\0';
+    }
+
+  // Pad out last line if not exactly 16 characters.
+  while ((i % 16) != 0)
+    {
+      printf ("   ");
+      i++;
+    }
+
+  // And print the final ASCII bit.
+  printf ("  %s\n", buff);
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/common.h b/lib/src/common.h
new file mode 100755
index 000000000..9ddbdeb09
--- /dev/null
+++ b/lib/src/common.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file common.c
+ * @brief Common interfaces abstracting low-level platform.
+ * details.
+ *
+ * The role of this header file is to provide an uniform interface to the
+ * different platform on top of which we build the hICN interface:
+ *  - syntax helpers
+ *  - IP address management
+ *  - protocol definition
+ *  - ...
+ *
+ * The rationale is to leverage as much as possible platform-specific code,
+ * however some level of harmonization is needed to build code on top. Whenever
+ * possible, we align to VPP structure and naming.
+ */
+
+#ifndef HICN_COMMON_H
+#define HICN_COMMON_H
+
+#include <stdint.h>
+#include <assert.h>
+
+/* Concise type definitions */
+
+typedef uint64_t u64;
+typedef uint32_t u32;
+typedef uint16_t u16;
+typedef uint8_t u8;
+
+/*
+ * Code annotations
+ *
+ * NOTE: these are defined by default in VPP.
+ */
+
+#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 ASSERT
+
+#define STATIC_ASSERT(x)
+
+#endif /* ! HICN_VPP_PLUGIN */
+
+/*
+ * 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
+
+#else
+
+#include <netinet/in.h>
+
+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
+ * @return AF_INET or AF_INET6 if successful, -1 otherwise
+ */
+int get_addr_family (const char *ip_address);
+
+/*
+ * Checksum computation
+ *
+ * NOTE: VPP provides efficient (incremental) checksum computations
+ * that we reuse, and provide alternative implementation otherwise.
+ */
+
+#ifndef HICN_VPP_PLUGIN
+
+typedef u16 ip_csum_t;
+
+/*
+ * Checksum update (incremental and non-incremental)
+ *
+ * Those functions are already defined in VPP in vnet/ip/ip_packet.h, and we
+ * borrow this code here.
+ */
+
+static_always_inline u16
+ip_csum_fold (ip_csum_t c)
+{
+  /* Reduce to 16 bits. */
+#if 0				// uword_bits == 64
+  c = (c & (ip_csum_t) 0xffffffff) + (c >> (ip_csum_t) 32);
+  c = (c & 0xffff) + (c >> 16);
+#endif
+
+  c = (c & 0xffff) + (c >> 16);
+  c = (c & 0xffff) + (c >> 16);
+
+  return c;
+}
+
+static_always_inline ip_csum_t
+ip_csum_with_carry (ip_csum_t sum, ip_csum_t x)
+{
+  ip_csum_t t = sum + x;
+  return t + (t < x);
+}
+
+/* Update checksum changing field at even byte offset from x -> 0. */
+static_always_inline ip_csum_t
+ip_csum_add_even (ip_csum_t c, ip_csum_t x)
+{
+  ip_csum_t d;
+
+  d = c - x;
+
+  /* Fold in carry from high bit. */
+  d -= d > c;
+
+  return d;
+}
+
+/* Update checksum changing field at even byte offset from 0 -> x. */
+static_always_inline ip_csum_t
+ip_csum_sub_even (ip_csum_t c, ip_csum_t x)
+{
+  return ip_csum_with_carry (c, x);
+}
+
+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 (uint8_t * buffer, size_t len);
+
+#endif /* ! HICN_VPP_PLUGIN */
+
+/**
+ * @brief Computes buffer checksum
+ * @param [in] addr - Pointer to buffer start
+ * @param [in] size - Size of buffer
+ * @param [in] init - Checksum initial value
+ * @return Checksum of specified buffer
+ */
+always_inline u16
+csum (const void *addr, size_t size, u16 init)
+{
+  u32 sum = init;
+  const u16 *bytes = (u16 *) addr;
+
+  while (size > 1)
+    {
+      sum += *bytes++;
+      size -= sizeof (u16);
+    }
+  if (size)
+    {
+      sum += *(const u8 *) bytes;
+    }
+  sum = (sum >> 16) + (sum & 0xffff);
+  sum += (sum >> 16);
+
+  return (u16) ~ sum;
+}
+
+/*
+ * Useful aliases
+ */
+
+/* Symmetry with IPPROTO_ICMPV6 */
+#define IPPROTO_ICMPV4 IPPROTO_ICMP
+
+/*
+ * 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
+
+#endif /* HICN_COMMON_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/compat.c b/lib/src/compat.c
new file mode 100755
index 000000000..7d9eef025
--- /dev/null
+++ b/lib/src/compat.c
@@ -0,0 +1,1177 @@
+/*
+ * 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 compat.c
+ * @brief Implementation of the compatibility layer.
+ */
+
+#include <netinet/in.h>
+#include <string.h>		// memset
+#include <stddef.h>		// offsetof
+
+#include "common.h"
+#include "compat.h"
+#include "error.h"
+#include "header.h"
+#include "name.h"
+#include "ops.h"
+
+#define member_size(type, member) sizeof(((type *)0)->member)
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
+
+#define HICN_NAME_COMPONENT_SIZE 2
+
+int
+hicn_packet_get_format (const hicn_header_t * h, hicn_format_t * format)
+{
+  *format = HF_UNSPEC;
+
+  switch (HICN_IP_VERSION (h))
+    {
+    case 4:
+      switch (h->v4.ip.protocol)
+	{
+	case IPPROTO_TCP:
+	  if (h->v4.tcp.flags & AH_FLAG)
+	    *format = HF_INET_TCP_AH;
+	  else
+	    *format = HF_INET_TCP;
+	  break;
+	case IPPROTO_ICMP:
+	  *format = HF_INET_ICMP;
+	  break;
+	default:
+	  return HICN_LIB_ERROR_NOT_HICN;
+	}
+      break;
+    case 6:
+      switch (h->v6.ip.nxt)
+	{
+	case IPPROTO_TCP:
+	  if (h->v6.tcp.flags & AH_FLAG)
+	    *format = HF_INET6_TCP_AH;
+	  else
+	    *format = HF_INET6_TCP;
+	  break;
+	case IPPROTO_ICMPV6:
+	  *format = HF_INET6_ICMP;
+	  break;
+	default:
+	  return HICN_LIB_ERROR_NOT_HICN;
+	}
+      break;
+    default:
+      return HICN_LIB_ERROR_NOT_HICN;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+/**
+ * @brief Convert (former) hICN format into (newer) hICN type
+ * @param [in] format - hICN format
+ * @return hICN type, all zero'ed if type is unknown
+ */
+hicn_type_t
+hicn_format_to_type (hicn_format_t format)
+{
+  switch (format)
+    {
+    case HF_INET_TCP:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_NONE,.l2 = IPPROTO_TCP,.l1 =
+	  IPPROTO_IP};
+    case HF_INET6_TCP:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_NONE,.l2 = IPPROTO_TCP,.l1 =
+	  IPPROTO_IPV6};
+    case HF_INET_ICMP:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_NONE,.l2 = IPPROTO_ICMP,.l1 =
+	  IPPROTO_IP};
+    case HF_INET6_ICMP:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_NONE,.l2 = IPPROTO_ICMPV6,.l1 =
+	  IPPROTO_IPV6};
+    case HF_INET_TCP_AH:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_AH,.l2 = IPPROTO_TCP,.l1 = IPPROTO_IP};
+    case HF_INET6_TCP_AH:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_AH,.l2 = IPPROTO_TCP,.l1 =
+	  IPPROTO_IPV6};
+    case HF_INET_ICMP_AH:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_AH,.l2 = IPPROTO_ICMP,.l1 =
+	  IPPROTO_IP};
+    case HF_INET6_ICMP_AH:
+      return (hicn_type_t)
+      {
+      .l4 = IPPROTO_NONE,.l3 = IPPROTO_AH,.l2 = IPPROTO_ICMPV6,.l1 =
+	  IPPROTO_IPV6};
+    default:
+      break;
+    }
+  return (hicn_type_t)
+  {
+    {
+    IPPROTO_NONE}
+  };
+}
+
+/**
+ * @brief Parse hICN header and return hICN type
+ * @param [in] h - hICN header
+ * @param [out] format - hICN type
+ * @return hICN error code
+ *
+ * This function is used to wrap old API calls to new ones
+ */
+hicn_type_t
+hicn_header_to_type (const hicn_header_t * h)
+{
+  hicn_format_t format;
+  hicn_packet_get_format (h, &format);
+  return hicn_format_to_type (format);
+}
+
+int
+hicn_packet_init_header (hicn_format_t format, hicn_header_t * packet)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->init_packet_header (type, &packet->protocol);
+}
+
+int
+hicn_packet_compute_checksum (hicn_format_t format, hicn_header_t * h)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->update_checksums (type, &h->protocol, 0, 0);
+}
+
+int
+hicn_packet_compute_header_checksum (hicn_format_t format, hicn_header_t * h,
+				     u16 init_sum)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  /* payload_length == ~0: ignore payload */
+  return hicn_ops_vft[type.l1]->update_checksums (type, &h->protocol,
+						  init_sum, ~0);
+}
+
+int
+hicn_packet_check_integrity (hicn_format_t format, hicn_header_t * h)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->verify_checksums (type, &h->protocol, 0, 0);
+}
+
+int
+hicn_packet_get_header_length_from_format (hicn_format_t format,
+					   size_t * header_length)
+{
+  *header_length = _is_ipv4 (format) * IPV4_HDRLEN;
+  *header_length += _is_ipv6 (format) * IPV6_HDRLEN;
+  *header_length += _is_icmp (format) * ICMP_HDRLEN;
+  *header_length += _is_tcp (format) * TCP_HDRLEN;
+  *header_length += _is_ah (format) * AH_HDRLEN;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+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
+  *header_length += (is_ah * is_ipv4) * (h->v4ah.ah.payloadlen) << 2;
+  *header_length += (is_ah * is_ipv6) * (h->v6ah.ah.payloadlen) << 2;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_payload_length (hicn_format_t format, const hicn_header_t * h,
+				size_t * payload_length)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->get_payload_length (type, &h->protocol,
+						    payload_length);
+}
+
+int
+hicn_packet_set_payload_length (hicn_format_t format, hicn_header_t * h,
+				size_t payload_length)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->set_payload_length (type, &h->protocol,
+						    payload_length);
+}
+
+int
+hicn_packet_compare (const hicn_header_t * packet1,
+		     const hicn_header_t * packet2)
+{
+  hicn_type_t type1 = hicn_header_to_type (packet1);
+  hicn_type_t type2 = hicn_header_to_type (packet2);
+
+  size_t len1, len2;
+  int rc;
+
+  if (type1.as_u32 != type2.as_u32)
+    return HICN_LIB_ERROR_UNEXPECTED;
+
+  rc = hicn_ops_vft[type1.l1]->get_length (type1, &packet1->protocol, &len1);
+  if (PREDICT_FALSE (rc < 0))
+    return HICN_LIB_ERROR_UNEXPECTED;
+
+  rc = hicn_ops_vft[type2.l1]->get_length (type2, &packet2->protocol, &len2);
+  if (PREDICT_FALSE (rc < 0))
+    return HICN_LIB_ERROR_UNEXPECTED;
+
+  if (len1 != len2)
+    return HICN_LIB_ERROR_UNEXPECTED;
+
+  return memcmp ((u8 *) packet1, (u8 *) packet2, len1);
+
+}
+
+int
+hicn_packet_get_name (hicn_format_t format, const hicn_header_t * h,
+		      hicn_name_t * name, u8 is_interest)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+
+  if (is_interest)
+    return hicn_ops_vft[type.l1]->get_interest_name (type, &h->protocol,
+						     name);
+  else
+    return hicn_ops_vft[type.l1]->get_data_name (type, &h->protocol, name);
+}
+
+int
+hicn_packet_set_name (hicn_format_t format, hicn_header_t * h,
+		      const hicn_name_t * name, u8 is_interest)
+{
+  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
+    return hicn_ops_vft[type.l1]->set_data_name (type, &h->protocol, name);
+}
+
+int
+hicn_packet_set_payload (hicn_format_t format, hicn_header_t * h,
+			 const u8 * payload, u16 payload_length)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  size_t header_length;
+  int rc;
+
+  rc =
+    hicn_ops_vft[type.l1]->get_header_length (type, &h->protocol,
+					      &header_length);
+  if (rc < 0)
+    return rc;
+
+  memcpy ((u8 *) h + header_length, payload, payload_length);
+
+  return hicn_ops_vft[type.l1]->set_payload_length (type, &h->protocol,
+						    payload_length);
+}
+
+int
+hicn_packet_get_payload (hicn_format_t format, const hicn_header_t * h,
+			 u8 ** payload, size_t * payload_size, bool hard_copy)
+{
+  size_t header_length, payload_length;
+  int rc;
+  hicn_type_t type = hicn_format_to_type (format);
+
+  rc =
+    hicn_ops_vft[type.l1]->get_header_length (type, &h->protocol,
+					      &header_length);
+  if (rc < 0)
+    return rc;
+
+  rc =
+    hicn_ops_vft[type.l1]->get_payload_length (type, &h->protocol,
+					       &payload_length);
+  if (rc < 0)
+    return rc;
+
+  if (hard_copy)
+    {
+      memcpy (payload, (u8 *) h + header_length, payload_length);
+    }
+  else
+    {
+      *payload = (u8 *) h + header_length;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_locator (hicn_format_t format, const hicn_header_t * h,
+			 ip_address_t * ip_address, bool is_interest)
+{
+  const void *locator;
+  int is_ipv4 = (format & HFO_INET);
+  int is_ipv6 = (format & HFO_INET6) >> 1;
+
+  if (is_ipv4)
+    {
+      locator = is_interest ? &h->v4.ip.saddr : &h->v4.ip.daddr;
+      ip_address->family = AF_INET;
+      ip_address->prefix_len = IPV4_ADDR_LEN_BITS;
+    }
+  else if (is_ipv6)
+    {
+      locator = is_interest ? &h->v6.ip.saddr : &h->v6.ip.daddr;
+      ip_address->family = AF_INET6;
+      ip_address->prefix_len = IPV6_ADDR_LEN_BITS;
+    }
+  else
+    {
+      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+    }
+
+  memcpy (ip_address->buffer, locator, ip_address_len (ip_address));
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_locator (hicn_format_t format, hicn_header_t * h,
+			 const ip_address_t * ip_address, bool is_interest)
+{
+  void *locator;
+  int is_ipv4 = (format & HFO_INET);
+  int is_ipv6 = (format & HFO_INET6) >> 1;
+
+  if (is_ipv6)
+    {
+      locator = is_interest ? &h->v6.ip.saddr : &h->v6.ip.daddr;
+    }
+  else if (is_ipv4)
+    {
+      locator = is_interest ? &h->v4.ip.saddr : &h->v4.ip.daddr;
+    }
+  else
+    {
+      return HICN_LIB_ERROR_INVALID_PARAMETER;
+    }
+
+  memcpy (locator, ip_address->buffer, ip_address_len (ip_address));
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_signature_size (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_size (type, &h->protocol,
+						    bytes);
+}
+
+int
+hicn_packet_set_signature_size (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_size (type, &h->protocol,
+						    bytes);
+}
+
+int
+hicn_packet_set_signature_timestamp (hicn_format_t format, hicn_header_t * h,
+				uint64_t signature_timestamp)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->set_signature_timestamp (type, &h->protocol,
+						    signature_timestamp);
+}
+
+int
+hicn_packet_get_signature_timestamp (hicn_format_t format, const hicn_header_t * h,
+				uint64_t *signature_timestamp)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->get_signature_timestamp (type, &h->protocol,
+						    signature_timestamp);
+}
+
+int
+hicn_packet_set_validation_algorithm (hicn_format_t format, hicn_header_t * h,
+				uint8_t validation_algorithm)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->set_validation_algorithm (type, &h->protocol,
+						    validation_algorithm);
+}
+
+int
+hicn_packet_get_validation_algorithm (hicn_format_t format, const hicn_header_t * h,
+				uint8_t * validation_algorithm)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->get_validation_algorithm (type, &h->protocol,
+						    validation_algorithm);
+}
+
+int
+hicn_packet_set_key_id (hicn_format_t format, hicn_header_t * h,
+				uint8_t *key_id)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->set_key_id (type, &h->protocol,
+						    key_id);
+}
+
+int
+hicn_packet_get_key_id (hicn_format_t format, hicn_header_t * h,
+				uint8_t ** key_id, uint8_t *key_id_length)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->get_key_id (type, &h->protocol,
+						    key_id, key_id_length);
+}
+
+int
+hicn_packet_get_hoplimit (const hicn_header_t * h, u8 * hops)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *hops = h->v6.ip.hlim;
+      break;
+    case 4:
+      *hops = h->v4.ip.ttl;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_hoplimit (hicn_header_t * h, u8 hops)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.ip.hlim = hops;
+      break;
+    case 4:
+      h->v4.ip.ttl = hops;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+
+int
+hicn_packet_get_lifetime (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,
+					      (hicn_lifetime_t *) lifetime);
+}
+
+int
+hicn_packet_set_lifetime (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,
+					      (hicn_lifetime_t) lifetime);
+}
+
+int
+hicn_packet_get_reserved_bits (const hicn_header_t * h, u8 * reserved_bits)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *reserved_bits = h->v6.tcp.reserved;
+      break;
+    case 4:
+      *reserved_bits = h->v4.tcp.reserved;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_reserved_bits (hicn_header_t * h, u8 reserved_bits)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.reserved = reserved_bits;
+      break;
+    case 4:
+      h->v4.tcp.reserved = reserved_bits;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_payload_type (const hicn_header_t * h,
+			      hicn_payload_type_t * payload_type)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *payload_type = ((h->v6.tcp.flags & TCP_FLAG_URG) == TCP_FLAG_URG);
+      break;
+    case 4:
+      *payload_type = ((h->v4.tcp.flags & TCP_FLAG_URG) == 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;
+}
+
+int
+hicn_packet_set_payload_type (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 | TCP_FLAG_URG;
+      else
+	h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_URG;
+      break;
+    case 4:
+      if (payload_type)
+	h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_URG;
+      else
+	h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_URG;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_syn (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags | TCP_FLAG_SYN;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_SYN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_reset_syn (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_SYN;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_SYN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_test_syn (const hicn_header_t * h, bool * flag)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *flag = h->v6.tcp.flags & TCP_FLAG_SYN;
+      break;
+    case 4:
+      *flag = h->v4.tcp.flags & TCP_FLAG_SYN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_ack (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags | TCP_FLAG_ACK;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_ACK;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_reset_ack (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_ACK;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_ACK;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_test_ack (const hicn_header_t * h, bool * flag)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *flag = h->v6.tcp.flags & TCP_FLAG_ACK;
+      break;
+    case 4:
+      *flag = h->v4.tcp.flags & TCP_FLAG_ACK;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_rst (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags | TCP_FLAG_RST;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_RST;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_reset_rst (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_RST;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_RST;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_test_rst (const hicn_header_t * h, bool * flag)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *flag = h->v6.tcp.flags & TCP_FLAG_RST;
+      break;
+    case 4:
+      *flag = h->v4.tcp.flags & TCP_FLAG_RST;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_fin (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags | TCP_FLAG_FIN;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_FIN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_reset_fin (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_FIN;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_FIN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_test_fin (const hicn_header_t * h, bool * flag)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *flag = h->v6.tcp.flags & TCP_FLAG_FIN;
+      break;
+    case 4:
+      *flag = h->v4.tcp.flags & TCP_FLAG_FIN;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_ece (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags | TCP_FLAG_ECE;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags | TCP_FLAG_ECE;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_reset_ece (hicn_header_t * h)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.flags = h->v6.tcp.flags & ~TCP_FLAG_ECE;
+      break;
+    case 4:
+      h->v4.tcp.flags = h->v4.tcp.flags & ~TCP_FLAG_ECE;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_test_ece (const hicn_header_t * h, bool * flag)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *flag = h->v6.tcp.flags & TCP_FLAG_ECE;
+      break;
+    case 4:
+      *flag = h->v4.tcp.flags & TCP_FLAG_ECE;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_src_port (hicn_header_t * h, u16 src_port)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.sport = htons (src_port);
+      break;
+    case 4:
+      h->v4.tcp.sport = htons (src_port);
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_src_port (const hicn_header_t * h, u16 * src_port)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *src_port = ntohs (h->v6.tcp.sport);
+      break;
+    case 4:
+      *src_port = ntohs (h->v4.tcp.sport);
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_set_dst_port (hicn_header_t * h, u16 dst_port)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      h->v6.tcp.dport = htons (dst_port);
+      break;
+    case 4:
+      h->v4.tcp.dport = htons (dst_port);
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_get_dst_port (const hicn_header_t * h, u16 * dst_port)
+{
+  switch (HICN_IP_VERSION (h))
+    {
+    case 6:
+      *dst_port = ntohs (h->v6.tcp.dport);
+      break;
+    case 4:
+      *dst_port = ntohs (h->v4.tcp.dport);
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_packet_copy_header (hicn_format_t format, const hicn_header_t * packet,
+			 hicn_header_t * destination, bool copy_ah)
+{
+  size_t header_length = _is_ipv4 (format) * IPV4_HDRLEN;
+  header_length += _is_ipv6 (format) * IPV6_HDRLEN;
+  header_length += _is_icmp (format) * ICMP_HDRLEN;
+  header_length += _is_tcp (format) * TCP_HDRLEN;
+  header_length += _is_ah (format) * copy_ah * AH_HDRLEN;
+
+  memcpy (destination, packet, header_length);
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+#define _INTEREST 1
+#define _DATA     0
+
+/* Interest */
+
+int
+hicn_interest_get_name (hicn_format_t format, const hicn_header_t * interest,
+			hicn_name_t * name)
+{
+  return hicn_packet_get_name (format, interest, name, _INTEREST);
+}
+
+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 (interest);	//interest packet -> ece flag unset
+  if (ret_err < 0)
+    return HICN_LIB_ERROR_UNEXPECTED;
+  return hicn_packet_set_name (format, interest, name, _INTEREST);
+}
+
+int
+hicn_interest_get_locator (hicn_format_t format,
+			   const hicn_header_t * interest,
+			   ip_address_t * ip_address)
+{
+  return hicn_packet_get_locator (format, interest, ip_address, _INTEREST);
+}
+
+int
+hicn_interest_set_locator (hicn_format_t format, hicn_header_t * interest,
+			   const ip_address_t * ip_address)
+{
+  return hicn_packet_set_locator (format, interest, ip_address, _INTEREST);
+}
+
+int
+hicn_interest_compare (const hicn_header_t * interest_1,
+		       const hicn_header_t * interest_2)
+{
+  return hicn_packet_compare (interest_1, interest_2);
+}
+
+int
+hicn_interest_get_lifetime (const hicn_header_t * interest, u32 * lifetime)
+{
+  return hicn_packet_get_lifetime (interest, lifetime);
+}
+
+int
+hicn_interest_set_lifetime (hicn_header_t * interest, u32 lifetime)
+{
+  return hicn_packet_set_lifetime (interest, lifetime);
+}
+
+int
+hicn_interest_get_header_length (hicn_format_t format,
+				 const hicn_header_t * interest,
+				 size_t * header_length)
+{
+  return hicn_packet_get_header_length (format, interest, header_length);
+}
+
+int
+hicn_interest_get_payload_length (hicn_format_t format,
+				  const hicn_header_t * interest,
+				  size_t * payload_length)
+{
+  return hicn_packet_get_payload_length (format, interest, payload_length);
+}
+
+int
+hicn_interest_get_payload (hicn_format_t format,
+			   const hicn_header_t * interest, u8 ** payload,
+			   size_t * payload_size, bool hard_copy)
+{
+  return hicn_packet_get_payload (format, interest, payload, payload_size,
+				  hard_copy);
+}
+
+int
+hicn_interest_set_payload (hicn_format_t format, hicn_header_t * interest,
+			   const u8 * payload, size_t payload_length)
+{
+  return hicn_packet_set_payload (format, interest, payload, payload_length);
+}
+
+int
+hicn_interest_reset_for_hash (hicn_format_t format, hicn_header_t * packet)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->reset_interest_for_hash (type,
+							 &packet->protocol);
+}
+
+/* Data */
+
+int
+hicn_data_get_name (hicn_format_t format, const hicn_header_t * data,
+		    hicn_name_t * name)
+{
+  return hicn_packet_get_name (format, data, name, _DATA);
+}
+
+int
+hicn_data_set_name (hicn_format_t format, hicn_header_t * data,
+		    hicn_name_t * name)
+{
+  int ret_err = hicn_packet_set_ece (data);	//data packet -> ece flag set
+  if (ret_err < 0)
+    return HICN_LIB_ERROR_UNEXPECTED;
+  return hicn_packet_set_name (format, data, name, _DATA);
+}
+
+int
+hicn_data_get_locator (hicn_format_t format, const hicn_header_t * data,
+		       ip_address_t * ip_address)
+{
+  return hicn_packet_get_locator (format, data, ip_address, _DATA);
+}
+
+int
+hicn_data_set_locator (hicn_format_t format, hicn_header_t * data,
+		       const ip_address_t * ip_address)
+{
+  return hicn_packet_set_locator (format, data, ip_address, _DATA);
+}
+
+int
+hicn_data_compare (const hicn_header_t * data_1, const hicn_header_t * data_2)
+{
+  return hicn_packet_compare (data_1, data_2);
+}
+
+int
+hicn_data_get_expiry_time (const hicn_header_t * data, u32 * expiry_time)
+{
+  return hicn_packet_get_lifetime (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);
+}
+
+int
+hicn_data_get_header_length (hicn_format_t format, hicn_header_t * data,
+			     size_t * header_length)
+{
+  return hicn_packet_get_header_length (format, data, header_length);
+}
+
+int
+hicn_data_get_payload_length (hicn_format_t format,
+			      const hicn_header_t * data,
+			      size_t * payload_length)
+{
+  return hicn_packet_get_payload_length (format, data, payload_length);
+}
+
+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);
+  return hicn_ops_vft[type.l1]->get_data_pathlabel (type, &data->protocol,
+						    path_label);
+}
+
+int
+hicn_data_set_path_label (hicn_header_t * data, u32 path_label)
+{
+  hicn_type_t type = hicn_header_to_type (data);
+  return hicn_ops_vft[type.l1]->set_data_pathlabel (type, &data->protocol,
+						    path_label);
+}
+
+int
+hicn_data_set_payload (hicn_format_t format, hicn_header_t * data,
+		       const u8 * payload, size_t payload_length)
+{
+  return hicn_packet_set_payload (format, data, payload, payload_length);
+}
+
+int
+hicn_data_get_payload (hicn_format_t format, const hicn_header_t * data,
+		       u8 ** payload, size_t * payload_size, bool hard_copy)
+{
+  return hicn_packet_get_payload (format, data, payload, payload_size,
+				  hard_copy);
+}
+
+int
+hicn_data_reset_for_hash (hicn_format_t format, hicn_header_t * packet)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->reset_interest_for_hash (type,
+							 &packet->protocol);
+
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/compat.h b/lib/src/compat.h
new file mode 100755
index 000000000..1a1743de2
--- /dev/null
+++ b/lib/src/compat.h
@@ -0,0 +1,462 @@
+/*
+ * 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 compat.h
+ * @brief Implementation of the compatibility layer.
+ *
+ * The structure of the core API has evolved to support operations of a variety
+ * of packet formats in addition to IPv4/TCP and IPv6/TCP, namely with the use
+ * of ICMP for signalization and AH headers for integrity. The new API format
+ * has been designed to scale better with the multiplicity of packet formats,
+ * and provide a unified interface on top. We maintain an interface for the
+ * former API in this file, which mainly acts as a wrapper on top of new calls.
+ */
+#ifndef HICN_COMPAT_H
+#define HICN_COMPAT_H
+
+#include "common.h"
+#include "header.h"
+#include "name.h"
+
+/* HICN format options */
+#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 _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)
+
+typedef enum
+{
+  HF_UNSPEC = 0,
+  HF_INET_TCP = HFO_INET | HFO_TCP,
+  HF_INET6_TCP = HFO_INET6 | HFO_TCP,
+  HF_INET_ICMP = HFO_INET | HFO_ICMP,
+  HF_INET6_ICMP = HFO_INET6 | HFO_ICMP,
+  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
+} hicn_format_t;
+
+/**
+ * Maximum Size of the hICN header (the effective size will depend on the
+ * underlying IP version)
+ */
+#define HICN_HDR_LEN sizeof(hicn_header_t)
+
+/**
+ * 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 size.
+ */
+#define HICN_V6_MIN_HDR_LEN 6	/* bytes */
+#define HICN_V4_MIN_HDR_LEN 4	/* bytes */
+
+// #define HICN_MIN_HDR_LEN ((HICN_V6_MIN_HDR_LEN > HICN_V4_MIN_HDR_LEN) ? HICN_V6_MIN_HDR_LEN : HICN_V4_MIN_HDR_LEN)
+#define HICN_MIN_HDR_LEN HICN_V6_MIN_HDR_LEN
+
+/**
+ * @brief Parse packet headers and return hICN format
+ * @param [in] format - hICN Format
+ * @param [in, out] packet - Buffer containing the hICN header to be initialized
+ * @return hICN error code
+ */
+int hicn_packet_init_header (hicn_format_t format, hicn_header_t * packet);
+
+/**
+ * @brief Parse packet headers and return hICN format
+ * @param [in] h - hICN header
+ * @param [out] format - hICN format
+ * @return hICN error code
+ */
+int hicn_packet_get_format (const hicn_header_t * packet,
+			    hicn_format_t * format);
+
+/**
+ * @brief Update checksums in packet headers
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @return hICN error code
+ */
+int hicn_packet_compute_checksum (hicn_format_t format,
+				  hicn_header_t * packet);
+
+/**
+ * @brief compute the checksum of the packet header, adding init_sum to the final value
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @param [in] init_sum - value to add to the final checksum
+ * @return hICN error code
+ */
+int hicn_packet_compute_header_checksum (hicn_format_t format,
+					 hicn_header_t * packet,
+					 u16 init_sum);
+
+/**
+ * @brief Verify checksums in packet headers
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @return hICN error code
+ */
+int hicn_packet_check_integrity (hicn_format_t format,
+				 hicn_header_t * packet);
+
+// this is not accounted here
+/**
+ * @brief Return total length of hicn headers (but signature payload)
+ * @param [in] format - hICN format
+ * @param [out] header_length - Total length of headers
+ * @return hICN error code
+ */
+int hicn_packet_get_header_length_from_format (hicn_format_t format,
+					       size_t * header_length);
+
+/**
+ * @brief Return total length of hicn headers (before payload)
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] header_length - Total length of headers
+ * @return hICN error code
+ */
+int hicn_packet_get_header_length (hicn_format_t format,
+				   const hicn_header_t * packet,
+				   size_t * header_length);
+
+/**
+ * @brief Return payload length
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] payload_length - payload length
+ * @return hICN error code
+ */
+int hicn_packet_get_payload_length (hicn_format_t format,
+				    const hicn_header_t * packet,
+				    size_t * payload_length);
+
+/**
+ * @brief Sets payload length
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @param [in] payload_length - payload length
+ * @return hICN error code
+ */
+int hicn_packet_set_payload_length (hicn_format_t format,
+				    hicn_header_t * packet,
+				    const size_t payload_length);
+
+/**
+ * @brief Compare two hICN packets
+ * @param [in] packet_1 - First packet
+ * @param [in] packet_2 - Second packet
+ * @return 0 if both packets are considered equal, any other value otherwise.
+ */
+int hicn_packet_compare (const hicn_header_t * packet1,
+			 const hicn_header_t * packet2);
+
+/**
+ * @brief Retrieve the name of an interest/data packet
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] name - name holding the result
+ * @param [in] is_interest - Flag to determine whether it is an interest (1) or
+ * data packet (0)
+ * @return hICN error code
+ */
+int hicn_packet_get_name (hicn_format_t format, const hicn_header_t * packet,
+			  hicn_name_t * name, u8 is_interest);
+
+/**
+ * @brief Sets the name of an interest/data packet
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @param [in] name - name to set into packet
+ * @param [in] is_interest - Flag to determine whether it is an interest (1) or
+ * data packet (0)
+ * @return hICN error code
+ */
+int hicn_packet_set_name (hicn_format_t format, hicn_header_t * packet,
+			  const hicn_name_t * name, u8 is_interest);
+
+/**
+ * @brief Sets the payload of a packet
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @param [in] payload - payload to set
+ * @param [in] payload_length - size of the payload to set
+ * @return hICN error code
+ *
+ * NOTE:
+ *  - The buffer holding payload is assumed sufficiently large
+ *  - This function updates header fields with the new length, but no checksum.
+ */
+int hicn_packet_set_payload (hicn_format_t format, hicn_header_t * packet,
+			     const u8 * payload, u16 payload_length);
+
+/**
+ * @brief Retrieves the payload of a packet
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] payload - pointer to buffer for storing the result
+ * @param [out] payload_length - size of the retreived payload
+ * @param [in] hard_copy - Flag : if true (eg. 1), a copy of the payload is made
+ * into the payload buffer, otherwise (0) the pointer is changed to point to the payload offset in the packet.
+ * @return hICN error code
+ *
+ * NOTE:
+ *  - The buffer holding payload is assumed sufficiently large
+ */
+int hicn_packet_get_payload (hicn_format_t format,
+			     const hicn_header_t * packet, u8 ** payload,
+			     size_t * payload_size, bool hard_copy);
+
+/**
+ * @brief Retrieve the locator of an interest / data packet
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] ip_address - retrieved locator
+ * @param [in] is_interest - Flag to determine whether it is an interest (1) or
+ * data packet (0)
+ * @return hICN error code
+ */
+int hicn_packet_get_locator (hicn_format_t format,
+			     const hicn_header_t * packet,
+			     ip_address_t * ip_address, bool is_interest);
+
+/**
+ * @brief Sets the locator of an interest / data packet
+ * @param [in] format - hICN format
+ * @param [in,out] packet - packet header
+ * @param [out] ip_address - retrieved locator
+ * @param [in] is_interest - Flag to determine whether it is an interest (1) or
+ * data packet (0)
+ * @return hICN error code
+ */
+int hicn_packet_set_locator (hicn_format_t format, hicn_header_t * packet,
+			     const ip_address_t * ip_address,
+			     bool is_interest);
+
+/**
+ * @brief Retrieves the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] bytes - Retrieved signature size
+ * @return hICN error code
+ */
+int hicn_packet_get_signature_size (hicn_format_t format,
+				    const hicn_header_t * packet,
+				    size_t * bytes);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [in] bytes - Retrieved signature size
+ * @return hICN error code
+ */
+int hicn_packet_set_signature_size (hicn_format_t format,
+				    hicn_header_t * packet, size_t bytes);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [in] signature_timestamp - Signature timestamp to set
+ * @return hICN error code
+ */
+int hicn_packet_set_signature_timestamp (hicn_format_t format, hicn_header_t * h,
+				uint64_t signature_timestamp);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] signature_timestamp - Retrieved signature timestamp
+ * @return hICN error code
+ */
+int hicn_packet_get_signature_timestamp (hicn_format_t format, const hicn_header_t * h,
+				uint64_t *signature_timestamp);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [in] validation_algorithm - Validation algorithm to set
+ * @return hICN error code
+ */
+int hicn_packet_set_validation_algorithm (hicn_format_t format, hicn_header_t * h,
+				uint8_t validation_algorithm);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] validation_algorithm - Retrieved validation algorithm
+ * @return hICN error code
+ */
+int hicn_packet_get_validation_algorithm (hicn_format_t format, const hicn_header_t * h,
+				uint8_t * validation_algorithm);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [in] key_id - Key id to set
+ * @return hICN error code
+ */
+int hicn_packet_set_key_id (hicn_format_t format, hicn_header_t * h,
+				uint8_t *key_id);
+
+/**
+ * @brief Sets the signature size
+ * @param [in] format - hICN format
+ * @param [in] packet - packet header
+ * @param [out] key_id - Retrieved key id
+ * @return hICN error code
+ */
+int hicn_packet_get_key_id (hicn_format_t format, hicn_header_t * h,
+				uint8_t ** key_id, uint8_t *key_id_length);
+
+/**
+ * @brief Retrieves the packet hop limit
+ * @param [in] packet - packet header
+ * @param [out] hops - Retrieved hop limit
+ * @return hICN error code
+ */
+int hicn_packet_get_hoplimit (const hicn_header_t * packet, u8 * hops);
+
+/**
+ * @brief Sets the packet hop limit
+ * @param [in] packet - packet header
+ * @param [in] hops - Hop limit to set
+ * @return hICN error code
+ */
+int hicn_packet_set_hoplimit (hicn_header_t * packet, u8 hops);
+
+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_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,
+				  hicn_payload_type_t * payload_type);
+int hicn_packet_set_payload_type (hicn_header_t * packet,
+				  const hicn_payload_type_t payload_type);
+
+int hicn_packet_set_syn (hicn_header_t * packet);
+int hicn_packet_reset_syn (hicn_header_t * packet);
+int hicn_packet_test_syn (const hicn_header_t * packet, bool * flag);
+int hicn_packet_set_ack (hicn_header_t * packet);
+int hicn_packet_reset_ack (hicn_header_t * packet);
+int hicn_packet_test_ack (const hicn_header_t * packet, bool * flag);
+int hicn_packet_set_rst (hicn_header_t * packet);
+int hicn_packet_reset_rst (hicn_header_t * packet);
+int hicn_packet_test_rst (const hicn_header_t * packet, bool * flag);
+int hicn_packet_set_fin (hicn_header_t * packet);
+int hicn_packet_reset_fin (hicn_header_t * packet);
+int hicn_packet_test_fin (const hicn_header_t * packet, bool * flag);
+int hicn_packet_set_ece (hicn_header_t * packet);
+int hicn_packet_reset_ece (hicn_header_t * packet);
+int hicn_packet_test_ece (const hicn_header_t * packet, bool * flag);
+
+int hicn_packet_set_src_port (hicn_header_t * packet, u16 src_port);
+int hicn_packet_get_src_port (const hicn_header_t * packet, u16 * src_port);
+int hicn_packet_set_dst_port (hicn_header_t * packet, u16 dst_port);
+int hicn_packet_get_dst_port (const hicn_header_t * packet, u16 * dst_port);
+
+/* Interest */
+
+int hicn_interest_get_name (hicn_format_t format,
+			    const hicn_header_t * interest,
+			    hicn_name_t * name);
+int hicn_interest_set_name (hicn_format_t format, hicn_header_t * interest,
+			    const hicn_name_t * name);
+int hicn_interest_get_locator (hicn_format_t format,
+			       const hicn_header_t * interest,
+			       ip_address_t * ip_address);
+int hicn_interest_set_locator (hicn_format_t format, hicn_header_t * interest,
+			       const ip_address_t * ip_address);
+int hicn_interest_compare (const hicn_header_t * interest_1,
+			   const hicn_header_t * interest_2);
+int hicn_interest_set_lifetime (hicn_header_t * interest, u32 lifetime);
+int hicn_interest_get_lifetime (const hicn_header_t * interest,
+				u32 * lifetime);
+int hicn_interest_get_header_length (hicn_format_t format,
+				     const hicn_header_t * interest,
+				     size_t * header_length);
+int hicn_interest_get_payload_length (hicn_format_t format,
+				      const hicn_header_t * interest,
+				      size_t * payload_length);
+int hicn_interest_set_payload (hicn_format_t format, hicn_header_t * interest,
+			       const u8 * payload, size_t payload_length);
+int hicn_interest_get_payload (hicn_format_t format,
+			       const hicn_header_t * interest, u8 ** payload,
+			       size_t * payload_size, bool hard_copy);
+int hicn_interest_reset_for_hash (hicn_format_t format,
+				  hicn_header_t * packet);
+
+/* Data */
+
+int hicn_data_get_name (hicn_format_t format, const hicn_header_t * data,
+			hicn_name_t * name);
+int hicn_data_set_name (hicn_format_t format, hicn_header_t * data,
+			hicn_name_t * name);
+int hicn_data_get_locator (hicn_format_t format, const hicn_header_t * data,
+			   ip_address_t * ip_address);
+int hicn_data_set_locator (hicn_format_t format, hicn_header_t * data,
+			   const ip_address_t * ip_address);
+int 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);
+int hicn_data_set_expiry_time (hicn_header_t * data, u32 expiry_time);
+int hicn_data_get_header_length (hicn_format_t format, hicn_header_t * data,
+				 size_t * header_length);
+int hicn_data_get_payload_length (hicn_format_t format,
+				  const hicn_header_t * data,
+				  size_t * payload_length);
+int hicn_data_get_path_label (const hicn_header_t * data, u32 * path_label);
+int hicn_data_set_path_label (hicn_header_t * data, u32 path_label);
+int hicn_data_get_payload (hicn_format_t format, const hicn_header_t * data,
+			   u8 ** payload, size_t * payload_size,
+			   bool hard_copy);
+int hicn_data_set_payload (hicn_format_t format, hicn_header_t * data,
+			   const u8 * payload, size_t payload_length);
+int hicn_data_get_payload_type (const hicn_header_t * data,
+				hicn_payload_type_t * payload_type);
+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);
+
+#endif /* HICN_COMPAT_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/error.c b/lib/src/error.c
new file mode 100755
index 000000000..865e2b47d
--- /dev/null
+++ b/lib/src/error.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file error.c
+ * @brief Implementation of error management functions.
+ */
+
+#include "error.h"
+
+const char *HICN_LIB_ERROR_STRING[] = {
+#define _(a,b,c) [b] = c,
+  foreach_libhicn_error
+#undef _
+};
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/error.h b/lib/src/error.h
new file mode 100755
index 000000000..3e027c4e5
--- /dev/null
+++ b/lib/src/error.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file error.h
+ * @brief Error management functions.
+ */
+#ifndef HICN_ERROR_H
+#define HICN_ERROR_H
+
+/******************************************************************************
+ * 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 ")                            \
+_(UNEXPECTED,           298,    "Unexpected error")
+
+typedef enum
+{
+#define _(a,b,c) HICN_LIB_ERROR_##a = (-b),
+  foreach_libhicn_error
+#undef _
+    HICN_LIB_N_ERROR,
+} hicn_lib_error_t;
+
+extern const char *HICN_LIB_ERROR_STRING[];
+
+#define hicn_strerror(errno) (char *)(HICN_LIB_ERROR_STRING[-errno])
+
+#endif /* HICN_ERROR_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/header.h b/lib/src/header.h
new file mode 100755
index 000000000..3864064f2
--- /dev/null
+++ b/lib/src/header.h
@@ -0,0 +1,105 @@
+/*
+ * 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 header.h
+ * @brief hICN header data structures.
+ * details.
+ */
+#ifndef HICN_HEADER_H
+#define HICN_HEADER_H
+
+#include "common.h"
+#include "protocol.h"
+
+
+typedef struct
+{
+  _ipv6_header_t ip;
+  union
+  {
+    _tcp_header_t tcp;
+    _icmp_header_t icmp;
+    _icmp_wldr_header_t wldr;
+  };
+} hicn_v6_hdr_t;
+
+typedef struct
+{
+  _ipv6_header_t ip;
+  union
+  {
+    struct
+    {
+      _tcp_header_t tcp;
+      _ah_header_t ah;
+    };
+    struct
+    {
+      _icmp_header_t icmp;
+      _ah_header_t icmp_ah;
+    };
+  };
+} hicn_v6ah_hdr_t;
+
+typedef struct
+{
+  _ipv4_header_t ip;
+  union
+  {
+    _tcp_header_t tcp;
+    _icmp_header_t icmp;
+    _icmp_wldr_header_t wldr;
+  };
+} hicn_v4_hdr_t;
+
+typedef struct
+{
+  _ipv4_header_t ip;
+  union
+  {
+    struct
+    {
+      _tcp_header_t tcp;
+      _ah_header_t ah;
+    };
+    struct
+    {
+      _icmp_header_t icmp;
+      _ah_header_t icmp_ah;
+    };
+  };
+} hicn_v4ah_hdr_t;
+
+typedef union
+{
+  /* To deprecate as redundant with hicn_type_t */
+  hicn_v6_hdr_t v6;
+  hicn_v6ah_hdr_t v6ah;
+  hicn_v4_hdr_t v4;
+  hicn_v4ah_hdr_t v4ah;
+
+  hicn_protocol_t protocol;
+} hicn_header_t;
+
+#endif /* HICN_HEADER_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/hicn.h b/lib/src/hicn.h
new file mode 100755
index 000000000..749fd4247
--- /dev/null
+++ b/lib/src/hicn.h
@@ -0,0 +1,79 @@
+/*
+ * 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 hicn.h
+ * @brief hICN master include file.
+ *
+ * Reference: https://tools.ietf.org/html/draft-muscariello-intarea-hicn
+ *
+ * This file is the entry point for projects to libhicn, which provides a
+ * reference implementation for hICN specifications [1], including:
+ *  - naming
+ *  - packet headers
+ *  - protocol mappings (IPv4, IPv6, TCP, ICMP, AH)
+ *  - protocol independent packet operations
+ *  - helpers for additional features such as Wireless Loss Detection and
+ *    Recovery (WLDR) [2], Anchorless Mobility Management (hICN-AMM) [3],
+ *    including MAP-Me producer mobility mechanisms [4].
+ *
+ *  [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
+ *
+ *  [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
+ *
+ *
+ *  [4] MAP-Me : Managing Anchorless Mobility in Content Centric Networking
+ *      J. Augé, G. Carofiglio, L. Muscariello, M. Papalini
+ *      IRTF draft (ICNRG) @ https://tools.ietf.org/html/draft-irtf-icnrg-mapme
+ */
+
+#ifndef HICN__H
+#define HICN__H
+
+#ifdef HICN_VPP_PLUGIN
+
+#include <hicn/header.h>
+#include <hicn/name.h>
+#include <hicn/ops.h>
+#include <hicn/mapme.h>
+
+#else
+
+#include <hicn/error.h>
+#include <hicn/header.h>
+#include <hicn/name.h>
+#include <hicn/ops.h>
+#include <hicn/mapme.h>
+#include <hicn/compat.h>
+
+#endif
+
+#endif /* HICN__H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/mapme.c b/lib/src/mapme.c
new file mode 100755
index 000000000..e4c5ee1f2
--- /dev/null
+++ b/lib/src/mapme.c
@@ -0,0 +1,224 @@
+/*
+ * 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 mapme.c
+ * @brief Implementation  of MAP-Me anchorless producer mobility management.
+ */
+
+#include "mapme.h"
+#include "common.h"
+#include "error.h"
+
+#include "protocol/ipv4.h"
+#include "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_header_t *mh = (hicn_mapme_v4_header_t *) buf;
+  /* *INDENT-OFF* */
+  *mh = (hicn_mapme_v4_header_t) {
+    .ip = {
+      .version_ihl = (IPV4_DEFAULT_VERSION << 4) | (0x0f & IPV4_DEFAULT_IHL),
+      .tos = IPV4_DEFAULT_TOS,
+      .len = HICN_MAPME_V4_HDRLEN,
+      .id = htons(IPV4_DEFAULT_ID),
+      .frag_off = htons(IPV4_DEFAULT_FRAG_OFF),
+      .ttl = HICN_MAPME_TTL,
+      .protocol = IPPROTO_ICMP,
+      .csum = 0,
+      .saddr.as_u32 = 0,
+      .daddr = prefix->name.ip4,
+     },
+    .icmp = {
+      .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,
+    },
+    .icmp_rd = {
+      .ip = prefix->name.ip4,
+    },
+    .seq = htonl(params->seq),
+    .len = prefix->len,
+  };
+  /* *INDENT-ON* */
+
+  return HICN_MAPME_V4_HDRLEN;
+}
+
+size_t
+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,
+      .version_class_flow = htonl(
+          (IPV6_DEFAULT_VERSION       << 28) |
+          (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |
+          (IPV6_DEFAULT_FLOW_LABEL     & 0xfffff)),
+      .len = htons(HICN_MAPME_V6_HDRLEN - IPV6_HDRLEN),
+      .nxt = IPPROTO_ICMPV6,
+      .hlim = HICN_MAPME_TTL,
+     },
+    .icmp = {
+      .type = ((params->type == UPDATE) || (params->type == NOTIFICATION))
+		? HICN_MAPME_ICMP_TYPE_IPV6
+		: HICN_MAPME_ICMP_TYPE_ACK_IPV6,
+      .code = HICN_MAPME_ICMP_CODE,
+      .csum = 0,
+    },
+    .icmp_rd = {
+      .res = 0,
+      .tgt = prefix->name.ip6,
+      .dst = prefix->name.ip6,
+    },
+    .seq = htonl(params->seq),
+    .len = prefix->len,
+  };
+  /* *INDENT-ON* */
+  return HICN_MAPME_V6_HDRLEN;
+}
+
+size_t
+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))
+    return hicn_mapme_v6_create_packet (buf, prefix, params);
+  else
+    return hicn_mapme_v4_create_packet (buf, prefix, params);
+}
+
+size_t
+hicn_mapme_v4_create_ack (u8 * buf, const mapme_params_t * params)
+{
+  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;
+  mh->ip.daddr = mh->ip.saddr;
+  mh->ip.saddr = tmp;
+  mh->ip.ttl = HICN_MAPME_TTL;
+  mh->icmp.type = (params->type == UPDATE) ? UPDATE_ACK : NOTIFICATION_ACK;
+  mh->icmp.csum = 0;
+
+  return HICN_MAPME_V4_HDRLEN;
+}
+
+size_t
+hicn_mapme_v6_create_ack (u8 * buf, const mapme_params_t * params)
+{
+  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;
+  mh->ip.daddr = mh->ip.saddr;
+  mh->ip.saddr = tmp;
+  mh->ip.hlim = HICN_MAPME_TTL;
+  mh->icmp.type = (params->type == UPDATE) ? UPDATE_ACK : NOTIFICATION_ACK;
+  mh->icmp.csum = 0;
+
+  return HICN_MAPME_V6_HDRLEN;
+}
+
+size_t
+hicn_mapme_create_ack (u8 * buf, const mapme_params_t * params)
+{
+  /* We currently ignore subsequent protocol definitions */
+  if (PREDICT_TRUE (params->protocol == IPPROTO_IPV6))
+    return hicn_mapme_v6_create_ack (buf, params);
+  else
+    return hicn_mapme_v4_create_ack (buf, params);
+}
+
+int
+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.type) ? mh->ip.daddr : mh->ip.saddr,
+    },
+    .len = mh->len,
+  };
+
+  *params = (mapme_params_t) {
+    .protocol = IPPROTO_IP,
+    .type = (mh->icmp.type == HICN_MAPME_ICMP_TYPE_IPV4) ? UPDATE : UPDATE_ACK,
+    .seq = ntohl (mh->seq),
+  };
+  /* *INDENT-ON* */
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+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.type) ? mh->ip.daddr : mh->ip.saddr,
+    },
+    .len = mh->len,
+  };
+
+  *params = (mapme_params_t) {
+    .protocol = IPPROTO_IPV6,
+    .type = (mh->icmp.type == HICN_MAPME_ICMP_TYPE_IPV6) ? UPDATE : UPDATE_ACK,
+    .seq = ntohl (mh->seq),
+  };
+  /* *INDENT-ON* */
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_mapme_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
+			 mapme_params_t * params)
+{
+  switch (HICN_IP_VERSION (packet))
+    {
+    case 4:
+      return hicn_mapme_v4_parse_packet (packet, prefix, params);
+    case 6:
+      return hicn_mapme_v6_parse_packet (packet, prefix, params);
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/mapme.h b/lib/src/mapme.h
new file mode 100755
index 000000000..460c15282
--- /dev/null
+++ b/lib/src/mapme.h
@@ -0,0 +1,152 @@
+/*
+ * 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 mapme.h
+ * @brief MAP-Me anchorless producer mobility management.
+ */
+#ifndef HICN_MAPME_H
+#define HICN_MAPME_H
+
+#include <stdint.h>		// u32
+#include <stdbool.h>
+
+#include "common.h"
+#include "protocol.h"
+#include "ops.h"
+
+/**
+ * @brief MAP-Me configuration options
+ */
+typedef struct
+{
+    /** MAP-Me enabled flag (default: false) */
+  bool enabled;
+    /** timescale (T_U parameter) in ms (default: 0 for no notifications) */
+  u32 timescale;
+    /** retransmission timer in ms (default: 50) */
+  u32 retx;
+    /**
+     * Discovery enabled flag (default: true, should be true if mandatory is
+     * notifications are enabled)
+     */
+  bool discovery;
+} hicn_mapme_conf_t;
+
+/** @brief Default MAP-Me configuration */
+static const hicn_mapme_conf_t hicn_mapme_conf = {
+  .enabled = false,
+  .timescale = 0,
+  .retx = 50,
+  .discovery = true,
+};
+
+/** @brief MAP-Me update sequence number */
+typedef u32 seq_t;
+
+/** @brief MAP-Me packet types */
+typedef enum
+{
+  UNKNOWN,
+  UPDATE,
+  UPDATE_ACK,
+  NOTIFICATION,
+  NOTIFICATION_ACK,
+} hicn_mapme_type_t;
+
+/** @brief MAP-Me parameters (excluding those contained in * hicn_prefix_t) */
+typedef struct
+{
+  int protocol;
+  hicn_mapme_type_t type;
+  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);
+
+/* Implementation & parsing : ICMP Redirect */
+
+#define HEADER_TYPE_MAPME4 (hicn_type_t) {0, IPPROTO_ICMPRD, IPPROTO_ICMP, IPPROTO_IP}
+#define HEADER_TYPE_MAPME6 (hicn_type_t) {0, IPPROTO_ICMPRD, IPPROTO_ICMP, IPPROTO_IPV6}
+
+#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))
+
+/* 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?)
+
+/** @brief MAP-Me packet header for IPv4 */
+typedef struct __attribute__ ((packed))
+{
+  _ipv4_header_t ip;
+  _icmp_header_t icmp;
+  _icmprd4_header_t icmp_rd;
+  seq_t seq;
+  u8 len;
+  u8 _pad[3];
+} hicn_mapme_v4_header_t;
+
+/** @brief MAP-Me packet header for IPv6 */
+typedef struct __attribute__ ((packed))
+{
+  _ipv6_header_t ip;
+  _icmp_header_t icmp;
+  _icmprd_header_t icmp_rd;
+  seq_t seq;
+  u8 len;
+  u8 _pad[3];
+} hicn_mapme_v6_header_t;
+
+/** @brief MAP-Me packet header (IP version agnostic) */
+typedef union
+{
+  hicn_mapme_v4_header_t v4;
+  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)
+
+#endif /* HICN_MAPME_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/name.c b/lib/src/name.c
new file mode 100755
index 000000000..6e5711252
--- /dev/null
+++ b/lib/src/name.c
@@ -0,0 +1,676 @@
+/*
+ * 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 name.c
+ * @brief Implementation of hICN name helpers.
+ */
+
+#include <arpa/inet.h>		// inet_ptin
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>		// strtoul
+#include <string.h>		// memcpy
+
+#include "common.h"
+#include "error.h"
+#include "name.h"
+
+#define DUMMY_PORT ntohs(1234)
+
+#if ! HICN_VPP_PLUGIN
+int
+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;
+    }
+
+  if ((name->type != HNT_CONTIGUOUS_V4) && (name->type != HNT_CONTIGUOUS_V6))
+    {
+      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+    }
+
+  rc = inet_pton (af, ip_address, name->buffer);
+  if (rc <= 0)
+    {
+      return HICN_LIB_ERROR_UNKNOWN_ADDRESS;
+    }
+  *(u32 *) (name->buffer + name->len) = id;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_name_create_from_ip_address (const ip_address_t * ip_address, u32 id,
+				  hicn_name_t * name)
+{
+  switch (ip_address->family)
+    {
+    case AF_INET:
+      if (name->type == HNT_UNSPEC)
+	{
+	  name->type = HNT_CONTIGUOUS_V4;
+	}
+      break;
+    case AF_INET6:
+      if (name->type == HNT_UNSPEC)
+	{
+	  name->type = HNT_CONTIGUOUS_V6;
+	}
+      break;
+    default:
+      return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
+    }
+
+  name->len = ip_address->prefix_len;
+  if ((name->type != HNT_CONTIGUOUS_V4) && (name->type != HNT_CONTIGUOUS_V6))
+    {
+      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+    }
+
+  memcpy (name->buffer, ip_address->buffer, ip_address_len (ip_address));
+  *(u32 *) (name->buffer + name->len) = 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_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;
+
+  u8 *buffer11, *buffer12, *buffer21, *buffer22;
+
+  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;
+}
+
+int
+hicn_name_hash (const hicn_name_t * name, u32 * hash)
+{
+  switch (name->type)
+    {
+    case HNT_CONTIGUOUS_V4:
+      *hash = hash32 (name->buffer, HICN_V4_NAME_LEN);
+      break;
+    case HNT_CONTIGUOUS_V6:
+      *hash = hash32 (name->buffer, HICN_V6_NAME_LEN);
+      break;
+    case HNT_IOV_V4:
+    case HNT_IOV_V6:
+      *hash =
+	hash32 (name->iov.buffers[0].iov_base, name->iov.buffers[0].iov_len);
+      *hash =
+	cumulative_hash32 (name->iov.buffers[1].iov_base,
+			   name->iov.buffers[1].iov_len, *hash);
+      break;
+    default:
+      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_name_empty (hicn_name_t * name)
+{
+  return name->type == HNT_UNSPEC ? HICN_LIB_ERROR_NONE : 1;
+}
+
+int
+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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_name_copy_to_destination (u8 * dst, const hicn_name_t * src,
+			       bool copy_suffix)
+{
+  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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+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)
+    {
+    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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_name_to_ip_address (const hicn_name_t * name, ip_address_t * ip_address)
+{
+  switch (name->type)
+    {
+    case HNT_CONTIGUOUS_V6:
+      memcpy (&ip_address->buffer, name->buffer, IPV6_ADDR_LEN);
+      ip_address->family = AF_INET6;
+      break;
+    case HNT_IOV_V6:
+      memcpy (&ip_address->buffer, name->iov.buffers[0].iov_base,
+	      name->iov.buffers[0].iov_len);
+      ip_address->family = AF_INET6;
+      break;
+    case HNT_CONTIGUOUS_V4:
+      memcpy (&ip_address->buffer, name->buffer, IPV4_ADDR_LEN);
+      ip_address->family = AF_INET;
+      break;
+    case HNT_IOV_V4:
+      memcpy (&ip_address->buffer, name->iov.buffers[0].iov_base,
+	      name->iov.buffers[0].iov_len);
+      ip_address->family = AF_INET;
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+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, len);
+      seg_number = (u8 *) src->buffer + IPV6_ADDR_LEN;
+      break;
+    case HNT_CONTIGUOUS_V4:
+      rc = inet_ntop (AF_INET, src->buffer, dst, 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, 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, len);
+      seg_number = src->iov.buffers[1].iov_base;
+      break;
+    default:
+      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+    }
+
+  if (!rc)
+    {
+      goto ERR;
+    }
+
+  offset = strlen (dst);
+  dst[offset] = '|';
+
+  sprintf (dst + offset + 1, "%lu", (unsigned long) (*(u32 *) seg_number));
+
+  return HICN_LIB_ERROR_NONE;
+
+ERR:
+  return HICN_LIB_ERROR_UNSPECIFIED;
+}
+
+int
+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)
+{
+  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;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+hicn_prefix_create_from_ip_address (const ip_address_t * ip_address,
+				    hicn_prefix_t * prefix)
+{
+  switch (ip_address->family)
+    {
+    case AF_INET:
+      prefix->name.ip4.as_u32 = ip_address->as_u32[0];
+      break;
+    case AF_INET6:
+      prefix->name.ip6.as_u64[0] = ip_address->as_u64[0];
+      prefix->name.ip6.as_u64[1] = ip_address->as_u64[1];
+      break;
+    default:
+      return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
+    }
+  prefix->len = ip_address->prefix_len;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+#endif /* ! HICN_VPP_PLUGIN */
+
+/********
+ * IP
+ */
+
+inline int
+ip_address_len (const ip_address_t * ip_address)
+{
+  return (ip_address->family == AF_INET6) ? IPV6_ADDR_LEN :
+    (ip_address->family == AF_INET) ? IPV4_ADDR_LEN : 0;
+}
+
+bool
+ip_address_empty (const ip_address_t * ip_address)
+{
+  return ip_address->prefix_len == 0;
+}
+
+int
+hicn_ip_ntop (const ip_address_t * ip_address, char *dst, const size_t len)
+{
+  const char *rc;
+
+  rc = inet_ntop (ip_address->family, ip_address->buffer, dst, len);
+  if (!rc)
+    {
+      printf ("error ntop: %d %s\n", errno, strerror (errno));
+      return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+/*
+ * Parse ip addresses in presentation format, or prefixes (in bits, separated by a slash)
+ */
+int
+hicn_ip_pton (const char *ip_address_str, ip_address_t * ip_address)
+{
+  int pton_fd;
+  char *p;
+  char *eptr;
+  u32 dst_len;
+  char *addr = strdup (ip_address_str);
+
+  p = strchr (addr, '/');
+  if (!p)
+    {
+      dst_len = 0;		// until we get the ip address family
+    }
+  else
+    {
+      dst_len = strtoul (p + 1, &eptr, 10);
+      *p = 0;
+    }
+
+  ip_address->family = get_addr_family (addr);
+
+  switch (ip_address->family)
+    {
+    case AF_INET6:
+      if (dst_len > IPV6_ADDR_LEN_BITS)
+	goto ERR;
+      pton_fd = inet_pton (AF_INET6, addr, &ip_address->buffer);
+      ip_address->prefix_len = dst_len ? : IPV6_ADDR_LEN_BITS;
+      break;
+    case AF_INET:
+      if (dst_len > IPV4_ADDR_LEN_BITS)
+	goto ERR;
+      pton_fd = inet_pton (AF_INET, addr, &ip_address->buffer);
+      ip_address->prefix_len = dst_len ? : IPV4_ADDR_LEN_BITS;
+      break;
+    default:
+      goto ERR;
+    }
+
+  //   0 = not in presentation format
+  // < 0 = other error (use perror)
+  if (pton_fd <= 0)
+    {
+      goto ERR;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+ERR:
+  free (addr);
+  return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
+}
+
+int
+hicn_ip_to_sockaddr_address (const ip_address_t * ip_address,
+			     struct sockaddr *sockaddr_address)
+{
+  struct sockaddr_in6 *tmp6 = (struct sockaddr_in6 *) sockaddr_address;
+  struct sockaddr_in *tmp4 = (struct sockaddr_in *) sockaddr_address;
+
+  switch (ip_address->family)
+    {
+    case AF_INET6:
+      tmp6->sin6_family = AF_INET6;
+      tmp6->sin6_port = DUMMY_PORT;
+      tmp6->sin6_scope_id = 0;
+      memcpy (&tmp6->sin6_addr, ip_address->buffer, IPV6_ADDR_LEN);
+      break;
+    case AF_INET:
+      tmp4->sin_family = AF_INET;
+      tmp4->sin_port = DUMMY_PORT;
+      memcpy (&tmp4->sin_addr, ip_address->buffer, IPV4_ADDR_LEN);
+      break;
+    default:
+      return HICN_LIB_ERROR_UNEXPECTED;
+    }
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/name.h b/lib/src/name.h
new file mode 100755
index 000000000..0a55fedc6
--- /dev/null
+++ b/lib/src/name.h
@@ -0,0 +1,336 @@
+/*
+ * 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 name.h
+ * @brief hICN name helpers.
+ *
+ * The purpose of the file is to offer an efficient, platform- and protocol-
+ * independent way to manipulate hICN names.
+ */
+
+#ifndef HICN_NAME_H
+#define HICN_NAME_H
+
+#include <stdbool.h>
+#include <netinet/in.h>		// struct sockadd
+
+#include "common.h"
+
+/******************************************************************************
+ * IP address helpers
+ ******************************************************************************/
+
+/* Presentation format */
+#define INET_ADDRSTRLEN 16
+#define INET6_ADDRSTRLEN 46
+//#define INET_MAX_ADDRSTRLEN INET6_ADDRSTRLEN
+
+/* Address size */
+#define bytes_to_bits(x) (x * 8)
+#define IPV6_ADDR_LEN 16	/* bytes */
+#define IPV4_ADDR_LEN 4		/* bytes */
+#define IPV6_ADDR_LEN_BITS bytes_to_bits(IPV6_ADDR_LEN)
+#define IPV4_ADDR_LEN_BITS bytes_to_bits(IPV4_ADDR_LEN)
+
+#define IP_MAX_ADDR_LEN IPV6_ADDR_LEN
+#define TCP_SEQNO_LEN 4		/* bytes */
+
+typedef struct
+{
+  union
+  {
+    u8 buffer[IP_MAX_ADDR_LEN];
+    u8 as_u8[IP_MAX_ADDR_LEN];
+    u16 as_u16[IP_MAX_ADDR_LEN >> 1];
+    u32 as_u32[IP_MAX_ADDR_LEN >> 2];
+    u64 as_u64[IP_MAX_ADDR_LEN >> 3];
+    ip4_address_t as_ip4;
+    ip6_address_t as_ip6;
+  };
+  int family;
+  unsigned short prefix_len;
+} ip_address_t;
+
+int ip_address_len (const ip_address_t * ip_address);
+bool ip_address_empty (const ip_address_t * ip_address);
+
+int hicn_ip_ntop (const ip_address_t * ip_address, char *dst,
+		  const size_t len);
+int hicn_ip_pton (const char *ip_address_str, ip_address_t * ip_address);
+int hicn_ip_to_sockaddr_address (const ip_address_t * ip_address,
+				 struct sockaddr *sockaddr_address);
+
+/******************************************************************************
+ * hICN names
+ ******************************************************************************/
+
+#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 */
+
+/* Prefix */
+
+typedef u32 hicn_name_suffix_t;
+
+typedef struct
+{
+  ip46_address_t name;
+  u8 len;
+} hicn_prefix_t;
+
+/*
+ * Name
+ *
+ * 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;
+
+typedef struct
+{
+  u8 buffer[0];
+} hicn_v46_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[0];
+#endif				/* HICN_VPP_PLUGIN */
+  };
+} 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 */
+
+/**
+ * @brief Create an hICN name from IP address in presentation format
+ * @param [in] ip_address - IP address
+ * @param [in] id - Segment identifier
+ * @param [out] Resulting hICN name
+ * @return hICN error code
+ */
+int hicn_name_create (const char *ip_address, u32 id, hicn_name_t * name);
+
+/**
+ * @brief Create an hICN name from IP address
+ * @param [in] ip_address - IP address
+ * @param [in] id Segment - identifier
+ * @param [out] Resulting - hICN name
+ * @return hICN error code
+ */
+int hicn_name_create_from_ip_address (const ip_address_t * ip_address, 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);
+
+/**
+ * @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
+ * @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);
+
+/**
+ * @brief Provides a 32-bit hash of an hICN name
+ * @param [in] name - Name to hash
+ * @param [out] hash - Resulting hash
+ * @return hICN error code
+ */
+int hicn_name_hash (const hicn_name_t * name, u32 * hash);
+
+/**
+ * @brief Test whether an hICN name is empty
+ * @param [in] name - Name to test
+ * @return 0 if the name is empty, any other value otherwise (implementation
+ *   returns 1)
+ */
+int hicn_name_empty (hicn_name_t * name);
+
+/**
+ * @brief Copy an hICN name
+ * @param [out] dst - Destination 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);
+
+/**
+ * @brief Copy an hICN name to a buffer
+ * @param [out] dst - Destination buffer
+ * @param [in] src - Source name to copy
+ * @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);
+
+/**
+ * @brief Sets the segment part of an hICN name
+ * @param [in,out] name - hICN name to modify
+ * @param [in] seq_number - Segment identifier
+ * @return hICN error code
+ */
+int hicn_name_set_seq_number (hicn_name_t * name, u32 seq_number);
+
+/**
+ * @brief Retrieves the segment part of an hICN name
+ * @param [in,out] name - hICN name
+ * @param [in] seq_number - Segment identifier
+ * @return hICN error code
+ */
+int hicn_name_get_seq_number (const hicn_name_t * name, u32 * seq_number);
+
+/**
+ * @brief Convert an hICN name to a socket address
+ * @param [in] name - Name to convert
+ * @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);
+
+/**
+ * @brief Convert an hICN name to an IP address
+ * @param [in] name - Name to convert
+ * @param [out] ip_address - Resulting IP address
+ * @return hICN error code
+ */
+int hicn_name_to_ip_address (const hicn_name_t * name,
+			     ip_address_t * ip_address);
+
+/**
+ * @brief Convert an hICN name to presentation format
+ * @param [in] src - Name to convert
+ * @param [out] dst - Buffer to receive the name in presentation format
+ * @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);
+
+/**
+ * @brief Convert an hICN name from presentation format
+ * @param [in] src - Name in presentation format to parse
+ * @param [out] dst - Resulting name
+ * @return hICN error code
+ */
+int hicn_name_pton (const char *src, hicn_name_t * dst);
+
+/**
+ * @brief Returns the IP address family of an hICN name
+ * @param [in] name - Name to lookup
+ * @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);
+
+/**
+ * @brief Creates an hICN prefix from an IP address
+ * @param [in] ip_address - Input IP address
+ * @param [out] prefix - Resulting prefix
+ * @return hICN error code
+ */
+int hicn_prefix_create_from_ip_address (const ip_address_t * ip_address,
+					hicn_prefix_t * prefix);
+
+#endif /* HICN_NAME_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/ops.c b/lib/src/ops.c
new file mode 100755
index 000000000..ad45a13a5
--- /dev/null
+++ b/lib/src/ops.c
@@ -0,0 +1,93 @@
+/*
+ * 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 ops.c
+ * @brief Initializers for protocol-independent packet operations
+ */
+
+#include <netinet/in.h>
+#include <stdlib.h>
+#include "ops.h"
+
+#include "header.h"
+
+extern const hicn_ops_t hicn_ops_ipv4;
+extern const hicn_ops_t hicn_ops_icmp;
+extern const hicn_ops_t hicn_ops_tcp;
+extern const hicn_ops_t hicn_ops_ipv6;
+extern const hicn_ops_t hicn_ops_ah;
+
+/* Declare empty operations (terminates recursion on protocol layers) */
+DECLARE_init_packet_header (none, NONE);
+DECLARE_get_interest_locator (none, NONE);
+DECLARE_set_interest_locator (none, NONE);
+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_reset_interest_for_hash (none, NONE);
+DECLARE_get_data_locator (none, NONE);
+DECLARE_set_data_locator (none, NONE);
+DECLARE_get_data_name (none, NONE);
+DECLARE_set_data_name (none, NONE);
+DECLARE_get_data_name_suffix (none, NONE);
+DECLARE_set_data_name_suffix (none, NONE);
+DECLARE_get_data_pathlabel (none, NONE);
+DECLARE_set_data_pathlabel (none, NONE);
+DECLARE_update_data_pathlabel (none, NONE);
+DECLARE_reset_data_for_hash (none, NONE);
+DECLARE_get_lifetime (none, NONE);
+DECLARE_set_lifetime (none, NONE);
+DECLARE_update_checksums (none, NONE);
+DECLARE_verify_checksums (none, NONE);
+DECLARE_rewrite_interest (none, NONE);
+DECLARE_rewrite_data (none, NONE);
+DECLARE_get_length (none, NONE);
+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_signature_size (none, NONE);
+DECLARE_set_signature_size (none, NONE);
+DECLARE_set_signature_timestamp (none, NONE);
+DECLARE_get_signature_timestamp (none, NONE);
+DECLARE_set_validation_algorithm (none, NONE);
+DECLARE_get_validation_algorithm (none, NONE);
+DECLARE_set_key_id (none, NONE);
+DECLARE_get_key_id (none, NONE);
+DECLARE_HICN_OPS (none);
+
+/**
+ * @brief Virtual function table for packet operations
+ * NOTE: protocol numbers have to be kept in order
+ */
+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,
+  /* 41 */ [IPPROTO_IPV6] = &hicn_ops_ipv6,
+  /* 51 */ [IPPROTO_AH] = &hicn_ops_ah,
+  /* 58 */ [IPPROTO_ICMPV6] = &hicn_ops_icmp,
+  [IPPROTO_NONE] = &hicn_ops_none,
+};
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/ops.h b/lib/src/ops.h
new file mode 100755
index 000000000..d56e6ae4a
--- /dev/null
+++ b/lib/src/ops.h
@@ -0,0 +1,624 @@
+/*
+ * 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 base.h
+ * @brief Protocol-independent packet operations
+ */
+
+#ifndef HICN_OPS_H
+#define HICN_OPS_H
+
+#include <stdlib.h>
+
+#include "error.h"
+#include "header.h"
+#include "name.h"
+
+/*
+ * hICN operations on packets
+ *
+ * All prototypes take an hicn_type_t parameter as their first argument, as this
+ * decides the sequence of protocols that are being used by the different
+ * operations.
+ */
+
+typedef struct hicn_ops_s
+{
+    /** Protocol name */
+  const char *name;
+
+    /**
+     * @brief Initialize the headers of the hicn packet
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the packet
+     */
+  int (*init_packet_header) (hicn_type_t type, hicn_protocol_t * h);
+
+    /**
+     * @brief Retrieves an Interest locator
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest packet
+     * @param [out] ip_address - Retrieved locator
+     * @return hICN error code
+     */
+  int (*get_interest_locator) (hicn_type_t type, const hicn_protocol_t * h,
+			       ip46_address_t * ip_address);
+
+    /**
+     * @brief Sets an Interest locator
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest packet
+     * @param [in] ip_address - Locator to set
+     * @return hICN error code
+     */
+  int (*set_interest_locator) (hicn_type_t type, hicn_protocol_t * h,
+			       const ip46_address_t * ip_address);
+
+    /**
+     * @brief Retrieves an Interest name
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest packet
+     * @param [out] name - Retrieved name
+     * @return hICN error code
+     */
+  int (*get_interest_name) (hicn_type_t type, const hicn_protocol_t * h,
+			    hicn_name_t * name);
+
+    /**
+     * @brief Sets an Interest name
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest packet
+     * @param [in] name - Name to set
+     * @return hICN error code
+     */
+  int (*set_interest_name) (hicn_type_t type, hicn_protocol_t * h,
+			    const hicn_name_t * name);
+
+    /**
+     * @brief Retrieves an Interest name suffix
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest packet
+     * @param [out] suffix - Retrieved name suffix
+     * @return hICN error code
+     */
+  int (*get_interest_name_suffix) (hicn_type_t type,
+				   const hicn_protocol_t * h,
+				   hicn_name_suffix_t * suffix);
+
+    /**
+     * @brief Sets an Interest name suffix
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest packet
+     * @param [in] suffix - Name suffix to set
+     * @return hICN error code
+     */
+  int (*set_interest_name_suffix) (hicn_type_t type, hicn_protocol_t * h,
+				   const hicn_name_suffix_t * suffix);
+
+    /**
+     * @brief Clear the necessary Interest fields in order to hash it
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest packet
+     * @return hICN error code
+     */
+  int (*reset_interest_for_hash) (hicn_type_t type, hicn_protocol_t * h);
+
+    /**
+     * @brief Retrieves a Data locator
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Data packet
+     * @param [out] ip_address - Retrieved locator
+     * @return hICN error code
+     */
+  int (*get_data_locator) (hicn_type_t type, const hicn_protocol_t * h,
+			   ip46_address_t * ip_address);
+
+    /**
+     * @brief Sets a Data locator
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @param [in] ip_address - Locator to set
+     * @return hICN error code
+     */
+  int (*set_data_locator) (hicn_type_t type, hicn_protocol_t * h,
+			   const ip46_address_t * ip_address);
+
+    /**
+     * @brief Retrieves a Data name
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Data packet
+     * @param [out] name - Retrieved name
+     * @return hICN error code
+     */
+  int (*get_data_name) (hicn_type_t type, const hicn_protocol_t * h,
+			hicn_name_t * name);
+
+    /**
+     * @brief Sets a Data name
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @param [in] name - Name to set
+     * @return hICN error code
+     */
+  int (*set_data_name) (hicn_type_t type, hicn_protocol_t * h,
+			const hicn_name_t * name);
+
+    /**
+     * @brief Retrieves a Data name suffix
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Data packet
+     * @param [out] suffix - Retrieved name suffix
+     * @return hICN error code
+     */
+  int (*get_data_name_suffix) (hicn_type_t type, const hicn_protocol_t * h,
+			       hicn_name_suffix_t * suffix);
+
+    /**
+     * @brief Sets a Data name suffix
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @param [in] suffix - Name suffix to set
+     * @return hICN error code
+     */
+  int (*set_data_name_suffix) (hicn_type_t type, hicn_protocol_t * h,
+			       const hicn_name_suffix_t * suffix);
+
+    /**
+     * @brief Retrieves a Data pathlabel
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Data packet
+     * @param [out] pathlabel - Retrieved pathlabel
+     * @return hICN error code
+     */
+  int (*get_data_pathlabel) (hicn_type_t type, const hicn_protocol_t * h,
+			     u32 * pathlabel);
+
+    /**
+     * @brief Sets a Data pathlabel
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @param [in] pathlabel - Pathlabel to set
+     * @return hICN error code
+     */
+  int (*set_data_pathlabel) (hicn_type_t type, hicn_protocol_t * h,
+			     const u32 pathlabel);
+
+    /**
+     * @brief Update a Data pathlabel with a new face identifier
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @param [in] pathlabel - Face identifier used to update pathlabel
+     * @return hICN error code
+     */
+  int (*update_data_pathlabel) (hicn_type_t type, hicn_protocol_t * h,
+				const hicn_faceid_t face_id);
+
+    /**
+     * @brief Clear the necessary Data fields in order to hash it
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Data packet
+     * @return hICN error code
+     */
+  int (*reset_data_for_hash) (hicn_type_t type, hicn_protocol_t * h);
+
+    /**
+     * @brief Retrieves an Interest or Data lifetime
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest or Data packet
+     * @param [out] pathlabel - Retrieved lifetime
+     * @return hICN error code
+     */
+  int (*get_lifetime) (hicn_type_t type, const hicn_protocol_t * h,
+		       hicn_lifetime_t * lifetime);
+
+    /**
+     * @brief Sets an Interest or Data lifetime
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [in] pathlabel - Lifetime to set
+     * @return hICN error code
+     */
+  int (*set_lifetime) (hicn_type_t type, hicn_protocol_t * h,
+		       const hicn_lifetime_t lifetime);
+
+    /**
+     * @brief Update all checksums in packet headers
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the packet
+     * @param [in] partial_csum - Partial checksum (set to 0, used internally to
+     *   carry intermediate values from IP pseudo-header)
+     * @param [in] payload_length - Payload length (can be set to 0, retrieved
+     *   and used internally to carry payload length across protocol headers)
+     * @return hICN error code
+     */
+  int (*update_checksums) (hicn_type_t type, hicn_protocol_t * h,
+			   u16 partial_csum, size_t payload_length);
+
+    /**
+     * @brief Validate all checksums in packet headers
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the packet
+     * @param [in] partial_csum - Partial checksum (set to 0, used internally to
+     *   carry intermediate values from IP pseudo-header)
+     * @param [in] payload_length - Payload length (can be set to 0, retrieved
+     *   and used internally to carry payload length across protocol headers)
+     * @return hICN error code
+     */
+  int (*verify_checksums) (hicn_type_t type, hicn_protocol_t * h,
+			   u16 partial_csum, size_t payload_length);
+
+    /**
+     * @brief Rewrite an Interest packet header (locator)
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest packet
+     * @param [in] addr_new - New locator
+     * @param [in] addr_old - Old locator (set to NULL, used internally to
+     *   compute incremental checksums)
+     * @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);
+
+    /**
+     * @brief Rewrite a Data packet header (locator + pathlabel)
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Data packet
+     * @param [in] addr_new - New locator
+     * @param [in] addr_old - Old locator (set to NULL, used internally to
+     *   compute incremental checksums)
+     * @param [in] face_id - Face identifier used to update pathlabel
+     * @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);
+
+    /**
+     * @brief Return the packet length
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the packet
+     * @parma [out] length - Returned packet length
+     * @return hICN error code
+     */
+  int (*get_length) (hicn_type_t type, const hicn_protocol_t * h,
+		     size_t * length);
+
+    /**
+     * @brief Return the current packet header length
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the packet
+     * @parma [out] header_length - Returned packet current header length
+     * @return hICN error code
+     */
+  int (*get_current_header_length) (hicn_type_t type,
+				    const hicn_protocol_t * h,
+				    size_t * header_length);
+
+    /**
+     * @brief Return the packet header length
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the packet
+     * @parma [out] header_length - Returned packet header length
+     * @return hICN error code
+     */
+  int (*get_header_length) (hicn_type_t type, const hicn_protocol_t * h,
+			    size_t * header_length);
+
+    /**
+     * @brief Return the packet payload length
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the packet
+     * @parma [out] payload_length - Returned packet payload length
+     * @return hICN error code
+     */
+  int (*get_payload_length) (hicn_type_t type, const hicn_protocol_t * h,
+			     size_t * payload_length);
+
+    /**
+     * @brief Sets the packet paylaod length
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the packet
+     * @parma [out] payload_length - Payload length to set
+     * @return hICN error code
+     */
+  int (*set_payload_length) (hicn_type_t type, hicn_protocol_t * h,
+			     size_t payload_length);
+
+    /**
+     * @brief Retrieves an Interest or Data signature size
+     * @param [in] type - hICN packet type
+     * @param [in] h - Buffer holding the Interest or Data packet
+     * @param [out] signature_size - Retrieved signature size
+     * @return hICN error code
+     */
+  int (*get_signature_size) (hicn_type_t type, const hicn_protocol_t * h,
+			     size_t * signature_size);
+
+    /**
+     * @brief Sets an Interest or Data signature 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_size) (hicn_type_t type, hicn_protocol_t * h,
+			     size_t signature_size);
+
+    /**
+     * @brief Sets the signature timestamp
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [in] signature_timestamp - Signature timestamp to set
+     * @return hICN error code
+     */
+  int (*set_signature_timestamp) (hicn_type_t type, hicn_protocol_t * h,
+                 uint64_t signature_timestamp);
+
+    /**
+     * @brief Gets the signature timestamp
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [out] signature_timestamp - Retrieved signature timestamp
+     * @return hICN error code
+     */
+  int (*get_signature_timestamp) (hicn_type_t type, const hicn_protocol_t * h,
+                 uint64_t *signature_timestamp);
+
+    /**
+     * @brief Sets the signature validation algorithm
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [in] validation_algorithm - Validation algorithm enumeration
+     * @return hICN error code
+     */
+  int (*set_validation_algorithm) (hicn_type_t type, hicn_protocol_t * h,
+                 uint8_t validation_algorithm);
+
+    /**
+     * @brief Gets the signature validation algorithm
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [out] validation_algorithm - Retrieved validation_algorithm
+     * @return hICN error code
+     */
+  int (*get_validation_algorithm) (hicn_type_t type, const hicn_protocol_t * h,
+                 uint8_t *validation_algorithm);
+
+    /**
+     * @brief Sets the key id
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [in] key_id - Key id first byte address
+     * @return hICN error code
+     */
+  int (*set_key_id) (hicn_type_t type, hicn_protocol_t * h,
+                 uint8_t *key_id);
+
+    /**
+     * @brief Gets the key id
+     * @param [in] type - hICN packet type
+     * @param [in,out] h - Buffer holding the Interest or Data packet
+     * @param [out] key_id - Retrieved key id first byte address
+     * @return hICN error code
+     */
+  int (*get_key_id) (hicn_type_t type, hicn_protocol_t * h,
+                 uint8_t **key_id, uint8_t *key_id_size);
+
+} hicn_ops_t;
+
+#define DECLARE_HICN_OPS(protocol)                                              \
+    const hicn_ops_t hicn_ops_ ## protocol = {                                  \
+        .init_packet_header       = protocol ## _init_packet_header,            \
+        .get_interest_locator     = protocol ## _get_interest_locator,          \
+        .set_interest_locator     = protocol ## _set_interest_locator,          \
+        .get_interest_name        = protocol ## _get_interest_name,             \
+        .set_interest_name        = protocol ## _set_interest_name,             \
+        .get_interest_name_suffix = protocol ## _get_interest_name_suffix,      \
+        .set_interest_name_suffix = protocol ## _set_interest_name_suffix,      \
+        .reset_interest_for_hash  = protocol ## _reset_interest_for_hash,       \
+        .get_data_locator         = protocol ## _get_data_locator,              \
+        .set_data_locator         = protocol ## _set_data_locator,              \
+        .get_data_name            = protocol ## _get_data_name,                 \
+        .set_data_name            = protocol ## _set_data_name,                 \
+        .get_data_name_suffix     = protocol ## _get_data_name_suffix,          \
+        .set_data_name_suffix     = protocol ## _set_data_name_suffix,          \
+        .get_data_pathlabel       = protocol ## _get_data_pathlabel,            \
+        .set_data_pathlabel       = protocol ## _set_data_pathlabel,            \
+        .update_data_pathlabel    = protocol ## _update_data_pathlabel,         \
+        .reset_data_for_hash      = protocol ## _reset_data_for_hash,           \
+        .get_lifetime             = protocol ## _get_lifetime,                  \
+        .set_lifetime             = protocol ## _set_lifetime,                  \
+        .update_checksums         = protocol ## _update_checksums,              \
+        .verify_checksums         = protocol ## _verify_checksums,              \
+        .rewrite_interest         = protocol ## _rewrite_interest,              \
+        .rewrite_data             = protocol ## _rewrite_data,                  \
+        .get_length               = protocol ## _get_length,                    \
+        .get_current_header_length= protocol ## _get_current_header_length,     \
+        .get_header_length        = protocol ## _get_header_length,             \
+        .get_payload_length       = protocol ## _get_payload_length,            \
+        .set_payload_length       = protocol ## _set_payload_length,            \
+        .get_signature_size       = protocol ## _get_signature_size,            \
+        .set_signature_size       = protocol ## _set_signature_size,            \
+        .set_signature_timestamp  = protocol ## _set_signature_timestamp,       \
+        .get_signature_timestamp  = protocol ## _get_signature_timestamp,       \
+        .set_validation_algorithm = protocol ## _set_validation_algorithm,      \
+        .get_validation_algorithm = protocol ## _get_validation_algorithm,      \
+        .set_key_id               = protocol ## _set_key_id,                    \
+        .get_key_id               = protocol ## _get_key_id,                    \
+    }
+
+/**
+ * @brief Protocol-independent packet operations VFT
+ * NOTE: The following declarations should be kept in order
+ */
+extern const hicn_ops_t *const hicn_ops_vft[];
+
+/*
+ * Helpers for writing recursive protocol operations on packet headers
+ *
+ * NOTE : we cannot use a shift operation as IPPROTO_NONE != 0 (and 0 is IPv4...)
+ */
+always_inline hicn_type_t
+TYPE_POP (hicn_type_t type)
+{
+  return (hicn_type_t)
+  {
+    {
+    .l1 = type.l2,.l2 = type.l3,.l3 = type.l4,.l4 = IPPROTO_NONE,}
+  };
+}
+
+always_inline hicn_protocol_t *
+PAYLOAD (hicn_type_t type, const hicn_protocol_t * h)
+{
+  size_t header_length;
+  int rc = hicn_ops_vft[type.l1]->get_current_header_length (type, h,
+							     &header_length);
+  if (rc < 0)
+    return NULL;
+  return (hicn_protocol_t *) ((u8 *) h + header_length);
+}
+
+#define CHILD_OPS(f, type, h, ...) (hicn_ops_vft[type.l2]->f(TYPE_POP(type), PAYLOAD(type, h), ## __VA_ARGS__))
+
+/** Shortcuts to entry points in VFT */
+#define HICN_OPS4 hicn_ops_vft[IPPROTO_IP]
+#define HICN_OPS6 hicn_ops_vft[IPPROTO_IPV6]
+
+/* Helpers for simple declarations */
+
+#define DECLARE_init_packet_header(protocol, error) \
+    int protocol ## _init_packet_header(hicn_type_t type, hicn_protocol_t * h) { return HICN_LIB_ERROR_ ## error ; }
+
+#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) { 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) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_interest_name(protocol, error) \
+    int protocol ## _get_interest_name(hicn_type_t type, const hicn_protocol_t * h, hicn_name_t * name) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_interest_name(protocol, error) \
+    int protocol ## _set_interest_name(hicn_type_t type, hicn_protocol_t * h, const hicn_name_t * name) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_interest_name_suffix(protocol, error) \
+    int protocol ## _get_interest_name_suffix(hicn_type_t type, const hicn_protocol_t * h, hicn_name_suffix_t * suffix) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_interest_name_suffix(protocol, error) \
+    int protocol ## _set_interest_name_suffix(hicn_type_t type, hicn_protocol_t * h, const hicn_name_suffix_t * suffix) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_reset_interest_for_hash(protocol, error) \
+    int protocol ## _reset_interest_for_hash(hicn_type_t type, hicn_protocol_t * h) { return HICN_LIB_ERROR_ ## error ; }
+
+#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) { 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) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_data_name(protocol, error) \
+    int protocol ## _get_data_name(hicn_type_t type, const hicn_protocol_t * h, hicn_name_t * name) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_data_name(protocol, error) \
+    int protocol ## _set_data_name(hicn_type_t type, hicn_protocol_t * h, const hicn_name_t * name) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_data_name_suffix(protocol, error) \
+    int protocol ## _get_data_name_suffix(hicn_type_t type, const hicn_protocol_t * h, hicn_name_suffix_t * suffix) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_data_name_suffix(protocol, error) \
+    int protocol ## _set_data_name_suffix(hicn_type_t type, hicn_protocol_t * h, const hicn_name_suffix_t * suffix) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_data_pathlabel(protocol, error) \
+    int protocol ## _get_data_pathlabel(hicn_type_t type, const hicn_protocol_t * h, u32 * pathlabel) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_data_pathlabel(protocol, error) \
+    int protocol ## _set_data_pathlabel(hicn_type_t type, hicn_protocol_t * h, const u32 pathlabel) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_update_data_pathlabel(protocol, error) \
+    int protocol ## _update_data_pathlabel(hicn_type_t type, hicn_protocol_t * h, const hicn_faceid_t face_id) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_reset_data_for_hash(protocol, error) \
+    int protocol ## _reset_data_for_hash(hicn_type_t type, hicn_protocol_t * h) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_lifetime(protocol, error) \
+    int protocol ## _get_lifetime(hicn_type_t type, const hicn_protocol_t * h, hicn_lifetime_t * lifetime) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_lifetime(protocol, error) \
+    int protocol ## _set_lifetime(hicn_type_t type, hicn_protocol_t * h, const hicn_lifetime_t lifetime) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_update_checksums(protocol, error) \
+    int protocol ## _update_checksums(hicn_type_t type, hicn_protocol_t * h, u16 partial_csum, size_t payload_length) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_verify_checksums(protocol, error) \
+    int protocol ## _verify_checksums(hicn_type_t type, hicn_protocol_t * h, u16 partial_csum, size_t payload_length) { return HICN_LIB_ERROR_ ## error ; }
+
+#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) { 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) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_length(protocol, error) \
+    int protocol ## _get_length(hicn_type_t type, const hicn_protocol_t * h, size_t * length) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_current_header_length(protocol, error) \
+    int protocol ## _get_current_header_length(hicn_type_t type, const hicn_protocol_t * h, size_t * header_length) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_header_length(protocol, error) \
+    int protocol ## _get_header_length(hicn_type_t type, const hicn_protocol_t * h, size_t * header_length) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_payload_length(protocol, error) \
+    int protocol ## _get_payload_length(hicn_type_t type, const hicn_protocol_t * h, size_t * payload_length) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_payload_length(protocol, error) \
+    int protocol ## _set_payload_length(hicn_type_t type, hicn_protocol_t * h, size_t payload_length) { 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) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_signature_size(protocol, error) \
+    int protocol ## _set_signature_size(hicn_type_t type, hicn_protocol_t * h, size_t signature_size) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_signature_timestamp(protocol, error) \
+    int protocol ## _set_signature_timestamp(hicn_type_t type, hicn_protocol_t * h, uint64_t signature_timestamp) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_signature_timestamp(protocol, error) \
+    int protocol ## _get_signature_timestamp(hicn_type_t type, const hicn_protocol_t * h, uint64_t * signature_timestamp) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_validation_algorithm(protocol, error) \
+    int protocol ## _set_validation_algorithm(hicn_type_t type, hicn_protocol_t * h, uint8_t validation_algorithm) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_validation_algorithm(protocol, error) \
+    int protocol ## _get_validation_algorithm(hicn_type_t type, const hicn_protocol_t * h, uint8_t * validation_algorithm) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_set_key_id(protocol, error) \
+    int protocol ## _set_key_id(hicn_type_t type, hicn_protocol_t * h, uint8_t * key_id) { return HICN_LIB_ERROR_ ## error ; }
+
+#define DECLARE_get_key_id(protocol, error) \
+    int protocol ## _get_key_id(hicn_type_t type, hicn_protocol_t * h, uint8_t ** key_id, uint8_t *key_id_size) { return HICN_LIB_ERROR_ ## error ; }
+
+#endif /* HICN_OPS_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol.h b/lib/src/protocol.h
new file mode 100755
index 000000000..a97cc99cf
--- /dev/null
+++ b/lib/src/protocol.h
@@ -0,0 +1,51 @@
+/*
+ * 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 protocol.h
+ * @brief Protocol header definitions
+ */
+#ifndef HICN_PROTOCOL_H
+#define HICN_PROTOCOL_H
+
+#include "protocol/ah.h"
+#include "protocol/ipv4.h"
+#include "protocol/ipv6.h"
+#include "protocol/icmp.h"
+#include "protocol/icmprd.h"
+#include "protocol/tcp.h"
+#include "protocol/udp.h"
+
+typedef union
+{
+  _ipv4_header_t ipv4;
+  _ipv6_header_t ipv6;
+  _tcp_header_t tcp;
+  _udp_header_t udp;
+  _icmp_header_t icmp;
+  _icmprd_header_t icmprd;
+  _ah_header_t ah;
+  void *bytes;
+} hicn_protocol_t;
+
+#endif /* HICN_PROTOCOL_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ah.c b/lib/src/protocol/ah.c
new file mode 100755
index 000000000..f9ddf7775
--- /dev/null
+++ b/lib/src/protocol/ah.c
@@ -0,0 +1,211 @@
+/*
+ * 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 protocol/ah.c
+ * @brief hICN operations for AH header
+ */
+
+#include <string.h>		// memcpy
+#include "../common.h"
+#include "../error.h"
+#include "../header.h"
+#include "../ops.h"
+#include "ah.h"
+
+DECLARE_get_interest_locator (ah, UNEXPECTED);
+DECLARE_set_interest_locator (ah, UNEXPECTED);
+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_get_data_locator (ah, UNEXPECTED);
+DECLARE_set_data_locator (ah, UNEXPECTED);
+DECLARE_get_data_name (ah, UNEXPECTED);
+DECLARE_set_data_name (ah, UNEXPECTED);
+DECLARE_get_data_name_suffix (ah, UNEXPECTED);
+DECLARE_set_data_name_suffix (ah, UNEXPECTED);
+DECLARE_get_data_pathlabel (ah, UNEXPECTED);
+DECLARE_set_data_pathlabel (ah, UNEXPECTED);
+DECLARE_update_data_pathlabel (ah, UNEXPECTED);
+DECLARE_get_lifetime (ah, UNEXPECTED);
+DECLARE_set_lifetime (ah, UNEXPECTED);
+DECLARE_get_payload_length (ah, UNEXPECTED);
+DECLARE_set_payload_length (ah, UNEXPECTED);
+
+int
+ah_init_packet_header (hicn_type_t type, hicn_protocol_t * h)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+}
+
+int
+ah_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  size_t signature_size;
+  int rc =
+    hicn_ops_vft[type.l1]->get_signature_size (type, h, &signature_size);
+  if (rc < 0)
+    return rc;
+  memset (&(h->ah.validationPayload), 0, signature_size);
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+ah_reset_data_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  size_t signature_size;
+  int rc =
+    hicn_ops_vft[type.l1]->get_signature_size (type, h, &signature_size);
+  if (rc < 0)
+    return rc;
+  memset (&(h->ah.validationPayload), 0, signature_size);
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+ah_update_checksums (hicn_type_t type, hicn_protocol_t * h, u16 partial_csum,
+		     size_t payload_length)
+{
+  /* Nothing to do as there is no checksum in AH */
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_verify_checksums (hicn_type_t type, hicn_protocol_t * h, u16 partial_csum,
+		     size_t payload_length)
+{
+  /* Nothing to do as there is no checksum in AH */
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_rewrite_interest (hicn_type_t type, hicn_protocol_t * h,
+		     const ip46_address_t * addr_new,
+		     ip46_address_t * addr_old)
+{
+  /* Nothing to do on signature */
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_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)
+{
+  /* Nothing to do on signature */
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_get_length (hicn_type_t type, const hicn_protocol_t * h, size_t * length)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+}
+
+int
+ah_get_current_header_length (hicn_type_t type, const hicn_protocol_t * h,
+			      size_t * header_length)
+{
+  *header_length = AH_HDRLEN + (h->ah.payloadlen << 2);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_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 = AH_HDRLEN + (h->ah.payloadlen << 2) + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_get_signature_size (hicn_type_t type, const hicn_protocol_t * h,
+		       size_t * signature_size)
+{
+  *signature_size = h->ah.payloadlen << 2;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_set_signature_size (hicn_type_t type, hicn_protocol_t * h,
+		       const size_t signature_size)
+{
+  h->ah.payloadlen = signature_size >> 2;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_set_signature_timestamp(hicn_type_t type, hicn_protocol_t * h,
+       uint64_t signature_timestamp)
+{
+  h->ah.timestamp_as_u64 = signature_timestamp;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_get_signature_timestamp (hicn_type_t type, const hicn_protocol_t * h,
+       uint64_t * signature_timestamp)
+{
+  *signature_timestamp = h->ah.timestamp_as_u64;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_set_validation_algorithm (hicn_type_t type, hicn_protocol_t * h,
+       uint8_t validation_algorithm)
+{
+  h->ah.validationAlgorithm = validation_algorithm;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_get_validation_algorithm (hicn_type_t type, const hicn_protocol_t * h,
+       uint8_t * validation_algorithm)
+{
+  *validation_algorithm = h->ah.validationAlgorithm;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_set_key_id (hicn_type_t type, hicn_protocol_t * h,
+       uint8_t *key_id)
+{
+  memcpy(h->ah.keyId, key_id, sizeof(h->ah.keyId));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ah_get_key_id (hicn_type_t type, hicn_protocol_t * h,
+       uint8_t **key_id, uint8_t *key_id_size)
+{
+  *key_id = h->ah.keyId;
+  *key_id_size = sizeof(h->ah.keyId);
+  return HICN_LIB_ERROR_NONE;
+}
+
+DECLARE_HICN_OPS (ah);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ah.h b/lib/src/protocol/ah.h
new file mode 100755
index 000000000..0b4171135
--- /dev/null
+++ b/lib/src/protocol/ah.h
@@ -0,0 +1,72 @@
+/*
+ * 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 protocol/ah.h
+ * @brief AH packet header
+ */
+#ifndef HICN_PROTOCOL_AH_H
+#define HICN_PROTOCOL_AH_H
+
+/*
+ * The TCP PSH flag is set to indicate TCP payload in fact contains a AH header
+ * with signature information for the packet
+ */
+#define AH_FLAG 0x10
+
+typedef struct
+{
+  u8 nh;			// (to match with reserved in IPSEC AH)
+  u8 payloadlen;		// Len of signature/HMAC in 4-bytes words
+  union
+  {
+    u16 reserved;
+    struct
+    {
+      u8 validationAlgorithm;	// As defined in parc_SignerAlgorithm.h
+      u8 unused;		// Unused (to match with reserved in IPSEC AH)
+    };
+  };
+  union
+  {
+    struct
+    {
+      u32 spi;
+      u32 seq;
+    };
+    union
+    {
+      u8 timestamp_as_u8[8];
+      u64 timestamp_as_u64;
+    }; // Unix timestamp indicating when the signature has been calculated
+
+  };
+  // ICV would follow
+  u8 keyId[32];			// Hash of the pub key
+  /* 44 B + validationPayload */
+  u8 validationPayload[0];	// Holds the signature
+} _ah_header_t;
+
+#define AH_HDRLEN sizeof(_ah_header_t)
+
+#endif /* HICN_PROTOCOL_AH_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/icmp.c b/lib/src/protocol/icmp.c
new file mode 100755
index 000000000..44b646fb2
--- /dev/null
+++ b/lib/src/protocol/icmp.c
@@ -0,0 +1,229 @@
+/*
+ * 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 <string.h>
+#include "icmp.h"
+
+#include "../error.h"
+#include "../ops.h"
+
+DECLARE_get_interest_locator (icmp, UNEXPECTED)
+DECLARE_set_interest_locator (icmp, UNEXPECTED)
+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_get_data_locator (icmp, UNEXPECTED)
+DECLARE_set_data_locator (icmp, UNEXPECTED)
+DECLARE_get_data_name (icmp, UNEXPECTED)
+DECLARE_set_data_name (icmp, UNEXPECTED)
+DECLARE_get_data_name_suffix (icmp, UNEXPECTED)
+DECLARE_set_data_name_suffix (icmp, UNEXPECTED)
+DECLARE_get_data_pathlabel (icmp, UNEXPECTED)
+DECLARE_set_data_pathlabel (icmp, UNEXPECTED)
+DECLARE_update_data_pathlabel (icmp, UNEXPECTED)
+DECLARE_get_lifetime (icmp, UNEXPECTED)
+DECLARE_set_lifetime (icmp, UNEXPECTED)
+DECLARE_get_length (icmp, UNEXPECTED)
+DECLARE_get_payload_length (icmp, UNEXPECTED)
+DECLARE_set_payload_length (icmp, UNEXPECTED)
+     int icmp_init_packet_header (hicn_type_t type, hicn_protocol_t * h)
+{
+  h->icmp = (_icmp_header_t)
+  {
+  .type = 0,.code = 0,.csum = 0,};
+
+  return HICN_LIB_ERROR_NONE;	// CHILD_OPS(init_packet_header, type, h->icmp);
+}
+
+int
+icmp_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  h->icmp.csum = 0;
+
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+icmp_reset_data_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  h->icmp.csum = 0;
+
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+int
+icmp_update_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+//    h->icmp.csum = 0;
+//    h->icmp.csum = csum(h->bytes, TCP_HDRLEN + payload_length, ~partial_csum);
+//
+//    return CHILD_OPS(update_checksums, type, h->icmp, 0, payload_length);
+}
+
+int
+icmp_verify_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+//    if (csum(h->bytes, TCP_HDRLEN + payload_length, ~partial_csum) != 0)
+//        return HICN_LIB_ERROR_CORRUPTED_PACKET;
+//    return CHILD_OPS(verify_checksums, type, h->icmp, 0, payload_length);
+}
+
+int
+icmp_rewrite_interest (hicn_type_t type, hicn_protocol_t * h,
+		       const ip46_address_t * addr_new,
+		       ip46_address_t * addr_old)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+//    u16 *icmp_checksum = &(h->icmp.csum);
+//
+//    /*
+//     * Padding fields are set to zero so we can apply checksum on the
+//     * whole struct by interpreting it as IPv6 in all cases
+//     *
+//     * v4 code would be:
+//     * csum = ip_csum_sub_even (*icmp_checksum, h->ipv4.saddr.as_u32);
+//     * csum = ip_csum_add_even (csum, h->ipv4.saddr.as_u32);
+//     */
+//    u16 csum = ip_csum_sub_even (*icmp_checksum, h->ipv6.saddr.as_u64[0]);
+//    csum = ip_csum_sub_even (csum, h->ipv6.saddr.as_u64[1]);
+//    csum = ip_csum_add_even (csum, h->ipv6.saddr.as_u64[0]);
+//    csum = ip_csum_add_even (csum, h->ipv6.saddr.as_u64[1]);
+//
+//    *icmp_checksum = ip_csum_fold (csum);
+//
+//    return HICN_LIB_ERROR_NONE;
+}
+
+int
+icmp_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)
+{
+  return HICN_LIB_ERROR_NOT_IMPLEMENTED;
+//    u16 *icmp_checksum = &(h->icmp.csum);
+//
+//    /*
+//     * Padding fields are set to zero so we can apply checksum on the
+//     * whole struct by interpreting it as IPv6 in all cases
+//     *
+//     * v4 code would be:
+//     * csum = ip_csum_sub_even (*icmp_checksum, h->ipv4.saddr.as_u32);
+//     * csum = ip_csum_add_even (csum, h->ipv4.saddr.as_u32);
+//     */
+//    u16 csum = ip_csum_sub_even (*icmp_checksum, addr_old->ip6.as_u64[0]);
+//    csum = ip_csum_sub_even (*icmp_checksum, addr_old->ip6.as_u64[1]);
+//    csum = ip_csum_add_even (csum, addr_new->ip6.as_u64[0]);
+//    csum = ip_csum_add_even (csum, addr_new->ip6.as_u64[1]);
+//
+//    csum = ip_csum_sub_even (csum, h->icmp.pathlabel);
+//    icmp_update_data_pathlabel(type, h, face_id);
+//    csum = ip_csum_add_even (csum, h->icmp.pathlabel);
+//
+//    *icmp_checksum = ip_csum_fold (csum);
+//
+//    return HICN_LIB_ERROR_NONE;
+}
+
+int
+icmp_get_current_header_length (hicn_type_t type, const hicn_protocol_t * h,
+				size_t * header_length)
+{
+  *header_length = ICMP_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+icmp_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 = ICMP_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+icmp_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
+icmp_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
+icmp_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
+icmp_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
+icmp_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
+icmp_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
+icmp_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
+icmp_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);
+}
+
+DECLARE_HICN_OPS (icmp);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/icmp.h b/lib/src/protocol/icmp.h
new file mode 100755
index 000000000..5a84995b6
--- /dev/null
+++ b/lib/src/protocol/icmp.h
@@ -0,0 +1,68 @@
+/*
+ * 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 protocol/icmp.h
+ * @brief ICMP packet header
+ */
+#ifndef HICN_PROTOCOL_ICMP_H
+#define HICN_PROTOCOL_ICMP_H
+
+#include "../common.h"
+
+typedef struct
+{
+  u8 type;
+  u8 code;
+  u16 csum;
+} _icmp_header_t;
+
+typedef struct
+{
+  u8 type;
+  u8 code;
+  u16 csum;
+  union
+  {
+    struct
+    {
+      u16 id;
+      u16 sequence;
+    } echo;			/* echo datagram */
+    u32 gateway;		/* gateway address */
+    struct
+    {
+      u16 _unused;
+      u16 mtu;
+    } frag;			/* path mtu discovery */
+    struct
+    {
+      u16 expected_lbl;
+      u16 received_lbl;
+    } wldr_notification_lbl;
+  };
+} _icmp_wldr_header_t;
+
+#define ICMP_HDRLEN sizeof(_icmp_header_t)
+
+#endif /* HICN_PROTOCOL_ICMP_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/icmprd.h b/lib/src/protocol/icmprd.h
new file mode 100755
index 000000000..c2f27d673
--- /dev/null
+++ b/lib/src/protocol/icmprd.h
@@ -0,0 +1,47 @@
+/*
+ * 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 protocol/icmp-rd.c
+ * @brief hICN operations for ICMP Redirect header
+ */
+#ifndef HICN_PROTOCOL_ICMPRD_H
+#define HICN_PROTOCOL_ICMPRD_H
+
+#include "../common.h"
+
+typedef struct __attribute__ ((__packed__))
+{
+  ip4_address_t ip;
+  _ipv4_header_t iph;
+  u8 data[64];
+} _icmprd4_header_t;
+
+typedef struct __attribute__ ((__packed__))
+{
+  u32 res;
+  ip6_address_t tgt;
+  ip6_address_t dst;
+} _icmprd_header_t;
+
+#endif /* HICN_PROTOCOL_ICMPRD_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ipv4.c b/lib/src/protocol/ipv4.c
new file mode 100755
index 000000000..7c6af127d
--- /dev/null
+++ b/lib/src/protocol/ipv4.c
@@ -0,0 +1,452 @@
+/*
+ * 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 protocol/ipv4.c
+ * @brief hICN operations for IPv4 header
+ *
+ * NOTE: IPv4 options (affecting the header size) are currently not supported.
+ */
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../error.h"
+#include "../ops.h"
+#include "../common.h"
+#include "../header.h"
+
+#include "ipv4.h"
+
+int ipv4_get_payload_length (hicn_type_t type, const hicn_protocol_t * h,
+			     size_t * payload_length);
+
+int
+ipv4_init_packet_header (hicn_type_t type, hicn_protocol_t * h)
+{
+  size_t total_header_length;
+  int rc =
+    hicn_ops_vft[type.l1]->get_header_length (type, h, &total_header_length);
+  if (rc < 0)
+    return rc;
+
+  h->ipv4 = (_ipv4_header_t)
+  {
+  .version_ihl =
+      (IPV4_DEFAULT_VERSION << 4) | (0x0f & IPV4_DEFAULT_IHL),.tos =
+      IPV4_DEFAULT_TOS,.len = htons ((u16) total_header_length),.id =
+      htons (IPV4_DEFAULT_ID),.frag_off =
+      htons (IPV4_DEFAULT_FRAG_OFF),.ttl = HICN_DEFAULT_TTL,.protocol =
+      type.l2,.csum = 0,.saddr.as_u32 = 0,.daddr.as_u32 = 0,};
+
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+ipv4_get_interest_locator (hicn_type_t type, const hicn_protocol_t * h,
+			   ip46_address_t * ip_address)
+{
+  ip_address->ip4 = 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)
+{
+  h->ipv4.saddr = ip_address->ip4;
+  return HICN_LIB_ERROR_NONE;
+}
+
+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));
+}
+
+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));
+}
+
+int
+ipv4_get_interest_name_suffix (hicn_type_t type, const hicn_protocol_t * h,
+			       hicn_name_suffix_t * suffix)
+{
+  return CHILD_OPS (set_interest_name_suffix, type, h, suffix);
+}
+
+int
+ipv4_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
+ipv4_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  /* Sets everything to 0 up to IP destination address */
+  memset (&(h->ipv4), 0, 16);
+
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+ipv4_get_data_locator (hicn_type_t type, const hicn_protocol_t * h,
+		       ip46_address_t * ip_address)
+{
+  ip_address->ip4 = 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)
+{
+  h->ipv4.daddr = ip_address->ip4;
+  return HICN_LIB_ERROR_NONE;
+}
+
+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));
+}
+
+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));
+}
+
+int
+ipv4_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
+ipv4_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
+ipv4_get_data_pathlabel (hicn_type_t type, const hicn_protocol_t * h,
+			 u32 * pathlabel)
+{
+  return CHILD_OPS (get_data_pathlabel, type, h, pathlabel);
+}
+
+int
+ipv4_set_data_pathlabel (hicn_type_t type, hicn_protocol_t * h,
+			 const u32 pathlabel)
+{
+  return CHILD_OPS (set_data_pathlabel, type, h, pathlabel);
+}
+
+int
+ipv4_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
+ipv4_reset_data_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  /* Sets everything to 0 up to source address */
+  memset (&h->ipv4, 0, 12);
+  /* Clears destination address */
+  memset (&(h->ipv4.daddr), 0, 4);
+
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+int
+ipv4_get_lifetime (hicn_type_t type, const hicn_protocol_t * h,
+		   hicn_lifetime_t * lifetime)
+{
+  return CHILD_OPS (get_lifetime, type, h, lifetime);
+}
+
+int
+ipv4_set_lifetime (hicn_type_t type, hicn_protocol_t * h,
+		   const hicn_lifetime_t lifetime)
+{
+  return CHILD_OPS (set_lifetime, type, h, lifetime);
+}
+
+int
+ipv4_update_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  /*
+   * Checksum field is not accounted for in lower layers, so we can compute
+   * them in any order. Note that it is only a header checksum.
+   */
+  h->ipv4.csum = 0;
+  h->ipv4.csum = csum (h, IPV4_HDRLEN, 0);
+
+  /* Retrieve payload length if not specified, as it is not available later */
+  if (payload_length == 0)
+    {
+      int rc = ipv4_get_payload_length (type, h, &payload_length);
+      if (rc < 0)
+	return rc;
+    }
+
+  /* Ignore the payload if payload_length = ~0 */
+  if (payload_length == ~0)
+    {
+      payload_length = 0;
+    }
+
+  /* Build pseudo-header */
+  ipv4_pseudo_header_t psh;
+  psh.ip_src = h->ipv4.saddr;
+  psh.ip_dst = h->ipv4.daddr;
+  /* Size is u32 and not u16, we cannot copy and need to care about endianness */
+  psh.size = htons (ntohs (h->ipv4.len) - (u16) IPV4_HDRLEN);
+  psh.zero = 0;
+  psh.protocol = (u8) h->ipv4.protocol;
+
+  /* Compute partial checksum based on pseudo-header */
+  if (partial_csum != 0)
+    {
+      partial_csum = ~partial_csum;
+    }
+  partial_csum = csum (&psh, IPV4_PSHDRLEN, partial_csum);
+
+  return CHILD_OPS (update_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+ipv4_verify_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  /*
+   * Checksum field is not accounted for in lower layers, so we can compute
+   * them in any order. Note that it is only a header checksum.
+   */
+  if (csum (h, IPV4_HDRLEN, 0) != 0)
+    return HICN_LIB_ERROR_CORRUPTED_PACKET;
+
+  /* Retrieve payload length if not specified, as it is not available later */
+  if (payload_length == 0)
+    {
+      int rc = ipv4_get_payload_length (type, h, &payload_length);
+      if (rc < 0)
+	return rc;
+    }
+
+  /* Build pseudo-header */
+  ipv4_pseudo_header_t psh;
+  psh.ip_src = h->ipv4.saddr;
+  psh.ip_dst = h->ipv4.daddr;
+  /* Size is u32 and not u16, we cannot copy and need to care about endianness */
+  psh.size = htons (ntohs (h->ipv4.len) - (u16) IPV4_HDRLEN);
+  psh.zero = 0;
+  psh.protocol = (u8) h->ipv4.protocol;
+
+  /* Compute partial checksum based on pseudo-header */
+  partial_csum = csum (&psh, IPV4_PSHDRLEN, 0);
+
+  return CHILD_OPS (update_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+ipv4_rewrite_interest (hicn_type_t type, hicn_protocol_t * h,
+		       const ip46_address_t * addr_new,
+		       ip46_address_t * addr_old)
+{
+  // ASSERT(addr_old == NULL);
+  addr_old->ip4 = 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.csum = 0;
+  h->ipv4.csum = csum (&h->ipv4, IPV4_HDRLEN, 0);
+
+  return CHILD_OPS (rewrite_interest, type, h, addr_new, addr_old);
+}
+
+int
+ipv4_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)
+{
+  // ASSERT(addr_old == NULL);
+  addr_old->ip4 = 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.csum = 0;
+  h->ipv4.csum = csum (&h->ipv4, IPV4_HDRLEN, 0);
+
+  return CHILD_OPS (rewrite_data, type, h, addr_new, addr_old, face_id);
+}
+
+int
+ipv4_get_current_length (hicn_type_t type, const hicn_protocol_t * h,
+			 size_t * header_length)
+{
+  *header_length = IPV4_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_get_length (hicn_type_t type, const hicn_protocol_t * h,
+		 size_t * header_length)
+{
+  *header_length = h->ipv4.len;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_get_current_header_length (hicn_type_t type, const hicn_protocol_t * h,
+				size_t * header_length)
+{
+  *header_length = IPV4_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_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 = IPV4_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_get_payload_length (hicn_type_t type, const hicn_protocol_t * h,
+			 size_t * payload_length)
+{
+  size_t child_header_length;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  *payload_length = htons (h->ipv4.len) - IPV4_HDRLEN - child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_set_payload_length (hicn_type_t type, hicn_protocol_t * h,
+			 size_t payload_length)
+{
+  size_t child_header_length;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  h->ipv4.len = htons (payload_length + IPV4_HDRLEN + child_header_length);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv4_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
+ipv4_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
+ipv4_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
+ipv4_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
+ipv4_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
+ipv4_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
+ipv4_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
+ipv4_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);
+}
+
+DECLARE_HICN_OPS (ipv4);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ipv4.h b/lib/src/protocol/ipv4.h
new file mode 100755
index 000000000..c57485b6c
--- /dev/null
+++ b/lib/src/protocol/ipv4.h
@@ -0,0 +1,91 @@
+/*
+ * 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 HICN_PROTOCOL_IPV4
+#define HICN_PROTOCOL_IPV4
+
+#include "../base.h"
+#include "../common.h"
+#include "../protocol.h"
+
+/* Headers were adapted from linux' definitions in netinet/ip.h */
+
+typedef struct
+{
+  union
+  {
+    struct
+    {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+      u8 ihl:4;
+      u8 version:4;
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+      u8 version:4;
+      u8 ihl:4;
+#else
+#error "Unsupported endianness"
+#endif
+    };
+
+    u8 version_ihl;
+  };
+  u8 tos;
+  u16 len;
+  u16 id;
+  u16 frag_off;
+  u8 ttl;
+  u8 protocol;
+  u16 csum;
+  ip4_address_t saddr;
+  ip4_address_t daddr;
+} _ipv4_header_t;
+
+#define ipv4_header_bytes(ipv4_header) (sizeof(u32) * (ipv4_header->version_ihl & 0xf))
+
+#define IPV4_HDRLEN sizeof(_ipv4_header_t)
+
+typedef struct
+{
+  ip4_address_t ip_src;
+  ip4_address_t ip_dst;
+  u8 zero;
+  u8 protocol;
+  u16 size;
+} ipv4_pseudo_header_t;
+
+#define IPV4_PSHDRLEN sizeof(ipv4_pseudo_header_t)
+
+/* 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
+
+
+#endif /* HICN_PROTOCOL_IPV4 */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ipv6.c b/lib/src/protocol/ipv6.c
new file mode 100755
index 000000000..41b00ec92
--- /dev/null
+++ b/lib/src/protocol/ipv6.c
@@ -0,0 +1,412 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "../common.h"
+#include "../error.h"
+#include "../ops.h"
+
+int
+ipv6_get_payload_length (hicn_type_t type, const hicn_protocol_t * h,
+			 size_t * payload_length);
+
+int
+ipv6_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->ipv6 = (_ipv6_header_t)
+  {
+    .saddr = {{ 0 }}
+    ,.daddr = {{ 0 }}
+    ,.version_class_flow = htonl ((IPV6_DEFAULT_VERSION << 28) |
+				  (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |
+				  (IPV6_DEFAULT_FLOW_LABEL & 0xfffff)),
+    .len = htons ((u16) total_header_length),
+    .nxt = type.l2,
+    .hlim = HICN_DEFAULT_TTL,
+  };
+  /* *INDENT-ON* */
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+ipv6_get_interest_locator (hicn_type_t type, const hicn_protocol_t * h,
+			   ip46_address_t * ip_address)
+{
+  ip_address->ip6 = 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)
+{
+  h->ipv6.saddr = ip_address->ip6;
+  return HICN_LIB_ERROR_NONE;
+}
+
+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));
+}
+
+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));
+}
+
+int
+ipv6_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
+ipv6_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
+ipv6_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  /* Sets everything to 0 up to IP destination address */
+  memset (&(h->ipv6), 0, 24);
+
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+ipv6_get_data_locator (hicn_type_t type, const hicn_protocol_t * h,
+		       ip46_address_t * ip_address)
+{
+  ip_address->ip6 = 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)
+{
+  h->ipv6.daddr = ip_address->ip6;
+  return HICN_LIB_ERROR_NONE;
+}
+
+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));
+}
+
+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));
+}
+
+int
+ipv6_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
+ipv6_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
+ipv6_get_data_pathlabel (hicn_type_t type, const hicn_protocol_t * h,
+			 u32 * pathlabel)
+{
+  return CHILD_OPS (get_data_pathlabel, type, h, pathlabel);
+}
+
+int
+ipv6_set_data_pathlabel (hicn_type_t type, hicn_protocol_t * h,
+			 const u32 pathlabel)
+{
+  return CHILD_OPS (set_data_pathlabel, type, h, pathlabel);
+}
+
+int
+ipv6_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
+ipv6_reset_data_for_hash (hicn_type_t type, hicn_protocol_t * h)
+{
+  /* IP: Set everithing to 0 up to destination address */
+  memset (&h->ipv6, 0, 8);
+  /* Clears destination address */
+  memset (&(h->ipv6.daddr), 0, 16);
+
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+int
+ipv6_get_lifetime (hicn_type_t type, const hicn_protocol_t * h,
+		   hicn_lifetime_t * lifetime)
+{
+  return CHILD_OPS (get_lifetime, type, h, lifetime);
+}
+
+int
+ipv6_set_lifetime (hicn_type_t type, hicn_protocol_t * h,
+		   const hicn_lifetime_t lifetime)
+{
+  return CHILD_OPS (set_lifetime, type, h, lifetime);
+}
+
+int
+ipv6_update_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  /* Retrieve payload length if not specified */
+  if (payload_length == 0)
+    {
+      int rc = ipv6_get_payload_length (type, h, &payload_length);
+      if (rc < 0)
+	return rc;
+    }
+
+  /* Ignore the payload if payload_length = ~0 */
+  if (payload_length == ~0)
+    {
+      payload_length = 0;
+    }
+
+  /* Build pseudo-header */
+  ipv6_pseudo_header_t psh;
+  psh.ip_src = h->ipv6.saddr;
+  psh.ip_dst = h->ipv6.daddr;
+  /* Size is u32 and not u16, we cannot copy and need to care about endianness */
+  psh.size = htonl (ntohs (h->ipv6.len));
+  psh.zeros = 0;
+  psh.zero = 0;
+  psh.protocol = h->ipv6.nxt;
+
+  /* Compute partial checksum based on pseudo-header */
+  if (partial_csum != 0)
+    {
+      partial_csum = ~partial_csum;
+    }
+  partial_csum = csum (&psh, IPV6_PSHDRLEN, partial_csum);
+
+  return CHILD_OPS (update_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+ipv6_verify_checksums (hicn_type_t type, hicn_protocol_t * h,
+		       u16 partial_csum, size_t payload_length)
+{
+  /* Retrieve payload length if not specified */
+  if (payload_length == 0)
+    {
+      int rc = ipv6_get_payload_length (type, h, &payload_length);
+      if (rc < 0)
+	return rc;
+    }
+
+  /* Build pseudo-header */
+  ipv6_pseudo_header_t pseudo;
+  pseudo.ip_src = h->ipv6.saddr;
+  pseudo.ip_dst = h->ipv6.daddr;
+  /* Size is u32 and not u16, we cannot copy and need to care about endianness */
+  pseudo.size = htonl (ntohs (h->ipv6.len));
+  pseudo.zeros = 0;
+  pseudo.zero = 0;
+  pseudo.protocol = h->ipv6.nxt;
+
+  /* Compute partial checksum based on pseudo-header */
+  partial_csum = csum (&pseudo, IPV6_PSHDRLEN, 0);
+
+  return CHILD_OPS (verify_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+ipv6_rewrite_interest (hicn_type_t type, hicn_protocol_t * h,
+		       const ip46_address_t * addr_new,
+		       ip46_address_t * addr_old)
+{
+  // ASSERT(addr_old == NULL);
+  addr_old->ip6 = h->ipv6.saddr;
+  h->ipv6.saddr = addr_new->ip6;
+
+  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 hicn_faceid_t face_id)
+{
+  // ASSERT(addr_old == NULL);
+  addr_old->ip6 = h->ipv6.daddr;
+  h->ipv6.daddr = addr_new->ip6;
+
+  return CHILD_OPS (rewrite_data, type, h, addr_new, addr_old, face_id);
+}
+
+int
+ipv6_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
+ipv6_get_current_header_length (hicn_type_t type, const hicn_protocol_t * h,
+				size_t * header_length)
+{
+  *header_length = IPV6_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv6_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 = IPV6_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv6_get_payload_length (hicn_type_t type, const hicn_protocol_t * h,
+			 size_t * payload_length)
+{
+  size_t child_header_length;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  *payload_length = ntohs (h->ipv6.len) - child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv6_set_payload_length (hicn_type_t type, hicn_protocol_t * h,
+			 size_t payload_length)
+{
+  size_t child_header_length;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  h->ipv6.len = htons (payload_length + child_header_length);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+ipv6_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
+ipv6_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
+ipv6_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
+ipv6_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
+ipv6_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
+ipv6_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
+ipv6_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
+ipv6_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);
+}
+
+DECLARE_HICN_OPS (ipv6);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/ipv6.h b/lib/src/protocol/ipv6.h
new file mode 100755
index 000000000..28a1aa47f
--- /dev/null
+++ b/lib/src/protocol/ipv6.h
@@ -0,0 +1,67 @@
+/*
+ * 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 HICN_PROTOCOL_IPV6_H
+#define HICN_PROTOCOL_IPV6_H
+
+#include "../common.h"
+
+typedef struct
+{
+  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 */
+    };
+    u8 vfc;			/* 4 bits version, top 4 bits class */
+  };
+  ip6_address_t saddr;		/* source address */
+  ip6_address_t daddr;		/* destination address */
+} _ipv6_header_t;
+
+
+#define IPV6_HDRLEN sizeof(_ipv6_header_t)
+
+typedef struct
+{
+  ip6_address_t ip_src;
+  ip6_address_t ip_dst;
+  u32 size;
+  u16 zeros;
+  u8 zero;
+  u8 protocol;
+} ipv6_pseudo_header_t;
+
+#define IPV6_PSHDRLEN sizeof(ipv6_pseudo_header_t)
+
+/* 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
+
+#endif
+
+/*
+ * 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
new file mode 100755
index 000000000..2afc4f6f4
--- /dev/null
+++ b/lib/src/protocol/tcp.c
@@ -0,0 +1,370 @@
+/*
+ * 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 <string.h>
+#include "tcp.h"
+
+#include "../error.h"
+#include "../ops.h"
+
+#define TCP_DEFAULT_SRC_PORT           0x8000
+#define TCP_DEFAULT_DST_PORT           0x0080
+#define TCP_DEFAULT_WINDOW_SIZE        0	// In [2, 65535]
+#define TCP_DEFAULT_HLEN               20
+#define TCP_DEFAULT_DATA_OFFSET_RES    (TCP_DEFAULT_HLEN >> 2) << 4
+#define TCP_DEFAULT_CWR                0
+#define TCP_DEFAULT_ECE                0
+#define TCP_DEFAULT_URG                0
+#define TCP_DEFAULT_ACK                0
+#define TCP_DEFAULT_PSH                0
+#define TCP_DEFAULT_RST                0
+#define TCP_DEFAULT_SYN                1
+#define TCP_DEFAULT_FIN                0
+
+DECLARE_get_interest_locator (tcp, UNEXPECTED);
+DECLARE_set_interest_locator (tcp, UNEXPECTED);
+DECLARE_get_interest_name (tcp, UNEXPECTED);
+DECLARE_set_interest_name (tcp, UNEXPECTED);
+DECLARE_get_data_locator (tcp, UNEXPECTED);
+DECLARE_set_data_locator (tcp, UNEXPECTED);
+DECLARE_get_data_name (tcp, UNEXPECTED);
+DECLARE_set_data_name (tcp, UNEXPECTED);
+DECLARE_get_length (tcp, UNEXPECTED);
+DECLARE_get_payload_length (tcp, UNEXPECTED);
+DECLARE_set_payload_length (tcp, UNEXPECTED);
+
+int
+tcp_init_packet_header (hicn_type_t type, hicn_protocol_t * h)
+{
+  h->tcp = (_tcp_header_t)
+  {
+  .sport = htons (TCP_DEFAULT_SRC_PORT),.dport =
+      htons (TCP_DEFAULT_DST_PORT),.seq = 0,.seq_ack =
+      0,.data_offset_and_reserved = TCP_DEFAULT_DATA_OFFSET_RES,.flags =
+      TCP_DEFAULT_CWR << 7 | TCP_DEFAULT_ECE << 6 | TCP_DEFAULT_URG << 5 |
+      TCP_DEFAULT_ACK << 4 | TCP_DEFAULT_PSH << 3 | TCP_DEFAULT_RST << 2 |
+      TCP_DEFAULT_SYN << 1 | TCP_DEFAULT_FIN << 0,.window =
+      htons (TCP_DEFAULT_WINDOW_SIZE),.csum = 0,.urg_ptr = 65000,};
+
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+tcp_get_interest_name_suffix (hicn_type_t type, const hicn_protocol_t * h,
+			      hicn_name_suffix_t * suffix)
+{
+  *suffix = ntohl (h->tcp.name_suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+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);
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+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);
+
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+
+int
+tcp_get_data_name_suffix (hicn_type_t type, const hicn_protocol_t * h,
+			  hicn_name_suffix_t * suffix)
+{
+  *suffix = ntohl (h->tcp.name_suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_set_data_name_suffix (hicn_type_t type, hicn_protocol_t * h,
+			  const hicn_name_suffix_t * suffix)
+{
+  h->tcp.name_suffix = htonl (*suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_get_data_pathlabel (hicn_type_t type, const hicn_protocol_t * h,
+			u32 * pathlabel)
+{
+  *pathlabel = h->tcp.seq_ack;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_set_data_pathlabel (hicn_type_t type, hicn_protocol_t * h,
+			const u32 pathlabel)
+{
+  h->tcp.seq_ack = pathlabel;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_update_data_pathlabel (hicn_type_t type, hicn_protocol_t * h,
+			   const hicn_faceid_t face_id)
+{
+  hicn_pathlabel_t pl =
+    (hicn_pathlabel_t) ((h->tcp.pathlabel & HICN_PATH_LABEL_MASK) >> (32 -
+								      HICN_PATH_LABEL_SIZE));
+  hicn_pathlabel_t new_pl;
+
+  update_pathlabel (pl, face_id, &new_pl);
+  h->tcp.pathlabel = new_pl;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+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);
+
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+
+int
+tcp_get_lifetime (hicn_type_t type, const hicn_protocol_t * h,
+		  hicn_lifetime_t * lifetime)
+{
+  *lifetime =
+    ntohs (h->tcp.urg_ptr) << (h->tcp.data_offset_and_reserved & 0xF);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_set_lifetime (hicn_type_t type, hicn_protocol_t * h,
+		  const hicn_lifetime_t lifetime)
+{
+  u8 multiplier = 0;
+  u32 lifetime_scaled = lifetime;
+
+  if (PREDICT_FALSE (lifetime >= HICN_MAX_LIFETIME))
+    {
+      h->tcp.urg_ptr = htons (HICN_MAX_LIFETIME_SCALED);
+      h->tcp.data_offset_and_reserved =
+	(h->
+	 tcp.data_offset_and_reserved & ~0xF) | HICN_MAX_LIFETIME_MULTIPLIER;
+      return HICN_LIB_ERROR_NONE;
+    }
+
+  while (lifetime_scaled > HICN_MAX_LIFETIME_SCALED
+	 && multiplier <= HICN_MAX_LIFETIME_MULTIPLIER)
+    {
+      multiplier++;
+      lifetime_scaled = lifetime_scaled >> 1;
+    }
+
+  h->tcp.urg_ptr = htons (lifetime_scaled);
+  h->tcp.data_offset_and_reserved =
+    (h->tcp.data_offset_and_reserved & ~0xF) | multiplier;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_update_checksums (hicn_type_t type, hicn_protocol_t * h, u16 partial_csum,
+		      size_t payload_length)
+{
+  h->tcp.csum = 0;
+
+  if (PREDICT_TRUE (partial_csum != 0))
+    {
+      partial_csum = ~partial_csum;
+    }
+
+  h->tcp.csum = csum (h, TCP_HDRLEN + payload_length, partial_csum);
+
+  return CHILD_OPS (update_checksums, type, h, 0, payload_length);
+}
+
+int
+tcp_verify_checksums (hicn_type_t type, hicn_protocol_t * h, u16 partial_csum,
+		      size_t payload_length)
+{
+  if (csum (h, TCP_HDRLEN + payload_length, ~partial_csum) != 0)
+    return HICN_LIB_ERROR_CORRUPTED_PACKET;
+  return CHILD_OPS (verify_checksums, type, h, 0, payload_length);
+}
+
+#define TCP_OFFSET_MASK                13
+#define TCP_OFFSET_DATA_OFFSET         12
+#define TCP_OFFSET_IN_BITS_DATA_OFFSET 0
+#define TCP_OFFSET_IN_BITS_RESERVED    4
+#define TCP_OFFSET_IN_BITS_NS          7
+
+#define TCP_DEFAULT_SRC_PORT           0x8000
+#define TCP_DEFAULT_DST_PORT           0x0080
+#define TCP_DEFAULT_WINDOW_SIZE        0	// In [2, 65535]
+#define TCP_DEFAULT_DATA_OFFSET        5	// Size of the TCP header in words (= 4 bytes). Must be greater or equal than 5.
+#define TCP_DEFAULT_CWR                0
+#define TCP_DEFAULT_ECE                0
+#define TCP_DEFAULT_URG                0
+#define TCP_DEFAULT_ACK                0
+#define TCP_DEFAULT_PSH                0
+#define TCP_DEFAULT_RST                0
+#define TCP_DEFAULT_SYN                1
+#define TCP_DEFAULT_FIN                0
+
+int
+tcp_rewrite_interest (hicn_type_t type, hicn_protocol_t * h,
+		      const ip46_address_t * addr_new,
+		      ip46_address_t * addr_old)
+{
+  u16 *tcp_checksum = &(h->tcp.csum);
+
+  /*
+   * Padding fields are set to zero so we can apply checksum on the
+   * whole struct by interpreting it as IPv6 in all cases
+   *
+   * v4 code would be:
+   * csum = ip_csum_sub_even (*tcp_checksum, h->ipv4.saddr.as_u32);
+   * csum = ip_csum_add_even (csum, h->ipv4.saddr.as_u32);
+   */
+  u16 csum = ip_csum_sub_even (*tcp_checksum, h->ipv6.saddr.as_u64[0]);
+  csum = ip_csum_sub_even (csum, h->ipv6.saddr.as_u64[1]);
+  csum = ip_csum_add_even (csum, h->ipv6.saddr.as_u64[0]);
+  csum = ip_csum_add_even (csum, h->ipv6.saddr.as_u64[1]);
+
+  *tcp_checksum = ip_csum_fold (csum);
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_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)
+{
+  u16 *tcp_checksum = &(h->tcp.csum);
+
+  /*
+   * Padding fields are set to zero so we can apply checksum on the
+   * whole struct by interpreting it as IPv6 in all cases
+   *
+   * v4 code would be:
+   * csum = ip_csum_sub_even (*tcp_checksum, h->ipv4.saddr.as_u32);
+   * csum = ip_csum_add_even (csum, h->ipv4.saddr.as_u32);
+   */
+  u16 csum = ip_csum_sub_even (*tcp_checksum, addr_old->ip6.as_u64[0]);
+  csum = ip_csum_sub_even (*tcp_checksum, addr_old->ip6.as_u64[1]);
+  csum = ip_csum_add_even (csum, addr_new->ip6.as_u64[0]);
+  csum = ip_csum_add_even (csum, addr_new->ip6.as_u64[1]);
+
+  csum = ip_csum_sub_even (csum, h->tcp.pathlabel);
+  tcp_update_data_pathlabel (type, h, face_id);
+  csum = ip_csum_add_even (csum, h->tcp.pathlabel);
+
+  *tcp_checksum = ip_csum_fold (csum);
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_get_current_header_length (hicn_type_t type, const hicn_protocol_t * h,
+			       size_t * header_length)
+{
+  *header_length = TCP_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_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 = TCP_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_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
+tcp_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
+tcp_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
+tcp_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
+tcp_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
+tcp_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
+tcp_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
+tcp_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);
+}
+
+DECLARE_HICN_OPS (tcp);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/tcp.h b/lib/src/protocol/tcp.h
new file mode 100755
index 000000000..68f4bf8f9
--- /dev/null
+++ b/lib/src/protocol/tcp.h
@@ -0,0 +1,166 @@
+/*
+ * 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 HICN_PROTOCOL_TCP_H
+#define HICN_PROTOCOL_TCP_H
+
+#include "../base.h"
+#include "../common.h"
+#include "../name.h"
+
+/*
+ * NOTE: bitfields are problematic for portability reasons. There are provided
+ * here for reference and documentation purposes, we might just provide a macro
+ * to disable and use it instead of __BYTE_ORDER__.
+ */
+typedef struct __attribute__ ((packed))
+{
+  u16 sport;
+  u16 dport;
+  union
+  {
+    u32 seq;
+    hicn_name_suffix_t name_suffix;
+  };
+  union
+  {
+    u32 seq_ack;
+    struct
+    {
+      hicn_pathlabel_t pathlabel;
+      u8 pad[3];
+    };
+  };
+
+  union
+  {
+    struct
+    {
+      u8 data_offset_and_reserved;
+      u8 flags;
+    };
+#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;
+    };
+    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;
+    };
+#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;
+    };
+    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;
+    };
+#endif
+  };
+  union
+  {
+    u16 window;
+    u16 ldr;
+  };
+  u16 csum;
+  union
+  {
+    u16 urg_ptr;
+    u16 lifetime;
+  };
+} _tcp_header_t;
+
+#define TCP_HDRLEN sizeof(_tcp_header_t)
+
+#ifndef HICN_VPP_PLUGIN
+
+/* 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 */
+
+enum
+{
+#define _(f) TCP_FLAG_BIT_##f,
+  foreach_tcp_flag
+#undef _
+    TCP_N_FLAG_BITS,
+};
+
+enum
+{
+#define _(f) TCP_FLAG_##f = 1 << TCP_FLAG_BIT_##f,
+  foreach_tcp_flag
+#undef _
+};
+
+#endif /* HICN_VPP_PLUGIN */
+
+// get_data_name_suffix
+// name->ip4.suffix = h->v4.tcp.seq;
+
+
+#endif /* HICN_PROTOCOL_TCP_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/udp.h b/lib/src/protocol/udp.h
new file mode 100755
index 000000000..58cd65095
--- /dev/null
+++ b/lib/src/protocol/udp.h
@@ -0,0 +1,37 @@
+/*
+ * 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 HICN_PROTOCOL_UDP_H
+#define HICN_PROTOCOL_UDP_H
+
+typedef struct
+{
+  u16 src_port;
+  u16 dst_port;
+  u16 length;
+  u16 checksum;
+} _udp_header_t;
+
+#define UDP_HDRLEN sizeof(_udp_header_t)
+
+#endif /* HICN_PROTOCOL_UDP_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */