sys/net/nanocoap: add and use coap_get_response_hdr_len()

examples/nanocoap_server/coap_handler.c

@@ -41,19 +41,19 @@
                              (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;
     coap_block2_init(pkt, &slicer);
-    uint8_t *payload = buf + coap_get_total_hdr_len(pkt);
+    uint8_t *payload = buf + coap_get_response_hdr_len(pkt);
 
     uint8_t *bufpos = payload;
 
@@ -63,7 +63,7 @@
 
     /* 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
@@ -199,12 +199,12 @@
                                 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)) {
         puts("_separate_handler(): response already scheduled");
         return coap_build_reply(pkt, COAP_CODE_SERVICE_UNAVAILABLE, buf, len, 0);
     }

sys/include/net/nanocoap.h

@@ -677,6 +677,22 @@
            coap_get_token_len(pkt);
 }
 
+/**
+ * @brief   Get the header length a response to the given packet will have
+ *
+ * @param[in]   pkt     CoAP packet to reply to
+ * @return      Length of the response header including token excluding
+ *              CoAP options and any payload marker
+ *
+ * @note    The main use case is the use of @ref coap_block2_build_reply, which
+ *          is building the CoAP header of the response after options and
+ *          payload have been added.
+ */
+static inline unsigned coap_get_response_hdr_len(const coap_pkt_t *pkt)
+{
+    return coap_get_total_hdr_len(pkt);
+}
+
 /**
  * @brief   Write the given raw message code to given CoAP header
  *
@@ -1881,7 +1897,7 @@
  *
  * @returns     amount of bytes written to @p buf
  */
 size_t coap_put_option(uint8_t *buf, uint16_t lastonum, uint16_t onum, const void *odata, size_t olen);
 
 /**
  * @brief   Insert block1 option into buffer
@@ -1939,6 +1955,9 @@
  * @param[in]   payload_len length of payload
  * @param[in]   slicer      slicer to use
  *
+ * @warning Use @ref coap_get_response_hdr_len to determine the size of the
+ *          header this will write.
+ *
  * @returns     size of reply packet on success
  * @returns     <0 on error
  */
@@ -2320,4 +2339,4 @@
 }
 #endif
 #endif /* NET_NANOCOAP_H */
 /** @} */

sys/include/net/nanocoap_sock.h

@@ -110,10 +110,13 @@
  * Start with coap_block2_init() to read the client request and initialize a
  * coap_slicer_t struct with the size and location for this slice of the
  * overall payload. Then write the block2 option in the response with
- * coap_opt_put_block2(). The option includes an indicator ("more") that a
- * slice completes the overall payload transfer. You may not know the value for
- * _more_ at this point, but you must initialize the space in the packet for
- * the option before writing the payload. The option is rewritten later.
+ * coap_opt_put_block2(). Use @ref coap_get_response_hdr_len to get the length
+ * of the response header: This will be the offset in the buffer where you
+ * should start adding options. The Block2 option includes an indicator
+ * ("more") that a slice completes the overall payload transfer. You may not
+ * know the value for _more_ at this point, but you must initialize the space
+ * in the packet for the option before writing the payload. The option is
+ * rewritten later.
  *
  * Next, use the coap_blockwise_put_xxx() functions to write the payload
  * content. These functions use the coap_block_slicer_t to enable or disable

sys/net/application_layer/nanocoap/nanocoap.c

@@ -1415,7 +1415,7 @@ ssize_t coap_well_known_core_default_handler(coap_pkt_t *pkt, uint8_t *buf, \
     (void)context;
     coap_block_slicer_t slicer;
     coap_block2_init(pkt, &slicer);
-    uint8_t *payload = buf + coap_get_total_hdr_len(pkt);
+    uint8_t *payload = buf + coap_get_response_hdr_len(pkt);
     uint8_t *bufpos = payload;
     bufpos += coap_put_option_ct(bufpos, 0, COAP_FORMAT_LINK);
     bufpos += coap_opt_put_block2(bufpos, COAP_OPT_CONTENT_FORMAT, &slicer, 1);