sys/net/nanocoap: Implement Observe (Server-Side)

examples/nanocoap_server/Makefile

@@ -20,7 +20,7 @@ USEMODULE += gnrc_icmpv6_echo
 USEMODULE += nanocoap_sock
 USEMODULE += nanocoap_resources
 
-USEMODULE += xtimer
+USEMODULE += ztimer_msec
 
 # include this for nicely formatting the returned internal value
 USEMODULE += fmt
@@ -48,10 +48,12 @@ HIGH_MEMORY_BOARDS := native native64 same54-xpro mcb2388
 
 ifneq (,$(filter $(BOARD),$(HIGH_MEMORY_BOARDS)))
   # enable separate response
-  USEMODULE += nanocoap_server_separate
   USEMODULE += event_callback
+  USEMODULE += event_periodic
   USEMODULE += event_thread
   USEMODULE += event_timeout_ztimer
+  USEMODULE += nanocoap_server_observe
+  USEMODULE += nanocoap_server_separate
 
   # enable fileserver
   USEMODULE += nanocoap_fileserver

examples/nanocoap_server/coap_handler.c

@@ -11,13 +11,13 @@
 #include <string.h>
 
 #include "event/callback.h"
-#include "event/timeout.h"
+#include "event/periodic.h"
 #include "event/thread.h"
+#include "event/timeout.h"
 #include "fmt.h"
 #include "net/nanocoap.h"
 #include "net/nanocoap_sock.h"
 #include "hashes/sha256.h"
-#include "kernel_defines.h"
 
 /* internal value that can be read/written via CoAP */
 static uint8_t internal_value = 0;
@@ -41,14 +41,14 @@
                              (uint8_t *)sub_uri, sub_uri_len);
 }
 
 static ssize_t _riot_board_handler(coap_pkt_t *pkt, uint8_t *buf, size_t len, coap_request_ctx_t *context)
 {
     (void)context;
     return coap_reply_simple(pkt, COAP_CODE_205, buf, len,
             COAP_FORMAT_TEXT, (uint8_t*)RIOT_BOARD, strlen(RIOT_BOARD));
 }
 
 static ssize_t _riot_block2_handler(coap_pkt_t *pkt, uint8_t *buf, size_t len, coap_request_ctx_t *context)
 {
     (void)context;
     coap_block_slicer_t slicer;
@@ -59,11 +59,11 @@
 
     bufpos += coap_put_option_ct(bufpos, 0, COAP_FORMAT_TEXT);
     bufpos += coap_opt_put_block2(bufpos, COAP_OPT_CONTENT_FORMAT, &slicer, 1);
-    *bufpos++ = 0xff;
+    *bufpos++ = COAP_PAYLOAD_MARKER;
 
     /* Add actual content */
     bufpos += coap_blockwise_put_bytes(&slicer, bufpos, block2_intro, sizeof(block2_intro)-1);
     bufpos += coap_blockwise_put_bytes(&slicer, bufpos, (uint8_t*)RIOT_VERSION, strlen(RIOT_VERSION));
     bufpos += coap_blockwise_put_char(&slicer, bufpos, ')');
     bufpos += coap_blockwise_put_bytes(&slicer, bufpos, block2_board, sizeof(block2_board)-1);
     bufpos += coap_blockwise_put_bytes(&slicer, bufpos, (uint8_t*)RIOT_BOARD, strlen(RIOT_BOARD));
@@ -81,7 +81,7 @@
                                    buf, len, payload_len, &slicer);
 }
 
 static ssize_t _riot_value_handler(coap_pkt_t *pkt, uint8_t *buf, size_t len, coap_request_ctx_t *context)
 {
     (void) context;
 
@@ -92,7 +92,7 @@
     /* read coap method type in packet */
     unsigned method_flag = coap_method2flag(coap_get_code_detail(pkt));
 
     switch(method_flag) {
     case COAP_GET:
         /* write the response buffer with the internal value */
         p += fmt_u32_dec(rsp, internal_value);
@@ -177,7 +177,7 @@
     .path = "/riot/board", .methods = COAP_GET, .handler = _riot_board_handler
 };
 NANOCOAP_RESOURCE(value) {
     .path = "/riot/value", .methods = COAP_GET | COAP_PUT | COAP_POST, .handler = _riot_value_handler
 };
 NANOCOAP_RESOURCE(ver) {
     .path = "/riot/ver", .methods = COAP_GET, .handler = _riot_block2_handler
@@ -196,15 +196,20 @@
 
     puts("_separate_handler(): send delayed response");
     nanocoap_server_send_separate(ctx, COAP_CODE_CONTENT, COAP_TYPE_NON,
-                                response, sizeof(response));
+                                  response, sizeof(response));
 }
 
 static ssize_t _separate_handler(coap_pkt_t *pkt, uint8_t *buf, size_t len, coap_request_ctx_t *context)
 {
     static event_timeout_t event_timeout;
     static event_callback_t event_timed = EVENT_CALLBACK_INIT(_send_response, &_separate_ctx);
 
-    if (event_timeout_is_pending(&event_timeout) && !sock_udp_ep_equal(context->remote, &_separate_ctx.remote)) {
+    if (event_timeout_is_pending(&event_timeout)) {
+        if (nanocoap_server_is_remote_in_response_ctx(&_separate_ctx, context)) {
+            /* duplicate of the request a separate response is already scheduled
+             * for --> resending the ACK */
+            return coap_build_empty_ack(pkt, (void *)buf);
+        }
         puts("_separate_handler(): response already scheduled");
         return coap_build_reply(pkt, COAP_CODE_SERVICE_UNAVAILABLE, buf, len, 0);
     }
@@ -229,6 +234,107 @@
 };
 #endif /* MODULE_EVENT_THREAD */
 
+#ifdef MODULE_NANOCOAP_SERVER_OBSERVE
+static ssize_t _time_handler(coap_pkt_t *pkt, uint8_t *buf, size_t len, coap_request_ctx_t *context)
+{
+    uint32_t obs;
+    bool registered = false;
+    if (coap_opt_get_uint(pkt, COAP_OPT_OBSERVE, &obs)) {
+        /* No (valid) observe option present */
+        obs = UINT32_MAX;
+    }
+
+    uint32_t now = ztimer_now(ZTIMER_MSEC);
+
+    switch (obs) {
+    case 0:
+        /* register */
+        if (nanocoap_register_observer(context, pkt) == 0) {
+            registered = true;
+        }
+        break;
+    case 1:
+        /* unregister */
+        nanocoap_unregister_observer(context, pkt);
+        break;
+    default:
+        /* No (valid) observe option present --> ignore observe and handle
+         * as regular GET */
+        break;
+    }
+
+    const size_t estimated_data_len =
+        4       /* Max Observe Option size */
+        + 1     /* payload marker */
+        + 10    /* strlen("4294967295"), 4294967295 == UINT32_MAX */
+        + 1;    /* '\n' */
+    ssize_t hdr_len = coap_build_reply(pkt, COAP_CODE_CONTENT, buf, len, estimated_data_len);
+
+    if (hdr_len < 0) {
+        /* we undo any potential registration if we cannot reply */
+        nanocoap_unregister_observer(context, pkt);
+        return len;
+    }
+
+    if (hdr_len == 0) {
+        /* no response required, probably because of no-response option matching
+         * the response class */
+        return 0;
+    }
+
+    /* coap_build_reply() is a bit goofy: It returns the size of the written
+     * header + `estiamted_data_len`, so we have to subtract it again to obtain
+     * the size of data written. */
+    uint8_t *pos = buf + hdr_len - estimated_data_len;
+
+    if (registered) {
+        uint16_t last_opt = 0;
+        pos += coap_opt_put_observe(pos, last_opt, now);
+    }
+    *pos++ = COAP_PAYLOAD_MARKER;
+    pos += fmt_u32_dec((void *)pos, now);
+    *pos++ = '\n';
+
+    return (uintptr_t)pos - (uintptr_t)buf;
+}
+
+NANOCOAP_RESOURCE(time) {
+    .path = "/time", .methods = COAP_GET, .handler = _time_handler,
+};
+
+static void _notify_observer_handler(event_t *ev)
+{
+    (void)ev;
+    uint32_t now = ztimer_now(ZTIMER_MSEC);
+    uint8_t buf[32];
+    uint8_t *pos = buf;
+    uint16_t last_opt = 0;
+    pos += coap_opt_put_observe(pos, last_opt, now);
+    *pos++ = COAP_PAYLOAD_MARKER;
+    pos += fmt_u32_dec((void *)pos, now);
+    *pos++ = '\n';
+    iolist_t data = {
+        .iol_base = buf,
+        .iol_len = (uintptr_t)pos - (uintptr_t)buf,
+    };
+
+    /* `NANOCOAP_RESOURCE(time)` expends to XFA magic adding an entry named
+     * `coap_resource_time`. */
+    nanocoap_notify_observers(&coap_resource_time, &data);
+}
+
+void setup_observe_event(void)
+{
+    static event_t ev = {
+        .handler = _notify_observer_handler
+    };
+    static event_periodic_t pev;
+
+    event_periodic_init(&pev, ZTIMER_MSEC, EVENT_PRIO_MEDIUM, &ev);
+    event_periodic_start(&pev, MS_PER_SEC);
+}
+#endif /* MODULE_NANOCOAP_SERVER_OBSERVE */
+
 /* we can also include the fileserver module */
 #ifdef MODULE_NANOCOAP_FILESERVER
 #include "net/nanocoap/fileserver.h"

examples/nanocoap_server/main.c

@@ -20,13 +20,15 @@
 #include <stdio.h>
 
 #include "net/nanocoap_sock.h"
-#include "xtimer.h"
+#include "ztimer.h"
 
 #define COAP_INBUF_SIZE (256U)
 
 #define MAIN_QUEUE_SIZE     (8)
 static msg_t _main_msg_queue[MAIN_QUEUE_SIZE];
 
+extern void setup_observe_event(void);
+
 int main(void)
 {
     puts("RIOT nanocoap example application");
@@ -35,7 +37,11 @@ int main(void)
     msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);
 
     puts("Waiting for address autoconfiguration...");
-    xtimer_sleep(3);
+    ztimer_sleep(ZTIMER_MSEC, 3 * MS_PER_SEC);
+
+    if (IS_USED(MODULE_NANOCOAP_SERVER_OBSERVE)) {
+        setup_observe_event();
+    }
 
     /* print network addresses */
     printf("{\"IPv6 addresses\": [\"");

sys/Makefile.dep

@@ -529,6 +529,10 @@ ifneq (,$(filter nanocoap_server_auto_init,$(USEMODULE)))
   USEMODULE += nanocoap_server
 endif
 
+ifneq (,$(filter nanocoap_server_observe,$(USEMODULE)))
+  USEMODULE += nanocoap_server_separate
+endif
+
 ifneq (,$(filter nanocoap_server_separate,$(USEMODULE)))
   USEMODULE += nanocoap_server
   USEMODULE += sock_aux_local

sys/include/net/coap.h

@@ -354,7 +354,7 @@
 #define COAP_FORMAT_SWID_CBOR               (258)
 /**
  * @brief   Content-Type `application/pkixcmp`
  * @see     [draft-ietf-ace-cmpv2-coap-transport](https://datatracker.ietf.org/doc/draft-ietf-ace-cmpv2-coap-transport/)
  * @see     [RFC 4210](https://datatracker.ietf.org/doc/html/rfc4210)
  */
 #define COAP_FORMAT_PKIXCMP                 (259)
@@ -441,12 +441,12 @@
 #define COAP_FORMAT_YAML_DATA_CBOR_ID_NAME  (341)
 /**
  * @brief   Content-Type `application/td+json`
  * @see     [Web of Things (WoT) Thing Description 1.1](https://www.w3.org/TR/wot-thing-description11/)
  */
 #define COAP_FORMAT_TD_JSON                 (432)
 /**
  * @brief   Content-Type `application/tm+json`
  * @see     [Web of Things (WoT) Thing Description 1.1](https://www.w3.org/TR/wot-thing-description11/)
  */
 #define COAP_FORMAT_TM_JSON                 (433)
 /**
@@ -519,6 +519,7 @@
  */
 #define COAP_OBS_REGISTER        (0)
 #define COAP_OBS_DEREGISTER      (1)
+#define COAP_OBS_MAX_VALUE_MASK  (0xffffff) /**< observe value is 24 bits */
 /** @} */
 
 /**

sys/include/net/nanocoap.h

@@ -1790,6 +1790,22 @@
                              (block->blknum << 4) | block->szx);
 }
 
+/**
+ * @brief   Insert an CoAP Observe Option into the buffer
+ *
+ * @param[out]  buf         Buffer to write to
+ * @param[in]   lastonum    last option number (must be < 6)
+ * @param[in]   obs         observe number to write
+ *
+ * @param[in]   lastonum    last option number (must be < 27)
+ */
+static inline size_t coap_opt_put_observe(uint8_t *buf, uint16_t lastonum,
+                                          uint32_t obs)
+{
+    obs &= COAP_OBS_MAX_VALUE_MASK; /* trim obs down to 24 bit */
+    return coap_opt_put_uint(buf, lastonum, COAP_OPT_OBSERVE, obs);
+}
+
 /**
  * @brief   Encode the given string as multi-part option into buffer
  *