[HICN-574] Host stack plugin for VPP.

Signed-off-by: Mauro Sardara <msardara@cisco.com>
Change-Id: I8d8fdffef31a7013265d6529c5f52f3d5ec70d18
Signed-off-by: Mauro Sardara <msardara@cisco.com>
Signed-off-by: Mauro <you@example.com>
Signed-off-by: Mauro Sardara <msardara@cisco.com>

31 files changed, 4911 insertions, 0 deletions

diff --git a/hicn-plugin/src/host_stack/FEATURE.yaml b/hicn-plugin/src/host_stack/FEATURE.yaml
new file mode 100644
index 000000000..580af2723
--- /dev/null
+++ b/hicn-plugin/src/host_stack/FEATURE.yaml
@@ -0,0 +1,9 @@
+---
+name: Hicn host stack
+maintainer: Mauro Sardara <msardara@cisco.com>
+features:
+  - Hicn host stack integration via session layer
+description: "IETF QUIC Protocol implementation"
+state: experimental
+properties: [API, CLI, STATS, MULTITHREAD]
+
diff --git a/hicn-plugin/src/host_stack/README.md b/hicn-plugin/src/host_stack/README.md
new file mode 100644
index 000000000..04166336a
--- /dev/null
+++ b/hicn-plugin/src/host_stack/README.md
@@ -0,0 +1,2 @@
+# host-stack-plugin
+HICN transport plugin for VPP
diff --git a/hicn-plugin/src/host_stack/cbr_proto.c b/hicn-plugin/src/host_stack/cbr_proto.c
new file mode 100644
index 000000000..54a851d41
--- /dev/null
+++ b/hicn-plugin/src/host_stack/cbr_proto.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "host_stack.h"
+#include "inlines.h"
+
+#include <hicn/transport/protocols/transport_algorithm.h>
+
+#define WINDOW_SIZE 200
+
+typedef struct hicn_hs_cbr_proto_data_
+{
+  u64 next_seq_number;
+  u16 window_size;
+  u16 in_flight_interests;
+} hicn_hs_cbr_proto_data_t;
+
+#define proto_data(ctx) ((hicn_hs_cbr_proto_data_t *)(ctx->hs_proto_data))
+
+static void
+reset_protocol(hicn_hs_cbr_proto_data_t *proto_data)
+{
+  proto_data->in_flight_interests = 0;
+  proto_data->window_size = WINDOW_SIZE;
+  proto_data->next_seq_number = 0;
+
+  TransportAlgorithm *t = transportAlgorithm_CreateRaaqm(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  proto_data->next_seq_number = (u64)t;
+}
+
+static void
+schedule_next_interests(hicn_hs_ctx_t *ctx)
+{
+  hicn_hs_cbr_proto_data_t *data = proto_data(ctx);
+  u32 scheduled_interests = 0;
+
+  if (data->in_flight_interests < data->window_size)
+    scheduled_interests = hicn_hs_send_interests(ctx, data->next_seq_number,
+                                                 data->window_size - data->in_flight_interests);
+
+  data->in_flight_interests += scheduled_interests;
+  data->next_seq_number += scheduled_interests;
+}
+
+u32 cbr_proto_init(hicn_hs_ctx_t *ctx)
+{
+  if (ctx->running)
+    return -1;
+
+  hicn_hs_cbr_proto_data_t *data = proto_data(ctx);
+
+  reset_protocol(data);
+  schedule_next_interests(ctx);
+  ctx->running = 1;
+
+  return 0;
+}
+
+u32 cbr_proto_on_data(hicn_hs_ctx_t *ctx, u16 n_data)
+{
+  hicn_hs_cbr_proto_data_t *data = proto_data(ctx);
+  data->in_flight_interests -= n_data;
+  schedule_next_interests(ctx);
+  return 0;
+}
+
+u32 cbr_proto_on_interest(hicn_hs_ctx_t *ctx)
+{
+  return 0;
+}
+
+u32 cbr_proto_interest_timeout(hicn_hs_ctx_t *ctx)
+{
+  return 0;
+}
+
+u32 cbr_proto_event(hicn_hs_ctx_t *ctx, hicn_hs_proto_event_t event)
+{
+  return 0;
+}
+
+hicn_hs_proto_t cbr_proto = {
+    .init = cbr_proto_init,
+    .rcv_data = cbr_proto_on_data,
+    .rcv_interest = cbr_proto_on_interest,
+    .on_interest_timeout = cbr_proto_interest_timeout,
+    .event = cbr_proto_event,
+    .options = {
+        .is_stream = 1}};
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/cli.c b/hicn-plugin/src/host_stack/cli.c
new file mode 100644
index 000000000..e569d83f1
--- /dev/null
+++ b/hicn-plugin/src/host_stack/cli.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 "host_stack.h"
+#include "route.h"
+
+#include <vnet/session/session.h>
+
+static clib_error_t *
+hicn_hs_enable_disable_fn (vlib_main_t * vm,
+		 unformat_input_t * input,
+		 vlib_cli_command_t * cmd)
+{
+  unformat_input_t _line_input, *line_input = &_line_input;
+  u8 is_en = 1;
+  clib_error_t *error;
+
+  session_cli_return_if_not_enabled ();
+
+  if (!unformat_user (input, unformat_line_input, line_input))
+    return clib_error_return (0, "expected enable | disable");
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "enable"))
+	is_en = 1;
+      else if (unformat (line_input, "disable"))
+	is_en = 0;
+      else
+	{
+	  error = clib_error_return (0, "unknown input `%U'",
+				     format_unformat_error, line_input);
+	  unformat_free (line_input);
+	  return error;
+	}
+    }
+
+  unformat_free (line_input);
+  return hicn_hs_enable_disable (vm, is_en);
+}
+
+static clib_error_t *
+hicn_hs_set_local_prefix_fn (vlib_main_t * vm,
+			     unformat_input_t * input,
+			     vlib_cli_command_t * cmd)
+{
+  unformat_input_t _line_input, *line_input = &_line_input;
+  clib_error_t *error = 0;
+  fib_prefix_t prefix;
+
+  if (!unformat_user (input, unformat_line_input, line_input))
+    return clib_error_return (0, "expected ip_address/prefix_len");
+
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (line_input, "%U/%d", unformat_ip46_address,
+		    &prefix.fp_addr, IP46_TYPE_ANY, &prefix.fp_len))
+	{
+	  prefix.fp_proto = ip46_address_is_ip4(&prefix.fp_addr) ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
+	  error = hicn_hs_set_local_prefix(&prefix);
+	}
+      else
+        {
+	  error = clib_error_return (0, "unknown input `%U'",
+				     format_unformat_error, line_input);
+	}
+    }
+
+  unformat_free (line_input);
+  return error;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (hicn_hs_onoff, static) =
+{
+  .path = "hicn hs",
+  .short_help = "hicn hs [enable|disable]",
+  .function = hicn_hs_enable_disable_fn,
+};
+
+VLIB_CLI_COMMAND(hicn_hs_set_local_pfx, static) =
+{
+  .path = "hicn hs set local prefix",
+  .short_help = "hicn hs set local prefix <ip_prefix/plen>",
+  .function = hicn_hs_set_local_prefix_fn,
+};
+/* *INDENT-ON* */
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/debug.h b/hicn-plugin/src/host_stack/debug.h
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/hicn-plugin/src/host_stack/debug.h
diff --git a/hicn-plugin/src/host_stack/error.c b/hicn-plugin/src/host_stack/error.c
new file mode 100644
index 000000000..fa802b553
--- /dev/null
+++ b/hicn-plugin/src/host_stack/error.c
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "error.h"
+
+u8 *
+quic_format_err (u8 * s, va_list * args)
+{
+  u64 code = va_arg (*args, u64);
+  switch (code)
+    {
+    case 0:
+      s = format (s, "no error");
+      break;
+    default:
+      s = format (s, "unknown error 0x%lx", code);
+      break;
+    }
+  return s;
+}
diff --git a/hicn-plugin/src/host_stack/error.h b/hicn-plugin/src/host_stack/error.h
new file mode 100644
index 000000000..76c6ff986
--- /dev/null
+++ b/hicn-plugin/src/host_stack/error.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __included_hs_hicn_error_h__
+#define __included_hs_hicn_error_h__
+
+#include <stdarg.h>
+
+#include <vppinfra/format.h>
+
+u8 *hicn_hs_format_err (u8 *s, va_list *args);
+
+#endif /* __included_hs_hicn_error_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/host_stack/errors/hicn_hs.def b/hicn-plugin/src/host_stack/errors/hicn_hs.def
new file mode 100644
index 000000000..11474b5d9
--- /dev/null
+++ b/hicn-plugin/src/host_stack/errors/hicn_hs.def
@@ -0,0 +1,32 @@
+/*
+ * hicn_hs_input_node_error.def: Errors in hicn_hs input node
+ *
+ * Copyright (c) 2013-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+hicn_hs_error (NONE, "no error")
+hicn_hs_error (ROUTE_NOT_FOUND, "no route found for given prefix")
+hicn_hs_error (ROUTE_DPO_NO_HICN, "DPO for route is not hicn dpo")
+hicn_hs_error (ROUTE_NO_LB_DPO, "DPO is not load balance")
+hicn_hs_error (ROUTE_NO_INSERT, "Route not inserted in FIB.")
+hicn_hs_error (NO_CONTEXT, "No context found for received packet")
+hicn_hs_error (PACKETS_SENT, "Packets sent")
+hicn_hs_error (NO_HICN, "Packet is not hicn")
+hicn_hs_error (DISPATCH, "Not possible to dispatch hicn packet")
+hicn_hs_error (WRONG_THREAD, "Context not found in current worker data.")
+hicn_hs_error (ENQUEUED, "Error enqueueing data to application.")
+hicn_hs_error (FORMAT, "Error parsing packet.")
+hicn_hs_error (FIFO_FULL, "Error FIFO full.")
+hicn_hs_error (ENQUEUED_OOO, "Enqueued OOO datas.")
+hicn_hs_error (PARTIALLY_ENQUEUED, "Partially enqueued, probably because of full fifo.")
diff --git a/hicn-plugin/src/host_stack/host_stack.c b/hicn-plugin/src/host_stack/host_stack.c
new file mode 100644
index 000000000..a8c27b8d0
--- /dev/null
+++ b/hicn-plugin/src/host_stack/host_stack.c
@@ -0,0 +1,517 @@
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/socket.h>
+
+#include <vnet/session/application.h>
+#include <vnet/session/transport.h>
+#include <vnet/session/session.h>
+#include <vlib/unix/plugin.h>
+#include <vppinfra/lock.h>
+
+#include "error.h"
+#include "host_stack.h"
+#include "inlines.h"
+
+#include "utils.h"
+#include "route.h"
+
+#define _IPV6 0
+
+char *hicn_hs_error_strings[] = {
+#define hicn_hs_error(n,s) s,
+#include "errors/hicn_hs.def"
+#undef hicn_hs_error
+};
+
+// Main hicn struct
+hicn_hs_main_t hicn_hs_main;
+
+/**
+ * Initiate the connection to rmt, which is actually a content.
+ * Send first interest and program rtx.
+ */
+int
+hicn_hs_connect (transport_endpoint_cfg_t * rmt)
+{
+  hicn_hs_main_t *hmm = hicn_hs_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
+  u32 thread_index = vm->thread_index;
+  int rv;
+  session_endpoint_cfg_t *sep;
+  hicn_hs_ctx_t *hc;
+  app_worker_t *app_wrk;
+  session_handle_t sh;
+  session_t *s;
+  u32 hc_index;
+  char name[128];
+  
+  hicn_ip_prefix_t ip_address;
+  hicn_name_t *cons_name;
+
+  CLIB_UNUSED (u32 node_index);
+
+  /* We don't poll main thread if we have workers */
+  if (vlib_num_workers ())
+    thread_index = 1;
+
+  sep = (session_endpoint_cfg_t *)(rmt);
+
+  /* XXX Here we alloc a new ctx. Not clear yet how to trigger the consumer protocol
+     from the session layer. TBD */
+  hc_index = hicn_hs_ctx_alloc (thread_index);
+  hc = hicn_hs_get_ctx_by_index(hc_index, thread_index);
+
+  ip_copy (&hc->connection.rmt_ip, &rmt->ip, rmt->is_ip4);
+  ip_copy ((ip46_address_t*)(&ip_address.address), &rmt->ip, rmt->is_ip4);
+  ip_address.family = rmt->is_ip4 ? AF_INET : AF_INET6;
+  ip_address.len = 128;
+  cons_name = hicn_hs_ctx_get_consumer_name(hc);
+
+  hicn_name_create_from_ip_prefix(&ip_address, 0, cons_name);
+  hicn_name_ntop(cons_name, name, 128);
+  HICN_HS_DBG(1, "Set name %s through hicn connect()", name);
+
+  hc->c_rmt_port = rmt->port;
+  hc->c_is_ip4 = sep->is_ip4;
+  hc->c_proto = hmm->transport_protocol_id;
+  /*
+    FixMe: Hardcoded fib index!
+   */
+  hc->c_fib_index = fib_table_find(hc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6, 10);
+  hc->parent_app_wrk_id = sep->app_wrk_index;
+  hc->c_s_index = HICN_HS_SESSION_INVALID;
+  hc->c_c_index = hc_index;
+  hc->c_flags |= TRANSPORT_CONNECTION_F_CLESS; 
+  hc->client_opaque = sep->opaque;
+
+  /* XXX Hardcoded CBR protocol for the moment */
+  hc->hs_proto = &cbr_proto;
+  hc->running = 0;
+  hc->accepted = 0;
+  hc->mss = hicn_hs_default_mtu (hmm, hc->c_is_ip4);
+  hc->current_content_size = 0;
+  hc->bytes_produced = 0;
+  hc->download_content_size = ~0;
+  vec_validate (hc->pending_interests, HICN_HS_PEND_INT_SIZE);
+  
+  /* Set context configuration */
+  if (!hicn_hs_cfg.csum_offload)
+    hc->cfg_flags |= HICN_HS_CFG_F_NO_CSUM_OFFLOAD;
+
+  if (!hicn_hs_cfg.allow_tso)
+    hc->cfg_flags |= HICN_HS_CFG_F_NO_TSO;
+
+  /**
+   * Connectionless session.
+   */
+
+  /**
+   * Allocate session and fifos now.
+   * XXX To check: Maybe it is better to allocate sessions and fifos
+   * upon reception of first data.
+   */
+  s = session_alloc_for_connection (&hc->connection);
+  s->app_wrk_index = hc->parent_app_wrk_id;
+  app_wrk = app_worker_get (s->app_wrk_index);
+//   app_worker_alloc_connects_segment_manager (app_wrk);
+
+  s->session_state = SESSION_STATE_OPENED;
+  if (app_worker_init_connected (app_wrk, s))
+    {
+      session_free (s);
+      return -1;
+    }
+
+  sh = session_handle (s);
+  session_lookup_add_connection (&hc->connection, sh);
+
+  rv = app_worker_connect_notify (app_wrk, s, SESSION_E_NONE, hc_index);
+
+  /* Initialize CBR protocol - consumer side */
+  hc->hs_proto->init(hc);
+
+  return rv;
+}
+
+void hicn_hs_proto_on_close (u32 conn_index, u32 thread_index)
+{
+  return;
+}
+
+/**
+ * The port is used as prefix length
+ */
+static u32
+hicn_hs_get_prefix_from_transport_endpoint(const ip46_address_t* ip, const u16 port, u8 is_ip4, fib_prefix_t *prefix)
+{
+  HICN_HS_ASSERT(port <= (is_ip4 ? IPV4_ADDR_LEN_BITS : IPV6_ADDR_LEN_BITS));
+  fib_prefix_from_ip46_addr(ip, prefix);
+  prefix->fp_len = port;
+
+  return HICN_HS_ERROR_NONE;
+}
+
+/**
+ * Start listen for interests belonging to prefix
+ */
+u32 hicn_hs_start_listen (u32 session_index, transport_endpoint_t * lcl)
+{
+//   hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_thread(0);
+  hicn_hs_ctx_t *ctx;
+  u32 ctx_index;
+  hicn_hs_main_t *hmm = hicn_hs_get_main ();
+
+//   vnet_listen_args_t _bargs, *args = &_bargs;
+//   session_handle_t udp_handle;
+  session_endpoint_cfg_t *sep;
+//   session_t *udp_listen_session;
+  app_worker_t *app_wrk;
+  CLIB_UNUSED(application_t *app);
+//   u32 lctx_index;
+//   int rv;
+  
+  sep = (session_endpoint_cfg_t *) lcl;
+  app_wrk = app_worker_get (sep->app_wrk_index);
+
+  app_worker_alloc_connects_segment_manager (app_wrk);
+  app = application_get (app_wrk->app_index);
+  HICN_HS_DBG (2, "Called hicn_hs_start_listen for app %d", app_wrk->app_index);
+
+  /**
+   * Choose a transport index.
+   * hicn_hs_get_next_trasnport_index()..
+   */
+//   u32 ctx_index = hicn_hs_wrk_get_next_ctx_index(wrk);
+  /* XXX Here we alloc a new ctx. Not clear yet how to trigger the consumer protocol
+     from the session layer. TBD */
+  ctx_index = hicn_hs_ctx_alloc (0);
+  ctx = hicn_hs_get_ctx_by_index(ctx_index, 0);
+
+  ip_copy (&ctx->connection.lcl_ip, &lcl->ip, lcl->is_ip4);
+  ctx->c_lcl_port = clib_net_to_host_u16(lcl->port);
+  ctx->c_is_ip4 = lcl->is_ip4;
+  ctx->c_proto = hmm->transport_protocol_id;
+  /* FixMe: Hardcoded Fib Index! */
+  ctx->c_fib_index = fib_table_find(ctx->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6, 10);
+  ctx->c_c_index = ctx_index;
+  ctx->session_index = session_index;
+  ctx->mss = hicn_hs_default_mtu (hmm, ctx->c_is_ip4);
+  ctx->current_content_size = 0;
+  ctx->bytes_produced = 0;
+
+  /* Init output buffer hash table */
+  clib_bihash_init_24_8 (&ctx->output_buffer, "prod-output-buffer",
+  			 /* 256 k */ 256 << 10, /* 8 MB */ 8 << 20);
+
+  /* XXX Hardcoded CBR protocol for the moment */
+  ctx->hs_proto = &cbr_proto;
+  ctx->running = 0;
+  ctx->accepted = 0;
+  
+  /* Set context configuration */
+  if (!hicn_hs_cfg.csum_offload)
+    ctx->cfg_flags |= HICN_HS_CFG_F_NO_CSUM_OFFLOAD;
+
+  if (!hicn_hs_cfg.allow_tso)
+    ctx->cfg_flags |= HICN_HS_CFG_F_NO_TSO;
+
+  /**
+   * Setup DPO
+   */
+  hicn_hs_dpo_create(ctx_index, lcl->is_ip4, &ctx->dpo);
+
+  /**
+   * Get prefix from transport_endpoint_t
+   */
+  hicn_hs_get_prefix_from_transport_endpoint(&ctx->c_lcl_ip, ctx->c_lcl_port, ctx->c_is_ip4, &ctx->producer_prefix);
+
+  /**
+   * Set prefix in fib
+   */
+  hicn_hs_route_add(&ctx->producer_prefix, &ctx->dpo);
+
+  /**
+   * Check if hicn_hs input node recives interests
+   */
+
+  return ctx_index;
+}
+
+u32 hicn_hs_stop_listen (u32 conn_index)
+{
+  return 0;
+}
+
+transport_connection_t *hicn_hs_connection_get (u32 conn_idx, u32 thread_idx)
+{
+  hicn_hs_ctx_t *ctx = hicn_hs_get_ctx_by_index(conn_idx, thread_idx);
+  return &ctx->connection;
+}
+
+transport_connection_t *hicn_hs_listener_get (u32 conn_index)
+{
+  hicn_hs_ctx_t *ctx = hicn_hs_get_ctx_by_index(conn_index, 0);
+  return &ctx->connection;
+}
+
+int hicn_hs_send_params (transport_connection_t * tconn,
+			 transport_send_params_t *sp)
+{
+  hicn_hs_ctx_t *ctx = (hicn_hs_ctx_t *) (tconn);
+  sp->snd_space = ~0;
+
+  /* TODO: figure out MTU of output interface! */
+  sp->snd_mss = ctx->mss;
+  sp->tx_offset = 0;
+  sp->flags = 0;
+  return 0;
+}
+
+/**
+ * Push hicn header on data packet.
+ * This function is not called for interests, which are rather crafted
+ * directly in the transport layer.
+ */
+u32 hicn_hs_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
+{
+  hicn_hs_ctx_t *ctx = (hicn_hs_ctx_t *) (tconn);
+  hicn_hs_worker_t * wrk = hicn_hs_get_worker_by_context (ctx);
+  u32 index;
+  int rv;
+
+  hicn_name_t *name = &ctx->current_production_name;
+  hicn_hs_buffer(b)->is_interest = 0;
+  hicn_hs_buffer(b)->ctx_index = ctx->c_c_index;
+  hicn_hs_buffer(b)->flush = 0;
+  vlib_buffer_push_hicn(ctx, b, name, ctx->snd_nxt, 0);
+  
+  index = vlib_get_buffer_index (wrk->vm, b);
+  obuffer_kv4_t kv;
+  make_obuffer_kv (&kv, &ctx->current_production_name.prefix, ctx->snd_nxt++, index);
+  rv = clib_bihash_add_del_24_8 (&ctx->output_buffer, &kv, 2);
+  
+  if (PREDICT_FALSE (rv < 0))
+    {
+      /* We tried to overwrite something already in the table. */
+      obuffer_kv4_t kv_ret;
+      rv = clib_bihash_search_inline_2_24_8 (&ctx->output_buffer, &kv, &kv_ret);
+      if (!rv)
+        {
+	  hicn_header_t *interest, *data;
+	  vlib_buffer_t *buffer;
+	  hicn_hs_buffer(b)->flush = 1;
+	  clib_bihash_add_del_24_8 (&ctx->output_buffer, &kv, 1);
+
+	  buffer = vlib_get_buffer (wrk->vm, kv_ret.value);
+	  interest = vlib_buffer_get_current (buffer);
+	  data = vlib_buffer_get_current (b);
+	  data->v6.ip.daddr = interest->v6.ip.saddr;
+
+	  vlib_buffer_free_one (wrk->vm, kv_ret.value);
+	}
+    }
+
+  return 0;
+}
+
+void hicn_hs_update_time (f64 time_now, u8 thread_index)
+{
+  return;
+}
+
+int hicn_hs_custom_app_rx_callback (transport_connection_t *tconn)
+{
+  return 0;
+}
+
+int hicn_hs_custom_tx_callback (void *session, transport_send_params_t *sp)
+{
+  return 0;
+}
+
+u8 *format_hicn_hs_connection (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+u8 *format_hicn_hs_half_open (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+u8 *format_hicn_hs_listener (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+void hicn_hs_get_transport_endpoint (u32 conn_index, u32 thread_index,
+        			     transport_endpoint_t *tep, u8 is_lcl)
+{
+  return;
+}
+
+void hicn_hs_get_transport_listener_endpoint (u32 conn_index,
+               				 transport_endpoint_t *tep,
+               				 u8 is_lcl)
+{
+  return;
+}
+
+static void
+hicn_hs_expired_timers_dispatch (u32 * expired_timers)
+{
+  HICN_HS_DBG(1, "Timer expired.");
+}
+
+static const transport_proto_vft_t hicn_hs_proto = {
+  .connect = hicn_hs_connect,
+  .close = hicn_hs_proto_on_close,
+  .start_listen = hicn_hs_start_listen,
+  .stop_listen = hicn_hs_stop_listen,
+  .get_connection = hicn_hs_connection_get,
+  .get_listener = hicn_hs_listener_get,
+  .update_time = hicn_hs_update_time,
+  .app_rx_evt = hicn_hs_custom_app_rx_callback,
+  .custom_tx = hicn_hs_custom_tx_callback,
+  .send_params = hicn_hs_send_params,
+  .push_header = hicn_hs_push_header,
+  .format_connection = format_hicn_hs_connection,
+  .format_half_open = format_hicn_hs_half_open,
+  .format_listener = format_hicn_hs_listener,
+  .get_transport_endpoint = hicn_hs_get_transport_endpoint,
+  .get_transport_listener_endpoint = hicn_hs_get_transport_listener_endpoint,
+  .transport_options = {
+	  /* Used by session_register_transport to select the tx function.
+	     TRANSPORT_TX_INTERNAL will delegate the transmission to the transport
+	     protocol itself, throught he function hicn_hs_custom_tx_callback. Magic. */
+    .tx_type = TRANSPORT_TX_DEQUEUE,
+    .service_type = TRANSPORT_SERVICE_APP,
+    .name = "hicn",
+    .short_name = "H"
+  },
+};
+
+/**
+ * Initialize default values for tcp parameters
+ */
+static void
+hicn_hs_configuration_init (void)
+{
+  hicn_hs_cfg.max_rx_fifo = 32 << 20;
+  hicn_hs_cfg.min_rx_fifo = 4 << 10;
+
+  hicn_hs_cfg.default_mtu = 1500;
+  hicn_hs_cfg.enable_tx_pacing = 0;
+  hicn_hs_cfg.allow_tso = 0;
+  hicn_hs_cfg.csum_offload = 1;
+
+  /* Time constants defined as timer tick (100ms) multiples */
+  hicn_hs_cfg.closewait_time = 20;	/* 2s */
+  hicn_hs_cfg.cleanup_time = 0.1;	/* 100ms */
+}
+
+clib_error_t *
+hicn_hs_enable (vlib_main_t * vm)
+{
+  HICN_HS_DBG (1, "Function called (%p).", &hicn_hs_proto);
+
+  hicn_hs_main_t *hm = &hicn_hs_main;
+
+  hicn_hs_configuration_init ();
+
+  // Register hicn_hs DPO
+  hicn_hs_dpo_module_init();
+
+  // Init route module
+  hicn_hs_route_init();
+  
+  hm->enabled = 1;
+  return 0;
+}
+
+clib_error_t *
+hicn_hs_enable_disable(vlib_main_t * vm, u8 is_en)
+{
+  if (is_en)
+    {  
+       if (session_main_is_enabled())
+         return hicn_hs_enable (vm);
+       else
+         return clib_error_return (0, "Session not enabled, so hicn hoststack not enabled.");
+    }
+
+  return 0;
+}
+
+void
+hicn_hs_init (vlib_main_t * vm)
+{
+  HICN_HS_DBG(1, "Function called");
+  hicn_hs_main_t *hm = &hicn_hs_main;
+  vlib_thread_main_t *vtm = vlib_get_thread_main ();
+  u32 i, num_threads = 1 /* main thread */  + vtm->n_threads;
+  tw_timer_wheel_1t_3w_1024sl_ov_t *tw;
+
+  hm->app_index = 0;
+  vec_validate_aligned (hm->workers, num_threads - 1, CLIB_CACHE_LINE_BYTES);
+
+  for (i = 0; i < num_threads; i++)
+    {
+      tw = &hm->workers[i].timer_wheel;
+      tw_timer_wheel_init_1t_3w_1024sl_ov (tw, hicn_hs_expired_timers_dispatch,
+					   1e-3 /* timer period 1ms */ , ~0);
+      tw->last_run_time = vlib_time_now (vlib_get_main ());
+      hm->workers[i].vm = vlib_mains[i];
+      hm->workers[i].next_hicn_ctx = 0;
+    }
+
+  hm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock / HICN_HS_TSTAMP_RESOLUTION;
+
+  hm->hicn_hs_in4_idx = hicn_hs_input4_node.index;
+  hm->hicn_hs_on4_idx = hicn_hs_output4_node.index;
+
+  hm->hicn_hs_in6_idx = hicn_hs_input6_node.index;
+  hm->hicn_hs_on6_idx = hicn_hs_output6_node.index;
+
+  // Not enabled by default
+  hm->enabled = 0;
+
+    // Register new protocol
+  hm->transport_protocol_id = transport_register_new_protocol(&hicn_hs_proto,
+			       				     FIB_PROTOCOL_IP6,
+							     hm->hicn_hs_on6_idx);
+  transport_register_protocol (hm->transport_protocol_id, &hicn_hs_proto,
+			       FIB_PROTOCOL_IP4, hm->hicn_hs_on4_idx);
+}
+
+/* *INDENT-ON* */
+
+// static clib_error_t *
+// hicn_hs_config_fn (vlib_main_t * vm, unformat_input_t * input)
+// {
+//   HICN_HS_DBG(1, "Function called early.");
+//   return 0;
+// }
+
+// static clib_error_t *
+// hicn_hs_config2_fn (vlib_main_t * vm, unformat_input_t * input)
+// {
+//   HICN_HS_DBG(1, "Function called.");
+//   return 0;
+// }
+
+// VLIB_EARLY_CONFIG_FUNCTION (hicn_hs_config_fn, "hicn_hs");
+// VLIB_CONFIG_FUNCTION (hicn_hs_config2_fn, "hicn_hs");
diff --git a/hicn-plugin/src/host_stack/host_stack.h b/hicn-plugin/src/host_stack/host_stack.h
new file mode 100644
index 000000000..5ad2db1ae
--- /dev/null
+++ b/hicn-plugin/src/host_stack/host_stack.h
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __included_hicn_hs_h__
+#define __included_hicn_hs_h__
+
+#include "producer_dpo.h"
+#include "hicn_buffer.h"
+
+#include <vnet/session/application_interface.h>
+#include <vnet/session/transport.h>
+
+#include <vppinfra/lock.h>
+#include <vppinfra/tw_timer_1t_3w_1024sl_ov.h>
+#include <vppinfra/bihash_24_8.h>
+#include <vnet/crypto/crypto.h>
+#include <vppinfra/lock.h>
+
+
+/* Log levels
+ * 1 - errors
+ * 2 - connection/stream events
+ * 3 - packet events
+ * 4 - timer events
+ **/
+
+#define HICN_HS_DEBUG               1
+#define HICN_HS_TSTAMP_RESOLUTION  0.001	/* HICN_HS tick resolution (1ms) */
+#define HICN_HS_TIMER_HANDLE_INVALID ((u32) ~0)
+#define HICN_HS_SESSION_INVALID ((u32) ~0 - 1)
+#define HICN_HS_MAX_PACKET_SIZE 1280
+
+#define HICN_HS_INT_MAX  0x3FFFFFFFFFFFFFFF
+#define HICN_HS_DEFAULT_FIFO_SIZE (64 << 10)
+#define HICN_HS_DEFAULT_CONN_TIMEOUT (30 * 1000)	/* 30 seconds */
+#define HICN_HS_SEND_PACKET_VEC_SIZE 16
+#define HICN_HS_IV_LEN 17
+
+#define HICN_HS_INPUT4_NODE_NAME "hicn_hs-input4"
+#define HICN_HS_OUTPUT4_NODE_NAME "hicn_hs-output4"
+
+#define HICN_HS_INPUT6_NODE_NAME "hicn_hs-input6"
+#define HICN_HS_OUTPUT6_NODE_NAME "hicn_hs-output6"
+
+#define HICN_HS_INPUT_INTEREST_NODE_NAME "hicn_hs-input-interest"
+#define HICN_HS_INPUT_DATA_NODE_NAME "hicn_hs-input-data"
+
+#define HICN_HS_DEFAULT_MTU (1500 - 40 - 20)
+
+#define PROTO_DATA_SIZE 32
+#define HICN_HS_PEND_INT_SIZE (1 << 11)
+#define HICN_HS_PEND_INT_MASK (HICN_HS_PEND_INT_SIZE - 1)
+
+#if HICN_HS_DEBUG
+#define HICN_HS_DBG(_lvl, _fmt, _args...)   \
+  if (_lvl <= HICN_HS_DEBUG)                \
+    clib_warning (_fmt, ##_args)
+#else
+#define HICN_HS_DBG(_lvl, _fmt, _args...)
+#endif
+
+#if CLIB_ASSERT_ENABLE
+#define HICN_HS_ASSERT(truth) ASSERT (truth)
+#else
+#define HICN_HS_ASSERT(truth)                        	\
+  do {                                            	\
+    if (PREDICT_FALSE (! (truth)))                	\
+      HICN_HS_ERR ("ASSERT(%s) failed", # truth);    	\
+  } while (0)
+#endif
+
+#define HICN_HS_ERR(_fmt, _args...)                	\
+  do {                                          	\
+    clib_warning ("HICN_HS-ERR: " _fmt, ##_args);  	\
+  } while (0)
+
+extern vlib_node_registration_t hicn_hs_input_node;
+extern vlib_node_registration_t hicn_hs_input_interest_node;
+extern vlib_node_registration_t hicn_hs_input_data_node;
+
+typedef enum
+{
+#define hicn_hs_error(n,s) HICN_HS_ERROR_##n,
+#include "errors/hicn_hs.def"
+#undef hicn_hs_error
+  HICN_HS_N_ERROR,
+} hicn_hs_error_t;
+
+typedef struct hicn_hs_proto_ hicn_hs_proto_t;
+
+/* hicn configuration flags */
+#define foreach_hicn_hs_cfg_flag 			\
+  _(NO_CSUM_OFFLOAD, "No csum offload")    	\
+  _(NO_TSO, "TSO off")
+
+typedef enum hicn_hs_cfg_flag_bits_
+{
+#define _(sym, str) HICN_HS_CFG_F_##sym##_BIT,
+  foreach_hicn_hs_cfg_flag
+#undef _
+  HICN_HS_CFG_N_FLAG_BITS
+} hicn_hs_cfg_flag_bits_e;
+
+typedef enum hicn_hs_cfg_flag_
+{
+#define _(sym, str) HICN_HS_CFG_F_##sym = 1 << HICN_HS_CFG_F_##sym##_BIT,
+  foreach_hicn_hs_cfg_flag
+#undef _
+  HICN_HS_CFG_N_FLAGS
+} hicn_hs_cfg_flags_e;
+
+typedef enum hicn_hs_proto_event_
+{
+  PROTO_N_EVENT,
+} hicn_hs_proto_event_t;
+
+typedef struct hicn_hs_ctx_
+{
+  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
+  transport_connection_t connection;		/* Must be first, for convenient casts!!! */
+  u32 parent_app_wrk_id;
+  u32 client_opaque;
+  u32 timer_handle;
+  u8 cfg_flags;					/**< Hicn ctx configuration flags */
+  hicn_hs_proto_t *hs_proto;
+  u8 hs_proto_data[PROTO_DATA_SIZE];
+
+  /* Maps interest suffix -> vlib buffer index */
+  u32 *pending_interests;
+
+  // The hicn name for the consumer session
+  hicn_name_t consumer_name;
+  // The current name in production in th eproducer session
+  hicn_name_t current_production_name;
+
+  // The prefix for the producer names.
+  /* XXX To be retrieved from a pool of names configured by the control protocol / network admin */
+  fib_prefix_t producer_prefix;
+
+  /* Store the size of the content currently produced. */
+  u32 current_content_size;
+  u32 number_of_segments;
+
+  /* Store size of content to download - consumer side */
+  u32 download_content_size;
+
+  u32 bytes_produced;
+
+  /* Seq number to assign to next segment */
+  u32 snd_nxt;
+
+  /* Expected bytes */
+  u32 rcv_nxt;
+
+  /* Some stats */
+  u64 int_in;
+  u64 data_in;
+  u64 int_out;
+  u64 data_out;
+  u64 bytes_in;
+  u64 bytes_outs;
+
+  /* The DPO for this hicn_hs ctx */
+  dpo_id_t dpo;
+
+  /* Hash table for exact match prefix-suffix */
+  clib_bihash_24_8_t output_buffer;
+
+  /* Unused listener session index */
+  u32 session_index;
+
+  u8 running;
+  u8 accepted;
+
+  u16 mss;
+} hicn_hs_ctx_t;
+
+typedef clib_bihash_kv_24_8_t obuffer_kv4_t;
+
+typedef struct {
+  u32 ctx_index;
+  u8 is_interest;
+  u8 is_ip4;
+  u8 flush;
+  u32 seq_number;
+  hicn_type_t type; 
+} hicn_hs_buffer_t;
+
+#define hicn_hs_buffer(b) ((hicn_hs_buffer_t *) (b)->opaque2)
+#define hicn_buffer_hdr(b) ((hicn_header_t *) (vlib_buffer_get_current(b)))
+
+always_inline void *
+hicn_hs_proto_data(hicn_hs_ctx_t *ctx)
+{
+  return (void*)(ctx->hs_proto_data);
+}
+
+struct hicn_hs_proto_
+{
+  u32 (*init) (hicn_hs_ctx_t * hc);
+  u32 (*rcv_data) (hicn_hs_ctx_t * hc, u16 n_data);
+  u32 (*rcv_interest) (hicn_hs_ctx_t * hc);
+  u32 (*on_interest_timeout) (hicn_hs_ctx_t *hc);
+  u32 (*event) (hicn_hs_ctx_t *hc, hicn_hs_proto_event_t event);
+  struct {
+    u8 is_stream;
+  } options;
+};
+
+typedef struct hicn_hs_worker_ctx_
+{
+  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
+  hicn_hs_ctx_t *hicn_ctxs;		   	   /**< worker's pool of hicn context */
+  u32 next_hicn_ctx;				   /**< Next hicn context, to be used in start_listen*/
+  int64_t time_now;				   /**< worker time */
+  tw_timer_wheel_1t_3w_1024sl_ov_t timer_wheel;	   /**< worker timer wheel */
+  vlib_main_t *vm;				   /**< pointer to thread's vlib main*/
+  /** Peekers rw lock */
+  clib_rwlock_t peekers_rw_locks;
+} hicn_hs_worker_t;
+
+typedef struct hicn_hs_configuration_
+{
+  /** Max rx fifo size for a session (in bytes). It is used in to compute the
+   *  rfc 7323 window scaling factor */
+  u32 max_rx_fifo;
+
+  /** Min rx fifo for a session (in bytes) */
+  u32 min_rx_fifo;
+
+  /** Default MTU to be used when establishing connections */
+  u16 default_mtu;
+
+  /** Enable tx pacing for new connections */
+  u8 enable_tx_pacing;
+
+  /** Allow use of TSO whenever available */
+  u8 allow_tso;
+
+  /** Set if csum offloading is enabled */
+  u8 csum_offload;
+
+  /** Timer ticks to wait for close from app */
+  u16 closewait_time;
+
+  /** Time to wait (sec) before cleaning up the connection */
+  f32 cleanup_time;
+} hicn_hs_configuration_t;
+
+typedef struct _hicn_hs_lookup_dispatch
+{
+  u8 next, error;
+} hicn_hs_lookup_dispatch_t;
+
+#define foreach_hicn_hs_packet                 	\
+  _ (DATA, "data")				\
+  _ (INTEREST, "interest")			\
+  _ (NO_HICN, "ho hicn")
+
+typedef enum _hicn_hs_packet
+{
+  #define _(n, s) HICN_HS_##n,
+  foreach_hicn_hs_packet
+  #undef _
+  HICN_HS_N_PACKET,
+} hicn_hs_packet_t;
+
+typedef struct hicn_hs_main_
+{
+  u32 app_index;
+  hicn_hs_worker_t *workers;
+  clib_bihash_24_8_t connection_hash;	/**< connection id -> conn handle */
+  f64 tstamp_ticks_per_clock;
+
+  // The new registered transport ID
+  transport_proto_t transport_protocol_id;
+
+  // Input/Output nodes information
+  u32 hicn_hs_in4_idx;
+  u32 hicn_hs_on4_idx;
+  u32 hicn_hs_in6_idx;
+  u32 hicn_hs_on6_idx;
+
+  // Enabled/Disabled
+  u8 enabled;
+
+  u32 udp_fifo_size;
+  u32 udp_fifo_prealloc;
+  u32 connection_timeout;
+
+  // Configuration
+  hicn_hs_configuration_t cfg;
+
+  // Dispatch table
+  hicn_hs_lookup_dispatch_t dispatch_table[HICN_HS_N_PACKET];
+} hicn_hs_main_t;
+
+void hicn_hs_init (vlib_main_t * vm);
+
+extern hicn_hs_main_t hicn_hs_main;
+extern vlib_node_registration_t hicn_hs_input4_node;
+extern vlib_node_registration_t hicn_hs_output4_node;
+extern vlib_node_registration_t hicn_hs_input6_node;
+extern vlib_node_registration_t hicn_hs_output6_node;
+extern char *hicn_hs_error_strings[];
+
+#define hicn_hs_cfg (hicn_hs_main.cfg)
+
+// Protocols
+extern hicn_hs_proto_t cbr_proto;
+
+always_inline
+hicn_hs_main_t *hicn_hs_get_main ()
+{
+  return &hicn_hs_main;
+}
+
+always_inline
+transport_proto_t hicn_hs_get_protocol_id()
+{
+  hicn_hs_main_t *hm = hicn_hs_get_main ();
+  return hm->transport_protocol_id;
+}
+
+clib_error_t * hicn_hs_enable_disable(vlib_main_t * vm, u8 is_en);
+
+always_inline void
+hicn_hs_update_transport(hicn_hs_ctx_t *ctx, u16 recv_data)
+{
+  // Pass data packet to transport
+  ctx->hs_proto->rcv_data(ctx, recv_data);
+}
+
+always_inline void
+hicn_hs_set_next_prod_size (hicn_hs_ctx_t *ctx, u32 prod_size)
+{
+  ctx->current_content_size = prod_size;
+  ctx->number_of_segments = (prod_size / ctx->mss) + ((prod_size % ctx->mss) > 0);
+}
+
+always_inline hicn_hs_worker_t *
+hicn_hs_get_worker_by_context (hicn_hs_ctx_t *ctx)
+{
+  hicn_hs_main_t *hmm = hicn_hs_get_main ();
+  return &hmm->workers[ctx->c_thread_index];
+}
+
+always_inline hicn_hs_worker_t *
+hicn_hs_get_worker_by_thread (u32 thread_idx)
+{
+  hicn_hs_main_t *hmm = hicn_hs_get_main ();
+  return &hmm->workers[thread_idx];
+}
+
+always_inline hicn_hs_ctx_t *
+hicn_hs_wrk_get_ctx(hicn_hs_worker_t *wrk, u32 index)
+{
+  return pool_elt_at_index (wrk->hicn_ctxs, index);
+}
+
+always_inline u32
+hicn_hs_wrk_get_next_ctx_index(hicn_hs_worker_t *wrk)
+{
+  return wrk->next_hicn_ctx++;
+}
+
+always_inline hicn_hs_ctx_t *
+hicn_hs_get_ctx_by_index (u32 ctx_index, u32 thread_index)
+{
+  hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_thread(thread_index);
+  return hicn_hs_wrk_get_ctx(wrk, ctx_index);
+}
+
+always_inline hicn_name_t*
+hicn_hs_ctx_get_consumer_name(hicn_hs_ctx_t *ctx)
+{
+  return &ctx->consumer_name;
+}
+
+always_inline dpo_id_t*
+hicn_hs_ctx_get_dpo(hicn_hs_ctx_t *ctx)
+{
+  return &ctx->dpo;
+}
+
+#endif /* __included_hicn_hs_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/host_stack/inlines.h b/hicn-plugin/src/host_stack/inlines.h
new file mode 100644
index 000000000..5c2c33915
--- /dev/null
+++ b/hicn-plugin/src/host_stack/inlines.h
@@ -0,0 +1,520 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __included_hicn_hs_inlines_h__
+#define __included_hicn_hs_inlines_h__
+
+#include "host_stack.h"
+#include "utils.h"
+
+always_inline void
+make_obuffer_kv (obuffer_kv4_t * kv, ip46_address_t * prefix, u32 suffix, u32 bi)
+{
+  kv->key[0] = prefix->as_u64[0];
+  kv->key[1] = prefix->as_u64[1];
+  kv->key[2] = suffix;
+  kv->value = bi;
+}
+
+always_inline void
+hicn_hs_app_notify_rx (hicn_hs_ctx_t *ctx)
+{
+  session_t *s;	
+  s = session_get(ctx->c_s_index, 0);
+  session_enqueue_notify(s);
+}
+
+always_inline u16
+hicn_hs_default_mtu (hicn_hs_main_t * hm, u8 is_ip4)
+{
+  u16 hicn_hlen = is_ip4 ? HICN_V4_TCP_HDRLEN : HICN_V6_TCP_HDRLEN;
+  return (hicn_hs_cfg.default_mtu - hicn_hlen);
+}
+
+always_inline u32
+hicn_hs_ctx_alloc(u32 thread_index)
+{
+  hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_thread(thread_index);
+  hicn_hs_ctx_t *ctx;
+
+  u8 will_expand;
+  pool_get_aligned_will_expand (wrk->hicn_ctxs, will_expand,
+			       CLIB_CACHE_LINE_BYTES);
+  /* If we have peekers, let them finish */
+  if (PREDICT_FALSE (will_expand && vlib_num_workers ()))
+    {
+      clib_rwlock_writer_lock (&wrk->peekers_rw_locks);
+      pool_get_aligned (wrk->hicn_ctxs, ctx, CLIB_CACHE_LINE_BYTES);
+      clib_rwlock_writer_unlock (&wrk->peekers_rw_locks);
+    }
+  else
+    {
+      pool_get_aligned (wrk->hicn_ctxs, ctx, CLIB_CACHE_LINE_BYTES);
+    }
+
+  clib_memset (ctx, 0, sizeof (hicn_hs_ctx_t));
+  ctx->c_thread_index = thread_index;
+  ctx->timer_handle = HICN_HS_TIMER_HANDLE_INVALID;
+  HICN_HS_DBG (3, "Allocated hicn_hs_ctx_t %u on thread %u",
+	       ctx - wrk->hicn_ctxs, thread_index);
+  
+  return ctx - wrk->hicn_ctxs;
+}
+
+always_inline void*
+vlib_buffer_push_hicn (hicn_hs_ctx_t *ctx, vlib_buffer_t *b,
+		       hicn_name_t* name, u32 seq_number, u8 is_interest)
+{
+  hicn_header_t *hicn_header;
+  hicn_hs_buffer_t *buffer = hicn_hs_buffer (b);
+  int rv;
+  u16 current_length = b->current_length;
+  u16 payload_len = current_length;
+  if (PREDICT_FALSE (b->flags & VLIB_BUFFER_TOTAL_LENGTH_VALID))
+    payload_len += b->total_length_not_including_first_buffer;
+
+  hicn_header = vlib_buffer_push_uninit (b, HICN_V6_TCP_HDRLEN);
+  buffer->type.l4 = IPPROTO_NONE;
+  buffer->type.l3 = IPPROTO_NONE;
+  buffer->type.l2 = IPPROTO_TCP;
+  buffer->type.l1 = IPPROTO_IPV6;
+
+  buffer->flush = 0;
+
+  name->suffix = seq_number;
+
+  rv = hicn_ops_vft[buffer->type.l1]->init_packet_header(buffer->type, &hicn_header->protocol);
+  rv += hicn_ops_vft[buffer->type.l1]->set_payload_length(buffer->type, &hicn_header->protocol, payload_len);
+
+  if (is_interest)
+    {
+      rv += hicn_ops_vft[buffer->type.l1]->set_interest_name(buffer->type, &hicn_header->protocol, name);
+      rv += hicn_ops_vft[buffer->type.l1]->mark_packet_as_interest(buffer->type, &hicn_header->protocol);
+    }
+  else
+    {
+      rv += hicn_ops_vft[buffer->type.l1]->set_data_name(buffer->type, &hicn_header->protocol, name);
+      rv += hicn_ops_vft[buffer->type.l1]->mark_packet_as_data(buffer->type, &hicn_header->protocol);
+    }
+
+  ASSERT (!rv);
+  
+  hicn_header->v6.tcp.csum = hicn_hs_compute_checksum (ctx, b);
+
+  vnet_buffer (b)->l4_hdr_offset = (u8 *) hicn_header - b->data;
+  b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
+
+  ctx->bytes_produced += current_length;
+
+  if (PREDICT_FALSE (!is_interest && ctx->bytes_produced == ctx->current_content_size))
+    {
+      // Last packet
+//       rv += hicn_packet_set_rst (hicn_header);
+    }
+
+  return hicn_header;
+}
+
+always_inline u32
+hicn_hs_make_interest (hicn_hs_ctx_t * ctx, vlib_buffer_t *b,
+		       hicn_name_t *name, u32 seq_number)
+{
+  vlib_buffer_push_hicn(ctx, b, name, seq_number, 1);
+  hicn_hs_buffer (b)->flush = 1;
+  b->ref_count = 1;
+  return 1;
+}
+
+always_inline void
+hicn_hs_enqueue_to_output (vlib_main_t *vm, session_main_t *smm,
+			   vlib_buffer_t * b, u32 bi, u8 is_ip4,
+			   session_type_t st)
+{
+  session_add_pending_tx_buffer (vm->thread_index, bi, smm->session_type_to_next[st]);
+}
+
+always_inline u32
+hicn_hs_send_interests_i (vlib_main_t *vm, hicn_hs_ctx_t *ctx, vlib_buffer_t **b, u32 *bi, u32 offset, u32 count)
+{
+  int ret = 0;
+  hicn_name_t *name = hicn_hs_ctx_get_consumer_name(ctx);
+  session_type_t st;
+  hicn_hs_main_t *hm = hicn_hs_get_main();
+  session_main_t *smm = vnet_get_session_main ();
+  transport_proto_t proto = hm->transport_protocol_id;
+
+  st = session_type_from_proto_and_ip (proto, ctx->c_is_ip4);
+
+  while (count >= 8)
+    {
+      {
+	vlib_prefetch_buffer_header (b[4], STORE);
+	CLIB_PREFETCH (b[4]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+
+	vlib_prefetch_buffer_header (b[5], STORE);
+	CLIB_PREFETCH (b[5]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+
+	vlib_prefetch_buffer_header (b[6], STORE);
+	CLIB_PREFETCH (b[6]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+
+	vlib_prefetch_buffer_header (b[7], STORE);
+	CLIB_PREFETCH (b[7]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+      }
+
+      ASSERT ((b[0]->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
+      b[0]->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+      b[0]->total_length_not_including_first_buffer = 0;
+      b[0]->current_data = 0;
+      b[0]->error = 0;
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
+      hicn_hs_buffer(b[0])->ctx_index = ctx->c_c_index;
+      hicn_hs_buffer(b[0])->is_interest = 1;
+      /* Leave enough space for headers */
+      vlib_buffer_make_headroom (b[0], TRANSPORT_MAX_HDRS_LEN);
+      ret += hicn_hs_make_interest (ctx, b[0], name, offset++);
+      hicn_hs_enqueue_to_output (vm, smm, b[0], bi[0], ctx->c_is_ip4, st);
+
+      ASSERT ((b[1]->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
+      b[1]->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+      b[1]->total_length_not_including_first_buffer = 0;
+      b[1]->current_data = 0;
+      b[1]->error = 0;
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
+      hicn_hs_buffer(b[1])->ctx_index = ctx->c_c_index;
+      hicn_hs_buffer(b[1])->is_interest = 1;
+      /* Leave enough space for headers */
+      vlib_buffer_make_headroom (b[1], TRANSPORT_MAX_HDRS_LEN);
+      ret += hicn_hs_make_interest (ctx, b[1], name, offset++);
+      hicn_hs_enqueue_to_output (vm, smm, b[1], bi[1], ctx->c_is_ip4, st);
+
+      ASSERT ((b[2]->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
+      b[2]->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+      b[2]->total_length_not_including_first_buffer = 0;
+      b[2]->current_data = 0;
+      b[2]->error = 0;
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
+      hicn_hs_buffer(b[2])->ctx_index = ctx->c_c_index;
+      hicn_hs_buffer(b[2])->is_interest = 1;
+      /* Leave enough space for headers */
+      vlib_buffer_make_headroom (b[2], TRANSPORT_MAX_HDRS_LEN);
+      ret += hicn_hs_make_interest (ctx, b[2], name, offset++);
+      hicn_hs_enqueue_to_output (vm, smm, b[2], bi[2], ctx->c_is_ip4, st);
+
+      ASSERT ((b[3]->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
+      b[3]->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+      b[3]->total_length_not_including_first_buffer = 0;
+      b[3]->current_data = 0;
+      b[3]->error = 0;
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
+      hicn_hs_buffer(b[3])->ctx_index = ctx->c_c_index;
+      hicn_hs_buffer(b[3])->is_interest = 1;
+      /* Leave enough space for headers */
+      vlib_buffer_make_headroom (b[3], TRANSPORT_MAX_HDRS_LEN);
+      ret += hicn_hs_make_interest (ctx, b[3], name, offset++);
+      hicn_hs_enqueue_to_output (vm, smm, b[3], bi[3], ctx->c_is_ip4, st);
+
+      b += 4;
+      bi += 4;
+      count -= 4;
+    }
+  while (count)
+    {
+      if (count > 1)
+        {
+	  vlib_prefetch_buffer_header (b[1], STORE);
+	  CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+        }
+      ASSERT ((b[0]->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
+      b[0]->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+      b[0]->total_length_not_including_first_buffer = 0;
+      b[0]->current_data = 0;
+      b[0]->error = 0;
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
+      hicn_hs_buffer(b[0])->ctx_index = ctx->c_c_index;
+      hicn_hs_buffer(b[0])->is_interest = 1;
+      /* Leave enough space for headers */
+      vlib_buffer_make_headroom (b[0], TRANSPORT_MAX_HDRS_LEN);
+      ret += hicn_hs_make_interest (ctx, b[0], name, offset++);
+      hicn_hs_enqueue_to_output (vm, smm, b[0], bi[0], ctx->c_is_ip4, st);
+
+      b += 1;
+      bi += 1;
+      count -= 1;
+    }
+
+  return ret;
+}
+
+always_inline u32
+hicn_hs_send_interests (hicn_hs_ctx_t * ctx, u32 start_offset, u32 n_interest)
+{
+  hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_context (ctx);
+  vlib_main_t *vm = wrk->vm;
+  vlib_buffer_t *b[VLIB_FRAME_SIZE];
+  u32 bi[VLIB_FRAME_SIZE];
+
+  if (PREDICT_FALSE (!vlib_buffer_alloc (vm, bi, n_interest)))
+    {
+      HICN_HS_DBG (1, "Vlib buffer alloc failed.");
+      return 0;
+    }
+  vlib_get_buffers (vm, bi, b, n_interest);
+  return hicn_hs_send_interests_i (vm, ctx, b, bi, start_offset, n_interest);
+}
+
+/* Modulo arithmetic for TCP sequence numbers */
+#define seq_lt(_s1, _s2) ((i32)((_s1)-(_s2)) < 0)
+#define seq_leq(_s1, _s2) ((i32)((_s1)-(_s2)) <= 0)
+#define seq_gt(_s1, _s2) ((i32)((_s1)-(_s2)) > 0)
+#define seq_geq(_s1, _s2) ((i32)((_s1)-(_s2)) >= 0)
+#define seq_max(_s1, _s2) (seq_gt((_s1), (_s2)) ? (_s1) : (_s2))
+
+/** Enqueue data for delivery to application */
+always_inline int
+hicn_hs_enqueue_data (hicn_hs_ctx_t * ctx, vlib_buffer_t * b,
+		      u16 data_len)
+{
+  int written, error = HICN_HS_ERROR_ENQUEUED;
+  hicn_hs_buffer_t *buffer = hicn_hs_buffer (b);
+
+  ASSERT (seq_geq (buffer->seq_number, ctx->rcv_nxt));
+  ASSERT (data_len);
+
+  written = session_enqueue_stream_connection (&ctx->connection, b, 0,
+					       1 /* queue event */ , 1);
+  ctx->bytes_in += written;
+
+  /* Update rcv_nxt */
+  if (PREDICT_TRUE (written == data_len))
+    {
+      ctx->rcv_nxt += written;
+    }
+  /* If more data written than expected, account for out-of-order bytes. */
+  else if (written > data_len)
+    {
+      ctx->rcv_nxt += written;
+    }
+  else if (written > 0)
+    {
+      /* We've written something but FIFO is probably full now */
+      ctx->rcv_nxt += written;
+      error = HICN_HS_ERROR_PARTIALLY_ENQUEUED;
+    }
+  else
+    {
+      error = HICN_HS_ERROR_FIFO_FULL;
+    }
+
+  if (PREDICT_FALSE (ctx->rcv_nxt >= ctx->download_content_size))
+    hicn_hs_app_notify_rx (ctx);
+
+  return error;
+}
+
+always_inline int
+hicn_hs_enqueue_ooo (hicn_hs_ctx_t * ctx, vlib_buffer_t * b,
+		     u16 data_len)
+{
+  int rv, CLIB_UNUSED(offset);
+  hicn_hs_buffer_t *buffer = hicn_hs_buffer (b);
+
+  ASSERT (seq_gt (buffer->seq_number, ctx->rcv_nxt));
+  ASSERT (data_len);
+
+  /* Enqueue out-of-order data with relative offset */
+  rv = session_enqueue_stream_connection (&ctx->connection, b,
+					  buffer->seq_number - ctx->rcv_nxt,
+					  0 /* queue event */ , 0);
+
+  /* Nothing written */
+  if (rv)
+    {
+      return HICN_HS_ERROR_FIFO_FULL;
+    }
+
+  ctx->bytes_in += data_len;
+
+  return HICN_HS_ERROR_ENQUEUED_OOO;
+}
+
+always_inline int
+hicn_hs_rcv_stream (hicn_hs_worker_t * wrk, hicn_hs_ctx_t * ctx,
+		    vlib_buffer_t * b)
+{
+  u32 error;
+  size_t n_data_bytes, skip;
+  hicn_hs_buffer_t *buffer = hicn_hs_buffer (b);
+  hicn_header_t *hicn_header;
+  int rv;
+  u8 rst = 0;
+  hicn_name_t data_name;
+  
+  /* XXX Assuming no signature for now. */
+  hicn_header = vlib_buffer_get_current (b);
+
+  rv = hicn_ops_vft[buffer->type.l1]->get_payload_length (buffer->type, &hicn_header->protocol, (size_t *)(&n_data_bytes));
+  rv += hicn_ops_vft[buffer->type.l1]->get_header_length (buffer->type, &hicn_header->protocol, (size_t *)(&skip));
+  rv += hicn_ops_vft[buffer->type.l1]->get_data_name (buffer->type, &hicn_header->protocol, &data_name);
+  rv += hicn_name_compare (&ctx->consumer_name, &data_name, 0);
+
+  vlib_buffer_advance (b, skip);
+
+  if (PREDICT_FALSE(rv < 0))
+    {
+      error = HICN_HS_ERROR_FORMAT;
+      return error;
+    }
+  
+//   TODO hicn_packet_test_rst (hicn_header, (bool *)(&rst));
+  if (PREDICT_FALSE (rst))
+    ctx->download_content_size = (buffer->seq_number - 1) * ctx->mss + n_data_bytes;
+	
+  ASSERT (n_data_bytes);
+
+  /* Adjust seq number in order to represent byte number */
+  buffer->seq_number *= ctx->mss;
+
+  /* Handle out-of-order data */
+  if (PREDICT_FALSE (buffer->seq_number != ctx->rcv_nxt))
+    {
+      rv = hicn_hs_enqueue_ooo (ctx, b, n_data_bytes);
+    }
+  else
+    /* In order data, enqueue. Fifo figures out by itself if any out-of-order
+     * segments can be enqueued after fifo tail offset changes. */
+    rv = hicn_hs_enqueue_data (ctx, b, n_data_bytes);
+  
+  vlib_buffer_push_uninit(b, skip);
+
+  return rv;
+}
+
+always_inline
+void hicn_hs_process_incoming_interest (hicn_hs_ctx_t *ctx, vlib_buffer_t* interest)
+{
+  hicn_hs_buffer_t *buffer;
+  vlib_buffer_t *data_packet;
+  hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_context (ctx);
+  session_main_t *smm = vnet_get_session_main ();
+  hicn_hs_main_t *hm = hicn_hs_get_main ();
+  vlib_main_t *vm = wrk->vm;
+  obuffer_kv4_t kv;
+  int rv;
+  session_type_t st;
+  u32 suffix;
+  u32 interest_index;
+
+  transport_proto_t proto = hm->transport_protocol_id;
+  st = session_type_from_proto_and_ip (proto, ctx->c_is_ip4);
+
+  buffer = hicn_hs_buffer (interest);
+
+  if (PREDICT_FALSE(!ctx->accepted))
+    {
+      session_stream_accept(&ctx->connection, ctx->session_index, 0, 1);
+      ctx->accepted = 1;
+    }
+
+  interest_index = vlib_get_buffer_index (wrk->vm, interest);
+
+  // Check for match in local output buffer
+  if (PREDICT_FALSE(buffer->is_ip4))
+    {
+      // Handle ip4 case
+      return;
+    }
+  else
+  {
+    hicn_hs_buffer_t *b = hicn_hs_buffer (interest);
+    ip6_header_t *ip6 = vlib_buffer_get_current (interest);
+    hicn_protocol_t *proto = (hicn_protocol_t *)(ip6);
+    hicn_ops_vft[b->type.l1]->get_interest_name_suffix(b->type, proto, &suffix);
+    make_obuffer_kv(&kv, (ip46_address_t *)&ip6->dst_address, suffix, ~0);
+    rv = clib_bihash_search_inline_24_8(&ctx->output_buffer, &kv);
+    if (PREDICT_TRUE(!rv))
+      {
+	u32 bi = (u32) kv.value;
+
+        // Retrieve corresponding data packet
+	data_packet = vlib_get_buffer(vm, bi);
+
+	hicn_header_t *interest = (hicn_header_t *)(proto);
+	hicn_header_t *data = vlib_buffer_get_current (data_packet);
+	
+	ASSERT(!hicn_hs_buffer (data_packet)->is_interest);
+	hicn_hs_buffer (data_packet)->ctx_index = ctx->c_c_index;
+	hicn_hs_buffer (data_packet)->flush = 1;
+
+	data->v6.ip.daddr = interest->v6.ip.saddr;
+	
+	hicn_hs_enqueue_to_output (vm, smm, data_packet, bi, 0, st);
+      }
+    else
+      {
+	/**
+	 * What it is better to do here is allocate connection upon
+	 * interest reception, once. This will allow to get the thread index,
+	 * the one which received the interest. The idea is that all interests
+	 * for same content should be processed by same thread. We cannot use
+	 * RSS hashing, since the source address will change..
+	 * Solutions:
+	 *   - Dispatcher node BEFORE hicn network plugin, doing exactly the same of RSS hashing
+	 *   - Configure hashing function in order to consider hICN-meaningful part of the packet
+	 */
+
+	if (ip46_address_is_equal ((ip46_address_t *) (&ctx->current_production_name.prefix),
+				   (ip46_address_t *) (&ip6->dst_address)))
+	  {
+	    /**
+	     * Content currently in production.
+	     **/
+	    if (PREDICT_FALSE(suffix >= ctx->number_of_segments))
+	      goto cleanup;
+	    
+	    kv.value = interest_index;
+	    clib_bihash_add_del_24_8 (&ctx->output_buffer, &kv, 1);
+	    return;
+	  }
+	
+	// Signal this cache miss to parent app.
+	// session_enqueue_dgram_connection(ctx->c_s_index, )
+	ip46_address_copy((ip46_address_t *) (&ctx->current_production_name.prefix),
+			  (ip46_address_t *) (&ip6->dst_address));
+	ctx->current_production_name.suffix = 0;
+	kv.value = interest_index;
+	clib_bihash_add_del_24_8 (&ctx->output_buffer, &kv, 1);
+	hicn_hs_app_notify_rx (ctx);
+	return;
+      }
+  }
+
+cleanup:
+  vlib_buffer_free_one (wrk->vm, interest_index);
+}
+
+always_inline
+void hicn_hs_process_incoming_data(hicn_hs_ctx_t *ctx, vlib_buffer_t* data)
+{
+  hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_context (ctx);
+  hicn_hs_rcv_stream (wrk, ctx, data);
+
+  /**
+   * If stream connection, tcp seq number in data packet stores
+   * the byte number of the first byte of data in the TCP packet sent.
+   */
+  
+}
+
+#endif  /* __included_hicn_hs_inlines_h__ */
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/input_node.c b/hicn-plugin/src/host_stack/input_node.c
new file mode 100644
index 000000000..962f8a204
--- /dev/null
+++ b/hicn-plugin/src/host_stack/input_node.c
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vlibmemory/api.h>
+#include <vlib/vlib.h>
+
+#include "host_stack.h"
+#include "inlines.h"
+
+#include <vppinfra/hash.h>
+#include <vppinfra/error.h>
+#include <vppinfra/elog.h>
+
+#include <vnet/vnet.h>
+#include <vnet/pg/pg.h>
+#include <vnet/ip/ip.h>
+#include <vnet/udp/udp.h>
+#include <vnet/udp/udp_packet.h>
+#include <vnet/session/session.h>
+
+typedef enum _hicn_hs_input_next
+{
+  HICN_HS_INPUT_NEXT_DATA,
+  HICN_HS_INPUT_NEXT_INTEREST,
+  HICN_HS_INPUT_NEXT_DROP,
+  HICN_HS_INPUT_N_NEXT
+} hicn_hs_input_next_t;
+
+#define foreach_hicn_hs_input_next4                 \
+  _ (DATA, HICN_HS_INPUT_DATA_NODE_NAME)	    \
+  _ (INTEREST, HICN_HS_INPUT_INTEREST_NODE_NAME)    \
+  _ (DROP, "ip4-drop")
+
+#define foreach_hicn_hs_input_next6                 \
+  _ (DATA, HICN_HS_INPUT_DATA_NODE_NAME)	    \
+  _ (INTEREST, HICN_HS_INPUT_INTEREST_NODE_NAME)    \
+  _ (DROP, "ip6-drop")
+
+/* packet trace format function */
+static u8 *
+format_hicn_hs_input4_trace (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+static u8 *
+format_hicn_hs_input6_trace (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+static u8 *
+format_hicn_hs_input_interest_trace (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+static u8 *
+format_hicn_hs_input_data_trace (u8 * s, va_list * args)
+{
+  return NULL;
+}
+
+static void
+hicn_hs_input_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node,
+		       vlib_buffer_t ** bs, u32 n_bufs, u8 is_ip4)
+{
+}
+
+always_inline hicn_hs_ctx_t *
+hicn_hs_input_lookup_buffer (vlib_buffer_t * b, u8 thread_index, u32 * error,
+			     u8 is_ip4)
+{
+  hicn_hs_ctx_t *ctx = 0;
+  hicn_header_t *hicn;
+  hicn_hs_buffer_t *buffer;
+  u32 ctx_index;
+  int ret;
+  u8 *packet_buffer;
+  u32 seq_number;
+  
+  hicn = hicn_buffer_hdr (b);
+  buffer = hicn_hs_buffer (b);
+  packet_buffer = vlib_buffer_get_current (b);
+
+  buffer->type.l4 = IPPROTO_NONE;
+  buffer->type.l3 = IPPROTO_NONE;
+  buffer->type.l2 = packet_buffer[6 + is_ip4 * 3];
+  buffer->type.l1 = (!is_ip4) * (IPPROTO_IPV6);
+
+  ret = hicn_ops_vft[buffer->type.l1]->test_packet_is_interest(buffer->type, &hicn->protocol, &buffer->is_interest);
+
+  if (PREDICT_FALSE(ret < 0))
+    {
+      *error = HICN_HS_ERROR_NO_HICN;
+      return ctx;
+    }
+  
+  if (buffer->is_interest)
+    {
+      ctx_index = vnet_buffer (b)->ip.adj_index[VLIB_TX];
+    }
+  else
+    {
+      ctx_index = vnet_buffer (b)->ip.adj_index[VLIB_TX];
+      hicn_ops_vft[buffer->type.l1]->get_data_name_suffix (buffer->type, &hicn->protocol, &seq_number);
+    }
+
+  ctx = hicn_hs_get_ctx_by_index(ctx_index, thread_index);
+
+  if (PREDICT_FALSE(!ctx))
+    *error = HICN_HS_ERROR_WRONG_THREAD;
+
+  buffer->seq_number = seq_number;
+  buffer->is_ip4 = is_ip4;
+
+  return ctx;
+}
+
+static inline void
+hicn_hs_input_dispatch_buffer (hicn_hs_main_t * hm, hicn_hs_ctx_t * ctx,
+			       vlib_buffer_t * b, u16 * next,
+			       vlib_node_runtime_t * error_node)
+{
+  u32 error;
+  hicn_hs_buffer_t *buffer = hicn_hs_buffer (b);
+  *next = hm->dispatch_table[buffer->is_interest].next;
+  error = hm->dispatch_table[buffer->is_interest].error;
+  b->error = error_node->errors[error];
+}
+
+always_inline void
+hicn_hs_input_set_error_next (hicn_hs_main_t * tm, u16 * next, u32 * error, u8 is_ip4)
+{
+  *next = HICN_HS_INPUT_NEXT_DROP;
+}
+
+always_inline uword
+hicn_hs_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
+		      vlib_frame_t * frame, u8 is_ip4)
+{
+  u32 n_left_from, *from, thread_index = vm->thread_index;
+  hicn_hs_main_t *hm = hicn_hs_get_main ();
+  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
+  u16 nexts[VLIB_FRAME_SIZE], *next;
+  vlib_node_runtime_t *error_node;
+
+//   tcp_set_time_now (tcp_get_worker (thread_index));
+
+  error_node = vlib_node_get_runtime (vm, is_ip4 ? hicn_hs_input4_node.index : hicn_hs_input6_node.index);
+  from = vlib_frame_vector_args (frame);
+  n_left_from = frame->n_vectors;
+  vlib_get_buffers (vm, from, bufs, n_left_from);
+
+  b = bufs;
+  next = nexts;
+
+  while (n_left_from >= 4)
+    {
+      u32 error0 = HICN_HS_ERROR_NO_CONTEXT, error1 = HICN_HS_ERROR_NO_CONTEXT;
+      hicn_hs_ctx_t *ctx0, *ctx1;
+
+      {
+	vlib_prefetch_buffer_header (b[2], STORE);
+	CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+
+	vlib_prefetch_buffer_header (b[3], STORE);
+	CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+      }
+
+      next[0] = next[1] = HICN_HS_INPUT_NEXT_DROP;
+
+      ctx0 = hicn_hs_input_lookup_buffer (b[0], thread_index, &error0, is_ip4);
+      ctx1 = hicn_hs_input_lookup_buffer (b[1], thread_index, &error1, is_ip4);
+
+      if (PREDICT_TRUE (!ctx0 + !ctx1 == 0))
+	{
+	  hicn_hs_input_dispatch_buffer (hm, ctx0, b[0], &next[0], error_node);
+	  hicn_hs_input_dispatch_buffer (hm, ctx1, b[1], &next[1], error_node);
+	}
+      else
+	{
+	  if (PREDICT_TRUE (ctx0 != 0))
+	    {
+	      hicn_hs_input_dispatch_buffer (hm, ctx0, b[0], &next[0], error_node);
+	    }
+	  else
+	    {
+	      hicn_hs_input_set_error_next (hm, &next[0], &error0, is_ip4);
+	      b[0]->error = error_node->errors[error0];
+	    }
+
+	  if (PREDICT_TRUE (ctx1 != 0))
+	    {
+	      hicn_hs_input_dispatch_buffer (hm, ctx1, b[1], &next[1], error_node);
+	    }
+	  else
+	    {
+	      hicn_hs_input_set_error_next (hm, &next[1], &error1, is_ip4);
+	      b[1]->error = error_node->errors[error1];
+	    }
+	}
+
+      b += 2;
+      next += 2;
+      n_left_from -= 2;
+    }
+  while (n_left_from > 0)
+    {
+      hicn_hs_ctx_t *ctx0;
+      u32 error0 = HICN_HS_ERROR_NO_CONTEXT;
+
+      if (n_left_from > 1)
+	{
+	  vlib_prefetch_buffer_header (b[1], STORE);
+	  CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+	}
+
+      next[0] = HICN_HS_INPUT_NEXT_DROP;
+      ctx0 = hicn_hs_input_lookup_buffer (b[0], thread_index, &error0, is_ip4);
+      if (PREDICT_TRUE (ctx0 != 0))
+	{
+	  hicn_hs_input_dispatch_buffer (hm, ctx0, b[0], &next[0], error_node);
+	}
+      else
+	{
+	  hicn_hs_input_set_error_next (hm, &next[0], &error0, is_ip4);
+	  b[0]->error = error_node->errors[error0];
+	}
+
+      b += 1;
+      next += 1;
+      n_left_from -= 1;
+    }
+
+  if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
+    hicn_hs_input_trace_frame (vm, node, bufs, frame->n_vectors, is_ip4);
+
+  vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
+  return frame->n_vectors;
+}
+
+static uword
+hicn_hs_input_data (vlib_main_t * vm, vlib_node_runtime_t * node,
+	    	    vlib_frame_t * from_frame)
+{
+  u32 n_left_from, *from, *first_buffer;
+  u32 thread_index = vm->thread_index;
+  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
+  u32 node_index = hicn_hs_input_data_node.index; 
+
+  from = first_buffer = vlib_frame_vector_args (from_frame);
+  n_left_from = from_frame->n_vectors;
+  vlib_get_buffers (vm, from, bufs, n_left_from);
+
+  b = bufs;
+
+  hicn_hs_ctx_t *ctx0 = 0;
+
+  while (n_left_from >= 4)
+    {
+      u32 ctxi0, ctxi1;
+      hicn_hs_ctx_t *ctx1;
+
+      {
+	vlib_prefetch_buffer_header (b[2], STORE);
+	CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+
+	vlib_prefetch_buffer_header (b[3], STORE);
+	CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
+      }
+
+      // ctxi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
+      ctxi0 = hicn_hs_buffer (b[0])->ctx_index;
+      ctx0 = hicn_hs_get_ctx_by_index(ctxi0, thread_index);
+      // ctxi1 = vnet_buffer (b[1])->ip.adj_index[VLIB_TX];
+      ctxi1 = hicn_hs_buffer (b[1])->ctx_index;
+      ctx1 = hicn_hs_get_ctx_by_index(ctxi1, thread_index);
+
+      ASSERT (ctx0 && ctx1);
+
+      hicn_hs_process_incoming_data (ctx0, b[0]);
+      hicn_hs_process_incoming_data (ctx1, b[1]);
+
+      b += 2;
+      n_left_from -= 2;
+    }
+
+  while (n_left_from > 0)
+    {
+      
+      u32 ctxi0;
+
+      // ctxi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
+      ctxi0 = hicn_hs_buffer (b[0])->ctx_index;
+      ctx0 = hicn_hs_get_ctx_by_index(ctxi0, thread_index);
+
+      ASSERT (ctx0);
+
+      hicn_hs_process_incoming_data (ctx0, b[0]);
+
+      b += 1;
+      n_left_from -= 1;
+    }
+
+  hicn_hs_update_transport (ctx0, from_frame->n_vectors);
+
+//   vlib_buffer_free (vm, first_buffer, from_frame->n_vectors);
+  vlib_node_increment_counter (vm, node_index, HICN_HS_ERROR_PACKETS_SENT, from_frame->n_vectors);
+  return from_frame->n_vectors;
+}
+
+static uword
+hicn_hs_input_interest (vlib_main_t * vm, vlib_node_runtime_t * node,
+	    	        vlib_frame_t * from_frame)
+{
+  u32 n_left_from, *from, *first_buffer;
+  u32 thread_index = vm->thread_index;
+  u32 ctx_index;
+
+  u32 node_index = hicn_hs_input_interest_node.index;
+
+  from = first_buffer = vlib_frame_vector_args (from_frame);
+  n_left_from = from_frame->n_vectors;
+
+  while (n_left_from > 0)
+    {
+      u32 bi, CLIB_UNUSED(error) = HICN_HS_ERROR_NONE;
+      hicn_hs_ctx_t *ctx;
+      vlib_buffer_t *b;
+
+      bi = from[0];
+      from += 1;
+      n_left_from -= 1;
+
+      b = vlib_get_buffer (vm, bi);
+      ctx_index = vnet_buffer (b)->ip.adj_index[VLIB_TX];
+      ctx = hicn_hs_get_ctx_by_index(ctx_index, thread_index);
+      hicn_hs_process_incoming_interest(ctx, b);
+    }
+
+  vlib_node_increment_counter (vm, node_index, HICN_HS_ERROR_PACKETS_SENT, from_frame->n_vectors);
+  return from_frame->n_vectors;
+}
+
+static uword
+hicn_hs_input4 (vlib_main_t * vm, vlib_node_runtime_t * node,
+	    vlib_frame_t * frame)
+{
+  return hicn_hs_input_inline (vm, node, frame, 1);
+}
+
+static uword
+hicn_hs_input6 (vlib_main_t * vm, vlib_node_runtime_t * node,
+	    vlib_frame_t * frame)
+{
+  return hicn_hs_input_inline (vm, node, frame, 0);
+}
+
+/* *INDENT-OFF* */
+
+VLIB_REGISTER_NODE (hicn_hs_input_interest_node) =
+{
+  .function = hicn_hs_input_interest,
+  .name = HICN_HS_INPUT_INTEREST_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .format_trace = format_hicn_hs_input_interest_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = 0,
+};
+
+VLIB_REGISTER_NODE (hicn_hs_input_data_node) =
+{
+  .function = hicn_hs_input_data,
+  .name = HICN_HS_INPUT_DATA_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .format_trace = format_hicn_hs_input_data_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = 0,
+};
+
+VLIB_REGISTER_NODE (hicn_hs_input4_node) =
+{
+  .function = hicn_hs_input4,
+  .name = HICN_HS_INPUT4_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .format_trace = format_hicn_hs_input4_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = HICN_HS_INPUT_N_NEXT,
+  .next_nodes =
+  {
+#define _(s,n) [HICN_HS_INPUT_NEXT_##s] = n,
+    foreach_hicn_hs_input_next4
+#undef _
+  },
+};
+
+VLIB_REGISTER_NODE (hicn_hs_input6_node) =
+{
+  .function = hicn_hs_input6,
+  .name = HICN_HS_INPUT6_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .format_trace = format_hicn_hs_input6_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = HICN_HS_INPUT_N_NEXT,
+  .next_nodes =
+  {
+#define _(s,n) [HICN_HS_INPUT_NEXT_##s] = n,
+    foreach_hicn_hs_input_next6
+#undef _
+  },
+};
+
+/* *INDENT-ON* */
+
+static void
+hicn_hs_dispatch_table_init (hicn_hs_main_t * tm)
+{
+  int i;
+  for (i = 0; i < ARRAY_LEN (tm->dispatch_table); i++)
+    {
+      tm->dispatch_table[i].next = HICN_HS_INPUT_NEXT_DROP;
+      tm->dispatch_table[i].error = HICN_HS_ERROR_DISPATCH;
+    }
+
+#define _(t,n,e)                                           	\
+do {                                                       	\
+    tm->dispatch_table[HICN_HS_##t].next = (n);         	\
+    tm->dispatch_table[HICN_HS_##t].error = (e);        	\
+} while (0)
+
+  _ (INTEREST, HICN_HS_INPUT_NEXT_INTEREST, HICN_HS_ERROR_NONE);
+  _ (DATA, HICN_HS_INPUT_NEXT_DATA, HICN_HS_ERROR_NONE);
+
+#undef _
+}
+
+static clib_error_t *
+hicn_hs_input_init (vlib_main_t * vm)
+{
+  hicn_hs_main_t *hm = hicn_hs_get_main ();
+
+  /* Initialize dispatch table. */
+  hicn_hs_dispatch_table_init (hm);
+
+  return 0;
+}
+
+VLIB_INIT_FUNCTION (hicn_hs_input_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/host_stack/output_node.c b/hicn-plugin/src/host_stack/output_node.c
new file mode 100644
index 000000000..8e5f1e307
--- /dev/null
+++ b/hicn-plugin/src/host_stack/output_node.c
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vlibmemory/api.h>
+#include <vlib/vlib.h>
+
+#include "host_stack.h"
+#include "inlines.h"
+
+#include <vppinfra/hash.h>
+#include <vppinfra/error.h>
+#include <vppinfra/elog.h>
+
+#include <vnet/vnet.h>
+#include <vnet/pg/pg.h>
+#include <vnet/ip/ip.h>
+#include <vnet/udp/udp.h>
+#include <vnet/udp/udp_packet.h>
+#include <vnet/session/session.h>
+
+typedef enum _hicn_hs_output_next
+{
+  HICN_HS_OUTPUT_NEXT_IP_LOOKUP,
+  HICN_HS_OUTPUT_NEXT_NO_FLUSH,
+  HICN_HS_OUTPUT_N_NEXT
+} hicn_hs_output_next_t;
+
+/**
+ * Next nodes.
+ */
+#define foreach_hicn_hs_output4_next		\
+  _ (IP_LOOKUP, "ip4-lookup")			\
+  _ (NO_FLUSH, "hicn_hs-no-flush")		
+//   _ (DROP, "ip4-drop")
+
+
+#define foreach_hicn_hs_output6_next		\
+  _ (IP_LOOKUP, "ip6-lookup")			\
+  _ (NO_FLUSH, "hicn_hs-no-flush")		
+//   _ (DROP, "ip6-drop")
+
+
+typedef enum
+{
+#define _(s, n) HICN_HS_OUTPUT4_NEXT_##s,
+  foreach_hicn_hs_output4_next
+#undef _
+    HICN_HS_OUTPUT4_N_NEXT,
+} hicn_hs_output4_next_t;
+
+typedef enum
+{
+#define _(s, n) HICN_HS_OUTPUT6_NEXT_##s,
+  foreach_hicn_hs_output6_next
+#undef _
+    HICN_HS_OUTPUT6_N_NEXT,
+} hicn_hs_output6_next_t;
+
+typedef struct
+{
+  u32 next_index;
+  hicn_name_t name;
+} hicn_hs_output_trace_t;
+
+always_inline u8 *
+format_hicn_hs_output_trace_i (u8 * s, va_list * args)
+{
+  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
+  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
+  hicn_hs_output_trace_t *t = va_arg (*args, hicn_hs_output_trace_t *);
+  char name[64];
+  u32 indent = format_get_indent (s);
+
+  hicn_name_ntop(&t->name, name, 64);
+  s = format (s, "hicn_hs_output: next-index %d",  t->next_index);
+  s = format (s, "\n%Upacket: name %s", format_white_space, indent + 2,
+	      name);
+  return s;
+}
+
+static u8 *
+format_hicn_hs_output4_trace (u8 * s, va_list * args)
+{
+  return format_hicn_hs_output_trace_i(s, args);
+}
+
+static u8 *
+format_hicn_hs_output6_trace (u8 * s, va_list * args)
+{
+  return format_hicn_hs_output_trace_i(s, args);
+}
+
+static_always_inline void
+hicn_hs_trace_buffer (vlib_main_t * vm, vlib_node_runtime_t * node,
+                      vlib_buffer_t * b, u32 next, uword * n_tracep)
+{
+  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
+
+  if (PREDICT_TRUE (b != 0))
+    {
+      hicn_hs_output_trace_t *tr;
+      vlib_trace_buffer (vm, node, next, b, /* follow_chain */ 0);
+      vlib_set_trace_count (vm, node, --(*n_tracep));
+      tr = vlib_add_trace (vm, node, b, sizeof (*tr));
+      tr->next_index = next;
+//       hicn_interest_get_name(HF_INET6_TCP,
+//       			    (const hicn_header_t *)vlib_buffer_get_current(b),
+// 			    &tr->name);
+    }
+}
+
+always_inline uword
+hicn_hs_output_inline (vlib_main_t * vm,
+		      vlib_node_runtime_t * node,
+		      vlib_frame_t * frame, int is_ip4)
+{
+  u32 n_left_from, *from, thread_index = vm->thread_index;
+  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
+  u16 nexts[VLIB_FRAME_SIZE], *next;
+
+  uword n_trace = vlib_get_trace_count (vm, node);
+
+  u32 node_index = is_ip4 ? hicn_hs_output4_node.index : hicn_hs_output6_node.index;
+
+  from = vlib_frame_vector_args (frame);
+  n_left_from = frame->n_vectors;
+
+  vlib_get_buffers (vm, from, bufs, n_left_from);
+  b = bufs;
+  next = nexts;
+
+  while (n_left_from >= 4)
+    {
+      hicn_hs_ctx_t *hc0, *hc1;
+      u8 flush0, flush1;
+
+      {
+	vlib_prefetch_buffer_header (b[2], STORE);
+	CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+
+	vlib_prefetch_buffer_header (b[3], STORE);
+	CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+      }
+
+      hc0 = hicn_hs_get_ctx_by_index (hicn_hs_buffer (b[0])->ctx_index, thread_index);
+      hc1 = hicn_hs_get_ctx_by_index (hicn_hs_buffer (b[1])->ctx_index, thread_index);
+      flush0 = hicn_hs_buffer(b[0])->flush;
+      flush1 = hicn_hs_buffer(b[1])->flush;
+
+      ASSERT (hc0 && hc1);
+
+      vnet_buffer (b[0])->sw_if_index[VLIB_TX] = hc0->c_fib_index;
+      vnet_buffer (b[0])->sw_if_index[VLIB_RX] = 0;
+      next[0] = !flush0;
+
+      vnet_buffer (b[1])->sw_if_index[VLIB_TX] = hc1->c_fib_index;
+      vnet_buffer (b[1])->sw_if_index[VLIB_RX] = 0;
+      next[1] = !flush1;
+
+      if (PREDICT_FALSE (n_trace > 0))
+        {
+	  hicn_hs_trace_buffer (vm, node, b[0], next[0], &n_trace);
+	  if (PREDICT_FALSE (n_trace > 0))
+	    hicn_hs_trace_buffer (vm, node, b[1], next[1], &n_trace);
+	}
+
+      b += 2;
+      n_left_from -= 2;
+      next += 2;
+    }
+  while (n_left_from > 0)
+    {
+      hicn_hs_ctx_t *hc0;
+      u8 flush0;
+
+      if (n_left_from > 1)
+	{
+	  vlib_prefetch_buffer_header (b[1], STORE);
+	  CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, STORE);
+	}
+
+      hc0 = hicn_hs_get_ctx_by_index (hicn_hs_buffer (b[0])->ctx_index, thread_index);
+      flush0 = hicn_hs_buffer(b[0])->flush;
+
+      ASSERT (hc0);
+
+      vnet_buffer (b[0])->sw_if_index[VLIB_TX] = hc0->c_fib_index;
+      vnet_buffer (b[0])->sw_if_index[VLIB_RX] = 0;
+      next[0] = !flush0;
+
+      if (PREDICT_FALSE (n_trace > 0))
+	hicn_hs_trace_buffer (vm, node, b[0], next[0], &n_trace);
+
+      b += 1;
+      n_left_from -= 1;
+      next += 1;
+    }
+
+  vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
+  vlib_node_increment_counter (vm, node_index, HICN_HS_ERROR_PACKETS_SENT, frame->n_vectors);
+  
+  return frame->n_vectors;
+}
+
+static uword
+hicn_hs_output4_node_fn (vlib_main_t * vm,
+		       vlib_node_runtime_t * node,
+		       vlib_frame_t * frame)
+{
+  return hicn_hs_output_inline (vm, node, frame, 1);
+}
+
+static uword
+hicn_hs_output6_node_fn (vlib_main_t * vm,
+		       vlib_node_runtime_t * node,
+		       vlib_frame_t * frame)
+{
+  return hicn_hs_output_inline (vm, node, frame, 0);
+}
+
+static uword
+hicn_hs_no_flush_node_fn (vlib_main_t * vm,
+		          vlib_node_runtime_t * node,
+		          vlib_frame_t * frame)
+{
+  return frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (hicn_hs_no_flush_node) = {
+  .function = hicn_hs_no_flush_node_fn,
+  .name = "hicn_hs-no-flush",
+  .vector_size = sizeof (u32),
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = 0,
+  .next_nodes = {},
+};
+
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (hicn_hs_output4_node) = {
+  .function = hicn_hs_output4_node_fn,
+  .name = HICN_HS_OUTPUT4_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
+  .format_trace = format_hicn_hs_output4_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = HICN_HS_OUTPUT4_N_NEXT,
+  .next_nodes = {
+#define _(s, n) [HICN_HS_OUTPUT4_NEXT_##s] = n,
+      foreach_hicn_hs_output4_next
+#undef _
+  },
+};
+
+VLIB_REGISTER_NODE (hicn_hs_output6_node) = {
+  .function = hicn_hs_output6_node_fn,
+  .name = HICN_HS_OUTPUT6_NODE_NAME,
+  .vector_size = sizeof (u32),
+  .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
+  .format_trace = format_hicn_hs_output6_trace,
+  .type = VLIB_NODE_TYPE_INTERNAL,
+  .n_errors = HICN_HS_N_ERROR,
+  .error_strings = hicn_hs_error_strings,
+  .n_next_nodes = HICN_HS_OUTPUT6_N_NEXT,
+  .next_nodes = {
+#define _(s, n) [HICN_HS_OUTPUT6_NEXT_##s] = n,
+      foreach_hicn_hs_output6_next
+#undef _
+  },
+};
+
+/* *INDENT-ON* */
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/producer_dpo.c b/hicn-plugin/src/host_stack/producer_dpo.c
new file mode 100644
index 000000000..c7b77705d
--- /dev/null
+++ b/hicn-plugin/src/host_stack/producer_dpo.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "producer_dpo.h"
+#include "host_stack.h"
+
+#include <vnet/ip/format.h>
+#include <vnet/adj/adj.h>
+#include <vnet/vnet.h>
+#include <vlib/vlib.h>
+
+dpo_type_t hicn_hs_dpo_type;
+
+const static char *const hicn_hs_prod_dpo4_nodes[] = {
+  "hicn_hs-input4",
+  NULL,
+};
+
+const static char *const hicn_hs_prod_dpo6_nodes[] = {
+  "hicn_hs-input6",
+  NULL,
+};
+
+const static char *const *const hicn_hs_prod_dpo_nodes[DPO_PROTO_NUM] = {
+  [DPO_PROTO_IP4] = hicn_hs_prod_dpo4_nodes,
+  [DPO_PROTO_IP6] = hicn_hs_prod_dpo6_nodes
+};
+
+void hicn_hs_prod_dpo_lock(dpo_id_t *dpo)
+{
+  return;
+}
+
+void hicn_hs_prod_dpo_unlock(dpo_id_t *dpo)
+{
+  return;
+}
+
+u8 *format_hicn_hs_prod_dpo (u8 * s, va_list * args)
+{
+  return s;
+}
+
+const static dpo_vft_t hicn_hs_prod_dpo_vft = {
+  .dv_lock = hicn_hs_prod_dpo_lock,
+  .dv_unlock = hicn_hs_prod_dpo_unlock,
+  .dv_format = format_hicn_hs_prod_dpo,
+};
+
+/**
+ * Register the new DPO type.
+ */
+void hicn_hs_dpo_module_init(void)
+{
+  hicn_hs_dpo_type = dpo_register_new_type (&hicn_hs_prod_dpo_vft, hicn_hs_prod_dpo_nodes);
+}
+
+int dpo_is_hicn_hs(const dpo_id_t *dpo)
+{
+  return dpo->dpoi_type == hicn_hs_dpo_type;
+}
+
+u32 hicn_hs_dpo_create(u32 hicn_hs_ctx_idx, u8 is_ip4, dpo_id_t *dpo)
+{
+  dpo->dpoi_type = DPO_FIRST;
+  dpo->dpoi_proto = DPO_PROTO_NONE;
+  dpo->dpoi_index = INDEX_INVALID;
+  dpo->dpoi_next_node = 0;
+
+  u16 next_node = is_ip4 ? hicn_hs_input4_node.index : hicn_hs_input6_node.index;
+  
+  index_t dpoi_index = hicn_hs_ctx_idx;
+  dpo_set(dpo, hicn_hs_dpo_type, is_ip4 ? DPO_PROTO_IP4 : DPO_PROTO_IP6, dpoi_index);
+  dpo->dpoi_next_node = next_node;
+  dpo_unlock (dpo);
+
+  return HICN_HS_ERROR_NONE;
+}
diff --git a/hicn-plugin/src/host_stack/producer_dpo.h b/hicn-plugin/src/host_stack/producer_dpo.h
new file mode 100644
index 000000000..ac748589b
--- /dev/null
+++ b/hicn-plugin/src/host_stack/producer_dpo.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @brief The hicn_hs dpo. It will store the 2 hicn_hs input nodes,
+ * altogether with the index of the corresponding hicn socket, in order
+ * to avoid a double lookup.
+ */
+
+#ifndef __HICN_HS_DPO_H__
+#define  __HICN_HS_DPO_H__
+
+#include <vnet/dpo/dpo.h>
+
+extern dpo_type_t hicn_hs_dpo_type;
+
+int dpo_is_hicn_hs(const dpo_id_t *dpo);
+u32 hicn_hs_dpo_create(u32 hicn_hs_ctx_idx, u8 is_ip4, dpo_id_t *dpo);
+void hicn_hs_dpo_module_init(void);
+
+#endif /* __HICN_HS_DPO_H__ */
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/proto.h b/hicn-plugin/src/host_stack/proto.h
new file mode 100644
index 000000000..0c89317a6
--- /dev/null
+++ b/hicn-plugin/src/host_stack/proto.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __included_hicn_hs_proto__
+#define __included_hicn_hs_proto__
+
+#define PROTO_DATA_SIZE 32
+
+typedef enum hicn_hs_proto_event_
+{
+  PROTO_N_EVENT,
+} hicn_hs_proto_event_t;
+
+struct hicn_hs_proto_
+{
+  u32 (*init) (hicn_hs_ctx_t * hc);
+  u32 (*rcv_data) (hicn_hs_ctx_t * hc);
+  u32 (*rcv_interest) (hicn_hs_ctx_t * hc);
+  u32 (*on_interest_timeout) (hicn_hs_ctx_t *hc);
+  u32 (*event) (hicn_hs_ctx_t *hc, hicn_hs_proto_event_t event);
+  u32 (*next_seq_number) (hicn_hs_ctx_t *hc);
+  u8 proto_data[PROTO_DATA_SIZE];
+};
+
+typedef struct hicn_hs_proto_ hicn_hs_proto_t;
+
+always_inline void *
+hicn_hs_proto_data(hicn_hs_proto_t *proto)
+{
+  return (void*)(proto->proto_data);
+}
+
+always_inline u32
+hicn_hs_proto_init ();
+
+#enfif /* __included_hicn_hs_proto__ */
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/route.c b/hicn-plugin/src/host_stack/route.c
new file mode 100644
index 000000000..5b42bea26
--- /dev/null
+++ b/hicn-plugin/src/host_stack/route.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "host_stack.h"
+#include "route.h"
+
+#include <vnet/fib/fib_entry.h>
+#include <vnet/fib/fib_table.h>
+#include <vnet/ip/ip6_packet.h>
+#include <vnet/dpo/dpo.h>
+#include <vnet/dpo/load_balance.h>
+#include <vlib/global_funcs.h>
+#include <vnet/dpo/drop_dpo.h>
+
+#define FIB_SOURCE_HICN_HS 0x04	//Right after the FIB_SOURCE_INTERFACE priority
+#define HICN_HS_FIB_TABLE 0
+
+fib_source_t hicn_hs_fib_src;
+
+void
+hicn_hs_route_init ()
+{
+  hicn_hs_fib_src = fib_source_allocate ("hicn_hs", FIB_SOURCE_HICN_HS, FIB_SOURCE_BH_API);
+}
+
+always_inline int
+hicn_route_get_dpo (const fib_prefix_t * prefix,
+		    const dpo_id_t ** hicn_dpo, u32 * fib_index)
+{
+  //fib_prefix_t fib_pfx;
+  const dpo_id_t *load_balance_dpo_id;
+  const dpo_id_t *former_dpo_id;
+  int found = 0, ret = HICN_HS_ERROR_ROUTE_NOT_FOUND;
+  fib_node_index_t fib_entry_index;
+
+  /* Check if the route already exist in the fib */
+  /*
+   * ASSUMPTION: we use table 0 which is the default table and it is
+   * already existing and locked
+   */
+  *fib_index = fib_table_find_or_create_and_lock (prefix->fp_proto,
+						  HICN_HS_FIB_TABLE,
+						  hicn_hs_fib_src);
+  fib_entry_index = fib_table_lookup_exact_match (*fib_index, prefix);
+
+  if (fib_entry_index != FIB_NODE_INDEX_INVALID)
+    {
+      /* Route already existing. We need to update the dpo. */
+      load_balance_dpo_id =
+	fib_entry_contribute_ip_forwarding (fib_entry_index);
+
+      /* The dpo is not a load balance dpo as expected */
+      if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE)
+	ret = HICN_HS_ERROR_ROUTE_NO_LB_DPO;
+      else
+	{
+	  /* former_dpo_id is a load_balance dpo */
+	  load_balance_t *lb =
+	    load_balance_get (load_balance_dpo_id->dpoi_index);
+
+	  /* FIB entry exists but there is no hicn_hs dpo. */
+	  ret = HICN_HS_ERROR_ROUTE_DPO_NO_HICN;
+	  for (int i = 0; i < lb->lb_n_buckets && !found; i++)
+	    {
+	      former_dpo_id = load_balance_get_bucket_i (lb, i);
+
+	      if (dpo_is_hicn_hs (former_dpo_id))
+		{
+		  *hicn_dpo = former_dpo_id;
+		  ret = HICN_HS_ERROR_NONE;
+		  found = 1;
+		}
+	    }
+	}
+    }
+  /*
+   * Remove the lock from the table. We keep one lock per route, not
+   * per dpo
+   */
+  fib_table_unlock (*fib_index, prefix->fp_proto, hicn_hs_fib_src);
+
+  return ret;
+}
+
+/* Add a new route for a name prefix */
+always_inline
+int hicn_hs_route_add_flags (const fib_prefix_t * prefix, const dpo_id_t *dpo, fib_entry_flag_t flags)
+{
+  CLIB_UNUSED(vlib_main_t *vm) = vlib_get_main ();
+  int ret = HICN_HS_ERROR_NONE;
+  u32 fib_index;
+  const dpo_id_t *_dpo;
+
+  ret = hicn_route_get_dpo (prefix, &_dpo, &fib_index);
+
+  if (ret == HICN_HS_ERROR_ROUTE_NOT_FOUND)
+    {
+      /* Here is where we create the "via" like route */
+      /*
+       * For the moment we use the global one the prefix you want
+       * to match Neale suggested -- FIB_SOURCE_HICN the client
+       * that is adding them -- no easy explanation at this time…
+       */
+      fib_node_index_t new_fib_node_index =
+	fib_table_entry_special_dpo_add (fib_index,
+					 prefix,
+					 hicn_hs_fib_src,
+					 flags,
+					 dpo);
+
+      /* We added a route, therefore add one lock to the table */
+      fib_table_lock (fib_index, prefix->fp_proto, hicn_hs_fib_src);
+
+      ret =
+	(new_fib_node_index !=
+	 FIB_NODE_INDEX_INVALID) ? HICN_HS_ERROR_NONE :
+	HICN_HS_ERROR_ROUTE_NO_INSERT;
+    }
+
+  return ret;
+}
+
+int
+hicn_hs_route_add (const fib_prefix_t * prefix, const dpo_id_t *dpo)
+{
+  return hicn_hs_route_add_flags(prefix, dpo, (FIB_ENTRY_FLAG_EXCLUSIVE |
+					       FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
+}
+
+clib_error_t *
+hicn_hs_set_local_prefix(const fib_prefix_t * prefix)
+{
+  clib_error_t * ret = 0;
+  int rv;
+  const dpo_id_t *drop_dpo = drop_dpo_get(prefix->fp_proto == FIB_PROTOCOL_IP4 ? DPO_PROTO_IP4 : DPO_PROTO_IP6);
+  rv = hicn_hs_route_add_flags(prefix, drop_dpo, (FIB_ENTRY_FLAG_EXCLUSIVE | FIB_ENTRY_FLAG_LOCAL | FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
+
+  if (rv)
+    ret = clib_error_return (0, "Error: %s", hicn_hs_error_strings[rv]);
+  
+  return ret;
+}
+
+int
+hicn_route_del (fib_prefix_t * prefix)
+{
+  const dpo_id_t *hicn_dpo_id;
+  int ret = HICN_HS_ERROR_NONE;
+  u32 fib_index;
+
+  /* Remove the fib entry only if the dpo is of type hicn */
+  ret = hicn_route_get_dpo (prefix, &hicn_dpo_id, &fib_index);
+
+  if (ret == HICN_HS_ERROR_NONE)
+    {
+      fib_table_entry_special_remove (HICN_HS_FIB_TABLE, prefix, hicn_hs_fib_src);
+
+      /*
+       * Remove the lock from the table. We keep one lock per route
+       */
+      fib_table_unlock (fib_index, prefix->fp_proto, hicn_hs_fib_src);
+    }
+  
+  // Remember to remove the lock from the table when removing the entry
+  return ret;
+}
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/route.h b/hicn-plugin/src/host_stack/route.h
new file mode 100644
index 000000000..880a34687
--- /dev/null
+++ b/hicn-plugin/src/host_stack/route.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __HICN_HS_ROUTE_H__
+#define __HICN_HS_ROUTE_H__
+
+#include <vnet/fib/fib.h>
+#include <vnet/dpo/dpo.h>
+
+/* Init the route module */
+void
+hicn_hs_route_init ();
+
+clib_error_t *
+hicn_hs_set_local_prefix(const fib_prefix_t * prefix);
+
+/* Add a new route for a name prefix */
+int
+hicn_hs_route_add (const fib_prefix_t * prefix, const dpo_id_t *dpo);
+
+/* Remove route for a name prefix */
+int
+hicn_route_del (fib_prefix_t * prefix);
+
+#endif /* __HICN_HS_ROUTE_H__ */
diff --git a/hicn-plugin/src/host_stack/test/hicn_hs_client.c b/hicn-plugin/src/host_stack/test/hicn_hs_client.c
new file mode 100644
index 000000000..b5f27ee12
--- /dev/null
+++ b/hicn-plugin/src/host_stack/test/hicn_hs_client.c
@@ -0,0 +1,804 @@
+/*
+ * hicn_hs_client.c - vpp built-in hicn client
+ *
+ * Copyright (c) 2017-2019 by Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 <vnet/vnet.h>
+#include <vlibapi/api.h>
+#include <vlibmemory/api.h>
+
+#include "hicn_hs_client.h"
+#include "../host_stack.h"
+
+hicn_client_main_t hicn_client_main;
+
+#define HICN_CLIENT_DBG (0)
+#define DBG(_fmt, _args...)			\
+    if (HICN_CLIENT_DBG) 				\
+      clib_warning (_fmt, ##_args)
+
+#define ec_cli_output(_fmt, _args...) 			\
+  if (!hcm->no_output)  				\
+    vlib_cli_output(vm, _fmt, ##_args)
+
+f64 t0;
+
+static void
+signal_evt_to_cli_i (int *code)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  ASSERT (vlib_get_thread_index () == 0);
+  vlib_process_signal_event (hcm->vlib_main, hcm->cli_node_index, *code, 0);
+}
+
+static void
+signal_evt_to_cli (int code)
+{
+  if (vlib_get_thread_index () != 0)
+    vl_api_rpc_call_main_thread (signal_evt_to_cli_i, (u8 *) & code,
+				 sizeof (code));
+  else
+    signal_evt_to_cli_i (&code);
+}
+
+static void
+receive_data_chunk (hicn_client_main_t * hcm, eclient_session_t * s)
+{
+  svm_fifo_t *rx_fifo = s->data.rx_fifo;
+  u32 thread_index = vlib_get_thread_index ();
+  int n_read, i;
+
+  if (hcm->test_bytes)
+    {
+      if (!hcm->is_dgram)
+	n_read = app_recv_stream (&s->data, hcm->rx_buf[thread_index],
+				  vec_len (hcm->rx_buf[thread_index]));
+      else
+	n_read = app_recv_dgram (&s->data, hcm->rx_buf[thread_index],
+				 vec_len (hcm->rx_buf[thread_index]));
+    }
+  else
+    {
+      n_read = svm_fifo_max_dequeue_cons (rx_fifo);
+      svm_fifo_dequeue_drop (rx_fifo, n_read);
+    }
+
+  if (n_read > 0)
+    {
+      if (HICN_CLIENT_DBG)
+	{
+          /* *INDENT-OFF* */
+          ELOG_TYPE_DECLARE (e) =
+            {
+              .format = "rx-deq: %d bytes",
+              .format_args = "i4",
+            };
+          /* *INDENT-ON* */
+	  struct
+	  {
+	    u32 data[1];
+	  } *ed;
+	  ed = ELOG_DATA (&vlib_global_main.elog_main, e);
+	  ed->data[0] = n_read;
+	}
+
+      if (hcm->test_bytes)
+	{
+	  for (i = 0; i < n_read; i++)
+	    {
+	      if (hcm->rx_buf[thread_index][i]
+		  != ((s->bytes_received + i) & 0xff))
+		{
+		  clib_warning ("read %d error at byte %lld, 0x%x not 0x%x",
+				n_read, s->bytes_received + i,
+				hcm->rx_buf[thread_index][i],
+				((s->bytes_received + i) & 0xff));
+		  hcm->test_failed = 1;
+		}
+	    }
+	}
+      vlib_main_t *vm = vlib_get_main();
+      hcm->test_end_time = vlib_time_now (vm);
+      f64 delta = hcm->test_end_time - hcm->test_start_time;
+
+      ec_cli_output ("Throughput (%d, %.20f): %.2f b/s", n_read, delta, ((f64)(n_read)) / delta);
+
+      s->bytes_to_receive -= n_read;
+      s->bytes_received += n_read;
+    }
+}
+
+// static uword
+// hicn_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
+// 		     vlib_frame_t * frame)
+// {
+//   hicns_client_main_t *hcm = &hicn_client_main;
+//   int my_thread_index = vlib_get_thread_index ();
+//   eclient_session_t *sp;
+//   int i;
+//   int delete_session;
+//   u32 *connection_indices;
+//   u32 *connections_this_batch;
+//   u32 nconnections_this_batch;
+
+//   connection_indices = hcm->connection_index_by_thread[my_thread_index];
+//   connections_this_batch =
+//     hcm->connections_this_batch_by_thread[my_thread_index];
+
+//   if ((hcm->run_test != HICN_CLIENT_RUNNING) ||
+//       ((vec_len (connection_indices) == 0)
+//        && vec_len (connections_this_batch) == 0))
+//     return 0;
+
+//   /* Grab another pile of connections */
+//   if (PREDICT_FALSE (vec_len (connections_this_batch) == 0))
+//     {
+//       nconnections_this_batch =
+// 	clib_min (hcm->connections_per_batch, vec_len (connection_indices));
+
+//       ASSERT (nconnections_this_batch > 0);
+//       vec_validate (connections_this_batch, nconnections_this_batch - 1);
+//       clib_memcpy_fast (connections_this_batch,
+// 			connection_indices + vec_len (connection_indices)
+// 			- nconnections_this_batch,
+// 			nconnections_this_batch * sizeof (u32));
+//       _vec_len (connection_indices) -= nconnections_this_batch;
+//     }
+
+//   if (PREDICT_FALSE (hcm->prev_conns != hcm->connections_per_batch
+// 		     && hcm->prev_conns == vec_len (connections_this_batch)))
+//     {
+//       hcm->repeats++;
+//       hcm->prev_conns = vec_len (connections_this_batch);
+//       if (hcm->repeats == 500000)
+// 	{
+// 	  clib_warning ("stuck clients");
+// 	}
+//     }
+//   else
+//     {
+//       hcm->prev_conns = vec_len (connections_this_batch);
+//       hcm->repeats = 0;
+//     }
+
+//   for (i = 0; i < vec_len (connections_this_batch); i++)
+//     {
+//       delete_session = 1;
+
+//       sp = pool_elt_at_index (hcm->sessions, connections_this_batch[i]);
+
+//       if (sp->bytes_to_send > 0)
+// 	{
+// 	  send_data_chunk (hcm, sp);
+// 	  delete_session = 0;
+// 	}
+//       if (sp->bytes_to_receive > 0)
+// 	{
+// 	  delete_session = 0;
+// 	}
+//       if (PREDICT_FALSE (delete_session == 1))
+// 	{
+// 	  session_t *s;
+
+// 	  clib_atomic_fetch_add (&hcm->tx_total, sp->bytes_sent);
+// 	  clib_atomic_fetch_add (&hcm->rx_total, sp->bytes_received);
+// 	  s = session_get_from_handle_if_valid (sp->vpp_session_handle);
+
+// 	  if (s)
+// 	    {
+// 	      vnet_disconnect_args_t _a, *a = &_a;
+// 	      a->handle = session_handle (s);
+// 	      a->app_index = hcm->app_index;
+// 	      vnet_disconnect_session (a);
+
+// 	      vec_delete (connections_this_batch, 1, i);
+// 	      i--;
+// 	      clib_atomic_fetch_add (&hcm->ready_connections, -1);
+// 	    }
+// 	  else
+// 	    {
+// 	      clib_warning ("session AWOL?");
+// 	      vec_delete (connections_this_batch, 1, i);
+// 	    }
+
+// 	  /* Kick the debug CLI process */
+// 	  if (hcm->ready_connections == 0)
+// 	    {
+// 	      signal_evt_to_cli (2);
+// 	    }
+// 	}
+//     }
+
+//   hcm->connection_index_by_thread[my_thread_index] = connection_indices;
+//   hcm->connections_this_batch_by_thread[my_thread_index] =
+//     connections_this_batch;
+//   return 0;
+// }
+
+// /* *INDENT-OFF* */
+// VLIB_REGISTER_NODE (hicn_clients_node) =
+// {
+//   .function = hicn_client_node_fn,
+//   .name = "hicn-client",
+//   .type = VLIB_NODE_TYPE_INPUT,
+//   .state = VLIB_NODE_STATE_DISABLED,
+// };
+// /* *INDENT-ON* */
+
+static int
+create_api_loopback (hicn_client_main_t * hcm)
+{
+  api_main_t *am = vlibapi_get_main ();
+  vl_shmem_hdr_t *shmem_hdr;
+
+  shmem_hdr = am->shmem_hdr;
+  hcm->vl_input_queue = shmem_hdr->vl_input_queue;
+  hcm->my_client_index = vl_api_memclnt_create_internal ("hicn_client",
+							hcm->vl_input_queue);
+  return 0;
+}
+
+static int
+hicn_client_init (vlib_main_t * vm)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vlib_thread_main_t *vtm = vlib_get_thread_main ();
+  u32 num_threads;
+  int i;
+
+  if (create_api_loopback (hcm))
+    return -1;
+
+  num_threads = 1 /* main thread */  + vtm->n_threads;
+
+  /* Init test data. Big buffer */
+  vec_validate (hcm->connect_test_data, 4 * 1024 * 1024 - 1);
+  for (i = 0; i < vec_len (hcm->connect_test_data); i++)
+    hcm->connect_test_data[i] = i & 0xff;
+
+  vec_validate (hcm->rx_buf, num_threads - 1);
+  for (i = 0; i < num_threads; i++)
+    vec_validate (hcm->rx_buf[i], vec_len (hcm->connect_test_data) - 1);
+
+  hcm->is_init = 1;
+
+  vec_validate (hcm->connection_index_by_thread, vtm->n_vlib_mains);
+  vec_validate (hcm->connections_this_batch_by_thread, vtm->n_vlib_mains);
+  vec_validate (hcm->vpp_event_queue, vtm->n_vlib_mains);
+
+  return 0;
+}
+
+static int
+hicn_client_session_connected_callback (u32 app_wrk_index, u32 opaque,
+					session_t * s, session_error_t code)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  eclient_session_t *session;
+  u32 session_index;
+  u8 thread_index;
+
+  if (PREDICT_FALSE (hcm->run_test != HICN_CLIENT_STARTING))
+    return -1;
+
+  if (code)
+    {
+      clib_warning ("connection %d failed!", opaque);
+      hcm->run_test = HICN_CLIENT_EXITING;
+      signal_evt_to_cli (-1);
+      return 0;
+    }
+
+  thread_index = s->thread_index;
+  ASSERT (thread_index == vlib_get_thread_index ()
+	  || session_transport_service_type (s) == TRANSPORT_SERVICE_CL);
+
+  if (!hcm->vpp_event_queue[thread_index])
+    hcm->vpp_event_queue[thread_index] =
+      session_main_get_vpp_event_queue (thread_index);
+
+  /*
+   * Setup session
+   */
+  clib_spinlock_lock_if_init (&hcm->sessions_lock);
+  pool_get (hcm->sessions, session);
+  clib_spinlock_unlock_if_init (&hcm->sessions_lock);
+
+  clib_memset (session, 0, sizeof (*session));
+  session_index = session - hcm->sessions;
+  session->bytes_to_send = hcm->bytes_to_send;
+  session->bytes_to_receive = hcm->no_return ? 0ULL : hcm->bytes_to_send;
+  session->data.rx_fifo = s->rx_fifo;
+  session->data.rx_fifo->client_session_index = session_index;
+  session->data.tx_fifo = s->tx_fifo;
+  session->data.tx_fifo->client_session_index = session_index;
+  session->data.vpp_evt_q = hcm->vpp_event_queue[thread_index];
+  session->vpp_session_handle = session_handle (s);
+
+  if (hcm->is_dgram)
+    {
+      transport_connection_t *tc;
+      tc = session_get_transport (s);
+      clib_memcpy_fast (&session->data.transport, tc,
+			sizeof (session->data.transport));
+      session->data.is_dgram = 1;
+    }
+
+  vec_add1 (hcm->connection_index_by_thread[thread_index], session_index);
+  clib_atomic_fetch_add (&hcm->ready_connections, 1);
+  if (hcm->ready_connections == hcm->expected_connections)
+    {
+      hcm->run_test = HICN_CLIENT_RUNNING;
+      /* Signal the CLI process that the action is starting... */
+      signal_evt_to_cli (1);
+    }
+
+  return 0;
+}
+
+static void
+hicn_client_session_reset_callback (session_t * s)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_disconnect_args_t _a = { 0 }, *a = &_a;
+
+  if (s->session_state == SESSION_STATE_READY)
+    clib_warning ("Reset active connection %U", format_session, s, 2);
+
+  a->handle = session_handle (s);
+  a->app_index = hcm->app_index;
+  vnet_disconnect_session (a);
+  return;
+}
+
+static int
+hicn_client_session_create_callback (session_t * s)
+{
+  return 0;
+}
+
+static void
+hicn_client_session_disconnect_callback (session_t * s)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_disconnect_args_t _a = { 0 }, *a = &_a;
+  a->handle = session_handle (s);
+  a->app_index = hcm->app_index;
+  vnet_disconnect_session (a);
+  return;
+}
+
+void
+hicn_client_session_disconnect (session_t * s)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_disconnect_args_t _a = { 0 }, *a = &_a;
+  a->handle = session_handle (s);
+  a->app_index = hcm->app_index;
+  vnet_disconnect_session (a);
+}
+
+static int
+hicn_client_rx_callback (session_t * s)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  eclient_session_t *sp;
+
+  if (PREDICT_FALSE (hcm->run_test != HICN_CLIENT_RUNNING))
+    {
+      hicn_client_session_disconnect (s);
+      return -1;
+    }
+
+  sp = pool_elt_at_index (hcm->sessions, s->rx_fifo->client_session_index);
+  receive_data_chunk (hcm, sp);
+
+  if (svm_fifo_max_dequeue_cons (s->rx_fifo))
+    {
+      if (svm_fifo_set_event (s->rx_fifo))
+	session_send_io_evt_to_thread (s->rx_fifo, SESSION_IO_EVT_BUILTIN_RX);
+    }
+  return 0;
+}
+
+int
+hicn_client_add_segment_callback (u32 client_index, u64 segment_handle)
+{
+  /* New heaps may be added */
+  return 0;
+}
+
+/* *INDENT-OFF* */
+static session_cb_vft_t hicn_client = {
+  .session_reset_callback = hicn_client_session_reset_callback,
+  .session_connected_callback = hicn_client_session_connected_callback,
+  .session_accept_callback = hicn_client_session_create_callback,
+  .session_disconnect_callback = hicn_client_session_disconnect_callback,
+  .builtin_app_rx_callback = hicn_client_rx_callback,
+  .add_segment_callback = hicn_client_add_segment_callback
+};
+/* *INDENT-ON* */
+
+static clib_error_t *
+hicn_client_attach (u8 * appns_id, u64 appns_flags, u64 appns_secret)
+{
+  vnet_app_add_tls_cert_args_t _a_cert, *a_cert = &_a_cert;
+  vnet_app_add_tls_key_args_t _a_key, *a_key = &_a_key;
+  u32 prealloc_fifos, segment_size = 256 << 20;
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_app_attach_args_t _a, *a = &_a;
+  u64 options[17];
+  int rv;
+
+  clib_memset (a, 0, sizeof (*a));
+  clib_memset (options, 0, sizeof (options));
+
+  a->api_client_index = hcm->my_client_index;
+  a->session_cb_vft = &hicn_client;
+
+  prealloc_fifos = hcm->prealloc_fifos ? hcm->expected_connections : 1;
+
+  if (hcm->private_segment_size)
+    segment_size = hcm->private_segment_size;
+
+  options[APP_OPTIONS_ACCEPT_COOKIE] = 0x12345678;
+  options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
+  options[APP_OPTIONS_ADD_SEGMENT_SIZE] = segment_size;
+  options[APP_OPTIONS_RX_FIFO_SIZE] = hcm->fifo_size;
+  options[APP_OPTIONS_TX_FIFO_SIZE] = hcm->fifo_size;
+  options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = hcm->private_segment_count;
+  options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = prealloc_fifos;
+  options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
+  options[APP_OPTIONS_TLS_ENGINE] = hcm->tls_engine;
+  options[APP_OPTIONS_PCT_FIRST_ALLOC] = 100;
+  if (appns_id)
+    {
+      options[APP_OPTIONS_FLAGS] |= appns_flags;
+      options[APP_OPTIONS_NAMESPACE_SECRET] = appns_secret;
+    }
+  a->options = options;
+  a->namespace_id = appns_id;
+
+  if ((rv = vnet_application_attach (a)))
+    return clib_error_return (0, "attach returned %d", rv);
+
+  hcm->app_index = a->app_index;
+
+  clib_memset (a_cert, 0, sizeof (*a_cert));
+  a_cert->app_index = a->app_index;
+  vec_validate (a_cert->cert, test_srv_crt_rsa_len);
+  clib_memcpy_fast (a_cert->cert, test_srv_crt_rsa, test_srv_crt_rsa_len);
+  vnet_app_add_tls_cert (a_cert);
+
+  clib_memset (a_key, 0, sizeof (*a_key));
+  a_key->app_index = a->app_index;
+  vec_validate (a_key->key, test_srv_key_rsa_len);
+  clib_memcpy_fast (a_key->key, test_srv_key_rsa, test_srv_key_rsa_len);
+  vnet_app_add_tls_key (a_key);
+  return 0;
+}
+
+static int
+hicn_client_detach ()
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_app_detach_args_t _da, *da = &_da;
+  int rv;
+
+  da->app_index = hcm->app_index;
+  da->api_client_index = ~0;
+  rv = vnet_application_detach (da);
+  hcm->test_client_attached = 0;
+  hcm->app_index = ~0;
+  return rv;
+}
+
+static void *
+hicn_client_thread_fn (void *arg)
+{
+  return 0;
+}
+
+/** Start a transmit thread */
+int
+hicn_client_start_tx_pthread (hicn_client_main_t * hcm)
+{
+  if (hcm->client_thread_handle == 0)
+    {
+      int rv = pthread_create (&hcm->client_thread_handle,
+			       NULL /*attr */ ,
+			       hicn_client_thread_fn, 0);
+      if (rv)
+	{
+	  hcm->client_thread_handle = 0;
+	  return -1;
+	}
+    }
+  return 0;
+}
+
+clib_error_t *
+hicn_client_connect (vlib_main_t * vm, u32 n_clients)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vnet_connect_args_t _a, *a = &_a;
+  int i, rv;
+
+  clib_memset (a, 0, sizeof (*a));
+
+  for (i = 0; i < n_clients; i++)
+    {
+      a->uri = (char *) hcm->connect_uri;
+      a->api_context = i;
+      a->app_index = hcm->app_index;
+
+      vlib_worker_thread_barrier_sync (vm);
+      if ((rv = vnet_connect_uri (a)))
+	{
+	  vlib_worker_thread_barrier_release (vm);
+	  return clib_error_return (0, "connect returned: %d", rv);
+	}
+      vlib_worker_thread_barrier_release (vm);
+
+      /* Crude pacing for call setups  */
+      if ((i % 16) == 0)
+	vlib_process_suspend (vm, 100e-6);
+      ASSERT (i + 1 >= hcm->ready_connections);
+      while (i + 1 - hcm->ready_connections > 128)
+	vlib_process_suspend (vm, 1e-3);
+    }
+
+  return 0;
+}
+
+static clib_error_t *
+hicn_client_command_fn (vlib_main_t * vm,
+		     unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  vlib_thread_main_t *thread_main = vlib_get_thread_main ();
+  u64 total_bytes, appns_flags = 0, appns_secret = 0;
+  f64 test_timeout = 20.0, syn_timeout = 20.0, delta;
+  char *default_uri = "hicn://b001::1";
+  uword *event_data = 0, event_type;
+  f64 time_before_connects;
+  u32 n_clients = 1;
+  int preallocate_sessions = 0;
+  char *transfer_type;
+  clib_error_t *error = 0;
+  u8 *appns_id = 0;
+  int i;
+  session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
+  int rv;
+
+  hcm->bytes_to_send = 8192;
+  hcm->no_return = 0;
+  hcm->fifo_size = 128 << 20;
+  hcm->connections_per_batch = 1000;
+  hcm->private_segment_count = 0;
+  hcm->private_segment_size = 0;
+  hcm->no_output = 0;
+  hcm->test_bytes = 0;
+  hcm->test_failed = 0;
+  hcm->vlib_main = vm;
+  hcm->tls_engine = CRYPTO_ENGINE_OPENSSL;
+  hcm->no_copy = 0;
+  hcm->run_test = HICN_CLIENT_STARTING;
+
+  if (thread_main->n_vlib_mains > 1)
+    clib_spinlock_init (&hcm->sessions_lock);
+  vec_free (hcm->connect_uri);
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "uri %s", &hcm->connect_uri))
+	;
+      else
+	return clib_error_return (0, "failed: unknown input `%U'",
+				  format_unformat_error, input);
+    }
+
+  /* Store cli process node index for signalling */
+  hcm->cli_node_index =
+    vlib_get_current_process (vm)->node_runtime.node_index;
+
+  if (hcm->is_init == 0)
+    {
+      if (hicn_client_init (vm))
+	return clib_error_return (0, "failed init");
+    }
+
+
+  hcm->ready_connections = 0;
+  hcm->expected_connections = n_clients;
+  hcm->rx_total = 0;
+  hcm->tx_total = 0;
+
+  if (!hcm->connect_uri)
+    {
+      clib_warning ("No uri provided. Using default: %s", default_uri);
+      hcm->connect_uri = format (0, "%s%c", default_uri, 0);
+    }
+
+  vlib_worker_thread_barrier_sync (vm);
+  vnet_session_enable_disable (vm, 1 /* turn on session and transports */ );
+  hicn_hs_enable_disable(vm, 1 /* enable hicn transport */);
+  vlib_worker_thread_barrier_release (vm);
+
+  if ((rv = parse_uri ((char *) hcm->connect_uri, &sep)))
+    return clib_error_return (0, "Uri parse error: %d", rv);
+  hcm->transport_proto = sep.transport_proto;
+  hcm->is_dgram = (sep.transport_proto == TRANSPORT_PROTO_UDP);
+
+#if HICN_CLIENT_PTHREAD
+  hicn_client_start_tx_pthread ();
+#endif
+
+  if (hcm->test_client_attached == 0)
+    {
+      if ((error = hicn_client_attach (appns_id, appns_flags, appns_secret)))
+	{
+	  vec_free (appns_id);
+	  clib_error_report (error);
+	  return error;
+	}
+      vec_free (appns_id);
+    }
+  hcm->test_client_attached = 1;
+
+  /* Turn on the builtin client input nodes */
+  for (i = 0; i < thread_main->n_vlib_mains; i++)
+    vlib_node_set_state (vlib_mains[i], hicn_client_node.index,
+			 VLIB_NODE_STATE_POLLING);
+
+  if (preallocate_sessions)
+    pool_init_fixed (hcm->sessions, 1.1 * n_clients);
+
+  /* Fire off connect requests */
+  time_before_connects = vlib_time_now (vm);
+  if ((error = hicn_client_connect (vm, n_clients)))
+    {
+      goto cleanup;
+    }
+
+  /* Park until the sessions come up, or ten seconds elapse... */
+  vlib_process_wait_for_event_or_clock (vm, syn_timeout);
+  event_type = vlib_process_get_events (vm, &event_data);
+  switch (event_type)
+    {
+    case ~0:
+      ec_cli_output ("Timeout with only %d sessions active...",
+		     hcm->ready_connections);
+      error = clib_error_return (0, "failed: syn timeout with %d sessions",
+				 hcm->ready_connections);
+      goto cleanup;
+
+    case 1:
+      delta = vlib_time_now (vm) - time_before_connects;
+      if (delta != 0.0)
+	ec_cli_output ("%d three-way handshakes in %.2f seconds %.2f/s",
+		       n_clients, delta, ((f64) n_clients) / delta);
+
+      hcm->test_start_time = vlib_time_now (hcm->vlib_main);
+      break;
+
+    default:
+      ec_cli_output ("unexpected event(1): %d", event_type);
+      error = clib_error_return (0, "failed: unexpected event(1): %d",
+				 event_type);
+      goto cleanup;
+    }
+
+  /* Now wait for the sessions to finish... */
+  vlib_process_wait_for_event_or_clock (vm, test_timeout);
+  event_type = vlib_process_get_events (vm, &event_data);
+  switch (event_type)
+    {
+    case ~0:
+      ec_cli_output ("Timeout with %d sessions still active...",
+		     hcm->ready_connections);
+      error = clib_error_return (0, "failed: timeout with %d sessions",
+				 hcm->ready_connections);
+      goto cleanup;
+
+    case 2:
+      hcm->test_end_time = vlib_time_now (vm);
+      ec_cli_output ("Test finished at %.6f", hcm->test_end_time);
+      break;
+
+    default:
+      ec_cli_output ("unexpected event(2): %d", event_type);
+      error = clib_error_return (0, "failed: unexpected event(2): %d",
+				 event_type);
+      goto cleanup;
+    }
+
+  delta = hcm->test_end_time - hcm->test_start_time;
+  if (delta != 0.0)
+    {
+      total_bytes = (hcm->no_return ? hcm->tx_total : hcm->rx_total);
+      transfer_type = hcm->no_return ? "half-duplex" : "full-duplex";
+      ec_cli_output ("%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds",
+		     total_bytes, total_bytes / (1ULL << 20),
+		     total_bytes / (1ULL << 30), delta);
+      ec_cli_output ("%.2f bytes/second %s", ((f64) total_bytes) / (delta),
+		     transfer_type);
+      ec_cli_output ("%.4f gbit/second %s",
+		     (((f64) total_bytes * 8.0) / delta / 1e9),
+		     transfer_type);
+    }
+  else
+    {
+      ec_cli_output ("zero delta-t?");
+      error = clib_error_return (0, "failed: zero delta-t");
+      goto cleanup;
+    }
+
+  if (hcm->test_bytes && hcm->test_failed)
+    error = clib_error_return (0, "failed: test bytes");
+
+cleanup:
+  hcm->run_test = HICN_CLIENT_EXITING;
+  vlib_process_wait_for_event_or_clock (vm, 10e-3);
+  for (i = 0; i < vec_len (hcm->connection_index_by_thread); i++)
+    {
+      vec_reset_length (hcm->connection_index_by_thread[i]);
+      vec_reset_length (hcm->connections_this_batch_by_thread[i]);
+    }
+
+  pool_free (hcm->sessions);
+
+  /* Detach the application, so we can use different fifo sizes next time */
+  if (hcm->test_client_attached)
+    {
+      if (hicn_client_detach ())
+	{
+	  error = clib_error_return (0, "failed: app detach");
+	  ec_cli_output ("WARNING: app detach failed...");
+	}
+    }
+  if (error)
+    ec_cli_output ("test failed");
+  vec_free (hcm->connect_uri);
+  return error;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (hicn_client_command, static) =
+{
+  .path = "test hicn hs client",
+  .short_help = "test hicn hs client [uri <hicn://ip6_address/port>]",
+  .function = hicn_client_command_fn,
+  .is_mp_safe = 1,
+};
+/* *INDENT-ON* */
+
+clib_error_t *
+hicn_client_main_init (vlib_main_t * vm)
+{
+  hicn_client_main_t *hcm = &hicn_client_main;
+  hcm->is_init = 0;
+  return 0;
+}
+
+VLIB_INIT_FUNCTION (hicn_client_main_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/host_stack/test/hicn_hs_client.h b/hicn-plugin/src/host_stack/test/hicn_hs_client.h
new file mode 100644
index 000000000..6600608e3
--- /dev/null
+++ b/hicn-plugin/src/host_stack/test/hicn_hs_client.h
@@ -0,0 +1,127 @@
+
+/*
+ * echo_client.h - built-in application layer echo client
+ *
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 __included_hicn_hs_client_h__
+#define __included_hicn_hs_client_h__
+
+#include <vnet/vnet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+#include <vppinfra/hash.h>
+#include <vppinfra/error.h>
+#include <vnet/session/session.h>
+#include <vnet/session/application_interface.h>
+
+typedef struct
+{
+  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
+  app_session_t data;
+  u64 bytes_to_send;
+  u64 bytes_sent;
+  u64 bytes_to_receive;
+  u64 bytes_received;
+  u64 vpp_session_handle;
+  u8 thread_index;
+} eclient_session_t;
+
+typedef struct
+{
+  /*
+   * Application setup parameters
+   */
+  svm_queue_t *vl_input_queue;		/**< vpe input queue */
+  svm_msg_q_t **vpp_event_queue;
+
+  u32 cli_node_index;			/**< cli process node index */
+  u32 my_client_index;			/**< loopback API client handle */
+  u32 app_index;			/**< app index after attach */
+
+  /*
+   * Configuration params
+   */
+  u8 *connect_uri;			/**< URI for slave's connect */
+  u64 bytes_to_send;			/**< Bytes to send */
+  u32 configured_segment_size;
+  u32 fifo_size;
+  u32 expected_connections;		/**< Number of clients/connections */
+  u32 connections_per_batch;		/**< Connections to rx/tx at once */
+  u32 private_segment_count;		/**< Number of private fifo segs */
+  u32 private_segment_size;		/**< size of private fifo segs */
+  u32 tls_engine;			/**< TLS engine mbedtls/openssl */
+  u8 is_dgram;
+  u32 no_copy;				/**< Don't memcpy data to tx fifo */
+
+  /*
+   * Test state variables
+   */
+  eclient_session_t *sessions;		/**< Session pool, shared */
+  clib_spinlock_t sessions_lock;
+  u8 **rx_buf;				/**< intermediate rx buffers */
+  u8 *connect_test_data;		/**< Pre-computed test data */
+  u32 **connection_index_by_thread;
+  u32 **connections_this_batch_by_thread; /**< active connection batch */
+  pthread_t client_thread_handle;
+
+  volatile u32 ready_connections;
+  volatile u32 finished_connections;
+  volatile u64 rx_total;
+  volatile u64 tx_total;
+  volatile int run_test;		/**< Signal start of test */
+
+  f64 test_start_time;
+  f64 test_end_time;
+  u32 prev_conns;
+  u32 repeats;
+  /*
+   * Flags
+   */
+  u8 is_init;
+  u8 test_client_attached;
+  u8 no_return;
+  u8 test_return_packets;
+  int i_am_master;
+  int drop_packets;		/**< drop all packets */
+  u8 prealloc_fifos;		/**< Request fifo preallocation */
+  u8 no_output;
+  u8 test_bytes;
+  u8 test_failed;
+  u8 transport_proto;
+
+  vlib_main_t *vlib_main;
+} hicn_client_main_t;
+
+enum
+{
+  HICN_CLIENT_STARTING,
+  HICN_CLIENT_RUNNING,
+  HICN_CLIENT_EXITING
+} hicn_client_state_e;
+
+extern hicn_client_main_t hicn_client_main;
+
+vlib_node_registration_t hicn_client_node;
+
+#endif /* __included_hicn_hs_client_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/host_stack/test/hicn_hs_server.c b/hicn-plugin/src/host_stack/test/hicn_hs_server.c
new file mode 100644
index 000000000..cab73adb0
--- /dev/null
+++ b/hicn-plugin/src/host_stack/test/hicn_hs_server.c
@@ -0,0 +1,505 @@
+/*
+* Copyright (c) 2020 Cisco and/or its affiliates.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at:
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vnet/vnet.h>
+#include <vlibmemory/api.h>
+#include <vnet/session/application.h>
+#include <vnet/session/application_interface.h>
+#include <vnet/session/session.h>
+
+#include "../host_stack.h"
+#include "../route.h"
+
+#define HICN_SERVER_DGB (0)
+#define DBG(_fmt, _args...)			\
+    if (HICN_SERVER_DGB) 				\
+      clib_warning (_fmt, ##_args)
+
+typedef struct
+{
+  /*
+   * Server app parameters
+   */
+  svm_msg_q_t **vpp_queue;
+  svm_queue_t *vl_input_queue;	/**< Sever's event queue */
+
+  u32 app_index;		/**< Server app index */
+  u32 my_client_index;		/**< API client handle */
+  u32 node_index;		/**< process node index for event scheduling */
+
+  /*
+   * Config params
+   */
+  u32 fifo_size;		/**< Fifo size */
+  u32 rcv_buffer_size;		/**< Rcv buffer size */
+  u32 prealloc_fifos;		/**< Preallocate fifos */
+  u32 private_segment_count;	/**< Number of private segments  */
+  u32 private_segment_size;	/**< Size of private segments  */
+  char *server_uri;		/**< Server URI */
+  u32 tls_engine;		/**< TLS engine: mbedtls/openssl */
+  u8 is_dgram;			/**< set if transport is dgram */
+  /*
+   * Test state
+   */
+  u8 **rx_buf;			/**< Per-thread RX buffer */
+  u64 byte_index;
+  u32 **rx_retries;
+  u8 transport_proto;
+  u64 listener_handle;		/**< Session handle of the root listener */
+
+  vlib_main_t *vlib_main;
+} hicn_server_main_t;
+
+hicn_server_main_t hicn_server_main;
+
+extern f64 t0;
+
+#define DEFAULT_PRODUCE_SIZE 64 << 20
+static u8 bytes[DEFAULT_PRODUCE_SIZE];
+
+int
+hicn_server_session_accept_callback (session_t * s)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  esm->vpp_queue[s->thread_index] =
+    session_main_get_vpp_event_queue (s->thread_index);
+  s->session_state = SESSION_STATE_READY;
+  esm->byte_index = 0;
+  ASSERT (vec_len (esm->rx_retries) > s->thread_index);
+  vec_validate (esm->rx_retries[s->thread_index], s->session_index);
+  esm->rx_retries[s->thread_index][s->session_index] = 0;
+  return 0;
+}
+
+void
+hicn_server_session_disconnect_callback (session_t * s)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  vnet_disconnect_args_t _a = { 0 }, *a = &_a;
+
+  a->handle = session_handle (s);
+  a->app_index = esm->app_index;
+  vnet_disconnect_session (a);
+}
+
+void
+hicn_server_session_reset_callback (session_t * s)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  vnet_disconnect_args_t _a = { 0 }, *a = &_a;
+  clib_warning ("Reset session %U", format_session, s, 2);
+  a->handle = session_handle (s);
+  a->app_index = esm->app_index;
+  vnet_disconnect_session (a);
+}
+
+int
+hicn_server_session_connected_callback (u32 app_wrk_index, u32 opaque,
+				     	session_t * s, session_error_t code)
+{
+  clib_warning ("called...");
+  return -1;
+}
+
+int
+hicn_server_add_segment_callback (u32 client_index, u64 segment_handle)
+{
+  /* New heaps may be added */
+  return 0;
+}
+
+int
+hicn_server_redirect_connect_callback (u32 client_index, void *mp)
+{
+  clib_warning ("called...");
+  return -1;
+}
+
+void
+test_bytes (hicn_server_main_t * esm, int actual_transfer)
+{
+  int i;
+  u32 my_thread_id = vlib_get_thread_index ();
+
+  for (i = 0; i < actual_transfer; i++)
+    {
+      if (esm->rx_buf[my_thread_id][i] != ((esm->byte_index + i) & 0xff))
+	{
+	  clib_warning ("at %lld expected %d got %d", esm->byte_index + i,
+			(esm->byte_index + i) & 0xff,
+			esm->rx_buf[my_thread_id][i]);
+	}
+    }
+  esm->byte_index += actual_transfer;
+}
+
+/*
+ * If no-echo, just drop the data and be done with it.
+ */
+int
+hicn_server_builtin_server_rx_callback_no_echo (session_t * s)
+{
+  svm_fifo_t *rx_fifo = s->rx_fifo;
+  svm_fifo_dequeue_drop (rx_fifo, svm_fifo_max_dequeue_cons (rx_fifo));
+  return 0;
+}
+
+int hicn_server_enqueue (session_t * s, svm_fifo_t *tx_fifo, u32 thread_index)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  CLIB_UNUSED(u32 n_written);
+  transport_connection_t *transport = session_get_transport(s);
+  hicn_hs_ctx_t *ctx = (hicn_hs_ctx_t *) (transport);
+  hicn_hs_set_next_prod_size (ctx, DEFAULT_PRODUCE_SIZE);
+
+  n_written = app_send_stream_raw (tx_fifo,
+				   esm->vpp_queue[thread_index],
+				   bytes,
+				   DEFAULT_PRODUCE_SIZE,
+				   SESSION_IO_EVT_TX,
+				   1 /* do_evt */ , 0);
+
+  return 0;
+}
+
+int
+hicn_server_rx_callback (session_t * s)
+{
+  u32 max_dequeue, max_enqueue;
+  svm_fifo_t *tx_fifo, *rx_fifo;
+  hicn_server_main_t *esm = &hicn_server_main;
+  u32 thread_index = vlib_get_thread_index ();
+
+  ASSERT (s->thread_index == thread_index);
+
+  rx_fifo = s->rx_fifo;
+  tx_fifo = s->tx_fifo;
+
+  ASSERT (rx_fifo->master_thread_index == thread_index);
+  ASSERT (tx_fifo->master_thread_index == thread_index);
+
+  max_enqueue = svm_fifo_max_enqueue_prod (tx_fifo);
+  if (!esm->is_dgram)
+    {
+      max_dequeue = svm_fifo_max_dequeue_cons (rx_fifo);
+    }
+  else
+    {
+      session_dgram_pre_hdr_t ph;
+      svm_fifo_peek (rx_fifo, 0, sizeof (ph), (u8 *) & ph);
+      max_dequeue = ph.data_length - ph.data_offset;
+      if (!esm->vpp_queue[s->thread_index])
+	{
+	  svm_msg_q_t *mq;
+	  mq = session_main_get_vpp_event_queue (s->thread_index);
+	  esm->vpp_queue[s->thread_index] = mq;
+	}
+      max_enqueue -= sizeof (session_dgram_hdr_t);
+    }
+
+  if (max_dequeue == 0)
+  {
+    return hicn_server_enqueue (s, tx_fifo, thread_index);
+  }
+
+  return 0;
+}
+
+static session_cb_vft_t hicn_server_session_cb_vft = {
+  .session_accept_callback = hicn_server_session_accept_callback,
+  .session_disconnect_callback = hicn_server_session_disconnect_callback,
+  .session_connected_callback = hicn_server_session_connected_callback,
+  .add_segment_callback = hicn_server_add_segment_callback,
+  .builtin_app_rx_callback = hicn_server_rx_callback,
+  .session_reset_callback = hicn_server_session_reset_callback
+};
+
+/* Abuse VPP's input queue */
+static int
+create_api_loopback (vlib_main_t * vm)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  api_main_t *am = vlibapi_get_main ();
+  vl_shmem_hdr_t *shmem_hdr;
+
+  shmem_hdr = am->shmem_hdr;
+  esm->vl_input_queue = shmem_hdr->vl_input_queue;
+  esm->my_client_index = vl_api_memclnt_create_internal ("hicn_server",
+							 esm->vl_input_queue);
+  return 0;
+}
+
+static int
+hicn_server_attach (u8 * appns_id, u64 appns_flags, u64 appns_secret)
+{
+  vnet_app_add_tls_cert_args_t _a_cert, *a_cert = &_a_cert;
+  vnet_app_add_tls_key_args_t _a_key, *a_key = &_a_key;
+  hicn_server_main_t *esm = &hicn_server_main;
+  vnet_app_attach_args_t _a, *a = &_a;
+  u64 options[APP_OPTIONS_N_OPTIONS];
+  u32 segment_size = 512 << 20;
+
+  clib_memset (a, 0, sizeof (*a));
+  clib_memset (options, 0, sizeof (options));
+
+  hicn_server_session_cb_vft.builtin_app_rx_callback =
+    hicn_server_rx_callback;
+
+  if (esm->private_segment_size)
+    segment_size = esm->private_segment_size;
+
+  a->api_client_index = esm->my_client_index;
+  a->session_cb_vft = &hicn_server_session_cb_vft;
+  a->options = options;
+  a->options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
+  a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = segment_size;
+  a->options[APP_OPTIONS_RX_FIFO_SIZE] = esm->fifo_size;
+  a->options[APP_OPTIONS_TX_FIFO_SIZE] = esm->fifo_size;
+  a->options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = esm->private_segment_count;
+  a->options[APP_OPTIONS_TLS_ENGINE] = esm->tls_engine;
+  a->options[APP_OPTIONS_PCT_FIRST_ALLOC] = 100;
+  a->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
+    esm->prealloc_fifos ? esm->prealloc_fifos : 1;
+
+  a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
+  if (appns_id)
+    {
+      a->namespace_id = appns_id;
+      a->options[APP_OPTIONS_FLAGS] |= appns_flags;
+      a->options[APP_OPTIONS_NAMESPACE_SECRET] = appns_secret;
+    }
+
+  if (vnet_application_attach (a))
+    {
+      clib_warning ("failed to attach server");
+      return -1;
+    }
+  esm->app_index = a->app_index;
+
+  clib_memset (a_cert, 0, sizeof (*a_cert));
+  a_cert->app_index = a->app_index;
+  vec_validate (a_cert->cert, test_srv_crt_rsa_len);
+  clib_memcpy_fast (a_cert->cert, test_srv_crt_rsa, test_srv_crt_rsa_len);
+  vnet_app_add_tls_cert (a_cert);
+
+  clib_memset (a_key, 0, sizeof (*a_key));
+  a_key->app_index = a->app_index;
+  vec_validate (a_key->key, test_srv_key_rsa_len);
+  clib_memcpy_fast (a_key->key, test_srv_key_rsa, test_srv_key_rsa_len);
+  vnet_app_add_tls_key (a_key);
+  return 0;
+}
+
+static int
+hicn_server_detach (void)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  vnet_app_detach_args_t _da, *da = &_da;
+  int rv;
+
+  da->app_index = esm->app_index;
+  rv = vnet_application_detach (da);
+  esm->app_index = ~0;
+  return rv;
+}
+
+static int
+hicn_server_listen ()
+{
+  int rv;
+  hicn_server_main_t *esm = &hicn_server_main;
+  vnet_listen_args_t _a, *a = &_a;
+  clib_memset (a, 0, sizeof (*a));
+  a->app_index = esm->app_index;
+  a->uri = esm->server_uri;
+  rv = vnet_bind_uri (a);
+  esm->listener_handle = a->handle;
+  return rv;
+}
+
+static int
+hicn_server_create (vlib_main_t * vm, u8 * appns_id, u64 appns_flags,
+		    u64 appns_secret)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  vlib_thread_main_t *vtm = vlib_get_thread_main ();
+  u32 num_threads;
+  int i;
+
+  if (esm->my_client_index == (u32) ~ 0)
+    {
+      if (create_api_loopback (vm))
+	{
+	  clib_warning ("failed to create api loopback");
+	  return -1;
+	}
+    }
+
+  num_threads = 1 /* main thread */  + vtm->n_threads;
+  vec_validate (hicn_server_main.vpp_queue, num_threads - 1);
+  vec_validate (esm->rx_buf, num_threads - 1);
+  vec_validate (esm->rx_retries, num_threads - 1);
+  for (i = 0; i < vec_len (esm->rx_retries); i++)
+    vec_validate (esm->rx_retries[i],
+		  pool_elts (session_main.wrk[i].sessions));
+  esm->rcv_buffer_size = clib_max (esm->rcv_buffer_size, esm->fifo_size);
+  for (i = 0; i < num_threads; i++)
+    vec_validate (esm->rx_buf[i], esm->rcv_buffer_size);
+
+  if (hicn_server_attach (appns_id, appns_flags, appns_secret))
+    {
+      clib_warning ("failed to attach server");
+      return -1;
+    }
+  if (hicn_server_listen ())
+    {
+      clib_warning ("failed to start listening");
+      if (hicn_server_detach ())
+	clib_warning ("failed to detach");
+      return -1;
+    }
+  return 0;
+}
+
+static clib_error_t *
+hicn_server_create_command_fn (vlib_main_t * vm, unformat_input_t * input,
+			       vlib_cli_command_t * cmd)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  u8 server_uri_set = 0, *appns_id = 0;
+  u64 tmp, appns_flags = 0, appns_secret = 0;
+  char *default_uri = "hicn://b001::1/64";
+  int rv, is_stop = 0;
+  session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
+
+  esm->fifo_size = 128 << 20;
+  esm->rcv_buffer_size = 2 << 20;
+  esm->prealloc_fifos = 0;
+  esm->private_segment_count = 0;
+  esm->private_segment_size = 0;
+  esm->tls_engine = CRYPTO_ENGINE_OPENSSL;
+  vec_free (esm->server_uri);
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "uri %s", &esm->server_uri))
+	server_uri_set = 1;
+      else if (unformat (input, "fifo-size %d", &esm->fifo_size))
+	esm->fifo_size <<= 10;
+      else if (unformat (input, "rcv-buf-size %d", &esm->rcv_buffer_size))
+	;
+      else if (unformat (input, "prealloc-fifos %d", &esm->prealloc_fifos))
+	;
+      else if (unformat (input, "private-segment-count %d",
+			 &esm->private_segment_count))
+	;
+      else if (unformat (input, "private-segment-size %U",
+			 unformat_memory_size, &tmp))
+	{
+	  if (tmp >= 0x100000000ULL)
+	    return clib_error_return
+	      (0, "private segment size %lld (%llu) too large", tmp, tmp);
+	  esm->private_segment_size = tmp;
+	}
+      else if (unformat (input, "appns %_%v%_", &appns_id))
+	;
+      else if (unformat (input, "all-scope"))
+	appns_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE
+			| APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE);
+      else if (unformat (input, "local-scope"))
+	appns_flags |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
+      else if (unformat (input, "global-scope"))
+	appns_flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
+      else if (unformat (input, "secret %lu", &appns_secret))
+	;
+      else if (unformat (input, "stop"))
+	is_stop = 1;
+      else if (unformat (input, "tls-engine %d", &esm->tls_engine))
+	;
+      else
+	return clib_error_return (0, "failed: unknown input `%U'",
+				  format_unformat_error, input);
+    }
+
+  if (is_stop)
+    {
+      if (esm->app_index == (u32) ~ 0)
+	{
+	  clib_warning ("server not running");
+	  return clib_error_return (0, "failed: server not running");
+	}
+      rv = hicn_server_detach ();
+      if (rv)
+	{
+	  clib_warning ("failed: detach");
+	  return clib_error_return (0, "failed: server detach %d", rv);
+	}
+      return 0;
+    }
+
+  vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
+  hicn_hs_enable_disable(vm, 1 /* enable hicn transport */);
+
+  if (!server_uri_set)
+    {
+      clib_warning ("No uri provided! Using default: %s", default_uri);
+      esm->server_uri = (char *) format (0, "%s%c", default_uri, 0);
+    }
+
+  if ((rv = parse_uri ((char *) esm->server_uri, &sep)))
+    return clib_error_return (0, "Uri parse error: %d", rv);
+  esm->transport_proto = sep.transport_proto;
+  esm->is_dgram = 0;
+
+  rv = hicn_server_create (vm, appns_id, appns_flags, appns_secret);
+  vec_free (appns_id);
+  if (rv)
+    {
+      vec_free (esm->server_uri);
+      return clib_error_return (0, "failed: server_create returned %d", rv);
+    }
+
+  return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (hicn_server_create_command, static) =
+{
+  .path = "test hicn hs server",
+  .short_help = "test echo server proto <proto> [no echo][fifo-size <mbytes>]"
+      "[rcv-buf-size <bytes>][prealloc-fifos <count>]"
+      "[private-segment-count <count>][private-segment-size <bytes[m|g]>]"
+      "[uri <hicn://ip/plen>]",
+  .function = hicn_server_create_command_fn,
+};
+/* *INDENT-ON* */
+
+clib_error_t *
+hicn_server_main_init (vlib_main_t * vm)
+{
+  hicn_server_main_t *esm = &hicn_server_main;
+  esm->my_client_index = ~0;
+  return 0;
+}
+
+VLIB_INIT_FUNCTION (hicn_server_main_init);
+
+/*
+* fd.io coding-style-patch-verification: ON
+*
+* Local Variables:
+* eval: (c-set-style "gnu")
+* End:
+*/
diff --git a/hicn-plugin/src/host_stack/testbed/Dockerfile b/hicn-plugin/src/host_stack/testbed/Dockerfile
new file mode 100644
index 000000000..4e7005938
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/Dockerfile
@@ -0,0 +1,46 @@
+FROM ubuntu:18.04 
+
+ARG USERNAME=ubuntu
+ARG USER_UID=1000
+ARG USER_GID=$USER_UID
+
+ARG VPP_GRP=vpp
+ARG VPP_GID=998
+
+ARG WORKDIR=/home/ubuntu
+
+RUN apt-get update \
+  && apt-get -y install --no-install-recommends apt-utils sudo dialog build-essential 	\
+    cmake cppcheck valgrind curl autoconf automake ccache debhelper dkms git libtool  	\
+    libapr1-dev dh-systemd libconfuse-dev git-review exuberant-ctags cscope pkg-config	\
+    lcov chrpath autoconf indent clang-format libnuma-dev python-all python3-all      	\
+    python3-setuptools python-dev python-virtualenv python-pip libffi6 check          	\
+    libboost-all-dev libffi-dev python3-ply libmbedtls-dev  cmake ninja-build uuid-dev 	\
+    python3-jsonschema gdb libssl-dev python-setuptools zsh 2>&1 						\
+  #
+  # Verify git, process tools, lsb-release (useful for CLI installs) installed
+  && apt-get -y install git procps lsb-release curl iproute2 \
+  #
+  # Create a non-root user to use if preferred - see https://aka.ms/vscode-remote/containers/non-root-user.
+  && groupadd --gid $USER_GID $USERNAME \
+  && useradd -s /bin/bash --uid $USER_UID --gid $USER_GID -m $USERNAME \
+  # [Optional] Uncomment the next three lines to add sudo support
+  && apt-get install -y sudo \
+  && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \
+  && chmod 0440 /etc/sudoers.d/$USERNAME \
+  # Create vpp group
+  && groupadd --gid $VPP_GID $VPP_GRP \
+  #
+  && mkdir -p $WORKDIR \
+  #
+  # Clean up
+  && apt-get autoremove -y \
+  && apt-get clean -y \
+  && rm -rf /var/lib/apt/lists/*
+
+USER $USERNAME
+COPY init.sh /init.sh
+
+WORKDIR $WORKDIR
+
+CMD ["bash", "/init.sh"]
diff --git a/hicn-plugin/src/host_stack/testbed/client-startup.txt b/hicn-plugin/src/host_stack/testbed/client-startup.txt
new file mode 100644
index 000000000..7165265b3
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/client-startup.txt
@@ -0,0 +1,6 @@
+create interface memif id 0 master
+set int state memif0/0 up
+set int ip addr memif0/0 192.168.10.1/24
+set int ip addr memif0/0 2001::1/64
+ip route add b001::/64 via 2001::2 memif0/0
+#hicn enable b001::/64
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/testbed/init.sh b/hicn-plugin/src/host_stack/testbed/init.sh
new file mode 100644
index 000000000..3017c2fea
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/init.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+sudo modprobe uio_pci_generic
+sudo cp /home/ubuntu/host-stack/install/lib/libhicn.so /usr/lib/libhicn.so
+
+tail -f /dev/null
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/testbed/run-client-server.sh b/hicn-plugin/src/host_stack/testbed/run-client-server.sh
new file mode 100644
index 000000000..53388cdda
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/run-client-server.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+docker run -d 										\
+	   --privileged 								\
+	   --cap-add=ALL 							\
+	   --security-opt seccomp=unconfined 						\
+	   --hostname=vpp-client 							\
+	   -e STARTUP_CONF=/home/ubuntu/host-stack/vpp/testbed/startup-client.conf 	\
+	   -v /home/ubuntu/host-stack:/home/ubuntu/host-stack				\
+	   -v /dev:/dev -v /lib/modules:/lib/modules					\
+	   -v /var/run/vpp:/var/run/vpp							\
+	   --name vpp-client vpp-develop
+
+docker run -d 										\
+	   --privileged 								\
+	   --cap-add=SYS_PTRACE 							\
+	   --security-opt seccomp=unconfined 						\
+	   --hostname=vpp-server							\
+	   -e STARTUP_CONF=/home/ubuntu/host-stack/vpp/testbed/startup-server.conf 	\
+	   --cap-add=NET_ADMIN 								\
+	   -v /home/ubuntu/host-stack:/home/ubuntu/host-stack 				\
+	   -v /dev:/dev -v /lib/modules:/lib/modules					\
+	   -v /var/run/vpp:/var/run/vpp							\
+	   --name vpp-server vpp-develop
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/testbed/server-startup.txt b/hicn-plugin/src/host_stack/testbed/server-startup.txt
new file mode 100644
index 000000000..1b4d54338
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/server-startup.txt
@@ -0,0 +1,7 @@
+create interface memif id 0 slave
+set int state memif0/0 up
+set int ip addr memif0/0 192.168.10.2/24
+set int ip addr memif0/0 2001::2/64
+hicn hs set local prefix b001::/16
+#test hicn hs server uri hicn://b001::/64
+#hicn enable b001::/64
diff --git a/hicn-plugin/src/host_stack/testbed/startup-client.conf b/hicn-plugin/src/host_stack/testbed/startup-client.conf
new file mode 100644
index 000000000..fb0c89c87
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/startup-client.conf
@@ -0,0 +1,188 @@
+
+unix {
+  nodaemon
+  interactive
+  log /var/log/vpp/vpp.log
+  full-coredump
+  cli-listen /run/vpp/cli.sock
+  gid vpp
+  startup-config /home/ubuntu/host-stack/vpp/testbed/client-startup.txt
+}
+
+api-trace {
+## This stanza controls binary API tracing. Unless there is a very strong reason,
+## please leave this feature enabled.
+  on
+## Additional parameters:
+##
+## To set the number of binary API trace records in the circular buffer, configure nitems
+##
+## nitems <nnn>
+##
+## To save the api message table decode tables, configure a filename. Results in /tmp/<filename>
+## Very handy for understanding api message changes between versions, identifying missing
+## plugins, and so forth.
+##
+## save-api-table <filename>
+}
+
+api-segment {
+  gid vpp
+}
+
+socksvr {
+  default
+}
+
+cpu {
+	## In the VPP there is one main thread and optionally the user can create worker(s)
+	## The main thread and worker thread(s) can be pinned to CPU core(s) manually or automatically
+
+	## Manual pinning of thread(s) to CPU core(s)
+
+	## Set logical CPU core where main thread runs, if main core is not set
+	## VPP will use core 1 if available
+	main-core 1
+
+	## Set logical CPU core(s) where worker threads are running
+	# corelist-workers 2-3,18-19
+
+	## Automatic pinning of thread(s) to CPU core(s)
+
+	## Sets number of CPU core(s) to be skipped (1 ... N-1)
+	## Skipped CPU core(s) are not used for pinning main thread and working thread(s).
+	## The main thread is automatically pinned to the first available CPU core and worker(s)
+	## are pinned to next free CPU core(s) after core assigned to main thread
+	# skip-cores 4
+
+	## Specify a number of workers to be created
+	## Workers are pinned to N consecutive CPU cores while skipping "skip-cores" CPU core(s)
+	## and main thread's CPU core
+	# workers 2
+
+	## Set scheduling policy and priority of main and worker threads
+
+	## Scheduling policy options are: other (SCHED_OTHER), batch (SCHED_BATCH)
+	## idle (SCHED_IDLE), fifo (SCHED_FIFO), rr (SCHED_RR)
+	# scheduler-policy fifo
+
+	## Scheduling priority is used only for "real-time policies (fifo and rr),
+	## and has to be in the range of priorities supported for a particular policy
+	# scheduler-priority 50
+}
+
+buffers {
+	## Increase number of buffers allocated, needed only in scenarios with
+	## large number of interfaces and worker threads. Value is per numa node.
+# Default is 16384 (8192 if running unpriviledged)
+	buffers-per-numa 600000
+	## Size of buffer data area
+	## Default is 2048
+	# default data-size 2048
+}
+
+# dpdk {
+	## Change default settings for all interfaces
+	# dev default {
+		## Number of receive queues, enables RSS
+		## Default is 1
+		# num-rx-queues 3
+
+		## Number of transmit queues, Default is equal
+		## to number of worker threads or 1 if no workers treads
+		# num-tx-queues 3
+
+		## Number of descriptors in transmit and receive rings
+		## increasing or reducing number can impact performance
+		## Default is 1024 for both rx and tx
+		# num-rx-desc 512
+		# num-tx-desc 512
+
+		## VLAN strip offload mode for interface
+		## Default is off
+		# vlan-strip-offload on
+
+		## TCP Segment Offload
+		## Default is off
+		## To enable TSO, 'enable-tcp-udp-checksum' must be set
+		# tso on
+
+		## Devargs
+                ## device specific init args
+                ## Default is NULL
+		# devargs safe-mode-support=1,pipeline-mode-support=1
+	# }
+
+	## Whitelist specific interface by specifying PCI address
+	# dev 0000:13:00.0
+
+	## Blacklist specific device type by specifying PCI vendor:device
+        ## Whitelist entries take precedence
+	# blacklist 8086:10fb
+
+	## Set interface name
+	# dev 0000:02:00.1 {
+	#	name eth0
+	# }
+
+	## Whitelist specific interface by specifying PCI address and in
+	## addition specify custom parameters for this interface
+	# dev 0000:02:00.1 {
+	#	num-rx-queues 2
+	# }
+
+	## Change UIO driver used by VPP, Options are: igb_uio, vfio-pci,
+	## uio_pci_generic or auto (default)
+	# uio-driver vfio-pci
+
+	## Disable multi-segment buffers, improves performance but
+	## disables Jumbo MTU support
+	# no-multi-seg
+
+	## Change hugepages allocation per-socket, needed only if there is need for
+	## larger number of mbufs. Default is 256M on each detected CPU socket
+	# socket-mem 2048,2048
+
+	## Disables UDP / TCP TX checksum offload. Typically needed for use
+	## faster vector PMDs (together with no-multi-seg)
+	# no-tx-checksum-offload
+
+	## Enable UDP / TCP TX checksum offload
+	## This is the reversed option of 'no-tx-checksum-offload'
+	# enable-tcp-udp-checksum
+# }
+
+
+plugins {
+	## Adjusting the plugin path depending on where the VPP plugins are
+	path /home/ubuntu/host-stack/vpp/build-root/install-vpp_debug-native/vpp/lib/x86_64-linux-gnu/vpp_plugins:/home/ubuntu/host-stack/vpp/build-root/install-vpp_debug-native/vpp/lib/vpp_plugins:/home/ubuntu/host-stack/install/lib/vpp_plugins
+	## Disable all plugins by default and then selectively enable specific plugins
+	plugin default { enable }
+	plugin dpdk_plugin.so { disable }
+	plugin hicn_plugin.so { enable }
+#        plugin hicn_plugin.so { enable }
+        
+
+	## Enable all plugins by default and then selectively disable specific plugins
+	# plugin dpdk_plugin.so { disable }
+	# plugin acl_plugin.so { disable }
+}
+
+## Statistics Segment
+# statseg {
+    # socket-name <filename>, name of the stats segment socket
+    #     defaults to /run/vpp/stats.sock
+    # size <nnn>[KMG], size of the stats segment, defaults to 32mb
+    # per-node-counters on | off, defaults to none
+    # update-interval <f64-seconds>, sets the segment scrape / update interval
+# }
+
+#hicn { 
+#    pit-size 2000000  
+#    cs-size 1000000 
+#    cs-reserved-app 10
+#}
+
+session { evt_qs_memfd_seg  }
+socksvr { socket-name /tmp/vpp-api.sock}
+tcp {cc-algo cubic}
diff --git a/hicn-plugin/src/host_stack/testbed/startup-server.conf b/hicn-plugin/src/host_stack/testbed/startup-server.conf
new file mode 100644
index 000000000..46fc220d8
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/startup-server.conf
@@ -0,0 +1,189 @@
+
+unix {
+  nodaemon
+  interactive
+  log /var/log/vpp/vpp.log
+  full-coredump
+  cli-listen /run/vpp/cli.sock
+  gid vpp
+  startup-config /home/ubuntu/host-stack/vpp/testbed/server-startup.txt
+}
+
+api-trace {
+## This stanza controls binary API tracing. Unless there is a very strong reason,
+## please leave this feature enabled.
+  on
+## Additional parameters:
+##
+## To set the number of binary API trace records in the circular buffer, configure nitems
+##
+## nitems <nnn>
+##
+## To save the api message table decode tables, configure a filename. Results in /tmp/<filename>
+## Very handy for understanding api message changes between versions, identifying missing
+## plugins, and so forth.
+##
+## save-api-table <filename>
+}
+
+api-segment {
+  gid vpp
+}
+
+socksvr {
+  default
+}
+
+cpu {
+	## In the VPP there is one main thread and optionally the user can create worker(s)
+	## The main thread and worker thread(s) can be pinned to CPU core(s) manually or automatically
+
+	## Manual pinning of thread(s) to CPU core(s)
+
+	## Set logical CPU core where main thread runs, if main core is not set
+	## VPP will use core 1 if available
+	main-core 2
+
+	## Set logical CPU core(s) where worker threads are running
+	# corelist-workers 2-3,18-19
+
+	## Automatic pinning of thread(s) to CPU core(s)
+
+	## Sets number of CPU core(s) to be skipped (1 ... N-1)
+	## Skipped CPU core(s) are not used for pinning main thread and working thread(s).
+	## The main thread is automatically pinned to the first available CPU core and worker(s)
+	## are pinned to next free CPU core(s) after core assigned to main thread
+	# skip-cores 4
+
+	## Specify a number of workers to be created
+	## Workers are pinned to N consecutive CPU cores while skipping "skip-cores" CPU core(s)
+	## and main thread's CPU core
+	# workers 2
+
+	## Set scheduling policy and priority of main and worker threads
+
+	## Scheduling policy options are: other (SCHED_OTHER), batch (SCHED_BATCH)
+	## idle (SCHED_IDLE), fifo (SCHED_FIFO), rr (SCHED_RR)
+	# scheduler-policy fifo
+
+	## Scheduling priority is used only for "real-time policies (fifo and rr),
+	## and has to be in the range of priorities supported for a particular policy
+	# scheduler-priority 50
+}
+
+buffers {
+	## Increase number of buffers allocated, needed only in scenarios with
+	## large number of interfaces and worker threads. Value is per numa node.
+# Default is 16384 (8192 if running unpriviledged)
+	buffers-per-numa 600000
+	## Size of buffer data area
+	## Default is 2048
+	# default data-size 2048
+}
+
+# dpdk {
+	## Change default settings for all interfaces
+	# dev default {
+		## Number of receive queues, enables RSS
+		## Default is 1
+		# num-rx-queues 3
+
+		## Number of transmit queues, Default is equal
+		## to number of worker threads or 1 if no workers treads
+		# num-tx-queues 3
+
+		## Number of descriptors in transmit and receive rings
+		## increasing or reducing number can impact performance
+		## Default is 1024 for both rx and tx
+		# num-rx-desc 512
+		# num-tx-desc 512
+
+		## VLAN strip offload mode for interface
+		## Default is off
+		# vlan-strip-offload on
+
+		## TCP Segment Offload
+		## Default is off
+		## To enable TSO, 'enable-tcp-udp-checksum' must be set
+		# tso on
+
+		## Devargs
+                ## device specific init args
+                ## Default is NULL
+		# devargs safe-mode-support=1,pipeline-mode-support=1
+	# }
+
+	## Whitelist specific interface by specifying PCI address
+	# dev 0000:13:00.1
+
+	## Blacklist specific device type by specifying PCI vendor:device
+        ## Whitelist entries take precedence
+	# blacklist 8086:10fb
+
+	## Set interface name
+	# dev 0000:02:00.1 {
+	#	name eth0
+	# }
+
+	## Whitelist specific interface by specifying PCI address and in
+	## addition specify custom parameters for this interface
+	# dev 0000:02:00.1 {
+	#	num-rx-queues 2
+	# }
+
+	## Change UIO driver used by VPP, Options are: igb_uio, vfio-pci,
+	## uio_pci_generic or auto (default)
+	# uio-driver vfio-pci
+
+	## Disable multi-segment buffers, improves performance but
+	## disables Jumbo MTU support
+	# no-multi-seg
+
+	## Change hugepages allocation per-socket, needed only if there is need for
+	## larger number of mbufs. Default is 256M on each detected CPU socket
+	# socket-mem 2048,2048
+
+	## Disables UDP / TCP TX checksum offload. Typically needed for use
+	## faster vector PMDs (together with no-multi-seg)
+	# no-tx-checksum-offload
+
+	## Enable UDP / TCP TX checksum offload
+	## This is the reversed option of 'no-tx-checksum-offload'
+	# enable-tcp-udp-checksum
+# }
+
+
+plugins {
+	## Adjusting the plugin path depending on where the VPP plugins are
+	path /home/ubuntu/host-stack/vpp/build-root/install-vpp_debug-native/vpp/lib/x86_64-linux-gnu/vpp_plugins:/home/ubuntu/host-stack/vpp/build-root/install-vpp_debug-native/vpp/lib/vpp_plugins:/home/ubuntu/host-stack/install/lib/vpp_plugins
+	## Disable all plugins by default and then selectively enable specific plugins
+	plugin default { enable }
+	plugin dpdk_plugin.so { disable }
+	plugin hicn_plugin.so { enable }
+#	plugin memif_plugin.so { enable }
+#        plugin hicn_plugin.so { enable }
+        
+
+	## Enable all plugins by default and then selectively disable specific plugins
+	# plugin dpdk_plugin.so { disable }
+	# plugin acl_plugin.so { disable }
+}
+
+## Statistics Segment
+# statseg {
+    # socket-name <filename>, name of the stats segment socket
+    #     defaults to /run/vpp/stats.sock
+    # size <nnn>[KMG], size of the stats segment, defaults to 32mb
+    # per-node-counters on | off, defaults to none
+    # update-interval <f64-seconds>, sets the segment scrape / update interval
+# }
+
+#hicn { 
+#    pit-size 2000000  
+#    cs-size 1000000 
+#    cs-reserved-app 10
+#}
+
+session { evt_qs_memfd_seg  }
+socksvr { socket-name /tmp/vpp-api.sock}
+tcp {cc-algo cubic}
diff --git a/hicn-plugin/src/host_stack/testbed/test_hicn_hs.txt b/hicn-plugin/src/host_stack/testbed/test_hicn_hs.txt
new file mode 100644
index 000000000..73a5b15f5
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/test_hicn_hs.txt
@@ -0,0 +1,6 @@
+hicn hs set local prefix b001::/8
+test hicn hs server uri hicn://b001::/64
+test hicn hs client uri hicn://b001::1/64
+
+
+b hicn_hs.c:772 if ctx->snd_nxt == 46604
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/testbed/vcl.conf b/hicn-plugin/src/host_stack/testbed/vcl.conf
new file mode 100644
index 000000000..694a3e3a1
--- /dev/null
+++ b/hicn-plugin/src/host_stack/testbed/vcl.conf
@@ -0,0 +1,7 @@
+vcl {
+  rx-fifo-size 4000000
+  tx-fifo-size 4000000
+  app-scope-local
+  app-scope-global
+  api-socket-name /tmp/vpp-api.sock
+}
\ No newline at end of file
diff --git a/hicn-plugin/src/host_stack/utils.h b/hicn-plugin/src/host_stack/utils.h
new file mode 100644
index 000000000..67568d568
--- /dev/null
+++ b/hicn-plugin/src/host_stack/utils.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Compute TCP checksum in software when offloading is disabled for a connection */
+
+#ifndef __HICN_HS_UTILS_H__
+#define __HICN_HS_UTILS_H__
+
+#include <vnet/ip/ip4.h>
+#include <vnet/ip/ip6.h>
+#include <vnet/tcp/tcp.h>
+
+always_inline u16
+ip6_tcp_compute_checksum_custom (vlib_main_t * vm, vlib_buffer_t * p0,
+				 ip46_address_t * src, ip46_address_t * dst)
+{
+  ip_csum_t sum0;
+  u16 payload_length_host_byte_order;
+  u32 i;
+
+  /* Initialize checksum with ip header. */
+  sum0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, p0)) +
+    clib_host_to_net_u16 (IP_PROTOCOL_TCP);
+  payload_length_host_byte_order = vlib_buffer_length_in_chain (vm, p0);
+
+  for (i = 0; i < ARRAY_LEN (src->ip6.as_uword); i++)
+    {
+      sum0 = ip_csum_with_carry
+	(sum0, clib_mem_unaligned (&src->ip6.as_uword[i], uword));
+      sum0 = ip_csum_with_carry
+	(sum0, clib_mem_unaligned (&dst->ip6.as_uword[i], uword));
+    }
+
+  return ip_calculate_l4_checksum (vm, p0, sum0,
+				   payload_length_host_byte_order, NULL, 0,
+				   NULL);
+}
+
+always_inline u16
+ip4_tcp_compute_checksum_custom (vlib_main_t * vm, vlib_buffer_t * p0,
+				 ip46_address_t * src, ip46_address_t * dst)
+{
+  ip_csum_t sum0;
+  u32 payload_length_host_byte_order;
+
+  payload_length_host_byte_order = vlib_buffer_length_in_chain (vm, p0);
+  sum0 =
+    clib_host_to_net_u32 (payload_length_host_byte_order +
+			  (IP_PROTOCOL_TCP << 16));
+
+  sum0 = ip_csum_with_carry (sum0, clib_mem_unaligned (&src->ip4, u32));
+  sum0 = ip_csum_with_carry (sum0, clib_mem_unaligned (&dst->ip4, u32));
+
+  return ip_calculate_l4_checksum (vm, p0, sum0,
+				   payload_length_host_byte_order, NULL, 0,
+				   NULL);
+}
+
+always_inline u16
+hicn_hs_compute_checksum (hicn_hs_ctx_t * ctx, vlib_buffer_t * b)
+{
+  u16 checksum = 0;
+  if (PREDICT_FALSE (ctx->cfg_flags & HICN_HS_CFG_F_NO_CSUM_OFFLOAD))
+    {
+      hicn_hs_worker_t *wrk = hicn_hs_get_worker_by_context (ctx);
+      vlib_main_t *vm = wrk->vm;
+      ip46_address_t local_ip = {0};
+
+      if (ctx->c_is_ip4)
+	checksum = ip4_tcp_compute_checksum_custom
+	  (vm, b, &local_ip, &ctx->c_rmt_ip);
+      else
+	checksum = ip6_tcp_compute_checksum_custom
+	  (vm, b, &local_ip, &ctx->c_rmt_ip);
+    }
+  else
+    {
+      b->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
+    }
+  return checksum;
+}
+
+#endif /* __HICN_HS_UTILS_H__ */