feat: boostrap hicn 22.02

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

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

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

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

- VPP plugin has been updated to support VPP 22.02

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

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

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

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

1 files changed, 354 insertions, 141 deletions

diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/api.h b/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
index b5a968800..8a59cf4d8 100644
--- a/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -67,15 +67,24 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include <stddef.h>  // object_offset_t
 
 #include <hicn/util/ip_address.h>
-#include <hicn/ctrl/commands.h>
-#include "face.h"
+#include <hicn/face.h>
+#include <hicn/strategy.h>
+/*
+ * This has to be common between hicn-light and hicn-plugin. We now we keep the
+ * minimum of the two
+ */
+#define SYMBOLIC_NAME_LEN 16
 
 #define HICN_DEFAULT_PORT 9695
 
 #define HOTFIXMARGIN 0
 
+#define INVALID_FACE_ID ~0
+#define INVALID_NETDEVICE_ID ~0
+
 /**
  * \brief Defines the default size for the allocated data arrays holding the
  * results of API calls.
@@ -99,26 +108,70 @@
  * Message helper types and aliases
  ******************************************************************************/
 
-#define foreach_command \
-  _(UNDEFINED)          \
-  _(CREATE)             \
-  _(UPDATE)             \
-  _(DELETE)             \
-  _(LIST)               \
-  _(SET)                \
+/* Action */
+
+#define foreach_action \
+  _(UNDEFINED)         \
+  _(CREATE)            \
+  _(UPDATE)            \
+  _(DELETE)            \
+  _(LIST)              \
+  _(SET)               \
+  _(SERVE)             \
+  _(STORE)             \
+  _(CLEAR)             \
   _(N)
 
 typedef enum {
 #define _(x) ACTION_##x,
-  foreach_command
+  foreach_action
 #undef _
 } hc_action_t;
 
+extern const char *action_str[];
+
+#define action_str(x) action_str[x]
+
+hc_action_t action_from_str(const char *action_str);
+
+/* Object type */
+
+#define foreach_object \
+  _(UNDEFINED)         \
+  _(CONNECTION)        \
+  _(LISTENER)          \
+  _(ROUTE)             \
+  _(FACE)              \
+  _(STRATEGY)          \
+  _(PUNTING)           \
+  _(POLICY)            \
+  _(CACHE)             \
+  _(MAPME)             \
+  _(LOCAL_PREFIX)      \
+  _(PROBE)             \
+  _(SUBSCRIPTION)      \
+  _(N)
+
+typedef enum {
+#define _(x) OBJECT_##x,
+  foreach_object
+#undef _
+} hc_object_type_t;
+
+extern const char *object_str[];
+
+#define object_str(x) object_str[x]
+
+hc_object_type_t object_from_str(const char *object_str);
+
+#define IS_VALID_OBJECT_TYPE(x) IS_VALID_ENUM_TYPE(OBJECT, x)
+#define IS_VALID_ACTION(x) IS_VALID_ENUM_TYPE(ACTION, x)
+
 /**
  * \brief hICN control message header
  */
 typedef struct hc_msg_s hc_msg_t;
-
+typedef struct hc_result_s hc_result_t;
 /******************************************************************************
  * Control Data
  ******************************************************************************/
@@ -140,7 +193,8 @@ typedef struct hc_data_s {
   bool complete;
 
   /* Callbacks */
-  data_callback_t complete_cb;  // XXX int (*complete_cb)(struct hc_data_s * data);
+  data_callback_t
+      complete_cb;  // XXX int (*complete_cb)(struct hc_data_s * data);
   void *complete_cb_data;
   int ret;
 } hc_data_t;
@@ -149,7 +203,8 @@ typedef struct hc_data_s {
  * Create a structure holding the results of an hICN control request.
  * \result The newly create data structure.
  */
-hc_data_t *hc_data_create(size_t in_element_size, size_t out_element_size, data_callback_t complete_cb);
+hc_data_t *hc_data_create(size_t in_element_size, size_t out_element_size,
+                          data_callback_t complete_cb);
 
 /**
  * Free a structure holding the results of an hICN control request.
@@ -214,38 +269,49 @@ int hc_data_reset(hc_data_t *data);
  * \param [out] found - A pointer to the element, or NULL if not found.
  * \return Error code
  */
-#define GENERATE_FIND_HEADER(TYPE)                                          \
-int                                                                         \
-hc_ ## TYPE ## _find(hc_data_t * data, const hc_ ## TYPE ## _t * element,   \
-        hc_ ## TYPE ## _t **found)
-
-#define GENERATE_FIND(TYPE)                                                 \
-int                                                                         \
-hc_ ## TYPE ## _find(hc_data_t * data, const hc_ ## TYPE ## _t * element,   \
-        hc_ ## TYPE ## _t **found)                                          \
-{                                                                           \
-    foreach_type(hc_ ## TYPE ## _t, x, data) {                              \
-        if (hc_ ## TYPE ## _cmp(x, element) == 0) {                         \
-            *found = x;                                                     \
-            return 0;                                                       \
-        }                                                                   \
-    };                                                                      \
-    *found = NULL; /* this is optional */                                   \
-    return 0;                                                               \
-}
+#define GENERATE_FIND_HEADER(TYPE)                                    \
+  int hc_##TYPE##_find(hc_data_t *data, const hc_##TYPE##_t *element, \
+                       hc_##TYPE##_t **found)
+
+#define GENERATE_FIND(TYPE)                                           \
+  int hc_##TYPE##_find(hc_data_t *data, const hc_##TYPE##_t *element, \
+                       hc_##TYPE##_t **found) {                       \
+    foreach_type(hc_##TYPE##_t, x, data) {                            \
+      if (hc_##TYPE##_cmp(x, element) == 0) {                         \
+        *found = x;                                                   \
+        return 0;                                                     \
+      }                                                               \
+    };                                                                \
+    *found = NULL; /* this is optional */                             \
+    return 0;                                                         \
+  }
 
 /******************************************************************************
  * Control socket
  ******************************************************************************/
 
-/* This should be at least equal to the maximum packet size */
-#define RECV_BUFLEN 8192
+/* With UDP, the buffer should be able to receieve a full packet, and thus MTU
+ * (max 9000) is sufficient. Messages will be received fully one by one.
+ * With TCP, the buffer should be at least able to receive a message header and
+ * the maximum size of a data element, so any reasonable size will be correct,
+ * it might just optimize performance. Messages might arrive in chunks that the
+ * library is able to parse.
+ */
+#define JUMBO_MTU 9000
+#define RECV_BUFLEN 65535
+
+#define foreach_forwarder_type \
+  _(UNDEFINED)                 \
+  _(HICNLIGHT)                 \
+  _(HICNLIGHT_NG)              \
+  _(VPP)                       \
+  _(N)
 
 typedef enum {
-  HICNLIGHT,
-  VPP,
-  UNDEFINED
-} forwarder_t;
+#define _(x) x,
+  foreach_forwarder_type
+#undef _
+} forwarder_type_t;
 
 /**
  * \brief Holds the state of an hICN control socket
@@ -257,22 +323,26 @@ typedef struct hc_sock_s hc_sock_t;
  * \param [in] url - The URL to connect to.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create_url(const char * url);
+hc_sock_t *hc_sock_create_url(const char *url);
 
 /**
  * \brief Create an hICN control socket using the provided forwarder.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create_forwarder(forwarder_t forwarder);
+hc_sock_t *hc_sock_create_forwarder(forwarder_type_t forwarder);
+
+/**
+ * \brief Create an hICN control socket using the provided forwarder and a URL.
+ * \return an hICN control socket
+ */
+hc_sock_t *hc_sock_create_forwarder_url(forwarder_type_t forwarder,
+                                        const char *url);
 
 /**
  * \brief Create an hICN control socket using the default connection type.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create(void);
+hc_sock_t *hc_sock_create(void);
 
 /**
  * \brief Frees an hICN control socket
@@ -324,7 +394,7 @@ int hc_sock_get_available(hc_sock_t *s, u8 **buffer, size_t *size);
  * \param [in] msglen - Length of the message to send
  * \return Error code
  */
-int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, int seq);
+int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, uint32_t seq);
 
 /**
  * \brief Helper for reading socket contents
@@ -356,6 +426,13 @@ int hc_sock_callback(hc_sock_t *s, hc_data_t **data);
  */
 int hc_sock_reset(hc_sock_t *s);
 
+void hc_sock_increment_woff(hc_sock_t *s, size_t bytes);
+
+int hc_sock_prepare_send(hc_sock_t *s, hc_result_t *result,
+                         data_callback_t complete_cb, void *complete_cb_data);
+
+int hc_sock_set_recv_timeout_ms(hc_sock_t *s, long timeout_ms);
+
 /******************************************************************************
  * Command-specific structures and functions
  ******************************************************************************/
@@ -420,50 +497,11 @@ int hc_sock_reset(hc_sock_t *s);
        VAR < (TYPE *)(data->buffer + data->size * data->out_element_size); \
        VAR++)
 
-/**
- * New type is defined to reconciliate different enum for add and list.
- * Also, values not implemented have been removed for clarity.
- */
-#define foreach_connection_type \
-  _(UNDEFINED)                  \
-  _(TCP)                        \
-  _(UDP)                        \
-  _(HICN)                       \
-  _(N)
-
-typedef enum {
-#define _(x) CONNECTION_TYPE_##x,
-  foreach_connection_type
-#undef _
-} hc_connection_type_t;
-
-#define MAXSZ_HC_CONNECTION_TYPE_ 9
-#define MAXSZ_HC_CONNECTION_TYPE MAXSZ_HC_CONNECTION_TYPE_ + NULLTERM + HOTFIXMARGIN
-
-extern const char *connection_type_str[];
-
-hc_connection_type_t connection_type_from_str(const char *str);
-
-/* Same order as connection_state_t in hicn/core/connectionState.h */
-#define foreach_connection_state \
-  _(UNDEFINED)                   \
-  _(DOWN)                        \
-  _(UP)                          \
-  _(N)
-
-typedef enum {
-#define _(x) HC_CONNECTION_STATE_##x,
-  foreach_connection_state
-#undef _
-} hc_connection_state_t;
-
-#define MAXSZ_HC_CONNECTION_STATE_ 9
-#define MAXSZ_HC_CONNECTION_STATE MAXSZ_HC_CONNECTION_STATE_ + NULLTERM
-
-extern const char *connection_state_str[];
-
 typedef int (*HC_PARSE)(const u8 *, u8 *);
 
+#define INPUT_ERROR -2
+#define UNSUPPORTED_CMD_ERROR -3
+
 /*----------------------------------------------------------------------------*
  * Listeners
  *----------------------------------------------------------------------------*/
@@ -473,27 +511,28 @@ typedef struct {
   char name[SYMBOLIC_NAME_LEN]; /* K.w */  // XXX clarify what used for
   char interface_name[INTERFACE_LEN];      /* Kr. */
   u32 id;
-  hc_connection_type_t type; /* .rw */
-  int family;                /* .rw */
-  ip_address_t local_addr;   /* .rw */
-  u16 local_port;            /* .rw */
+  face_type_t type;        /* .rw */
+  int family;              /* .rw */
+  ip_address_t local_addr; /* .rw */
+  u16 local_port;          /* .rw */
 } hc_listener_t;
 
 int hc_listener_create(hc_sock_t *s, hc_listener_t *listener);
 /* listener_found might eventually be allocated, and needs to be freed */
+hc_result_t *hc_listener_create_conf(hc_sock_t *s, hc_listener_t *listener);
 int hc_listener_get(hc_sock_t *s, hc_listener_t *listener,
                     hc_listener_t **listener_found);
 int hc_listener_delete(hc_sock_t *s, hc_listener_t *listener);
 int hc_listener_list(hc_sock_t *s, hc_data_t **pdata);
+hc_result_t *hc_listener_list_conf(hc_sock_t *s);
 
 int hc_listener_validate(const hc_listener_t *listener);
 int hc_listener_cmp(const hc_listener_t *l1, const hc_listener_t *l2);
-int hc_listener_parse(void *in, hc_listener_t *listener);
 
 #define foreach_listener(VAR, data) foreach_type(hc_listener_t, VAR, data)
 
 #define MAXSZ_HC_LISTENER_ \
-  INTERFACE_LEN + SPACE + MAXSZ_URL_ + SPACE + MAXSZ_HC_CONNECTION_TYPE_
+  INTERFACE_LEN + SPACE + MAXSZ_URL_ + SPACE + MAXSZ_FACE_TYPE_
 #define MAXSZ_HC_LISTENER MAXSZ_HC_LISTENER_ + NULLTERM
 
 GENERATE_FIND_HEADER(listener);
@@ -506,28 +545,30 @@ int hc_listener_snprintf(char *s, size_t size, hc_listener_t *listener);
 
 /*
  * NOTE :
- *  - interface_name is mainly used to derive listeners from connections, but is
- *  not itself used to create connections.
+ *  - interface_name is mainly used to derive listeners from connections,
+ * but is not itself used to create connections.
  */
 typedef struct {
   u32 id;                             /* Kr. */
   char name[SYMBOLIC_NAME_LEN];       /* K.w */
   char interface_name[INTERFACE_LEN]; /* Kr. */
-  hc_connection_type_t type;          /* .rw */
+  face_type_t type;                   /* .rw */
   int family;                         /* .rw */
   ip_address_t local_addr;            /* .rw */
   u16 local_port;                     /* .rw */
   ip_address_t remote_addr;           /* .rw */
   u16 remote_port;                    /* .rw */
-  hc_connection_state_t admin_state;  /* .rw */
+  face_state_t admin_state;           /* .rw */
 #ifdef WITH_POLICY
-    uint32_t priority;           /* .rw */
-    policy_tags_t tags;          /* .rw */
-#endif /* WITH_POLICY */
-    hc_connection_state_t state; /* .r. */
+  uint32_t priority;  /* .rw */
+  policy_tags_t tags; /* .rw */
+#endif                /* WITH_POLICY */
+  face_state_t state; /* .r. */
 } hc_connection_t;
 
 int hc_connection_create(hc_sock_t *s, hc_connection_t *connection);
+hc_result_t *hc_connection_create_conf(hc_sock_t *s,
+                                       hc_connection_t *connection);
 /* connection_found will be allocated, and must be freed */
 int hc_connection_get(hc_sock_t *s, hc_connection_t *connection,
                       hc_connection_t **connection_found);
@@ -536,6 +577,8 @@ int hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
 int hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current,
                          hc_connection_t *connection_updated);
 int hc_connection_delete(hc_sock_t *s, hc_connection_t *connection);
+hc_result_t *hc_connection_delete_conf(hc_sock_t *s,
+                                       hc_connection_t *connection);
 /*
 int hc_connection_remove_by_id(hc_sock_t * s, char * name);
 int hc_connection_remove_by_name(hc_sock_t * s, char * name);
@@ -544,19 +587,21 @@ int hc_connection_list(hc_sock_t *s, hc_data_t **pdata);
 
 int hc_connection_validate(const hc_connection_t *connection);
 int hc_connection_cmp(const hc_connection_t *c1, const hc_connection_t *c2);
-int hc_connection_parse(void *in, hc_connection_t *connection);
 
-int hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+int hc_connection_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                                  face_state_t state);
 #ifdef WITH_POLICY
-int hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-int hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
+int hc_connection_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                               uint32_t priority);
+int hc_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                           policy_tags_t tags);
 #endif /* WITH_POLICY */
 
 #define foreach_connection(VAR, data) foreach_type(hc_connection_t, VAR, data)
 
-#define MAXSZ_HC_CONNECTION_                                            \
-  MAXSZ_HC_CONNECTION_STATE_ + INTERFACE_LEN + SPACE + 2 * MAXSZ_URL_ + \
-      MAXSZ_HC_CONNECTION_TYPE_ + SPACES(3)
+#define MAXSZ_HC_CONNECTION_                                   \
+  MAXSZ_FACE_STATE_ + INTERFACE_LEN + SPACE + 2 * MAXSZ_URL_ + \
+      MAXSZ_FACE_TYPE_ + SPACES(3)
 #define MAXSZ_HC_CONNECTION MAXSZ_HC_CONNECTION_ + NULLTERM
 
 GENERATE_FIND_HEADER(connection);
@@ -591,14 +636,17 @@ typedef struct {
  */
 int hc_face_create(hc_sock_t *s, hc_face_t *face);
 int hc_face_get(hc_sock_t *s, hc_face_t *face, hc_face_t **face_found);
-int hc_face_delete(hc_sock_t *s, hc_face_t *face);
+int hc_face_delete(hc_sock_t *s, hc_face_t *face, uint8_t delete_listener);
 int hc_face_list(hc_sock_t *s, hc_data_t **pdata);
 int hc_face_list_async(hc_sock_t *s);  //, hc_data_t ** pdata);
 
-int hc_face_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+int hc_face_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                            face_state_t state);
 #ifdef WITH_POLICY
-int hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-int hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
+int hc_face_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                         uint32_t priority);
+int hc_face_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                     policy_tags_t tags);
 #endif /* WITH_POLICY */
 
 #define foreach_face(VAR, data) foreach_type(hc_face_t, VAR, data)
@@ -609,7 +657,8 @@ int hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t
 #define MAXSZ_FACE_NAME_ SYMBOLIC_NAME_LEN
 #define MAXSZ_FACE_NAME MAXSZ_FACE_NAME_ + NULLTERM
 
-#define MAXSZ_HC_FACE_ MAXSZ_FACE_ID_ + MAXSZ_FACE_NAME_ + MAXSZ_FACE_ + 5 + HOTFIXMARGIN
+#define MAXSZ_HC_FACE_ \
+  MAXSZ_FACE_ID_ + MAXSZ_FACE_NAME_ + MAXSZ_FACE_ + 5 + HOTFIXMARGIN
 #define MAXSZ_HC_FACE MAXSZ_HC_FACE_ + NULLTERM
 
 int hc_face_snprintf(char *s, size_t size, hc_face_t *face);
@@ -619,20 +668,20 @@ int hc_face_snprintf(char *s, size_t size, hc_face_t *face);
  *----------------------------------------------------------------------------*/
 
 typedef struct {
-  face_id_t face_id;               /* Kr. */
-  int family;               /* Krw */
-  ip_address_t remote_addr; /* krw */
-  u8 len;                   /* krw */
-  u16 cost;                 /* .rw */
-  hc_face_t face;
+  face_id_t face_id;            /* Kr.  use when name == NULL */
+  char name[SYMBOLIC_NAME_LEN]; /* Kr.  use by default vs face_id */
+  int family;                   /* Krw */
+  ip_address_t remote_addr;     /* krw */
+  u8 len;                       /* krw */
+  u16 cost;                     /* .rw */
+  hc_face_t face;               /* TODO remove, used by hicn_plugin_api */
 } hc_route_t;
 
-int hc_route_parse(void *in, hc_route_t *route);
-
-int hc_route_create(hc_sock_t * s, hc_route_t * route);
-int hc_route_delete(hc_sock_t * s, hc_route_t * route);
-int hc_route_list(hc_sock_t * s, hc_data_t ** pdata);
-int hc_route_list_async(hc_sock_t * s);
+int hc_route_create(hc_sock_t *s, hc_route_t *route);
+hc_result_t *hc_route_create_conf(hc_sock_t *s, hc_route_t *route);
+int hc_route_delete(hc_sock_t *s, hc_route_t *route);
+int hc_route_list(hc_sock_t *s, hc_data_t **pdata);
+int hc_route_list_async(hc_sock_t *s);
 
 #define foreach_route(VAR, data) foreach_type(hc_route_t, VAR, data)
 
@@ -646,6 +695,7 @@ int hc_route_list_async(hc_sock_t * s);
 #define MAXSZ_HC_ROUTE MAXSZ_HC_ROUTE_ + NULLTERM
 
 int hc_route_snprintf(char *s, size_t size, hc_route_t *route);
+int hc_route_validate(const hc_route_t *route);
 
 /*----------------------------------------------------------------------------*
  * Punting
@@ -653,9 +703,9 @@ int hc_route_snprintf(char *s, size_t size, hc_route_t *route);
 
 typedef struct {
   face_id_t face_id; /* Kr. */  // XXX listener id, could be NULL for all ?
-  int family;            /* Krw */
-  ip_address_t prefix;   /* krw */
-  u8 prefix_len;         /* krw */
+  int family;                   /* Krw */
+  ip_address_t prefix;          /* krw */
+  u8 prefix_len;                /* krw */
 } hc_punting_t;
 
 int hc_punting_create(hc_sock_t *s, hc_punting_t *punting);
@@ -666,7 +716,6 @@ int hc_punting_list(hc_sock_t *s, hc_data_t **pdata);
 
 int hc_punting_validate(const hc_punting_t *punting);
 int hc_punting_cmp(const hc_punting_t *c1, const hc_punting_t *c2);
-int hc_punting_parse(void *in, hc_punting_t *punting);
 
 #define foreach_punting(VAR, data) foreach_type(hc_punting_t, VAR, data)
 
@@ -681,8 +730,23 @@ int hc_punting_snprintf(char *s, size_t size, hc_punting_t *punting);
  * Cache
  *----------------------------------------------------------------------------*/
 
-int hc_cache_set_store(hc_sock_t *s, int enabled);
-int hc_cache_set_serve(hc_sock_t *s, int enabled);
+typedef struct {
+  uint8_t serve;  // 1 = on, 0 = off
+  uint8_t store;  // 1 = on, 0 = off
+} hc_cache_t;
+
+typedef struct {
+  bool store;
+  bool serve;
+  size_t cs_size;
+  size_t num_stale_entries;
+} hc_cache_info_t;
+
+int hc_cache_set_store(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_set_serve(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_clear(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_list(hc_sock_t *s, hc_data_t **pdata);
+int hc_cache_snprintf(char *s, size_t size, const hc_cache_info_t *cache_info);
 
 /*----------------------------------------------------------------------------*
  * Strategy
@@ -691,7 +755,13 @@ int hc_cache_set_serve(hc_sock_t *s, int enabled);
 #define MAXSZ_STRATEGY_NAME 255
 
 typedef struct {
+  // The name is not set by the controller
+  // but populated by the daemon
   char name[MAXSZ_STRATEGY_NAME];
+  strategy_type_t type;
+  ip_address_t address, local_address;
+  int family, local_family;
+  u8 len, local_len;
 } hc_strategy_t;
 
 int hc_strategy_list(hc_sock_t *s, hc_data_t **data);
@@ -704,8 +774,11 @@ int hc_strategy_list(hc_sock_t *s, hc_data_t **data);
 int hc_strategy_snprintf(char *s, size_t size, hc_strategy_t *strategy);
 
 // per prefix
-int hc_strategy_set(hc_sock_t *s /* XXX */);
-
+int hc_strategy_set(hc_sock_t *s, hc_strategy_t *strategy);
+hc_result_t *hc_strategy_set_conf(hc_sock_t *s, hc_strategy_t *strategy);
+int hc_strategy_add_local_prefix(hc_sock_t *s, hc_strategy_t *strategy);
+hc_result_t *hc_strategy_add_local_prefix_conf(hc_sock_t *s,
+                                               hc_strategy_t *strategy);
 /*----------------------------------------------------------------------------*
  * WLDR
  *----------------------------------------------------------------------------*/
@@ -717,10 +790,45 @@ int hc_wldr_set(hc_sock_t *s /* XXX */);
  * MAP-Me
  *----------------------------------------------------------------------------*/
 
-int hc_mapme_set(hc_sock_t *s, int enabled);
-int hc_mapme_set_discovery(hc_sock_t *s, int enabled);
-int hc_mapme_set_timescale(hc_sock_t *s, double timescale);
-int hc_mapme_set_retx(hc_sock_t *s, double timescale);
+typedef enum {
+  MAPME_TARGET_ENABLE,
+  MAPME_TARGET_DISCOVERY,
+  MAPME_TARGET_TIMESCALE,
+  MAPME_TARGET_RETX,
+} mapme_target_t;
+
+static inline mapme_target_t mapme_target_from_str(char *mapme_target_str) {
+  if (strcasecmp(mapme_target_str, "enable") == 0)
+    return MAPME_TARGET_ENABLE;
+  else if (strcasecmp(mapme_target_str, "discovery") == 0)
+    return MAPME_TARGET_DISCOVERY;
+  else if (strcasecmp(mapme_target_str, "timescale") == 0)
+    return MAPME_TARGET_TIMESCALE;
+  else
+    return MAPME_TARGET_RETX;
+}
+
+#define MAX_MAPME_ARG_LEN 30
+
+typedef struct {
+  mapme_target_t target;
+  // Command argument stored as a string
+  // before being parsed into 'enabled' or 'timescale'
+  char unparsed_arg[MAX_MAPME_ARG_LEN];
+
+  uint8_t enabled;     // 1 = on, 0 = off
+  uint32_t timescale;  // Milliseconds
+
+  ip_address_t address;
+  int family;
+  u8 len;
+} hc_mapme_t;
+
+int hc_mapme_set(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_discovery(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_timescale(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_retx(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_send_update(hc_sock_t *s, hc_mapme_t *mapme);
 
 /*----------------------------------------------------------------------------*
  * Policies
@@ -732,11 +840,9 @@ typedef struct {
   int family;               /* Krw */
   ip_address_t remote_addr; /* krw */
   u8 len;                   /* krw */
-  hicn_policy_t policy;          /* .rw */
+  hicn_policy_t policy;     /* .rw */
 } hc_policy_t;
 
-int hc_policy_parse(void *in, hc_policy_t *policy);
-
 int hc_policy_create(hc_sock_t *s, hc_policy_t *policy);
 int hc_policy_delete(hc_sock_t *s, hc_policy_t *policy);
 int hc_policy_list(hc_sock_t *s, hc_data_t **pdata);
@@ -748,7 +854,114 @@ int hc_policy_list(hc_sock_t *s, hc_data_t **pdata);
 #define MAXSZ_HC_POLICY MAXSZ_HC_POLICY_ + NULLTERM
 
 int hc_policy_snprintf(char *s, size_t size, hc_policy_t *policy);
+int hc_policy_validate(const hc_policy_t *policy);
 
 #endif /* WITH_POLICY */
 
+/*----------------------------------------------------------------------------*
+ * Subscription
+ *----------------------------------------------------------------------------*/
+// Topics
+
+#undef PUNTING  // TODO(eloparco): Undefined to avoid collisions
+                // Fix the collision
+
+// Used only to create 'hc_topic_t'
+typedef struct {
+#define _(x) char x;
+  foreach_object
+#undef _
+} object_offset_t;
+
+// Flags for topic subscriptions
+typedef enum {
+#define _(x) TOPIC_##x = (1 << offsetof(object_offset_t, x)),
+  foreach_object
+#undef _
+} hc_topic_t;
+
+static inline hc_object_type_t object_from_topic(hc_topic_t topic) {
+#define _(x) \
+  if (topic == TOPIC_##x) return OBJECT_##x;
+  foreach_object
+#undef _
+      return OBJECT_UNDEFINED;
+}
+
+#define NUM_TOPICS OBJECT_N  // Because a topic is created for each object
+#define ALL_TOPICS ~0
+
+// Subscriptions
+typedef uint32_t hc_topics_t;
+typedef struct {
+  hc_topics_t topics;
+} hc_subscription_t;
+
+int hc_subscription_create(hc_sock_t *s, hc_subscription_t *subscription);
+int hc_subscription_delete(hc_sock_t *s, hc_subscription_t *subscription);
+hc_result_t *hc_subscription_create_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription);
+hc_result_t *hc_subscription_delete_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription);
+
+/*----------------------------------------------------------------------------*
+ * Events
+ *----------------------------------------------------------------------------*/
+#define foreach_event_type \
+  _(UNDEFINED)             \
+  _(INTERFACE_UPDATE)      \
+  _(N)
+typedef enum {
+#define _(x) EVENT_##x,
+  foreach_event_type
+#undef _
+} event_type_t;
+
+extern const char *event_str[];
+#define event_str(x) event_str[x]
+
+typedef enum {
+  FLAG_INTERFACE_TYPE_WIRED = 0x1,
+  FLAG_INTERFACE_TYPE_WIFI = 0x2,
+  FLAG_INTERFACE_TYPE_CELLULAR = 0x4,
+} flag_interface_type_t;
+
+typedef struct {
+  flag_interface_type_t interface_type;
+} hc_event_interface_update_t;
+
+/* Result */
+
+hc_msg_t *hc_result_get_msg(hc_sock_t *s, hc_result_t *result);
+int hc_result_get_cmd_id(hc_sock_t *s, hc_result_t *result);
+bool hc_result_get_success(hc_sock_t *s, hc_result_t *result);
+void hc_result_free(hc_result_t *result);
+
+/* Object */
+
+typedef struct {
+  hc_object_type_t type;
+  union {
+    hc_connection_t connection;
+    hc_listener_t listener;
+    hc_route_t route;
+    hc_face_t face;
+    // hc_data_t *data;
+    hc_punting_t punting;
+    hc_strategy_t strategy;
+#ifdef WITH_POLICY
+    hc_policy_t policy;
+#endif /* WITH_POLICY */
+    hc_subscription_t subscription;
+    hc_cache_t cache;
+    hc_mapme_t mapme;
+    uint8_t as_uint8;
+  };
+} hc_object_t;
+
+typedef struct {
+  hc_action_t action;
+  hc_object_t object;
+} hc_command_t;
+
 #endif /* HICNTRL_API */