feat: Due to the deep modifications related to names and packet format,

this task cover a large part of the codebase and involves several changes:

- the library provides a name data structure (hicn_name_t ), which is composed
  of a name prefix (hicn_name_prefix_t) and a name suffix (hicn_name_suffix_t),
  and it has been extended to provide all support functions required for name
  manipulation, including common prefix computation, as required for the Longest
  Prefix Match (LPM)in the forwarder, in addition to Exact Prefix Match (EPM).
- all code has been rewritten to use this data structure instead of having for
  instance the forwarder define its own name class (used to be Name and NameBitVector)
  the code has been refactored to minimize name allocations and copies, one remaining
  aspect is the difference of name storage between PIT and CS entries (respectively
  in the PIT entry, and in the message buffer), which causes the packet cache
  index to be updated when a PIT entry is converted into a CS entry. By storing
  the name in the PIT/CS entry everytime, we might save on this operation).
- hicn-light FIB has been rewritten : code has been refactored and should now be
  shorter and documented; unit tests have been drafted but more would be required
  to cover all cases and match the algorithms to add/remove nodes, as specified in the doc.
  all protocol details and hICN header formats are now abstracted by the library
  for the forwarder (and thus header.h and  protocols/*.h have been removed from
  public includes, and replaced by packet.h providing protocol agnostic packet
  level functions, completely replacing the compat.h header that used to provide
  similar functions.
- this works by exposing a opaque buffer to the application (a kind of socket buffer)
  which is used by the lib to cache the packet format and offsets of the different
  layers in the buffer and provider efficient operations (the packet format is
  either defined for packet construction, or guessed at ingress, and this structure
  is updated accordingly only once).

Co-authored-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Signed-off-by: Luca Muscariello <muscariello@ieee.org>
Change-Id: I31e321897f85f0267fe8ba4720363c180564492f

11 files changed, 719 insertions, 0 deletions

diff --git a/ctrl/libhicnctrl/src/commands/command_cache.c b/ctrl/libhicnctrl/src/commands/command_cache.c
new file mode 100644
index 000000000..124fcd761
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_cache.c
@@ -0,0 +1,54 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define serve                                                            \
+  {                                                                      \
+    .name = "serve",                                                     \
+    .help =                                                              \
+        "Enables/disables replies from local content store. Either the " \
+        "string 'on' or 'off'",                                          \
+    .type = TYPE_ON_OFF, .offset = offsetof(hc_cache_t, serve),          \
+  }
+
+#define store                                                                 \
+  {                                                                           \
+    .name = "store",                                                          \
+    .help =                                                                   \
+        "enables/disables the storage of incoming data packets in the local " \
+        "content store. Either the string 'on' or 'off'",                     \
+    .type = TYPE_ON_OFF, .offset = offsetof(hc_cache_t, store),               \
+  }
+
+/* Commands */
+
+static const command_parser_t command_cache_set_serve = {
+    .action = ACTION_SERVE,
+    .object_type = OBJECT_TYPE_CACHE,
+    .nparams = 1,
+    .parameters = {serve},
+};
+COMMAND_REGISTER(command_cache_set_serve);
+
+static const command_parser_t command_cache_set_store = {
+    .action = ACTION_STORE,
+    .object_type = OBJECT_TYPE_CACHE,
+    .nparams = 1,
+    .parameters = {store},
+};
+COMMAND_REGISTER(command_cache_set_store);
+
+static const command_parser_t command_cache_clear = {
+    .action = ACTION_CLEAR,
+    .object_type = OBJECT_TYPE_CACHE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_cache_clear);
+
+static const command_parser_t command_cache_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_CACHE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_cache_list);
diff --git a/ctrl/libhicnctrl/src/commands/command_connection.c b/ctrl/libhicnctrl/src/commands/command_connection.c
new file mode 100644
index 000000000..30b3c3bf1
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_connection.c
@@ -0,0 +1,147 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define type_hicn                                                            \
+  {                                                                          \
+    .name = "type", .help = "connection type (hICN)",                        \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_connection_t, type), \
+  }
+
+#define type_tcp_udp                                                         \
+  {                                                                          \
+    .name = "type", .help = "connection type [tcp | udp]",                   \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_connection_t, type), \
+  }
+
+#define symbolic                                                              \
+  {                                                                           \
+    .name = "symbolic",                                                       \
+    .help = "symbolic name, e.g. 'conn1' (must be unique, start with alpha)", \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_connection_t, name),   \
+  }
+
+#define local_address                                                         \
+  {                                                                           \
+    .name = "local_addr", .help = "local IP address on which to bind.",       \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_connection_t, local_addr), \
+    .offset2 = offsetof(hc_connection_t, family),                             \
+  }
+
+#define local_port                                   \
+  {                                                  \
+    .name = "local_port", .help = "Local port.",     \
+    .type = TYPE_UINT16(1, UINT16_MAX),              \
+    .offset = offsetof(hc_connection_t, local_port), \
+  }
+
+#define remote_address                                                         \
+  {                                                                            \
+    .name = "remote_address",                                                  \
+    .help = "The IPv4 or IPv6 or hostname of the remote system.",              \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_connection_t, remote_addr), \
+    .offset2 = offsetof(hc_connection_t, family),                              \
+  }
+
+#define remote_port                                   \
+  {                                                   \
+    .name = "remote_port", .help = "Remote port.",    \
+    .type = TYPE_UINT16(1, UINT16_MAX),               \
+    .offset = offsetof(hc_connection_t, remote_port), \
+  }
+
+#define interface                                              \
+  {                                                            \
+    .name = "interface", .help = "Interface on which to bind", \
+    .type = TYPE_INTERFACE_NAME,                               \
+    .offset = offsetof(hc_connection_t, interface_name),       \
+  }
+
+#define symbolic_or_id                                                      \
+  {                                                                         \
+    .name = "symbolic", .help = "The connection symbolic name or id",       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_connection_t, name), \
+  }
+
+/* Commands */
+
+int on_connection_create(hc_connection_t* connection) {
+  connection->admin_state = FACE_STATE_UP;
+  return 0;
+}
+
+#if 0
+static command_parser_t command_connection_create4 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 4,
+    .parameters = {type_hicn, symbolic, local_address, remote_address},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create4);
+
+static const command_parser_t command_connection_create5 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_TYPE_CONNECTION,
+    .nparams = 5,
+    .parameters = {type_hicn, symbolic, local_address, remote_address,
+                   interface},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create5);
+#endif
+
+static const command_parser_t command_connection_create4 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 4,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create4);
+
+static const command_parser_t command_connection_create5 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 5,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port,
+                   interface},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create5);
+
+static const command_parser_t command_connection_create6 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 6,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port,
+                   local_address, local_port},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create6);
+
+static const command_parser_t command_connection_create7 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 7,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port,
+                   local_address, local_port, interface},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create7);
+
+static const command_parser_t command_connection_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_connection_list);
+
+static const command_parser_t command_connection_remove = {
+    .action = ACTION_DELETE,
+    .object_type = OBJECT_TYPE_CONNECTION,
+    .nparams = 1,
+    .parameters = {symbolic_or_id},
+};
+COMMAND_REGISTER(command_connection_remove);
diff --git a/ctrl/libhicnctrl/src/commands/command_face.c b/ctrl/libhicnctrl/src/commands/command_face.c
new file mode 100644
index 000000000..68a6abefe
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_face.c
@@ -0,0 +1,112 @@
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define type_hicn                                                             \
+  {                                                                           \
+    .name = "type", .help = "face type (hICN)", .type = TYPE_ENUM(face_type), \
+    .offset = offsetof(hc_face_t, type),                                      \
+  }
+
+#define type_tcp_udp                                                   \
+  {                                                                    \
+    .name = "type", .help = "face type [tcp | udp]",                   \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_face_t, type), \
+  }
+
+#define local_address                                                   \
+  {                                                                     \
+    .name = "local_addr", .help = "local IP address on which to bind.", \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_face_t, local_addr), \
+    .offset2 = offsetof(hc_face_t, family),                             \
+  }
+
+#define local_port                               \
+  {                                              \
+    .name = "local_port", .help = "Local port.", \
+    .type = TYPE_UINT16(1, UINT16_MAX),          \
+    .offset = offsetof(hc_face_t, local_port),   \
+  }
+
+#define remote_address                                                   \
+  {                                                                      \
+    .name = "remote_address",                                            \
+    .help = "The IPv4 or IPv6 or hostname of the remote system.",        \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_face_t, remote_addr), \
+    .offset2 = offsetof(hc_face_t, family),                              \
+  }
+
+#define remote_port                                \
+  {                                                \
+    .name = "remote_port", .help = "Remote port.", \
+    .type = TYPE_UINT16(1, UINT16_MAX),            \
+    .offset = offsetof(hc_face_t, remote_port),    \
+  }
+
+#define interface                                                           \
+  {                                                                         \
+    .name = "interface", .help = "Interface on which to bind",              \
+    .type = TYPE_INTERFACE_NAME,                                            \
+    .offset = offsetof(hc_face_t, netdevice) + offsetof(netdevice_t, name), \
+  }
+
+#define symbolic_or_id                                                \
+  {                                                                   \
+    .name = "symbolic", .help = "The face symbolic name or id",       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_face_t, name), \
+  }
+
+/* Commands */
+
+int on_face_create(hc_face_t* face) {
+  face->admin_state = FACE_STATE_UP;
+  return 0;
+}
+
+static command_parser_t command_face_create3 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_FACE,
+    .nparams = 3,
+    .parameters = {type_hicn, local_address, remote_address},
+    .post_hook = (parser_hook_t)on_face_create,
+};
+COMMAND_REGISTER(command_face_create3);
+
+#if 0
+static const command_parser_t command_face_create4 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_TYPE_FACE,
+    .nparams = 4,
+    .parameters = {type_hicn, local_address, remote_address,
+                   interface},
+    .post_hook = (parser_hook_t)on_face_create,
+};
+COMMAND_REGISTER(command_face_create4);
+#endif
+
+static const command_parser_t command_face_create5 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_FACE,
+    .nparams = 5,
+    .parameters = {type_tcp_udp, remote_address, remote_port, local_address,
+                   local_port},
+    .post_hook = (parser_hook_t)on_face_create,
+};
+COMMAND_REGISTER(command_face_create5);
+
+static const command_parser_t command_face_create6 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_FACE,
+    .nparams = 6,
+    .parameters = {type_tcp_udp, remote_address, remote_port, local_address,
+                   local_port, interface},
+    .post_hook = (parser_hook_t)on_face_create,
+};
+COMMAND_REGISTER(command_face_create6);
+
+static const command_parser_t command_face_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_FACE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_face_list);
diff --git a/ctrl/libhicnctrl/src/commands/command_listener.c b/ctrl/libhicnctrl/src/commands/command_listener.c
new file mode 100644
index 000000000..bba4f4541
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_listener.c
@@ -0,0 +1,111 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define protocol_hicn                                                      \
+  {                                                                        \
+    .name = "protocol", .help = "Protocol [hicn].",                        \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_listener_t, type), \
+  }
+
+#define protocol_tcp_udp                                                   \
+  {                                                                        \
+    .name = "protocol", .help = "Protocol [tcp | udp]",                    \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_listener_t, type), \
+  }
+
+#define symbolic                                                          \
+  {                                                                       \
+    .name = "symbolic",                                                   \
+    .help =                                                               \
+        "User defined name for listener, must start with alpha and be "   \
+        "alphanum",                                                       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_listener_t, name), \
+  }
+
+#define local_address                                                       \
+  {                                                                         \
+    .name = "local_addr",                                                   \
+    .help =                                                                 \
+        "IPv4 or IPv6 address (or prefix protocol = hicn) assigend to the " \
+        "local interface",                                                  \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_listener_t, local_addr), \
+    .offset2 = offsetof(hc_listener_t, family),                             \
+  }
+
+#define local_port                                 \
+  {                                                \
+    .name = "local_port", .help = "Local port.",   \
+    .type = TYPE_UINT16(1, UINT16_MAX),            \
+    .offset = offsetof(hc_listener_t, local_port), \
+  }
+
+#define interface                                              \
+  {                                                            \
+    .name = "interface", .help = "Interface on which to bind", \
+    .type = TYPE_INTERFACE_NAME,                               \
+    .offset = offsetof(hc_listener_t, interface_name),         \
+  }
+
+#define symbolic_or_id                                                    \
+  {                                                                       \
+    .name = "symbolic", .help = "The listener symbolic name or id",       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_listener_t, name), \
+  }
+
+/* Commands */
+
+/* The parse sets the wrong face_type_t for listener, we fix that here */
+int on_listener_create(hc_listener_t* listener) {
+  switch (listener->type) {
+    case FACE_TYPE_UDP:
+      listener->type = FACE_TYPE_UDP_LISTENER;
+      break;
+    case FACE_TYPE_TCP:
+      listener->type = FACE_TYPE_TCP_LISTENER;
+      break;
+    case FACE_TYPE_HICN:
+      listener->type = FACE_TYPE_HICN_LISTENER;
+      break;
+    default:
+      break;
+  }
+  return 0;
+}
+
+#if 0
+static const command_parser_t command_listener_create4 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_TYPE_LISTENER,
+    .nparams = 4,
+    .parameters = {protocol_hicn, symbolic, local_address, interface},
+    .post_hook = (parser_hook_t)on_listener_create,
+};
+COMMAND_REGISTER(command_listener_create4);
+#endif
+
+static const command_parser_t command_listener_create6 = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_LISTENER,
+    .nparams = 5,
+    .parameters = {protocol_tcp_udp, symbolic, local_address, local_port,
+                   interface},
+    .post_hook = (parser_hook_t)on_listener_create,
+};
+COMMAND_REGISTER(command_listener_create6);
+
+static const command_parser_t command_listener_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_LISTENER,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_listener_list);
+
+static const command_parser_t command_listener_remove = {
+    .action = ACTION_DELETE,
+    .object_type = OBJECT_TYPE_LISTENER,
+    .nparams = 1,
+    .parameters = {symbolic_or_id},
+};
+COMMAND_REGISTER(command_listener_remove);
diff --git a/ctrl/libhicnctrl/src/commands/command_mapme.c b/ctrl/libhicnctrl/src/commands/command_mapme.c
new file mode 100644
index 000000000..c67b7704f
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_mapme.c
@@ -0,0 +1,59 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define target                                                                \
+  {                                                                           \
+    .name = "target",                                                         \
+    .help =                                                                   \
+        "Target for the set action, e.g. enable, discovery, timescale, retx", \
+    .type = TYPE_ENUM(mapme_target), .offset = offsetof(hc_mapme_t, target),  \
+  }
+
+#define value                                                              \
+  {                                                                        \
+    .name = "value",                                                       \
+    .help = "Value to set for the target, e.g. 'on', 'off', milliseconds", \
+    .type = TYPE_STRN(4), .offset = offsetof(hc_mapme_t, unparsed_arg),    \
+  }
+
+#define prefix                                                         \
+  {                                                                    \
+    .name = "prefix",                                                  \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).", \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_mapme_t, address),   \
+    .offset2 = offsetof(hc_mapme_t, len),                              \
+    .offset3 = offsetof(hc_mapme_t, family),                           \
+  }
+
+/* Commands */
+
+// Parse the raw string argument into 'timescale' or 'enabled',
+// necessary since the command dispatch is based on the number
+// of arguments and not their type
+int parse_args(hc_mapme_t* mapme) {
+  mapme->timescale = atoi(mapme->unparsed_arg);
+
+  if (strcasecmp(mapme->unparsed_arg, "off") == 0) mapme->enabled = 0;
+  if (strcasecmp(mapme->unparsed_arg, "on") == 0) mapme->enabled = 1;
+
+  return 0;
+}
+
+static const command_parser_t command_mapme_set = {
+    .action = ACTION_SET,
+    .object_type = OBJECT_TYPE_MAPME,
+    .nparams = 2,
+    .parameters = {target, value},
+    .post_hook = (parser_hook_t)parse_args,
+};
+COMMAND_REGISTER(command_mapme_set);
+
+static const command_parser_t command_mapme_update = {
+    .action = ACTION_UPDATE,
+    .object_type = OBJECT_TYPE_MAPME,
+    .nparams = 1,
+    .parameters = {prefix},
+};
+COMMAND_REGISTER(command_mapme_update);
diff --git a/ctrl/libhicnctrl/src/commands/command_policy.c b/ctrl/libhicnctrl/src/commands/command_policy.c
new file mode 100644
index 000000000..2fc7a0a42
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_policy.c
@@ -0,0 +1,52 @@
+#if 0
+#include <hicn/policy.h>
+
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define prefix                                                            \
+  {                                                                       \
+    .name = "prefix",                                                     \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",    \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_policy_t, remote_addr), \
+    .offset2 = offsetof(hc_policy_t, len),                                \
+    .offset3 = offsetof(hc_policy_t, family),                             \
+  }
+
+#define app_name                                                        \
+  {                                                                     \
+    .name = "app_name",                                                 \
+    .help = "The application name associated to this policy",           \
+    .type = TYPE_STR, .offset = offsetof(hc_policy_t, policy.app_name), \
+  }
+
+/* Commands */
+
+static const command_parser_t command_policy_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_POLICY,
+    .nparams = 2 + POLICY_TAG_N,
+    .parameters = {prefix, app_name,
+#define _(x, y)                                                            \
+  {                                                                        \
+      .name = "flag:" #x,                                                  \
+      .help =                                                              \
+          "A value among [neutral|require|prefer|avoid|prohibit] with an " \
+          "optional '!' character prefix for disabling changes",           \
+      .type = TYPE_POLICY_STATE(POLICY_TAG_##x),                           \
+      .offset = offsetof(hc_policy_t, policy.tags),                        \
+  },
+                   foreach_policy_tag
+#undef _
+    },
+};
+COMMAND_REGISTER(command_policy_create);
+
+static const command_parser_t command_policy_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_POLICY,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_policy_list);
+#endif
diff --git a/ctrl/libhicnctrl/src/commands/command_punting.c b/ctrl/libhicnctrl/src/commands/command_punting.c
new file mode 100644
index 000000000..b845c52ee
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_punting.c
@@ -0,0 +1,40 @@
+#if 0
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define symbolic_or_id                                                      \
+  {                                                                         \
+    .name = "symbolic_or_id",                                               \
+    .help =                                                                 \
+        "The symbolic name for an egress, or the egress punting id (see "   \
+        "'help list puntings')",                                            \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_punting_t, face_id), \
+  }
+
+#define prefix                                                        \
+  {                                                                   \
+    .name = "prefix",                                                 \
+    .help = "Prefix to add as a punting rule. (example 1234::0/64)",  \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_punting_t, prefix), \
+    .offset2 = offsetof(hc_punting_t, prefix_len),                    \
+    .offset3 = offsetof(hc_punting_t, family),                        \
+  }
+
+/* Commands */
+
+static const command_parser_t command_punting_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_PUNTING,
+    .nparams = 2,
+    .parameters = {symbolic_or_id, prefix},
+};
+COMMAND_REGISTER(command_punting_create);
+
+static const command_parser_t command_punting_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_PUNTING,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_punting_list);
+#endif
diff --git a/ctrl/libhicnctrl/src/commands/command_route.c b/ctrl/libhicnctrl/src/commands/command_route.c
new file mode 100644
index 000000000..8e7db8192
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_route.c
@@ -0,0 +1,53 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define symbolic_or_id                                                        \
+  {                                                                           \
+    .name = "symbolic_or_id",                                                 \
+    .help =                                                                   \
+        "The symbolic name for an egress, or the egress route id (see 'help " \
+        "list routes')",                                                      \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_route_t, face_name),   \
+  }
+
+#define prefix                                                           \
+  {                                                                      \
+    .name = "prefix",                                                    \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",   \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_route_t, remote_addr), \
+    .offset2 = offsetof(hc_route_t, len),                                \
+    .offset3 = offsetof(hc_route_t, family),                             \
+  }
+
+#define cost                                                        \
+  {                                                                 \
+    .name = "cost", .help = "Positive integer representing cost.",  \
+    .type = TYPE_INT(1, 255), .offset = offsetof(hc_route_t, cost), \
+  }
+
+/* Commands */
+
+static const command_parser_t command_route_create = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_ROUTE,
+    .nparams = 3,
+    .parameters = {symbolic_or_id, prefix, cost},
+};
+COMMAND_REGISTER(command_route_create);
+
+static const command_parser_t command_route_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_ROUTE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_route_list);
+
+static const command_parser_t command_route_remove = {
+    .action = ACTION_DELETE,
+    .object_type = OBJECT_TYPE_ROUTE,
+    .nparams = 2,
+    .parameters = {symbolic_or_id, prefix},
+};
+COMMAND_REGISTER(command_route_remove);
diff --git a/ctrl/libhicnctrl/src/commands/command_stats.c b/ctrl/libhicnctrl/src/commands/command_stats.c
new file mode 100644
index 000000000..7c58b105e
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_stats.c
@@ -0,0 +1,18 @@
+#include <math.h>
+#include <hicn/ctrl/command.h>
+
+/* Commands */
+
+static const command_parser_t command_stats_get = {
+    .action = ACTION_GET,
+    .object_type = OBJECT_TYPE_STATS,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_stats_get);
+
+static const command_parser_t command_stats_list = {
+    .action = ACTION_LIST,
+    .object_type = OBJECT_TYPE_STATS,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_stats_list);
diff --git a/ctrl/libhicnctrl/src/commands/command_strategy.c b/ctrl/libhicnctrl/src/commands/command_strategy.c
new file mode 100644
index 000000000..5605822e7
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_strategy.c
@@ -0,0 +1,47 @@
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+#define prefix                                                          \
+  {                                                                     \
+    .name = "prefix",                                                   \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",  \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_strategy_t, address), \
+    .offset2 = offsetof(hc_strategy_t, len),                            \
+    .offset3 = offsetof(hc_strategy_t, family),                         \
+  }
+
+#define strategy                                                               \
+  {                                                                            \
+    .name = "strategy",                                                        \
+    .help =                                                                    \
+        "Strategy type (e.g. 'random', 'loadbalancer', 'low_latency', "        \
+        "'replication', 'bestpath').",                                         \
+    .type = TYPE_ENUM(strategy_type), .offset = offsetof(hc_strategy_t, type), \
+  }
+
+#define local_prefix                                                          \
+  {                                                                           \
+    .name = "local_prefix",                                                   \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",        \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_strategy_t, local_address), \
+    .offset2 = offsetof(hc_strategy_t, local_len),                            \
+    .offset3 = offsetof(hc_strategy_t, local_family),                         \
+  }
+
+/* Commands */
+
+static const command_parser_t command_strategy_list = {
+    .action = ACTION_SET,
+    .object_type = OBJECT_TYPE_STRATEGY,
+    .nparams = 2,
+    .parameters = {prefix, strategy},
+};
+COMMAND_REGISTER(command_strategy_list);
+
+static const command_parser_t local_prefix_add = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_LOCAL_PREFIX,
+    .nparams = 3,
+    .parameters = {prefix, strategy, local_prefix},
+};
+COMMAND_REGISTER(local_prefix_add);
diff --git a/ctrl/libhicnctrl/src/commands/command_subscription.c b/ctrl/libhicnctrl/src/commands/command_subscription.c
new file mode 100644
index 000000000..886ee454a
--- /dev/null
+++ b/ctrl/libhicnctrl/src/commands/command_subscription.c
@@ -0,0 +1,26 @@
+#include <limits.h>
+
+#include <hicn/ctrl/command.h>
+
+/* Parameters */
+
+#define topics                                                                 \
+  {                                                                            \
+    .name = "topics",                                                          \
+    .help =                                                                    \
+        "Topics to subscribe to, e.g. 6 (110 in binary) means topic 2 (10 in " \
+        "binary, TOPIC_CONNECTION) and topic 4 (100 in binary, "               \
+        "TOPIC_LISTENER).",                                                    \
+    .type = TYPE_INT(1, INT_MAX),                                              \
+    .offset = offsetof(hc_subscription_t, topics),                             \
+  }
+
+/* Commands */
+
+static const command_parser_t command_subscription_create = {
+    .action = ACTION_CREATE,
+    .object_type = OBJECT_TYPE_SUBSCRIPTION,
+    .nparams = 1,
+    .parameters = {topics},
+};
+COMMAND_REGISTER(command_subscription_create);