[HICN-713] Transport Library Major Refactoring 2

Co-authored-by: Luca Muscariello <muscariello@ieee.org>
Co-authored-by: Michele Papalini <micpapal@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Giulio Grassi <gigrassi@cisco.com>
Signed-off-by: Mauro Sardara <msardara@cisco.com>
Change-Id: I5b2c667bad66feb45abdb5effe22ed0f6c85d1c2

1 files changed, 2278 insertions, 0 deletions

diff --git a/ctrl/libhicnctrl/src/modules/hicn_light_api.c b/ctrl/libhicnctrl/src/modules/hicn_light_api.c
new file mode 100644
index 000000000..d1a055777
--- /dev/null
+++ b/ctrl/libhicnctrl/src/modules/hicn_light_api.c
@@ -0,0 +1,2278 @@
+/*
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file api.c
+ * \brief Implementation of hICN control library API
+ */
+
+#include "api_private.h"
+
+#include <assert.h> // assert
+#include <stdbool.h>
+#include <stdio.h> // snprintf
+#include <string.h> // memmove, strcasecmp
+#include <sys/socket.h> // socket
+#include <unistd.h> // close, fcntl
+#include <fcntl.h> // fcntl
+#include <sys/types.h> // getpid
+#include <unistd.h>    // getpid
+#ifdef __linux__
+#include <sys/syscall.h>
+#define gettid() syscall(SYS_gettid)
+#endif /* __linux__ */
+#include <strings.h>
+
+#define PORT 9695
+
+#define BOOLSTR(x) ((x) ? "true" : "false")
+
+/*
+ * Internal state associated to a pending request
+ */
+typedef struct {
+    int seq;
+    hc_data_t * data;
+    /* Information used to process results */
+    int size_in;
+    int (*parse)(const u8 * src, u8 * dst);
+} hc_sock_request_t;
+
+/**
+ * Messages to the forwarder might be multiplexed thanks to the seqNum fields in
+ * the header_control_message structure. The forwarder simply answers back the
+ * original sequence number. We maintain a map of such sequence number to
+ * outgoing queries so that replied can be demultiplexed and treated
+ * appropriately.
+ */
+TYPEDEF_MAP_H(hc_sock_map, int, hc_sock_request_t *);
+TYPEDEF_MAP(hc_sock_map, int, hc_sock_request_t *, int_cmp, int_snprintf, generic_snprintf);
+
+struct hc_sock_light_s {
+    /* This must be the first element of the struct */
+    hc_sock_t vft;
+
+    char * url;
+    int fd;
+
+    /* Partial receive buffer */
+    u8 buf[RECV_BUFLEN];
+    size_t roff; /**< Read offset */
+    size_t woff; /**< Write offset */
+
+    /*
+     * Because received messages are potentially unbounded in size, we might not
+     * guarantee that we can store a full packet before processing it. We must
+     * implement a very simple state machine remembering the current parsing
+     * status in order to partially process the packet.
+     */
+    size_t remaining;
+    u32 send_id;
+
+    /* Next sequence number to be used for requests */
+    int seq;
+
+    /* Request being parsed (NULL if none) */
+    hc_sock_request_t * cur_request;
+
+    bool async;
+    hc_sock_map_t * map;
+};
+
+typedef struct hc_sock_light_s hc_sock_light_t;
+
+#define TO_HC_SOCK_LIGHT(s) (hc_sock_light_t*)(s)
+
+hc_sock_request_t *
+hc_sock_request_create(int seq, hc_data_t * data, HC_PARSE parse)
+{
+    assert(data);
+
+    hc_sock_request_t * request = malloc(sizeof(hc_sock_request_t));
+    if (!request)
+        return NULL;
+    request->seq = seq;
+    request->data = data;
+    request->parse = parse;
+    return request;
+}
+
+void
+hc_sock_light_request_free(hc_sock_request_t * request)
+{
+    free(request);
+}
+
+/*
+ * list was working with all seq set to 0, but it seems hicnLightControl uses
+ * 1, and replies with the same seqno
+ */
+#define HICN_CTRL_SEND_SEQ_INIT 1
+#define HICN_CTRL_RECV_SEQ_INIT 1
+
+#define MAX(x, y) ((x > y) ? x : y)
+
+/**
+ * In practise, we want to preserve enough room to store a full packet of
+ * average expected size (say a header + N payload elements).
+ */
+#define AVG_ELEMENTS (1 << DEFAULT_SIZE_LOG)
+#define AVG_BUFLEN (sizeof(hc_msg_header_t) + AVG_ELEMENTS * sizeof(hc_msg_payload_t))
+
+/*
+ * We should at least have buffer space allowing to store one processable unit
+ * of data, either the header of the maximum possible payload
+ */
+#define MIN_BUFLEN MAX(sizeof(hc_msg_header_t), sizeof(hc_msg_payload_t))
+
+static const struct in6_addr loopback_addr = IN6ADDR_LOOPBACK_INIT;
+
+/******************************************************************************
+ * Message helper types and aliases
+ ******************************************************************************/
+
+#define foreach_hc_command      \
+    _(add_connection)           \
+    _(remove_connection)        \
+    _(list_connections)         \
+    _(add_listener)             \
+    _(remove_listener)          \
+    _(list_listeners)           \
+    _(add_route)                \
+    _(remove_route)             \
+    _(list_routes)              \
+    _(cache_store)              \
+    _(cache_serve)              \
+    /*_(cache_clear) */         \
+    _(set_strategy)             \
+    _(set_wldr)                 \
+    _(add_punting)              \
+    _(mapme_activator)          \
+    _(mapme_timing)
+
+typedef header_control_message hc_msg_header_t;
+
+typedef union {
+#define _(x) x ## _command x;
+        foreach_hc_command
+#undef _
+} hc_msg_payload_t;
+
+
+typedef struct hc_msg_s {
+    hc_msg_header_t hdr;
+    hc_msg_payload_t payload;
+} hc_msg_t;
+
+/******************************************************************************
+ * Control socket
+ ******************************************************************************/
+
+/**
+ * \brief Parse a connection URL into a sockaddr
+ * \param [in] url - URL
+ * \param [out] sa - Resulting struct sockaddr, expected zero'ed.
+ * \return 0 if parsing succeeded, a negative error value otherwise.
+ */
+static int
+_hc_sock_light_parse_url(const char * url, struct sockaddr * sa)
+{
+    /* FIXME URL parsing is currently not implemented */
+    assert(!url);
+
+#ifdef __linux__
+    srand(time(NULL) ^ getpid() ^ gettid());
+#else
+    srand((unsigned int )(time(NULL) ^ getpid()));
+#endif /* __linux__ */
+
+    /*
+     * A temporary solution is to inspect the sa_family fields of the passed in
+     * sockaddr, which defaults to AF_UNSPEC (0) and thus creates an IPv4/TCP
+     * connection to localhost.
+     */
+    switch (sa->sa_family) {
+        case AF_UNSPEC:
+        case AF_INET:
+        {
+            struct sockaddr_in * sai = (struct sockaddr_in *)sa;
+            sai->sin_family = AF_INET;
+            sai->sin_port = htons(PORT);
+            sai->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+            break;
+        }
+        case AF_INET6:
+        {
+            struct sockaddr_in6 * sai6 = (struct sockaddr_in6 *)sa;
+            sai6->sin6_family = AF_INET6;
+            sai6->sin6_port = htons(PORT);
+            sai6->sin6_addr = loopback_addr;
+            break;
+        }
+        default:
+             return -1;
+    }
+
+     return 0;
+}
+
+static int
+_hc_sock_light_reset(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    s->roff = s->woff = 0;
+    s->remaining = 0;
+    return 0;
+}
+
+void
+_hc_sock_light_free(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    hc_sock_request_t ** request_array = NULL;
+    int n = hc_sock_map_get_value_array(s->map, &request_array);
+    if (n < 0) {
+       ERROR("Could not retrieve pending request array for freeing up resources");
+    } else {
+        for (unsigned i = 0; i < n; i++) {
+            hc_sock_request_t * request = request_array[i];
+            if (hc_sock_map_remove(s->map, request->seq, NULL) < 0)
+                ERROR("[hc_sock_light_process] Error removing request from map");
+            hc_sock_light_request_free(request);
+        }
+        free(request_array);
+    }
+
+    hc_sock_map_free(s->map);
+    if (s->url)
+        free(s->url);
+    close(s->fd);
+    free(s);
+}
+
+static int
+_hc_sock_light_get_next_seq(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    return s->seq++;
+}
+
+static int
+_hc_sock_light_set_nonblocking(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    return (fcntl(s->fd, F_SETFL, fcntl(s->fd, F_GETFL) | O_NONBLOCK) < 0);
+}
+
+static int
+_hc_sock_light_get_fd(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    return s->fd;
+}
+
+static int
+_hc_sock_light_connect(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    struct sockaddr_storage ss;
+    memset(&ss, 0, sizeof(struct sockaddr_storage));
+
+    if (_hc_sock_light_parse_url(s->url, (struct sockaddr *)&ss) < 0)
+        goto ERR_PARSE;
+
+    size_t size = ss.ss_family == AF_INET
+        ? sizeof(struct sockaddr_in)
+        : sizeof(struct sockaddr_in6);
+    if (connect(s->fd, (struct sockaddr *)&ss, (socklen_t)size) < 0) //sizeof(struct sockaddr)) < 0)
+        goto ERR_CONNECT;
+
+     return 0;
+
+ERR_CONNECT:
+ERR_PARSE:
+     return -1;
+}
+
+static int
+_hc_sock_light_send(hc_sock_t * socket, hc_msg_t * msg, size_t msglen, int seq)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    int rc;
+    msg->hdr.seqNum = seq;
+    rc = (int)send(s->fd, msg, msglen, 0);
+    if (rc < 0) {
+        perror("hc_sock_light_send");
+        return -1;
+    }
+    return 0;
+}
+
+static int
+_hc_sock_light_get_available(hc_sock_t * socket, u8 ** buffer, size_t * size)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    *buffer = s->buf + s->woff;
+    *size = RECV_BUFLEN - s->woff;
+
+     return 0;
+}
+
+static int
+_hc_sock_light_recv(hc_sock_t * socket)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    int rc;
+
+    /*
+     * This condition should be ensured to guarantee correct processing of
+     * messages
+     */
+    assert(RECV_BUFLEN - s->woff > MIN_BUFLEN);
+
+    rc = (int)recv(s->fd, s->buf + s->woff, RECV_BUFLEN - s->woff, 0);
+    if (rc == 0) {
+        /* Connection has been closed */
+         return 0;
+    }
+    if (rc < 0) {
+        /*
+         * Let's not return 0 which currently means the socket has been closed
+         */
+        if (errno == EWOULDBLOCK)
+            return -1;
+        perror("hc_sock_light_recv");
+        return -1;
+    }
+    s->woff += rc;
+    return rc;
+}
+
+/*
+ * Returns -99 in case of internal error, -1 in case of API command failure
+ */
+static int
+_hc_sock_light_process(hc_sock_t * socket, hc_data_t ** data)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    int err = 0;
+
+    /* We must have received at least one byte */
+    size_t available = s->woff - s->roff;
+
+    while(available > 0) {
+
+        if (!s->cur_request) { // No message being parsed, alternatively (remaining == 0)
+            hc_msg_t * msg = (hc_msg_t*)(s->buf + s->roff);
+
+            /* We expect a message header */
+            if (available < sizeof(hc_msg_header_t)) {
+                break;
+            }
+
+            hc_sock_request_t * request = NULL;
+            if (hc_sock_map_get(s->map, msg->hdr.seqNum, &request) < 0) {
+                ERROR("[hc_sock_light_process] Error searching for matching request");
+                return -99;
+            }
+            if (!request) {
+                ERROR("[hc_sock_light_process] No request matching received sequence number");
+                return -99;
+            }
+
+            s->remaining = msg->hdr.length;
+            switch(msg->hdr.messageType) {
+                case ACK_LIGHT:
+                    assert(s->remaining == 1);
+                    assert(!data);
+                    s->cur_request = request;
+                    break;
+                case NACK_LIGHT:
+                    assert(s->remaining == 1);
+                    assert(!data);
+                    hc_data_set_error(request->data);
+                    s->cur_request = request;
+                    err = -1;
+                    break;
+                case RESPONSE_LIGHT:
+                    assert(data);
+                    if (s->remaining == 0) {
+                        hc_data_set_complete(request->data);
+                        *data = request->data;
+                        if (hc_sock_map_remove(s->map, request->seq, NULL) < 0)
+                            ERROR("[hc_sock_light_process] Error removing request from map");
+                        hc_sock_light_request_free(request);
+                    } else {
+                        /* We only remember it if there is still data to parse */
+                        s->cur_request = request;
+                    }
+                    break;
+                default:
+                    ERROR("[hc_sock_light_process] Invalid response received");
+                    return -99;
+            }
+
+            available -= sizeof(hc_msg_header_t);
+            s->roff += sizeof(hc_msg_header_t);
+        } else {
+            /* We expect the complete payload, or at least a chunk of it */
+            size_t num_chunks = available / s->cur_request->data->in_element_size;
+            if (num_chunks == 0)
+                break;
+            if (num_chunks > s->remaining)
+                num_chunks = s->remaining;
+
+            if (!s->cur_request->parse) {
+                /* If we don't need to parse results, then we can directly push
+                 * all of them into the result data structure */
+                hc_data_push_many(s->cur_request->data, s->buf + s->roff, num_chunks);
+            } else {
+                int rc;
+                rc = hc_data_ensure_available(s->cur_request->data, num_chunks);
+                if (rc < 0) {
+                    ERROR("[hc_sock_light_process] Error in hc_data_ensure_available");
+                    return -99;
+                }
+                for (int i = 0; i < num_chunks; i++) {
+                    u8 * dst = hc_data_get_next(s->cur_request->data);
+                    if (!dst) {
+                        ERROR("[hc_sock_light_process] Error in hc_data_get_next");
+                        return -99;
+                    }
+
+                    rc = s->cur_request->parse(s->buf + s->roff + i * s->cur_request->data->in_element_size, dst);
+                    if (rc < 0) {
+                        ERROR("[hc_sock_light_process] Error in parse");
+                        err = -99; /* FIXME we let the loop complete (?) */
+                    }
+                    s->cur_request->data->size++;
+                }
+            }
+
+            s->remaining -= num_chunks;
+            available -= num_chunks * s->cur_request->data->in_element_size;
+            s->roff += num_chunks * s->cur_request->data->in_element_size;
+            if (s->remaining == 0) {
+                if (hc_sock_map_remove(s->map, s->cur_request->seq, NULL) < 0) {
+                    ERROR("[hc_sock_light_process] Error removing request from map");
+                    return -99;
+                }
+                hc_data_set_complete(s->cur_request->data);
+                if (data)
+                    *data = s->cur_request->data;
+                hc_sock_light_request_free(s->cur_request);
+                s->cur_request = NULL;
+            }
+
+        }
+    }
+
+    /* Make sure there is enough remaining space in the buffer */
+    if (RECV_BUFLEN - s->woff < AVG_BUFLEN) {
+        /*
+         * There should be no overlap provided a sufficiently large BUFLEN, but
+         * who knows.
+         */
+        memmove(s->buf, s->buf + s->roff, s->woff - s->roff);
+        s->woff -= s->roff;
+        s->roff = 0;
+    }
+
+    return err;
+}
+
+static int
+_hc_sock_light_callback(hc_sock_t * socket, hc_data_t ** pdata)
+{
+    hc_data_t * data;
+
+    for (;;) {
+        int n = _hc_sock_light_recv(socket);
+        if (n == 0)
+            goto ERR_EOF;
+        if (n < 0) {
+            switch(errno) {
+                case ECONNRESET:
+                case ENODEV:
+                    /* Forwarder restarted */
+                    WARN("Forwarder likely restarted: not (yet) implemented");
+                    goto ERR;
+                case EWOULDBLOCK:
+                    //DEBUG("Would block... stop reading from socket");
+                    goto END;
+                default:
+                    perror("hc_sock_light_recv");
+                    goto ERR;
+            }
+        }
+        if (_hc_sock_light_process(socket, &data) < 0) {
+            goto ERR;
+        }
+    }
+END:
+    if (pdata)
+        *pdata = data;
+    else
+        hc_data_free(data);
+    return 0;
+
+ERR:
+    hc_data_free(data);
+ERR_EOF:
+    return -1;
+}
+
+/******************************************************************************
+ * Command-specific structures and functions
+ ******************************************************************************/
+
+typedef int (*HC_PARSE)(const u8 *, u8 *);
+
+typedef struct {
+    hc_action_t cmd;
+    command_id cmd_id;
+    size_t size_in;
+    size_t size_out;
+    HC_PARSE parse;
+} hc_command_params_t;
+
+static int
+_hc_execute_command(hc_sock_t * socket, hc_msg_t * msg, size_t msg_len,
+        hc_command_params_t * params, hc_data_t ** pdata, bool async)
+{
+    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+    int ret;
+    if (async)
+        assert(!pdata);
+
+    /* Sanity check */
+    switch(params->cmd) {
+        case ACTION_CREATE:
+            assert(params->size_in != 0); /* payload repeated */
+            assert(params->size_out == 0);
+            assert(params->parse == NULL);
+            break;
+        case ACTION_DELETE:
+            assert(params->size_in != 0); /* payload repeated */
+            assert(params->size_out == 0);
+            assert(params->parse == NULL);
+            break;
+        case ACTION_LIST:
+            assert(params->size_in != 0);
+            assert(params->size_out != 0);
+            assert(params->parse != NULL);
+            break;
+        case ACTION_SET:
+            assert(params->size_in != 0);
+            assert(params->size_out == 0);
+            assert(params->parse == NULL);
+            break;
+        default:
+             return -1;
+    }
+
+    //hc_sock_light_reset(s);
+
+    /* XXX data will at least store the result (complete) */
+    hc_data_t * data = hc_data_create(params->size_in, params->size_out, NULL);
+    if (!data) {
+        ERROR("[_hc_execute_command] Could not create data storage");
+        goto ERR_DATA;
+    }
+
+    int seq = _hc_sock_light_get_next_seq(socket);
+
+    /* Create state used to process the request */
+    hc_sock_request_t * request = NULL;
+    request = hc_sock_request_create(seq, data, params->parse);
+    if (!request) {
+        ERROR("[_hc_execute_command] Could not create request state");
+        goto ERR_REQUEST;
+    }
+
+    /* Add state to map */
+    if (hc_sock_map_add(s->map, seq, request) < 0) {
+        ERROR("[_hc_execute_command] Error adding request state to map");
+        goto ERR_MAP;
+    }
+
+    if (_hc_sock_light_send(socket, msg, msg_len, seq) < 0) {
+        ERROR("[_hc_execute_command] Error sending message");
+        goto ERR_PROCESS;
+    }
+
+    if (async)
+        return 0;
+
+    while(!data->complete) {
+        /*
+         * As the socket is non blocking it might happen that we need to read
+         * several times before success... shall we alternate between blocking
+         * and non-blocking mode ?
+         */
+        int n = _hc_sock_light_recv(socket);
+        if (n == 0)
+            goto ERR_EOF;
+        if (n < 0)
+            continue; //break;
+        int rc = _hc_sock_light_process(socket, pdata);
+        switch(rc) {
+            case 0:
+                break;
+            case -1:
+                ret = rc;
+                break;
+            case -99:
+                ERROR("[_hc_execute_command] Error processing socket results");
+                goto ERR;
+                break;
+            default:
+                ERROR("[_hc_execute_command] Unexpected return value");
+                goto ERR;
+        }
+    }
+
+ERR_EOF:
+    ret = data->ret;
+    if (!data->complete)
+        return -1;
+    if (!pdata)
+        hc_data_free(data);
+
+    return ret;
+
+ERR_PROCESS:
+ERR_MAP:
+    hc_sock_light_request_free(request);
+ERR:
+ERR_REQUEST:
+    hc_data_free(data);
+ERR_DATA:
+     return -99;
+}
+
+/*----------------------------------------------------------------------------*
+ * Listeners
+ *----------------------------------------------------------------------------*/
+
+/* LISTENER CREATE */
+
+static int
+_hc_listener_create_internal(hc_sock_t * socket, hc_listener_t * listener, bool async)
+{
+    char listener_s[MAXSZ_HC_LISTENER];
+    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+    if (rc >= MAXSZ_HC_LISTENER)
+        WARN("[_hc_listener_create] Unexpected truncation of listener string");
+    DEBUG("[_hc_listener_create] listener=%s async=%s", listener_s,
+            BOOLSTR(async));
+
+    if (!IS_VALID_FAMILY(listener->family))
+         return -1;
+
+    if (!IS_VALID_CONNECTION_TYPE(listener->type))
+         return -1;
+
+    struct {
+        header_control_message hdr;
+        add_listener_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = ADD_LISTENER,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = listener->local_addr,
+            .port = htons(listener->local_port),
+            .addressType = (u8)map_to_addr_type[listener->family],
+            .listenerMode = (u8)map_to_listener_mode[listener->type],
+            .connectionType = (u8)map_to_connection_type[listener->type],
+        }
+    };
+
+    rc = snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", listener->name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_listener_create] Unexpected truncation of symbolic name string");
+
+    rc = snprintf(msg.payload.interfaceName, INTERFACE_LEN, "%s", listener->interface_name);
+    if (rc >= INTERFACE_LEN)
+        WARN("[_hc_listener_create] Unexpected truncation of interface name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_CREATE,
+        .cmd_id = ADD_LISTENER,
+        .size_in = sizeof(add_listener_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_listener_create(hc_sock_t * s, hc_listener_t * listener)
+{
+    return _hc_listener_create_internal(s, listener, false);
+}
+
+static int
+_hc_listener_create_async(hc_sock_t * s, hc_listener_t * listener)
+{
+    return _hc_listener_create_internal(s, listener, true);
+}
+
+/* LISTENER LIST */
+
+static int
+_hc_listener_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
+{
+    DEBUG("[hc_listener_list] async=%s", BOOLSTR(async));
+
+    struct {
+        header_control_message hdr;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = LIST_LISTENERS,
+            .length = 0,
+            .seqNum = 0,
+        },
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_LIST,
+        .cmd_id = LIST_LISTENERS,
+        .size_in = sizeof(list_listeners_command),
+        .size_out = sizeof(hc_listener_t),
+        .parse = (HC_PARSE)hc_listener_parse,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
+}
+
+static int
+_hc_listener_list(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_listener_list_internal(s, pdata, false);
+}
+
+static int
+_hc_listener_list_async(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_listener_list_internal(s, pdata, true);
+}
+
+/* LISTENER GET */
+
+static int
+_hc_listener_get(hc_sock_t * socket, hc_listener_t * listener,
+        hc_listener_t ** listener_found)
+{
+    hc_data_t * listeners;
+    hc_listener_t * found;
+
+    char listener_s[MAXSZ_HC_LISTENER];
+    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+    if (rc >= MAXSZ_HC_LISTENER)
+        WARN("[hc_listener_get] Unexpected truncation of listener string");
+    DEBUG("[hc_listener_get] listener=%s", listener_s);
+
+    if (_hc_listener_list(socket, &listeners) < 0)
+        return -1;
+
+    /* Test */
+    if (hc_listener_find(listeners, listener, &found) < 0) {
+        hc_data_free(listeners);
+        return -1;
+    }
+
+    if (found) {
+        *listener_found = malloc(sizeof(hc_listener_t));
+        if (!*listener_found)
+            return -1;
+        **listener_found = *found;
+    } else {
+        *listener_found = NULL;
+    }
+
+    hc_data_free(listeners);
+
+    return 0;
+}
+
+
+/* LISTENER DELETE */
+
+static int
+_hc_listener_delete_internal(hc_sock_t * socket, hc_listener_t * listener, bool async)
+{
+    char listener_s[MAXSZ_HC_LISTENER];
+    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+    if (rc >= MAXSZ_HC_LISTENER)
+        WARN("[_hc_listener_delete] Unexpected truncation of listener string");
+    DEBUG("[_hc_listener_delete] listener=%s async=%s", listener_s,
+            BOOLSTR(async));
+
+    struct {
+        header_control_message hdr;
+        remove_listener_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = REMOVE_LISTENER,
+            .length = 1,
+            .seqNum = 0,
+        },
+    };
+
+    if (listener->id) {
+        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d", listener->id);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
+    } else if (*listener->name) {
+        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%s", listener->name);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
+    } else {
+        hc_listener_t * listener_found;
+        if (_hc_listener_get(socket, listener, &listener_found) < 0)
+            return -1;
+        if (!listener_found)
+            return -1;
+        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d", listener_found->id);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
+        free(listener_found);
+    }
+
+    hc_command_params_t params = {
+        .cmd = ACTION_DELETE,
+        .cmd_id = REMOVE_LISTENER,
+        .size_in = sizeof(remove_listener_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_listener_delete(hc_sock_t * s, hc_listener_t * listener)
+{
+    return _hc_listener_delete_internal(s, listener, false);
+}
+
+static int
+_hc_listener_delete_async(hc_sock_t * s, hc_listener_t * listener)
+{
+    return _hc_listener_delete_internal(s, listener, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * CONNECTION
+ *----------------------------------------------------------------------------*/
+
+/* CONNECTION CREATE */
+
+static int
+_hc_connection_create_internal(hc_sock_t * socket, hc_connection_t * connection, bool async)
+{
+    char connection_s[MAXSZ_HC_CONNECTION];
+    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+    if (rc >= MAXSZ_HC_CONNECTION)
+        WARN("[_hc_connection_create] Unexpected truncation of connection string");
+    DEBUG("[_hc_connection_create] connection=%s async=%s", connection_s, BOOLSTR(async));
+
+    if (hc_connection_validate(connection) < 0)
+        return -1;
+
+    struct {
+        header_control_message hdr;
+        add_connection_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = ADD_CONNECTION,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .remoteIp = connection->remote_addr,
+            .localIp = connection->local_addr,
+            .remotePort = htons(connection->remote_port),
+            .localPort = htons(connection->local_port),
+            .ipType = (u8)map_to_addr_type[connection->family],
+            .connectionType = (u8)map_to_connection_type[connection->type],
+            .admin_state = connection->admin_state,
+#ifdef WITH_POLICY
+            .priority = connection->priority,
+            .tags = connection->tags,
+#endif /* WITH_POLICY */
+        }
+    };
+    rc = snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", connection->name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_connection_create] Unexpected truncation of symbolic name string");
+    //snprintf(msg.payload.interfaceName, INTERFACE_NAME_LEN, "%s", connection->interface_name);
+
+    hc_command_params_t params = {
+        .cmd = ACTION_CREATE,
+        .cmd_id = ADD_CONNECTION,
+        .size_in = sizeof(add_connection_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_connection_create(hc_sock_t * s, hc_connection_t * connection)
+{
+    return _hc_connection_create_internal(s, connection, false);
+}
+
+static int
+_hc_connection_create_async(hc_sock_t * s, hc_connection_t * connection)
+{
+    return _hc_connection_create_internal(s, connection, true);
+}
+
+/* CONNECTION LIST */
+
+static int
+_hc_connection_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
+{
+    DEBUG("[hc_connection_list] async=%s", BOOLSTR(async));
+
+    struct {
+        header_control_message hdr;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = LIST_CONNECTIONS,
+            .length = 0,
+            .seqNum = 0,
+        },
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_LIST,
+        .cmd_id = LIST_CONNECTIONS,
+        .size_in = sizeof(list_connections_command),
+        .size_out = sizeof(hc_connection_t),
+        .parse = (HC_PARSE)hc_connection_parse,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
+}
+
+static int
+_hc_connection_list(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_connection_list_internal(s, pdata, false);
+}
+
+static int
+_hc_connection_list_async(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_connection_list_internal(s, pdata, true);
+}
+
+/* CONNECTION GET */
+
+static int
+_hc_connection_get(hc_sock_t * socket, hc_connection_t * connection,
+        hc_connection_t ** connection_found)
+{
+    hc_data_t * connections;
+    hc_connection_t * found;
+
+    char connection_s[MAXSZ_HC_CONNECTION];
+    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+    if (rc >= MAXSZ_HC_CONNECTION)
+        WARN("[hc_connection_get] Unexpected truncation of connection string");
+    DEBUG("[hc_connection_get] connection=%s", connection_s);
+
+    if (_hc_connection_list(socket, &connections) < 0)
+        return -1;
+
+    /* Test */
+    if (hc_connection_find(connections, connection, &found) < 0) {
+        hc_data_free(connections);
+        return -1;
+    }
+
+    if (found) {
+        *connection_found = malloc(sizeof(hc_connection_t));
+        if (!*connection_found)
+            return -1;
+        **connection_found = *found;
+    } else {
+        *connection_found = NULL;
+    }
+
+    hc_data_free(connections);
+
+    return 0;
+}
+
+
+/* CONNECTION DELETE */
+
+static int
+_hc_connection_delete_internal(hc_sock_t * socket, hc_connection_t * connection, bool async)
+{
+    char connection_s[MAXSZ_HC_CONNECTION];
+    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+    if (rc >= MAXSZ_HC_CONNECTION)
+        WARN("[_hc_connection_delete] Unexpected truncation of connection string");
+    DEBUG("[_hc_connection_delete] connection=%s async=%s", connection_s, BOOLSTR(async));
+
+    struct {
+        header_control_message hdr;
+        remove_connection_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = REMOVE_CONNECTION,
+            .length = 1,
+            .seqNum = 0,
+        },
+    };
+
+    if (connection->id) {
+        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", connection->id);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
+    } else if (*connection->name) {
+        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", connection->name);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
+    } else {
+        hc_connection_t * connection_found;
+        if (_hc_connection_get(socket, connection, &connection_found) < 0)
+            return -1;
+        if (!connection_found)
+            return -1;
+        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", connection_found->id);
+        if (rc >= SYMBOLIC_NAME_LEN)
+            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
+        free(connection_found);
+    }
+
+    hc_command_params_t params = {
+        .cmd = ACTION_DELETE,
+        .cmd_id = REMOVE_CONNECTION,
+        .size_in = sizeof(remove_connection_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_connection_delete(hc_sock_t * s, hc_connection_t * connection)
+{
+    return _hc_connection_delete_internal(s, connection, false);
+}
+
+static int
+_hc_connection_delete_async(hc_sock_t * s, hc_connection_t * connection)
+{
+    return _hc_connection_delete_internal(s, connection, true);
+}
+
+static int
+_hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
+                            hc_connection_t *connection)
+{
+    // Not implemented
+    return -1;
+}
+
+static int
+_hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current,
+                      hc_connection_t *connection_updated)
+{
+    // Not implemented
+    return -1;
+}
+
+/* CONNECTION SET ADMIN STATE */
+
+static int
+_hc_connection_set_admin_state_internal(hc_sock_t * socket, const char * conn_id_or_name,
+        face_state_t state, bool async)
+{
+    int rc;
+    DEBUG("[hc_connection_set_admin_state] connection_id/name=%s admin_state=%s async=%s",
+            conn_id_or_name, face_state_str[state], BOOLSTR(async));
+    struct {
+        header_control_message hdr;
+        connection_set_admin_state_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = CONNECTION_SET_ADMIN_STATE,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .admin_state = state,
+        },
+    };
+    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_connection_set_admin_state] Unexpected truncation of symbolic name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_SET,
+        .cmd_id = CONNECTION_SET_ADMIN_STATE,
+        .size_in = sizeof(connection_set_admin_state_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name,
+        face_state_t state)
+{
+    return _hc_connection_set_admin_state_internal(s, conn_id_or_name, state, false);
+}
+
+static int
+_hc_connection_set_admin_state_async(hc_sock_t * s, const char * conn_id_or_name,
+        face_state_t state)
+{
+    return _hc_connection_set_admin_state_internal(s, conn_id_or_name, state, true);
+}
+
+#ifdef WITH_POLICY
+
+static int
+_hc_connection_set_priority_internal(hc_sock_t * socket, const char * conn_id_or_name,
+        uint32_t priority, bool async)
+{
+    int rc;
+    DEBUG("[hc_connection_set_priority] connection_id/name=%s priority=%d async=%s",
+            conn_id_or_name, priority, BOOLSTR(async));
+    struct {
+        header_control_message hdr;
+        connection_set_priority_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = CONNECTION_SET_PRIORITY,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .priority = priority,
+        },
+    };
+    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_connection_set_priority] Unexpected truncation of symbolic name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_SET,
+        .cmd_id = CONNECTION_SET_PRIORITY,
+        .size_in = sizeof(connection_set_priority_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name,
+        uint32_t priority)
+{
+    return _hc_connection_set_priority_internal(s, conn_id_or_name, priority, false);
+}
+
+static int
+_hc_connection_set_priority_async(hc_sock_t * s, const char * conn_id_or_name,
+        uint32_t priority)
+{
+    return _hc_connection_set_priority_internal(s, conn_id_or_name, priority, true);
+}
+
+#endif // WITH_POLICY
+
+static int
+_hc_connection_set_tags_internal(hc_sock_t * s, const char * conn_id_or_name,
+        policy_tags_t tags, bool async)
+{
+    int rc;
+    DEBUG("[hc_connection_set_tags] connection_id/name=%s tags=%d async=%s",
+            conn_id_or_name, tags, BOOLSTR(async));
+    struct {
+        header_control_message hdr;
+        connection_set_tags_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = CONNECTION_SET_TAGS,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .tags = tags,
+        },
+    };
+    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_connection_set_tags] Unexpected truncation of symbolic name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_SET,
+        .cmd_id = CONNECTION_SET_TAGS,
+        .size_in = sizeof(connection_set_tags_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(s, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name,
+        policy_tags_t tags)
+{
+    return _hc_connection_set_tags_internal(s, conn_id_or_name, tags, false);
+}
+
+static int
+_hc_connection_set_tags_async(hc_sock_t * s, const char * conn_id_or_name,
+        policy_tags_t tags)
+{
+    return _hc_connection_set_tags_internal(s, conn_id_or_name, tags, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * Routes
+ *----------------------------------------------------------------------------*/
+
+/* ROUTE CREATE */
+
+static int
+_hc_route_create_internal(hc_sock_t * socket, hc_route_t * route, bool async)
+{
+    char route_s[MAXSZ_HC_ROUTE];
+    int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
+    if (rc >= MAXSZ_HC_ROUTE)
+        WARN("[_hc_route_create] Unexpected truncation of route string");
+    if (rc < 0)
+        WARN("[_hc_route_create] Error building route string");
+    else
+        DEBUG("[hc_route_create] route=%s async=%s", route_s, BOOLSTR(async));
+
+    if (!IS_VALID_FAMILY(route->family))
+         return -1;
+
+    struct {
+        header_control_message hdr;
+        add_route_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = ADD_ROUTE,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = route->remote_addr,
+            .cost = route->cost,
+            .addressType = (u8)map_to_addr_type[route->family],
+            .len = route->len,
+        }
+    };
+
+    /*
+     * The route commands expects the ID (or name that we don't use) as part of
+     * the symbolicOrConnid attribute.
+     */
+    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", route->face_id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_route_create] Unexpected truncation of symbolic name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_CREATE,
+        .cmd_id = ADD_ROUTE,
+        .size_in = sizeof(add_route_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_route_create(hc_sock_t * s, hc_route_t * route)
+{
+    return _hc_route_create_internal(s, route, false);
+}
+
+static int
+_hc_route_create_async(hc_sock_t * s, hc_route_t * route)
+{
+    return _hc_route_create_internal(s, route, true);
+}
+
+/* ROUTE DELETE */
+
+static int
+_hc_route_delete_internal(hc_sock_t * socket, hc_route_t * route, bool async)
+{
+    char route_s[MAXSZ_HC_ROUTE];
+    int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
+    if (rc >= MAXSZ_HC_ROUTE)
+        WARN("[_hc_route_delete] Unexpected truncation of route string");
+    DEBUG("[hc_route_delete] route=%s async=%s", route_s, BOOLSTR(async));
+
+    if (!IS_VALID_FAMILY(route->family))
+         return -1;
+
+    struct {
+        header_control_message hdr;
+        remove_route_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = REMOVE_ROUTE,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = route->remote_addr,
+            .addressType = (u8)map_to_addr_type[route->family],
+            .len = route->len,
+        }
+    };
+
+    /*
+     * The route commands expects the ID (or name that we don't use) as part of
+     * the symbolicOrConnid attribute.
+     */
+    snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", route->face_id);
+
+    hc_command_params_t params = {
+        .cmd = ACTION_DELETE,
+        .cmd_id = REMOVE_ROUTE,
+        .size_in = sizeof(remove_route_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_route_delete(hc_sock_t * s, hc_route_t * route)
+{
+    return _hc_route_delete_internal(s, route, false);
+}
+
+static int
+_hc_route_delete_async(hc_sock_t * s, hc_route_t * route)
+{
+    return _hc_route_delete_internal(s, route, true);
+}
+
+/* ROUTE LIST */
+
+static int
+_hc_route_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
+{
+    //DEBUG("[hc_route_list] async=%s", BOOLSTR(async));
+
+    struct {
+        header_control_message hdr;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = LIST_ROUTES,
+            .length = 0,
+            .seqNum = 0,
+        },
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_LIST,
+        .cmd_id = LIST_ROUTES,
+        .size_in = sizeof(list_routes_command),
+        .size_out = sizeof(hc_route_t),
+        .parse = (HC_PARSE)hc_route_parse,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
+}
+
+static int
+_hc_route_list(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_route_list_internal(s, pdata, false);
+}
+
+static int
+_hc_route_list_async(hc_sock_t * s)
+{
+    return _hc_route_list_internal(s, NULL, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * Face
+ *
+ * Face support is not directly available in hicn-light, but we can offer such
+ * an interface through a combination of listeners and connections. The code
+ * starts with some conversion functions between faces/listeners/connections.
+ *
+ * We also need to make sure that there always exist a (single) listener when a
+ * connection is created, and in the hICN face case, that there is a single
+ * connection attached to this listener.
+ *
+ *----------------------------------------------------------------------------*/
+
+/* FACE CREATE */
+
+static int
+_hc_face_create(hc_sock_t * socket, hc_face_t * face)
+{
+    hc_listener_t listener;
+    hc_listener_t * listener_found;
+
+    hc_connection_t connection;
+    hc_connection_t * connection_found;
+
+    char face_s[MAXSZ_HC_FACE];
+    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+    if (rc >= MAXSZ_HC_FACE)
+        WARN("[hc_face_create] Unexpected truncation of face string");
+    DEBUG("[hc_face_create] face=%s", face_s);
+
+    switch(face->face.type)
+    {
+        case FACE_TYPE_HICN:
+        case FACE_TYPE_TCP:
+        case FACE_TYPE_UDP:
+            if (hc_face_to_connection(face, &connection, true) < 0) {
+                ERROR("[hc_face_create] Could not convert face to connection.");
+                return -1;
+            }
+
+            /* Ensure we have a corresponding local listener */
+            if (hc_connection_to_local_listener(&connection, &listener) < 0) {
+                ERROR("[hc_face_create] Could not convert face to local listener.");
+                return -1;
+            }
+
+            if (_hc_listener_get(socket, &listener, &listener_found) < 0) {
+                ERROR("[hc_face_create] Could not retrieve listener");
+                return -1;
+            }
+
+            if (!listener_found) {
+                /* We need to create the listener if it does not exist */
+                if (_hc_listener_create(socket, &listener) < 0) {
+                    ERROR("[hc_face_create] Could not create listener.");
+                    free(listener_found);
+                    return -1;
+                }
+            } else {
+                free(listener_found);
+            }
+
+            /* Create corresponding connection */
+            if (_hc_connection_create(socket, &connection) < 0) {
+                ERROR("[hc_face_create] Could not create connection.");
+                return -1;
+            }
+
+            /*
+             * Once the connection is created, we need to list all connections
+             * and compare with the current one to find the created face ID.
+             */
+            if (_hc_connection_get(socket, &connection, &connection_found) < 0) {
+                ERROR("[hc_face_create] Could not retrieve connection");
+                return -1;
+            }
+
+            if (!connection_found) {
+                ERROR("[hc_face_create] Could not find newly created connection.");
+                return -1;
+            }
+
+            face->id = connection_found->id;
+            free(connection_found);
+
+            break;
+
+        case FACE_TYPE_HICN_LISTENER:
+        case FACE_TYPE_TCP_LISTENER:
+        case FACE_TYPE_UDP_LISTENER:
+            if (hc_face_to_listener(face, &listener) < 0) {
+                ERROR("Could not convert face to listener.");
+                return -1;
+            }
+            if (_hc_listener_create(socket, &listener) < 0) {
+                ERROR("[hc_face_create] Could not create listener.");
+                return -1;
+            }
+            return -1;
+            break;
+        default:
+            ERROR("[hc_face_create] Unknwon face type.");
+
+            return -1;
+    };
+
+    return 0;
+}
+
+static int
+_hc_face_get(hc_sock_t * socket, hc_face_t * face, hc_face_t ** face_found)
+{
+    hc_listener_t listener;
+    hc_listener_t * listener_found;
+
+    hc_connection_t connection;
+    hc_connection_t * connection_found;
+
+    char face_s[MAXSZ_HC_FACE];
+    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+    if (rc >= MAXSZ_HC_FACE)
+        WARN("[hc_face_get] Unexpected truncation of face string");
+    DEBUG("[hc_face_get] face=%s", face_s);
+
+    switch(face->face.type)
+    {
+        case FACE_TYPE_HICN:
+        case FACE_TYPE_TCP:
+        case FACE_TYPE_UDP:
+            if (hc_face_to_connection(face, &connection, false) < 0)
+                 return -1;
+            if (_hc_connection_get(socket, &connection, &connection_found) < 0)
+                 return -1;
+            if (!connection_found) {
+                *face_found = NULL;
+                return 0;
+            }
+            *face_found = malloc(sizeof(hc_face_t));
+            hc_connection_to_face(connection_found, *face_found);
+            free(connection_found);
+            break;
+
+        case FACE_TYPE_HICN_LISTENER:
+        case FACE_TYPE_TCP_LISTENER:
+        case FACE_TYPE_UDP_LISTENER:
+            if (hc_face_to_listener(face, &listener) < 0)
+                 return -1;
+            if (_hc_listener_get(socket, &listener, &listener_found) < 0)
+                 return -1;
+            if (!listener_found) {
+                *face_found = NULL;
+                return 0;
+            }
+            *face_found = malloc(sizeof(hc_face_t));
+            hc_listener_to_face(listener_found, *face_found);
+            free(listener_found);
+            break;
+
+        default:
+             return -1;
+    }
+
+    return 0;
+
+}
+
+/* FACE DELETE */
+
+static int
+_hc_face_delete(hc_sock_t * socket, hc_face_t * face)
+{
+    char face_s[MAXSZ_HC_FACE];
+    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+    if (rc >= MAXSZ_HC_FACE)
+        WARN("[hc_face_delete] Unexpected truncation of face string");
+    DEBUG("[hc_face_delete] face=%s", face_s);
+
+    hc_connection_t connection;
+    if (hc_face_to_connection(face, &connection, false) < 0) {
+        ERROR("[hc_face_delete] Could not convert face to connection.");
+        return -1;
+    }
+
+    if (_hc_connection_delete(socket, &connection) < 0) {
+        ERROR("[hc_face_delete] Error removing connection");
+        return -1;
+    }
+
+    /* If this is the last connection attached to the listener, remove it */
+
+    hc_data_t * connections;
+    hc_listener_t listener = {{0}};
+
+    /*
+     * Ensure we have a corresponding local listener
+     * NOTE: hc_face_to_listener is not appropriate
+     */
+    if (hc_connection_to_local_listener(&connection, &listener) < 0) {
+        ERROR("[hc_face_create] Could not convert face to local listener.");
+        return -1;
+    }
+#if 1
+    /*
+     * The name is generated to prepare listener creation, we need it to be
+     * empty for deletion. The id should not need to be reset though.
+     */
+    listener.id = 0;
+    memset(listener.name, 0, sizeof(listener.name));
+#endif
+    if (_hc_connection_list(socket, &connections) < 0) {
+        ERROR("[hc_face_delete] Error getting the list of listeners");
+        return -1;
+    }
+
+    bool delete = true;
+    foreach_connection(c, connections) {
+        if ((ip_address_cmp(&c->local_addr, &listener.local_addr, c->family) == 0) &&
+            (c->local_port == listener.local_port) &&
+                (strcmp(c->interface_name, listener.interface_name) == 0)) {
+            delete = false;
+        }
+    }
+
+    if (delete) {
+        if (_hc_listener_delete(socket, &listener) < 0) {
+            ERROR("[hc_face_delete] Error removing listener");
+            return -1;
+        }
+    }
+
+    hc_data_free(connections);
+
+    return 0;
+
+
+}
+
+/* FACE LIST */
+
+static int
+_hc_face_list(hc_sock_t * socket, hc_data_t ** pdata)
+{
+    hc_data_t * connection_data;
+    hc_face_t face;
+
+    //DEBUG("[hc_face_list]");
+
+    if (_hc_connection_list(socket, &connection_data) < 0) {
+        ERROR("[hc_face_list] Could not list connections.");
+        return -1;
+    }
+
+    hc_data_t * face_data = hc_data_create(sizeof(hc_connection_t), sizeof(hc_face_t), NULL);
+    foreach_connection(c, connection_data) {
+        if (hc_connection_to_face(c, &face) < 0) {
+            ERROR("[hc_face_list] Could not convert connection to face.");
+            goto ERR;
+        }
+        hc_data_push(face_data, &face);
+    }
+
+    *pdata = face_data;
+    hc_data_free(connection_data);
+    return 0;
+
+ERR:
+    hc_data_free(connection_data);
+    return -1;
+}
+
+static int
+_hc_face_list_async(hc_sock_t * socket)
+{
+    struct {
+        header_control_message hdr;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = LIST_CONNECTIONS,
+            .length = 0,
+            .seqNum = 0,
+        },
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_LIST,
+        .cmd_id = LIST_CONNECTIONS,
+        .size_in = sizeof(list_connections_command),
+        .size_out = sizeof(hc_face_t),
+        .parse = (HC_PARSE)hc_connection_parse_to_face,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, true);
+}
+
+static int
+_hc_face_set_admin_state(hc_sock_t * s, const char * conn_id_or_name,
+        face_state_t admin_state)
+{
+    return hc_connection_set_admin_state(s, conn_id_or_name, admin_state);
+}
+
+#ifdef WITH_POLICY
+static int
+_hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name,
+        uint32_t priority)
+{
+    return hc_connection_set_priority(s, conn_id_or_name, priority);
+}
+
+static int
+_hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name,
+        policy_tags_t tags)
+{
+    return hc_connection_set_tags(s, conn_id_or_name, tags);
+}
+#endif // WITH_POLICY
+
+/*----------------------------------------------------------------------------*
+ * Punting
+ *----------------------------------------------------------------------------*/
+
+static int
+_hc_punting_create_internal(hc_sock_t * socket, hc_punting_t * punting, bool async)
+{
+    int rc;
+
+    if (hc_punting_validate(punting) < 0)
+        return -1;
+
+    struct {
+        header_control_message hdr;
+        add_punting_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = ADD_PUNTING,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = punting->prefix,
+            .addressType = (u8)map_to_addr_type[punting->family],
+            .len = punting->prefix_len,
+        }
+    };
+    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", punting->face_id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+        WARN("[_hc_punting_create] Unexpected truncation of symbolic name string");
+
+    hc_command_params_t params = {
+        .cmd = ACTION_CREATE,
+        .cmd_id = ADD_PUNTING,
+        .size_in = sizeof(add_punting_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_punting_create(hc_sock_t * s, hc_punting_t * punting)
+{
+    return _hc_punting_create_internal(s, punting, false);
+}
+
+static int
+_hc_punting_create_async(hc_sock_t * s, hc_punting_t * punting)
+{
+    return _hc_punting_create_internal(s, punting, true);
+}
+
+static int
+_hc_punting_get(hc_sock_t * s, hc_punting_t * punting, hc_punting_t ** punting_found)
+{
+    ERROR("hc_punting_get not (yet) implemented.");
+    return -1;
+}
+
+static int
+_hc_punting_delete(hc_sock_t * s, hc_punting_t * punting)
+{
+    ERROR("hc_punting_delete not (yet) implemented.");
+    return -1;
+}
+
+static int
+_hc_punting_list(hc_sock_t * s, hc_data_t ** pdata)
+{
+    ERROR("hc_punting_list not (yet) implemented.");
+    return -1;
+}
+
+
+/*----------------------------------------------------------------------------*
+ * Cache
+ *----------------------------------------------------------------------------*/
+
+static int
+_hc_cache_set_store_internal(hc_sock_t * socket, int enabled, bool async)
+{
+    struct {
+        header_control_message hdr;
+        cache_store_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = CACHE_STORE,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .activate = enabled,
+        }
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_SET,
+        .cmd_id = CACHE_STORE,
+        .size_in = sizeof(cache_store_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_cache_set_store(hc_sock_t * s, int enabled)
+{
+    return _hc_cache_set_store_internal(s, enabled, false);
+}
+
+static int
+_hc_cache_set_store_async(hc_sock_t * s, int enabled)
+{
+    return _hc_cache_set_store_internal(s, enabled, true);
+}
+
+static int
+_hc_cache_set_serve_internal(hc_sock_t * socket, int enabled, bool async)
+{
+    struct {
+        header_control_message hdr;
+        cache_serve_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = CACHE_SERVE,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .activate = enabled,
+        }
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_SET,
+        .cmd_id = CACHE_SERVE,
+        .size_in = sizeof(cache_serve_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_cache_set_serve(hc_sock_t * s, int enabled)
+{
+    return _hc_cache_set_serve_internal(s, enabled, false);
+}
+
+static int
+_hc_cache_set_serve_async(hc_sock_t * s, int enabled)
+{
+    return _hc_cache_set_serve_internal(s, enabled, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * Strategy
+ *----------------------------------------------------------------------------*/
+
+// per prefix
+static int
+_hc_strategy_set(hc_sock_t * s /* XXX */)
+{
+     return 0;
+}
+
+/* How to retrieve that from the forwarder ? */
+static const char * strategies[] = {
+    "random",
+    "load_balancer",
+};
+
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
+
+static int
+_hc_strategy_list(hc_sock_t * s, hc_data_t ** data)
+{
+    int rc;
+
+    *data = hc_data_create(0, sizeof(hc_strategy_t), NULL);
+
+    for (unsigned i = 0; i < ARRAY_SIZE(strategies); i++) {
+        hc_strategy_t * strategy = (hc_strategy_t*)hc_data_get_next(*data);
+        if (!strategy)
+             return -1;
+        rc = snprintf(strategy->name, MAXSZ_HC_STRATEGY, "%s", strategies[i]);
+        if (rc >= MAXSZ_HC_STRATEGY)
+            WARN("[hc_strategy_list] Unexpected truncation of strategy name string");
+        (*data)->size++;
+    }
+
+    return 0;
+}
+
+/*----------------------------------------------------------------------------*
+ * WLDR
+ *----------------------------------------------------------------------------*/
+
+// per connection
+static int
+_hc_wldr_set(hc_sock_t * s /* XXX */)
+{
+     return 0;
+}
+
+/*----------------------------------------------------------------------------*
+ * MAP-Me
+ *----------------------------------------------------------------------------*/
+
+static int
+_hc_mapme_set(hc_sock_t * s, int enabled)
+{
+     return 0;
+}
+
+static int
+_hc_mapme_set_discovery(hc_sock_t * s, int enabled)
+{
+     return 0;
+}
+
+static int
+_hc_mapme_set_timescale(hc_sock_t * s, double timescale)
+{
+     return 0;
+}
+
+static int
+_hc_mapme_set_retx(hc_sock_t * s, double timescale)
+{
+     return 0;
+}
+
+/*----------------------------------------------------------------------------*
+ * Policy
+ *----------------------------------------------------------------------------*/
+
+#ifdef WITH_POLICY
+
+/* POLICY CREATE */
+
+static int
+_hc_policy_create_internal(hc_sock_t * socket, hc_policy_t * policy, bool async)
+{
+    if (!IS_VALID_FAMILY(policy->family))
+         return -1;
+
+    struct {
+        header_control_message hdr;
+        add_policy_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = ADD_POLICY,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = policy->remote_addr,
+            .addressType = (u8)map_to_addr_type[policy->family],
+            .len = policy->len,
+            .policy = policy->policy,
+        }
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_CREATE,
+        .cmd_id = ADD_POLICY,
+        .size_in = sizeof(add_policy_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_policy_create(hc_sock_t * s, hc_policy_t * policy)
+{
+    return _hc_policy_create_internal(s, policy, false);
+}
+
+static int
+_hc_policy_create_async(hc_sock_t * s, hc_policy_t * policy)
+{
+    return _hc_policy_create_internal(s, policy, true);
+}
+
+/* POLICY DELETE */
+
+static int
+_hc_policy_delete_internal(hc_sock_t * socket, hc_policy_t * policy, bool async)
+{
+    if (!IS_VALID_FAMILY(policy->family))
+         return -1;
+
+    struct {
+        header_control_message hdr;
+        remove_policy_command payload;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = REMOVE_POLICY,
+            .length = 1,
+            .seqNum = 0,
+        },
+        .payload = {
+            .address = policy->remote_addr,
+            .addressType = (u8)map_to_addr_type[policy->family],
+            .len = policy->len,
+        }
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_DELETE,
+        .cmd_id = REMOVE_POLICY,
+        .size_in = sizeof(remove_policy_command),
+        .size_out = 0,
+        .parse = NULL,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
+}
+
+static int
+_hc_policy_delete(hc_sock_t * s, hc_policy_t * policy)
+{
+    return _hc_policy_delete_internal(s, policy, false);
+}
+
+static int
+_hc_policy_delete_async(hc_sock_t * s, hc_policy_t * policy)
+{
+    return _hc_policy_delete_internal(s, policy, true);
+}
+
+/* POLICY LIST */
+
+static int
+_hc_policy_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
+{
+    struct {
+        header_control_message hdr;
+    } msg = {
+        .hdr = {
+            .messageType = REQUEST_LIGHT,
+            .commandID = LIST_POLICIES,
+            .length = 0,
+            .seqNum = 0,
+        },
+    };
+
+    hc_command_params_t params = {
+        .cmd = ACTION_LIST,
+        .cmd_id = LIST_POLICIES,
+        .size_in = sizeof(list_policies_command),
+        .size_out = sizeof(hc_policy_t),
+        .parse = (HC_PARSE)hc_policy_parse,
+    };
+
+    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
+}
+
+static int
+_hc_policy_list(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_policy_list_internal(s, pdata, false);
+}
+
+static int
+_hc_policy_list_async(hc_sock_t * s, hc_data_t ** pdata)
+{
+    return _hc_policy_list_internal(s, pdata, true);
+}
+
+#endif /* WITH_POLICY */
+
+static hc_sock_t hc_sock_light_interface = (hc_sock_t) {
+    .hc_sock_get_next_seq = _hc_sock_light_get_next_seq,
+    .hc_sock_set_nonblocking = _hc_sock_light_set_nonblocking,
+    .hc_sock_get_fd = _hc_sock_light_get_fd,
+    .hc_sock_connect = _hc_sock_light_connect,
+    .hc_sock_get_available = _hc_sock_light_get_available,
+    .hc_sock_send = _hc_sock_light_send,
+    .hc_sock_recv = _hc_sock_light_recv,
+    .hc_sock_process = _hc_sock_light_process,
+    .hc_sock_callback = _hc_sock_light_callback,
+    .hc_sock_reset = _hc_sock_light_reset,
+    .hc_sock_free = _hc_sock_light_free,
+    .hc_listener_create = _hc_listener_create,
+    .hc_listener_create_async = _hc_listener_create_async,
+    .hc_listener_get = _hc_listener_get,
+    .hc_listener_delete = _hc_listener_delete,
+    .hc_listener_delete_async = _hc_listener_delete_async,
+    .hc_listener_list = _hc_listener_list,
+    .hc_listener_list_async = _hc_listener_list_async,
+    .hc_connection_create = _hc_connection_create,
+    .hc_connection_create_async = _hc_connection_create_async,
+    .hc_connection_get = _hc_connection_get,
+    .hc_connection_update_by_id = _hc_connection_update_by_id,
+    .hc_connection_update = _hc_connection_update,
+    .hc_connection_delete = _hc_connection_delete,
+    .hc_connection_delete_async = _hc_connection_delete_async,
+    .hc_connection_list = _hc_connection_list,
+    .hc_connection_list_async = _hc_connection_list_async,
+    .hc_connection_set_admin_state = _hc_connection_set_admin_state,
+    .hc_connection_set_admin_state_async = _hc_connection_set_admin_state_async,
+
+#ifdef WITH_POLICY
+    .hc_connection_set_priority = _hc_connection_set_priority,
+    .hc_connection_set_priority_async = _hc_connection_set_priority_async,
+    .hc_connection_set_tags = _hc_connection_set_tags,
+    .hc_connection_set_tags_async = _hc_connection_set_tags_async,
+#endif // WITH_POLICY
+
+    .hc_face_create = _hc_face_create,
+    .hc_face_get = _hc_face_get,
+    .hc_face_delete = _hc_face_delete,
+    .hc_face_list = _hc_face_list,
+    .hc_face_list_async = _hc_face_list_async,
+    .hc_face_set_admin_state = _hc_face_set_admin_state,
+
+#ifdef WITH_POLICY
+    .hc_face_set_priority = _hc_face_set_priority,
+    .hc_face_set_tags = _hc_face_set_tags,
+#endif // WITH_POLICY
+
+    .hc_route_create = _hc_route_create,
+    .hc_route_create_async = _hc_route_create_async,
+    .hc_route_delete = _hc_route_delete,
+    .hc_route_delete_async = _hc_route_delete_async,
+    .hc_route_list = _hc_route_list,
+    .hc_route_list_async = _hc_route_list_async,
+
+    .hc_punting_create = _hc_punting_create,
+    .hc_punting_create_async = _hc_punting_create_async,
+    .hc_punting_get = _hc_punting_get,
+    .hc_punting_delete = _hc_punting_delete,
+    .hc_punting_list = _hc_punting_list,
+
+    .hc_cache_set_store = _hc_cache_set_store,
+    .hc_cache_set_store_async = _hc_cache_set_store_async,
+    .hc_cache_set_serve = _hc_cache_set_serve,
+    .hc_cache_set_serve_async = _hc_cache_set_serve_async,
+
+    .hc_strategy_list = _hc_strategy_list,
+    .hc_strategy_set = _hc_strategy_set,
+    .hc_wldr_set = _hc_wldr_set,
+
+    .hc_mapme_set = _hc_mapme_set,
+    .hc_mapme_set_discovery = _hc_mapme_set_discovery,
+    .hc_mapme_set_timescale = _hc_mapme_set_timescale,
+    .hc_mapme_set_retx = _hc_mapme_set_retx,
+
+#ifdef WITH_POLICY
+    .hc_policy_create = _hc_policy_create,
+    .hc_policy_create_async = _hc_policy_create_async,
+    .hc_policy_delete = _hc_policy_delete,
+    .hc_policy_delete_async = _hc_policy_delete_async,
+    .hc_policy_list = _hc_policy_list,
+    .hc_policy_list_async = _hc_policy_list_async
+#endif // WITH_POLICY
+};
+
+// Public contructors
+
+hc_sock_t *
+_hc_sock_create_url(const char * url)
+{
+    hc_sock_light_t * s = malloc(sizeof(hc_sock_light_t));
+    if (!s)
+        goto ERR_MALLOC;
+
+    s->vft = hc_sock_light_interface;
+    s->url = url ? strdup(url) : NULL;
+
+    s->fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (s->fd < 0)
+        goto ERR_SOCKET;
+
+    if (_hc_sock_light_reset((hc_sock_t*)s) < 0)
+        goto ERR_RESET;
+
+    s->seq = 0;
+    s->cur_request = NULL;
+
+    s->map = hc_sock_map_create();
+    if (!s->map)
+        goto ERR_MAP;
+
+    return (hc_sock_t*)(s);
+
+    //hc_sock_light_map_free(s->map);
+ERR_MAP:
+ERR_RESET:
+    if (s->url)
+        free(s->url);
+    close(s->fd);
+ERR_SOCKET:
+    free(s);
+ERR_MALLOC:
+    return NULL;
+}
+
+hc_sock_t *
+_hc_sock_create(void)
+{
+    return _hc_sock_create_url(NULL);
+}