net: added full RD endpoint implementation

Makefile.dep

@@ -768,6 +768,21 @@ ifneq (,$(filter rdcli_simple,$(USEMODULE)))
   USEMODULE += fmt
 endif
 
+ifneq (,$(filter rdcli_standalone,$(USEMODULE)))
+  USEMODULE += rdcli
+  USEMODULE += xtimer
+endif
+
+ifneq (,$(filter rdcli,$(USEMODULE)))
+  USEMODULE += rdcli_common
+  USEMODULE += core_thread_flags
+  USEMODULE += gcoap
+  USEMODULE += fmt
+  ifneq (,$(filter shell_commands,$(USEMODULE)))
+    USEMODULE += sock_util
+  endif
+endif
+
 ifneq (,$(filter rdcli_common,$(USEMODULE)))
   USEMODULE += fmt
   USEMODULE += gcoap

makefiles/pseudomodules.inc.mk

@@ -65,6 +65,7 @@ PSEUDOMODULES += pktqueue
 PSEUDOMODULES += printf_float
 PSEUDOMODULES += prng
 PSEUDOMODULES += prng_%
+PSEUDOMODULES += rdcli_standalone
 PSEUDOMODULES += rdcli_simple_standalone
 PSEUDOMODULES += saul_adc
 PSEUDOMODULES += saul_default

sys/Makefile

@@ -133,6 +133,10 @@ endif
 ifneq (,$(filter rdcli_simple,$(USEMODULE)))
     DIRS += net/application_layer/rdcli_simple
 endif
+ifneq (,$(filter rdcli,$(USEMODULE)))
+    DIRS += net/application_layer/rdcli
+endif
+
 
 DIRS += $(dir $(wildcard $(addsuffix /Makefile, $(USEMODULE))))
 

sys/include/net/rdcli.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2017-2018 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @defgroup    net_rdcli CoRE RD Endpoint Library
+ * @ingroup     net
+ * @brief       Library for using RIOT as CoRE Resource Directory endpoint
+ *
+ * This module implements a CoRE Resource Directory endpoint library, that
+ * allows RIOT nodes to register themselves with resource directories.
+ * It implements the standard endpoint functionality as defined in
+ * draft-ietf-core-resource-directory-15.
+ * @see https://tools.ietf.org/html/draft-ietf-core-resource-directory-15
+ *
+ * @note        As the name of this library (`rdcli`) can be misleading in
+ *              context of the RD draft (endpoint vs client), this library
+ *              will most likely undergo a name change in the near future...
+ *
+ * # Design Decisions
+ * - all operations provided by this module are fully synchronous, meaning that
+ *   the functions will block until an operation is successful or will time out
+ * - the implementation limits the client to be registered with a single RD at
+ *   any point in time
+ *
+ * @{
+ *
+ * @file
+ * @brief       CoRE Resource Directory endpoint interface
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ */
+
+#ifndef NET_RDCLI_H
+#define NET_RDCLI_H
+
+#include "net/sock/udp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Return values and error codes used by this module
+ */
+enum {
+    RDCLI_OK        =  0,   /**< everything went as expected */
+    RDCLI_TIMEOUT   = -1,   /**< no response from the network */
+    RDCLI_ERR       = -2,   /**< internal error or invalid reply */
+    RDCLI_NORD      = -3,   /**< not connected to an RD */
+    RDCLI_OVERFLOW  = -4,   /**< internal buffers can not handle input */
+};
+
+/**
+ * @brief   Discover the registration interface resource of a RD
+ *
+ * @param[in] remote    remote endpoint of the target RD
+ * @param[out] regif    the registration interface is written to this buffer
+ * @param[in] maxlen    size of @p regif
+ *
+ * @return  RDCLI_OK on success
+ * @return  RDCLI_TIMEOUT if the discovery request times out
+ * @return  RDCLI_NORD if addressed endpoint is not a RD
+ * @return  RDCLI_ERR on any other internal error
+ */
+int rdcli_discover_regif(const sock_udp_ep_t *remote,
+                         char *regif, size_t maxlen);
+
+/**
+ * @brief   Initiate the node registration by sending an empty push
+ *
+ * - if registration fails (e.g. timeout), we are not associated with any RD
+ *   anymore (even if we have been before we called rdcli_register)
+ *
+ * @note    In case a multicast address is given, the @p regif parameter MUST be
+ *          NULL. The first RD responding to the request will be chosen and all
+ *          replies from other RD servers are ignored.
+ *
+ * @param[in] remote    remote endpoint of the target RD
+ * @param[in] regif     registration interface resource of the RD, it will be
+ *                      discovered automatically when set to NULL
+ *
+ * @return  RDCLI_OK on success
+ * @return  RDCLI_TIMEOUT on registration timeout
+ * @return  RDCLI_NORD if addressed endpoint is not a RD
+ * @return  RDCLI_OVERFLOW if @p regif does not fit into internal buffer
+ * @return  RDCLI_ERR on any other internal error
+ */
+int rdcli_register(const sock_udp_ep_t *remote, const char *regif);
+
+/**
+ * @brief   Update our current entry at the RD
+ *
+ * @return  RDCLI_OK on success
+ * @return  RDCLI_TIMEOUT if the update request times out
+ * @return  RDCLI_ERR on any other internal error
+ */
+int rdcli_update(void);
+
+/**
+ * @brief   Unregister from a given RD server
+ *
+ * @return  RDCLI_OK on success
+ * @return  RDCLI_TIMEOUT if the remove request times out
+ * @return  RDCLI_ERR on any other internal error
+ */
+int rdcli_remove(void);
+
+/**
+ * @brief   Dump the current RD connection status to STDIO (for debugging)
+ */
+void rdcli_dump_status(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NET_RDCLI_H */
+/** @} */

sys/include/net/rdcli_standalone.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2017-2018 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @defgroup    net_rdcli_standalone CoRE RD Standalone Extension
+ * @ingroup     net_rdcli
+ * @brief       Run CoRE Resource Directory client in standalone configuration
+ *
+ * This sub-module enables the CoRE RD client to manage is registration state
+ * with a server autonomously by periodically running the update procedure. This
+ * is implemented by running a dedicated thread.
+ *
+ * @{
+ *
+ * @file
+ * @brief       CoRE Resource Directory client standalone extension
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ */
+
+#ifndef NET_RDCLI_STANDALONE_H
+#define NET_RDCLI_STANDALONE_H
+
+#include "net/sock/udp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Possible types of events triggered by the standalone rdcli module
+ */
+typedef enum {
+    RDCLI_REGISTERED,
+    RDCLI_DEREGISTERED,
+    RDCLI_UPDATED,
+} rdcli_standalone_event_t;
+
+/**
+ * @brief   Callback function signature for RD client state synchronization
+ *
+ * The registered callback function is executed in the context of the dedicated
+ * standalone RD client's thread.
+ *
+ * @param[in] t         type of event
+ */
+typedef void(*rdcli_standalone_cb_t)(rdcli_standalone_event_t event);
+
+/**
+ * @brief   Spawn a new thread that takes care of sending periodic updates to an
+ *          active RD entry
+ *
+ * @note    This function must only be called once (typically during system
+ *          initialization)
+ */
+void rdcli_standalone_run(void);
+
+/**
+ * @brief   Register a callback to be notified about RD client state changes
+ *
+ * Only a single callback can be active at any point in time, so setting a new
+ * callback will override the existing one.
+ *
+ * @pre                     @p cb != NULL
+ *
+ * @param[in] cb            callback to execute on RD client state changes
+ */
+void rdcli_standalone_reg_cb(rdcli_standalone_cb_t cb);
+
+/**
+ * @brief   Signal the rdcli thread about connection status change
+ *
+ * @note    This function should not be called by a user, but it is called from
+ *          withing the rdcli implementation
+ *
+ * @param[in] connected     set to true if we are connected to a RD
+ */
+void rdcli_standalone_signal(bool connected);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NET_RDCLI_STANDALONE_H */
+/** @} */

sys/net/application_layer/rdcli/Makefile

@@ -0,0 +1,7 @@
+SRC = rdcli.c
+
+ifneq (,$(filter rdcli_standalone,$(USEMODULE)))
+  SRC += rdcli_standalone.c
+endif
+
+include $(RIOTBASE)/Makefile.base

sys/net/application_layer/rdcli/rdcli.c

@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2017-2018 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup     net_rdcli
+ * @{
+ *
+ * @file
+ * @brief       CoRE Resource Directory client implementation
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ *
+ * @}
+ */
+
+#include <string.h>
+
+#include "fmt.h"
+#include "mutex.h"
+#include "thread_flags.h"
+
+#include "net/gcoap.h"
+#include "net/ipv6/addr.h"
+#include "net/rdcli.h"
+#include "net/rdcli_common.h"
+#include "net/rdcli_config.h"
+
+#ifdef MODULE_RDCLI_STANDALONE
+#include "net/rdcli_standalone.h"
+#endif
+
+#define ENABLE_DEBUG        (0)
+#include "debug.h"
+
+#define FLAG_SUCCESS        (0x0001)
+#define FLAG_TIMEOUT        (0x0002)
+#define FLAG_ERR            (0x0004)
+#define FLAG_OVERFLOW       (0x0008)
+#define FLAG_MASK           (0x000f)
+
+#define BUFSIZE             (512U)
+
+static char *_regif_buf;
+static size_t _regif_buf_len;
+
+static char _rd_loc[NANOCOAP_URI_MAX];
+static char _rd_regif[NANOCOAP_URI_MAX];
+static sock_udp_ep_t _rd_remote;
+
+static mutex_t _mutex = MUTEX_INIT;
+static volatile thread_t *_waiter;
+
+static uint8_t buf[BUFSIZE];
+
+static void _lock(void)
+{
+    mutex_lock(&_mutex);
+    _waiter = sched_active_thread;
+}
+
+static int _sync(void)
+{
+    thread_flags_t flags = thread_flags_wait_any(FLAG_MASK);
+
+    if (flags & FLAG_ERR) {
+        return RDCLI_ERR;
+    }
+    else if (flags & FLAG_TIMEOUT) {
+        return RDCLI_TIMEOUT;
+    }
+    else if (flags & FLAG_OVERFLOW) {
+        return RDCLI_OVERFLOW;
+    }
+    else {
+        return RDCLI_OK;
+    }
+}
+
+static void _on_register(unsigned req_state, coap_pkt_t* pdu,
+                        sock_udp_ep_t *remote)
+{
+    thread_flags_t flag = FLAG_ERR;
+
+    if ((req_state == GCOAP_MEMO_RESP) &&
+        (pdu->hdr->code == COAP_CODE_CREATED)) {
+        /* read the location header and save the RD details on success */
+        if (coap_get_location_path(pdu, (uint8_t *)_rd_loc,
+                                   sizeof(_rd_loc)) > 0) {
+            memcpy(&_rd_remote, remote, sizeof(_rd_remote));
+            flag = FLAG_SUCCESS;
+        }
+        else {
+            /* reset RD entry */
+            flag = FLAG_OVERFLOW;
+        }
+    }
+    else if (req_state == GCOAP_MEMO_TIMEOUT) {
+        flag = FLAG_TIMEOUT;
+    }
+
+    thread_flags_set((thread_t *)_waiter, flag);
+}
+
+static void _on_update_remove(unsigned req_state, coap_pkt_t *pdu, uint8_t code)
+{
+    thread_flags_t flag = FLAG_ERR;
+
+    if ((req_state == GCOAP_MEMO_RESP) && (pdu->hdr->code == code)) {
+        flag = FLAG_SUCCESS;
+    }
+    else if (req_state == GCOAP_MEMO_TIMEOUT) {
+        flag = FLAG_TIMEOUT;
+    }
+
+    thread_flags_set((thread_t *)_waiter, flag);
+}
+
+static void _on_update(unsigned req_state, coap_pkt_t *pdu, sock_udp_ep_t *remote)
+{
+    (void)remote;
+    _on_update_remove(req_state, pdu, COAP_CODE_CHANGED);
+}
+
+static void _on_remove(unsigned req_state, coap_pkt_t *pdu, sock_udp_ep_t *remote)
+{
+    (void)remote;
+    _on_update_remove(req_state, pdu, COAP_CODE_DELETED);
+}
+
+static int _update_remove(unsigned code, gcoap_resp_handler_t handle)
+{
+    coap_pkt_t pkt;
+
+    if (_rd_loc[0] == 0) {
+        return RDCLI_NORD;
+    }
+
+    /* build CoAP request packet */
+    int res = gcoap_req_init(&pkt, buf, sizeof(buf), code, _rd_loc);
+    if (res < 0) {
+        return RDCLI_ERR;
+    }
+    coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON);
+    ssize_t pkt_len = gcoap_finish(&pkt, 0, COAP_FORMAT_NONE);
+
+    /* send request */
+    gcoap_req_send2(buf, pkt_len, &_rd_remote, handle);
+
+    /* synchronize response */
+    return _sync();
+}
+
+static void _on_discover(unsigned req_state, coap_pkt_t *pdu,
+                         sock_udp_ep_t *remote)
+{
+    thread_flags_t flag = RDCLI_NORD;
+    (void)remote;
+
+    if (req_state == GCOAP_MEMO_RESP) {
+        unsigned ct = coap_get_content_type(pdu);
+        if (ct != COAP_FORMAT_LINK) {
+            goto end;
+        }
+        if (pdu->payload_len == 0) {
+            goto end;
+        }
+        /* do simplified parsing of registration interface location */
+        char *start = (char *)pdu->payload;
+        char *end;
+        char *limit = (char *)(pdu->payload + pdu->payload_len);
+        while ((*start != '<') && (start < limit)) {
+            start++;
+        }
+        if (*start != '<') {
+            goto end;
+        }
+        end = ++start;
+        while ((*end != '>') && (end < limit)) {
+            end++;
+        }
+        if (*end != '>') {
+            goto end;
+        }
+        /* TODO: verify size of interface resource identifier */
+        size_t uri_len = (size_t)(end - start);
+        if (uri_len >= _regif_buf_len) {
+            goto end;
+        }
+        memcpy(_regif_buf, start, uri_len);
+        memset((_regif_buf + uri_len), 0, (_regif_buf_len - uri_len));
+        flag = FLAG_SUCCESS;
+    }
+    else if (req_state == GCOAP_MEMO_TIMEOUT) {
+        flag = FLAG_TIMEOUT;
+    }
+
+end:
+    thread_flags_set((thread_t *)_waiter, flag);
+}
+
+static int _discover_internal(const sock_udp_ep_t *remote,
+                              char *regif, size_t maxlen)
+{
+    coap_pkt_t pkt;
+
+    /* save pointer to result buffer */
+    _regif_buf = regif;
+    _regif_buf_len = maxlen;
+
+    /* do URI discovery for the registration interface */
+    int res = gcoap_req_init(&pkt, buf, sizeof(buf), COAP_METHOD_GET,
+                             "/.well-known/core");
+    if (res < 0) {
+        return RDCLI_ERR;
+    }
+    coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON);
+    gcoap_add_qstring(&pkt, "rt", "core.rd");
+    size_t pkt_len = gcoap_finish(&pkt, 0, COAP_FORMAT_NONE);
+    res = gcoap_req_send2(buf, pkt_len, remote, _on_discover);
+    if (res < 0) {
+        return RDCLI_ERR;
+    }
+    return _sync();
+}
+
+int rdcli_discover_regif(const sock_udp_ep_t *remote, char *regif, size_t maxlen)
+{
+    assert(remote && regif);
+
+    _lock();
+    int res = _discover_internal(remote, regif, maxlen);
+    mutex_unlock(&_mutex);
+    return res;
+}
+
+int rdcli_register(const sock_udp_ep_t *remote, const char *regif)
+{
+    assert(remote);
+
+    int res;
+    ssize_t pkt_len;
+    int retval;
+    coap_pkt_t pkt;
+
+    _lock();
+
+    /* if no registration interface is given, we will need to trigger a URI
+     * discovery for it first (see section 5.2) */
+    if (regif == NULL) {
+        retval = _discover_internal(remote, _rd_regif, sizeof(_rd_regif));
+        if (retval != RDCLI_OK) {
+            goto end;
+        }
+    }
+    else {
+        if (strlen(_rd_regif) >= sizeof(_rd_regif)) {
+            retval = RDCLI_OVERFLOW;
+            goto end;
+        }
+        strncpy(_rd_regif, regif, sizeof(_rd_regif));
+    }
+
+    /* build and send CoAP POST request to the RD's registration interface */
+    res = gcoap_req_init(&pkt, buf, sizeof(buf), COAP_METHOD_POST, _rd_regif);
+    if (res < 0) {
+        retval = RDCLI_ERR;
+        goto end;
+    }
+    /* set some packet options and write query string */
+    coap_hdr_set_type(pkt.hdr, COAP_TYPE_CON);
+    rdcli_common_add_qstring(&pkt);
+
+    /* add the resource description as payload */
+    res = gcoap_get_resource_list(pkt.payload, pkt.payload_len,
+                                  COAP_FORMAT_LINK);
+    if (res < 0) {
+        retval = RDCLI_ERR;
+        goto end;
+    }
+
+    /* finish up the packet */
+    pkt_len = gcoap_finish(&pkt, res, COAP_FORMAT_LINK);
+
+    /* send out the request */
+    res = gcoap_req_send2(buf, pkt_len, remote, _on_register);
+    if (res < 0) {
+        retval = RDCLI_ERR;
+        goto end;
+    }
+    retval = _sync();
+
+end:
+    /* if we encountered any error, we mark the client as not connected */
+    if (retval != RDCLI_OK) {
+        _rd_loc[0] = '\0';
+    }
+#ifdef MODULE_RDCLI_STANDALONE
+    else {
+        rdcli_standalone_signal(true);
+    }
+#endif
+
+    mutex_unlock(&_mutex);
+    return retval;
+}
+
+int rdcli_update(void)
+{
+    _lock();
+    int res = _update_remove(COAP_METHOD_POST, _on_update);
+    if (res != RDCLI_OK) {
+        /* in case we are not able to reach the RD, we drop the association */
+#ifdef MODULE_RDCLI_STANDALONE
+        rdcli_standalone_signal(false);
+#endif
+        _rd_loc[0] = '\0';
+    }
+    mutex_unlock(&_mutex);
+    return res;
+}
+
+int rdcli_remove(void)
+{
+    _lock();
+    if (_rd_loc[0] == '\0') {
+        mutex_unlock(&_mutex);
+        return RDCLI_NORD;
+    }
+#ifdef MODULE_RDCLI_STANDALONE
+    rdcli_standalone_signal(false);
+#endif
+    _update_remove(COAP_METHOD_DELETE, _on_remove);
+    /* we actually do not care about the result, we drop the RD local RD entry
+     * in any case */
+    _rd_loc[0] = '\0';
+    mutex_unlock(&_mutex);
+    return RDCLI_OK;
+}
+
+void rdcli_dump_status(void)
+{
+    puts("CoAP RD connection status:");
+
+    if (_rd_loc[0] == 0) {
+        puts("  --- not registered with any RD ---");
+    }
+    else {
+        /* get address string */
+        char addr[IPV6_ADDR_MAX_STR_LEN];
+        ipv6_addr_to_str(addr, (ipv6_addr_t *)&_rd_remote.addr, sizeof(addr));
+
+        printf("RD address: coap://[%s]:%i\n", addr, (int)_rd_remote.port);
+        printf("   ep name: %s\n", rdcli_common_get_ep());
+        printf("  lifetime: %is\n", (int)RDCLI_LT);
+        printf("    reg if: %s\n", _rd_regif);
+        printf("  location: %s\n", _rd_loc);
+    }
+}

sys/net/application_layer/rdcli/rdcli_standalone.c

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2017-2018 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup     net_rdcli_simple
+ * @{
+ *
+ * @file
+ * @brief       Standalone extension for the simple RD registration client
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ *
+ * @}
+ */
+
+#include <stdint.h>
+
+#include "log.h"
+#include "assert.h"
+#include "thread.h"
+#include "xtimer.h"
+#include "net/rdcli.h"
+#include "net/rdcli_config.h"
+#include "net/rdcli_standalone.h"
+
+#define ENABLE_DEBUG    (0)
+#include "debug.h"
+
+/* stack configuration */
+#define STACKSIZE           (THREAD_STACKSIZE_DEFAULT)
+#define PRIO                (THREAD_PRIORITY_MAIN - 1)
+#define TNAME               "rdcli"
+
+#define UPDATE_TIMEOUT      (0xe537)
+
+#define TIMEOUT_US          ((uint64_t)(RDCLI_UPDATE_INTERVAL * US_PER_SEC))
+
+static char _stack[STACKSIZE];
+
+static xtimer_t _timer;
+static kernel_pid_t _runner_pid;
+static msg_t _msg;
+
+static rdcli_standalone_cb_t _cb = NULL;
+
+static void _set_timer(void)
+{
+    xtimer_set_msg64(&_timer, TIMEOUT_US, &_msg, _runner_pid);
+}
+
+static void _notify(rdcli_standalone_event_t event)
+{
+    if (_cb) {
+        _cb(event);
+    }
+}
+
+static void *_reg_runner(void *arg)
+{
+    (void)arg;
+    msg_t in;
+
+    /* prepare context and message */
+    _runner_pid = thread_getpid();
+    _msg.type = UPDATE_TIMEOUT;
+
+    while (1) {
+        DEBUG("rd stand: waiting for message\n");
+        msg_receive(&in);
+        if (in.type == UPDATE_TIMEOUT) {
+            if (rdcli_update() == RDCLI_OK) {
+                DEBUG("rd stand: update ok\n");
+                _set_timer();
+                _notify(RDCLI_UPDATED);
+            }
+            else {
+                _notify(RDCLI_DEREGISTERED);
+            }
+        }
+    }
+
+    return NULL;    /* should never be reached */
+}
+
+void rdcli_standalone_run(void)
+{
+    thread_create(_stack, sizeof(_stack), PRIO, 0, _reg_runner, NULL, TNAME);
+}
+
+void rdcli_standalone_signal(bool connected)
+{
+    /* clear timer in any case */
+    xtimer_remove(&_timer);
+    /* reset the update timer in case a connection was established or updated */
+    if (connected) {
+        _set_timer();
+        _notify(RDCLI_REGISTERED);
+    } else {
+        _notify(RDCLI_DEREGISTERED);
+    }
+}
+
+void rdcli_standalone_reg_cb(rdcli_standalone_cb_t cb)
+{
+    /* Note: we do not allow re-setting the callback (via passing cb := NULL),
+     *       as this would mean additional complexity for synchronizing the
+     *       value of `_cb` to prevent concurrency issues... */
+    assert(cb);
+    _cb = cb;
+}