nanocoap.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016-18 Kaspar Schleiser <kaspar@schleiser.de>
 *               2018 Freie Universität Berlin
 *               2018 Inria
 *               2018 Ken Bannister <kb2ma@runbox.com>
 *
 * 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.
 */
 
#pragma once

 
#include <assert.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
 
#include "bitarithm.h"
#include "bitfield.h"
#include "byteorder.h"
#include "iolist.h"
#include "macros/utils.h"
#include "modules.h"
#include "net/coap.h"
#include "net/sock/udp.h"
 
#if defined(MODULE_NANOCOAP_RESOURCES)
#include "xfa.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

#define COAP_GET                (0x01)
#define COAP_POST               (0x02)
#define COAP_PUT                (0x04)
#define COAP_DELETE             (0x08)
#define COAP_FETCH              (0x10)
#define COAP_PATCH              (0x20)
#define COAP_IPATCH             (0x40)
#define COAP_IGNORE             (0xFF)   
#define COAP_MATCH_SUBTREE      (0x8000) 

#define COAP_FORMAT_NONE        (UINT16_MAX)

#ifndef CONFIG_NANOCOAP_NOPTS_MAX
#define CONFIG_NANOCOAP_NOPTS_MAX          (16)
#endif

#ifndef CONFIG_NANOCOAP_URI_MAX
#define CONFIG_NANOCOAP_URI_MAX            (64)
#endif

#ifndef CONFIG_NANOCOAP_BLOCK_SIZE_EXP_MAX
#define CONFIG_NANOCOAP_BLOCK_SIZE_EXP_MAX  (6)
#endif

#ifndef CONFIG_NANOCOAP_BLOCKSIZE_DEFAULT
#define CONFIG_NANOCOAP_BLOCKSIZE_DEFAULT  COAP_BLOCKSIZE_64
#endif

#ifndef CONFIG_NANOCOAP_QS_MAX
#define CONFIG_NANOCOAP_QS_MAX             (64)
#endif

#ifndef CONFIG_NANOCOAP_BLOCK_HEADER_MAX
#define CONFIG_NANOCOAP_BLOCK_HEADER_MAX   (80)
#endif

#define COAP_OPT_FINISH_NONE     (0x0000)
#define COAP_OPT_FINISH_PAYLOAD  (0x0001)

typedef struct __attribute__((packed)) {
    uint8_t ver_t_tkl;          
    uint8_t code;               
    uint16_t id;                
} coap_udp_hdr_t;

typedef coap_udp_hdr_t coap_hdr_t;

typedef struct {
    uint16_t opt_num;           
    uint16_t offset;            
} coap_optpos_t;

typedef struct {
    union {
        uint8_t *buf;
        coap_udp_hdr_t *hdr;
    };
    uint8_t *payload;                                 
    iolist_t *snips;                                  
    uint16_t payload_len;                             
    uint16_t options_len;                             
    coap_optpos_t options[CONFIG_NANOCOAP_NOPTS_MAX]; 
    BITFIELD(opt_crit, CONFIG_NANOCOAP_NOPTS_MAX);    
#ifdef MODULE_GCOAP
    uint32_t observe_value;                           
#endif
} coap_pkt_t;

typedef struct _coap_request_ctx coap_request_ctx_t;

typedef ssize_t (*coap_handler_t)(coap_pkt_t *pkt, uint8_t *buf, size_t len,
                                  coap_request_ctx_t *context);

typedef int (*coap_blockwise_cb_t)(void *arg, size_t offset, uint8_t *buf, size_t len, int more);

typedef int (*coap_request_cb_t)(void *arg, coap_pkt_t *pkt);

typedef uint16_t coap_method_flags_t;

typedef struct {
    const char *path;               
    coap_method_flags_t methods;    
    coap_handler_t handler;         
    void *context;                  
} coap_resource_t;

typedef const struct {
    const coap_resource_t *resources;   
    const size_t resources_numof;       
} coap_resource_subtree_t;

void coap_request_ctx_init(coap_request_ctx_t *ctx, sock_udp_ep_t *remote);

struct _coap_request_ctx {
    const coap_resource_t *resource;    
    union {
        sock_udp_ep_t *remote_udp;      
        sock_udp_ep_t *remote;          
    };
#if defined(MODULE_SOCK_AUX_LOCAL) || DOXYGEN
    union {
        sock_udp_ep_t *local_udp;       
        sock_udp_ep_t *local;           
    };
#endif
#if defined(MODULE_GCOAP) || DOXYGEN
    uint32_t tl_type;
#endif
};
 
/* forward declarations */
static inline uint8_t *coap_hdr_data_ptr(const coap_udp_hdr_t *hdr);
static inline size_t coap_hdr_get_token_len(const coap_udp_hdr_t *hdr);
static inline const void *coap_hdr_get_token(const coap_udp_hdr_t *hdr);

const char *coap_request_ctx_get_path(const coap_request_ctx_t *ctx);

void *coap_request_ctx_get_context(const coap_request_ctx_t *ctx);

uint32_t coap_request_ctx_get_tl_type(const coap_request_ctx_t *ctx);

const sock_udp_ep_t *coap_request_ctx_get_remote_udp(const coap_request_ctx_t *ctx);

const sock_udp_ep_t *coap_request_ctx_get_local_udp(const coap_request_ctx_t *ctx);

typedef struct {
    uint8_t *buf;           
    uint16_t pos;           
    uint16_t size;          
    uint16_t last_opt_num;  
} coap_builder_t;

typedef struct {
    size_t offset;                  
    uint32_t blknum;                
    uint8_t szx;                    
    int8_t more;                    
} coap_block1_t;

typedef struct {
    size_t start;                   
    size_t end;                     
    size_t cur;                     
    uint8_t *opt_value;             
} coap_block_slicer_t;
 
#if defined(MODULE_NANOCOAP_RESOURCES) || DOXYGEN
#define NANOCOAP_RESOURCE(name) \
    XFA_CONST(coap_resource_t, coap_resources_xfa, 0) CONCAT(coap_resource_, name) =
#else
extern const coap_resource_t coap_resources[];

extern const unsigned coap_resources_numof;
#endif

static inline coap_udp_hdr_t *coap_get_udp_hdr(coap_pkt_t *pkt)
{
    /* currently only UDP as transport supported */
    return (coap_udp_hdr_t *)pkt->buf;
}

static inline const coap_udp_hdr_t *coap_get_udp_hdr_const(const coap_pkt_t *pkt)
{
    /* currently only UDP as transport supported */
    return (const coap_udp_hdr_t *)pkt->buf;
}

static inline uint8_t coap_code(unsigned cls, unsigned detail)
{
    return (cls << 5) | detail;
}

static inline unsigned coap_get_code_raw(const coap_pkt_t *pkt)
{
    return coap_get_udp_hdr_const(pkt)->code;
}

static inline unsigned coap_get_code_class(const coap_pkt_t *pkt)
{
    return coap_get_code_raw(pkt) >> 5;
}

static inline unsigned coap_get_code_detail(const coap_pkt_t *pkt)
{
    return coap_get_code_raw(pkt) & 0x1f;
}

static inline unsigned coap_get_code_decimal(const coap_pkt_t *pkt)
{
    return (coap_get_code_class(pkt) * 100) + coap_get_code_detail(pkt);
}

static inline coap_method_t coap_get_method(const coap_pkt_t *pkt)
{
    return coap_get_code_raw(pkt);
}

static inline unsigned coap_get_id(const coap_pkt_t *pkt)
{
    return ntohs(coap_get_udp_hdr_const(pkt)->id);
}

static inline void coap_set_id(coap_pkt_t *pkt, uint16_t id)
{
    coap_get_udp_hdr(pkt)->id = htons(id);
}

static inline unsigned coap_get_token_len(const coap_pkt_t *pkt)
{
    return coap_hdr_get_token_len((const coap_udp_hdr_t *)pkt->buf);
}

static inline void *coap_get_token(const coap_pkt_t *pkt)
{
    return coap_hdr_data_ptr(coap_get_udp_hdr_const(pkt));
}

static inline unsigned coap_get_total_len(const coap_pkt_t *pkt)
{
    return (uintptr_t)pkt->payload - (uintptr_t)pkt->buf + pkt->payload_len;
}

static inline unsigned coap_get_type(const coap_pkt_t *pkt)
{
    return (coap_get_udp_hdr_const(pkt)->ver_t_tkl & 0x30) >> 4;
}

static inline unsigned coap_get_ver(const coap_pkt_t *pkt)
{
    return (coap_get_udp_hdr_const(pkt)->ver_t_tkl & 0x60) >> 6;
}

static inline uint8_t coap_hdr_tkl_ext_len(const coap_udp_hdr_t *hdr)
{
    if (!IS_USED(MODULE_NANOCOAP_TOKEN_EXT)) {
        return 0;
    }
 
    switch (hdr->ver_t_tkl & 0x0f) {
    case 13:
        return 1;
    case 14:
        return 2;
    case 15:
        assert(0);
        /* fall-through */
    default:
        return 0;
    }
}

static inline uint8_t coap_pkt_tkl_ext_len(const coap_pkt_t *pkt)
{
    return coap_hdr_tkl_ext_len(coap_get_udp_hdr_const(pkt));
}

bool coap_is_hdr_in_bounds(const coap_pkt_t *pkt, size_t len);

static inline uint8_t *coap_hdr_data_ptr(const coap_udp_hdr_t *hdr)
{
    return ((uint8_t *)hdr) + sizeof(coap_udp_hdr_t) + coap_hdr_tkl_ext_len(hdr);
}

static inline unsigned coap_get_total_hdr_len(const coap_pkt_t *pkt)
{
    return sizeof(coap_udp_hdr_t) + coap_hdr_tkl_ext_len(pkt->hdr) +
           coap_get_token_len(pkt);
}

static inline unsigned coap_get_response_hdr_len(const coap_pkt_t *pkt)
{
    return coap_get_total_hdr_len(pkt);
}

static inline void coap_hdr_set_code(coap_udp_hdr_t *hdr, uint8_t code)
{
    hdr->code = code;
}

static inline void coap_pkt_set_code(coap_pkt_t *pkt, uint8_t code)
{
    coap_hdr_set_code(coap_get_udp_hdr(pkt), code);
}

static inline void coap_hdr_set_type(coap_udp_hdr_t *hdr, unsigned type)
{
    /* assert correct range of type */
    assert(!(type & ~0x3));
 
    hdr->ver_t_tkl &= ~0x30;
    hdr->ver_t_tkl |= type << 4;
}

static inline size_t coap_hdr_get_token_len(const coap_udp_hdr_t *hdr)
{
    const uint8_t *buf = (const void *)hdr;
    /* Regarding use unnamed magic numbers 13 and 269:
     * - If token length is < 13 it fits into TKL field (4 bit)
     * - If token length is < 269 it fits into 8-bit extended TKL field
     * - Otherwise token length goes into 16-bit extended TKL field.
     *
     * (Not using named constants here, as RFC 8974 also has no names for those
     * magic numbers.)
     *
     * See: https://www.rfc-editor.org/rfc/rfc8974#name-extended-token-length-tkl-f
     */
    switch (coap_hdr_tkl_ext_len(hdr)) {
    case 0:
        return hdr->ver_t_tkl & 0x0f;
    case 1:
        return buf[sizeof(coap_udp_hdr_t)] + 13;
    case 2:
        return byteorder_bebuftohs(buf + sizeof(coap_udp_hdr_t)) + 269;
    }
 
    return 0;
}

static inline const void * coap_hdr_get_token(const coap_udp_hdr_t *hdr)
{
    uint8_t *token = (void *)hdr;
    token += sizeof(*hdr) + coap_hdr_tkl_ext_len(hdr);
    return token;
}

static inline size_t coap_hdr_len(const coap_udp_hdr_t *hdr)
{
    return sizeof(*hdr) + coap_hdr_tkl_ext_len(hdr) + coap_hdr_get_token_len(hdr);
}

static inline void coap_pkt_set_type(coap_pkt_t *pkt, unsigned type)
{
    coap_udp_hdr_t *hdr = coap_get_udp_hdr(pkt);
 
    if (hdr) {
        coap_hdr_set_type(hdr, type);
    }
}

static inline void coap_pkt_set_tkl(coap_pkt_t *pkt, uint8_t tkl)
{
    coap_udp_hdr_t * hdr = coap_get_udp_hdr(pkt);
    hdr->ver_t_tkl &= 0xf0;
    hdr->ver_t_tkl |= (tkl & 0x0f);
}



uint8_t *coap_find_option(coap_pkt_t *pkt, unsigned opt_num);

uint8_t *coap_iterate_option(coap_pkt_t *pkt, unsigned opt_num,
                             uint8_t **opt_pos, int *opt_len);

unsigned coap_get_content_type(coap_pkt_t *pkt);

unsigned coap_get_accept(coap_pkt_t *pkt);

int coap_opt_get_uint(coap_pkt_t *pkt, uint16_t optnum, uint32_t *value);

ssize_t coap_opt_get_string(coap_pkt_t *pkt, uint16_t optnum,
                            char *target, size_t max_len, char separator);

static inline ssize_t coap_get_location_path(coap_pkt_t *pkt,
                                             char *target, size_t max_len)
{
    return coap_opt_get_string(pkt, COAP_OPT_LOCATION_PATH,
                               target, max_len, '/');
}

static inline ssize_t coap_get_location_query(coap_pkt_t *pkt,
                                              char *target, size_t max_len)
{
    return coap_opt_get_string(pkt, COAP_OPT_LOCATION_QUERY,
                               target, max_len, '&');
}

static inline ssize_t coap_get_uri_path(coap_pkt_t *pkt, char *target)
{
    return coap_opt_get_string(pkt, COAP_OPT_URI_PATH, target,
                               CONFIG_NANOCOAP_URI_MAX, '/');
}

static inline ssize_t coap_get_uri_query_string(coap_pkt_t *pkt, char *target,
                                                size_t max_len)
{
    return coap_opt_get_string(pkt, COAP_OPT_URI_QUERY,
                               target, max_len, '&');
}

bool coap_find_uri_query(coap_pkt_t *pkt, const char *key,
                         const char **value, size_t *len);

int coap_iterate_uri_query(coap_pkt_t *pkt, void **ctx,
                           char *key, size_t key_len_max,
                           char *value, size_t value_len_max);

ssize_t coap_opt_get_next(const coap_pkt_t *pkt, coap_optpos_t *opt,
                          uint8_t **value, bool init_opt);

ssize_t coap_opt_get_opaque(coap_pkt_t *pkt, unsigned opt_num, uint8_t **value);

static inline ssize_t coap_get_proxy_uri(coap_pkt_t *pkt, char **target)
{
    return coap_opt_get_opaque(pkt, COAP_OPT_PROXY_URI, (uint8_t **)target);
}

void coap_block_object_init(coap_block1_t *block, size_t blknum, size_t blksize,
                            int more);

bool coap_block_finish(coap_block_slicer_t *slicer);

static inline bool coap_block1_finish(coap_block_slicer_t *slicer)
{
    return coap_block_finish(slicer);
}

static inline bool coap_block2_finish(coap_block_slicer_t *slicer)
{
    return coap_block_finish(slicer);
}

void coap_block2_init(coap_pkt_t *pkt, coap_block_slicer_t *slicer);

void coap_block_slicer_init(coap_block_slicer_t *slicer, size_t blknum,
                            size_t blksize);

int coap_blockwise_put_bytes(coap_builder_t *state, coap_block_slicer_t *slicer,
                             const void *c, size_t len);

int coap_blockwise_put_bytes_pkt(coap_pkt_t *pdu, coap_block_slicer_t *slicer,
                                 const void *c, size_t len);

int coap_blockwise_put_char(coap_builder_t *state, coap_block_slicer_t *slicer, char c);

int coap_blockwise_put_char_pkt(coap_pkt_t *pdu, coap_block_slicer_t *slicer, char c);

int coap_get_block(coap_pkt_t *pkt, coap_block1_t *block, uint16_t option);

static inline int coap_get_block1(coap_pkt_t *pkt, coap_block1_t *block)
{
    return coap_get_block(pkt, block, COAP_OPT_BLOCK1);
}

static inline int coap_get_block2(coap_pkt_t *pkt, coap_block1_t *block)
{
    return coap_get_block(pkt, block, COAP_OPT_BLOCK2);
}

int coap_get_blockopt(coap_pkt_t *pkt, uint16_t option, uint32_t *blknum, uint8_t *szx);

bool coap_has_unprocessed_critical_options(const coap_pkt_t *pkt);

#define coap_szx2size(szx) (1U << ((szx) + 4))

static inline unsigned coap_size2szx(unsigned len)
{
    assert(len >= 16);
    return bitarithm_msb(len >> 4);
}


ssize_t coap_opt_add_block(coap_pkt_t *pkt, coap_block_slicer_t *slicer,
                           bool more, uint16_t option);

static inline ssize_t coap_opt_add_block1(coap_pkt_t *pkt,
                                          coap_block_slicer_t *slicer, bool more)
{
    return coap_opt_add_block(pkt, slicer, more, COAP_OPT_BLOCK1);
}

static inline ssize_t coap_opt_add_block2(coap_pkt_t *pkt,
                                          coap_block_slicer_t *slicer, bool more)
{
    return coap_opt_add_block(pkt, slicer, more, COAP_OPT_BLOCK2);
}

ssize_t coap_opt_add_uint(coap_pkt_t *pkt, uint16_t optnum, uint32_t value);

static inline ssize_t coap_opt_add_block1_control(coap_pkt_t *pkt, coap_block1_t *block) {
    return coap_opt_add_uint(pkt, COAP_OPT_BLOCK1,
                             (block->blknum << 4) | block->szx | (block->more ? 0x8 : 0));
}

static inline ssize_t coap_opt_add_block2_control(coap_pkt_t *pkt, coap_block1_t *block) {
    /* block.more must be zero, so no need to 'or' it in */
    return coap_opt_add_uint(pkt, COAP_OPT_BLOCK2,
                             (block->blknum << 4) | block->szx);
}

static inline ssize_t coap_opt_add_accept(coap_pkt_t *pkt, uint16_t format)
{
    return coap_opt_add_uint(pkt, COAP_OPT_ACCEPT, format);
}

static inline ssize_t coap_opt_add_format(coap_pkt_t *pkt, uint16_t format)
{
    return coap_opt_add_uint(pkt, COAP_OPT_CONTENT_FORMAT, format);
}

ssize_t coap_opt_add_opaque(coap_pkt_t *pkt, uint16_t optnum, const void *val, size_t val_len);

ssize_t coap_opt_add_uri_query2(coap_pkt_t *pkt, const char *key, size_t key_len,
                                const char *val, size_t val_len);

static inline ssize_t coap_opt_add_uri_query(coap_pkt_t *pkt, const char *key,
                                             const char *val)
{
    return coap_opt_add_uri_query2(pkt, key, strlen(key), val, val ? strlen(val) : 0);
}

ssize_t coap_opt_add_proxy_uri(coap_pkt_t *pkt, const char *uri);

ssize_t coap_opt_add_chars(coap_pkt_t *pkt, uint16_t optnum, const char *chars,
                           size_t chars_len, char separator);

static inline ssize_t coap_opt_add_string(coap_pkt_t *pkt, uint16_t optnum,
                                          const char *string, char separator)
{
    return coap_opt_add_chars(pkt, optnum, string, strlen(string), separator);
}

static inline ssize_t coap_opt_add_uri_path(coap_pkt_t *pkt, const char *path)
{
    return coap_opt_add_string(pkt, COAP_OPT_URI_PATH, path, '/');
}

static inline ssize_t coap_opt_add_uri_path_buffer(coap_pkt_t *pkt,
                                                   const char *path,
                                                   size_t path_len)
{
    return coap_opt_add_chars(pkt, COAP_OPT_URI_PATH, path, path_len, '/');
}

ssize_t coap_opt_finish(coap_pkt_t *pkt, uint16_t flags);

ssize_t coap_opt_remove(coap_pkt_t *pkt, uint16_t optnum);

int coap_builder_init(coap_builder_t *state, void *buf, size_t buf_len,
                      size_t header_len);

static inline bool coap_builder_has_overflown(const coap_builder_t *state)
{
    return (state->size == 0);
}

static inline ssize_t coap_builder_msg_size(const coap_builder_t *state)
{
    if (coap_builder_has_overflown(state)) {
        return -EOVERFLOW;
    }
 
    return state->pos;
}

static inline size_t coap_builder_buf_size(const coap_builder_t *state)
{
    return state->size;
}

static inline size_t coap_builder_buf_remaining(const coap_builder_t *state)
{
    if (state->size > state->pos) {
        return state->size - state->pos;
    }
 
    return 0;
}

WARN_UNUSED_RESULT
int coap_builder_init_reply(coap_builder_t *state, void *buf, size_t buf_len,
                            coap_pkt_t *req, uint8_t code);

int coap_builder_add_payload(coap_builder_t *state, const void *pld, size_t pld_len);

void * coap_builder_allocate_payload(coap_builder_t *state, size_t pld_len);

static inline int coap_builder_add_payload_marker(coap_builder_t *state)
{
    return coap_builder_add_payload(state, NULL, 0);
}

int coap_opt_put_block(coap_builder_t *state, coap_block_slicer_t *slicer,
                       uint16_t option);

static inline int coap_opt_put_block1(coap_builder_t *state,
                                      coap_block_slicer_t *slicer)
{
    return coap_opt_put_block(state, slicer, COAP_OPT_BLOCK1);
}

static inline int coap_opt_put_block2(coap_builder_t *state,
                                      coap_block_slicer_t *slicer)
{
    return coap_opt_put_block(state, slicer, COAP_OPT_BLOCK2);
}

int coap_opt_put_uint(coap_builder_t *state, uint16_t onum, uint32_t value);

static inline int coap_opt_put_block1_control(coap_builder_t *state,
                                              coap_block1_t *block)
{
    return coap_opt_put_uint(state, COAP_OPT_BLOCK1,
                             (block->blknum << 4) | block->szx | (block->more ? 0x8 : 0));
}

static inline int coap_opt_put_block2_control(coap_builder_t *state,
                                              coap_block1_t *block)
{
    /* block.more must be zero, so no need to 'or' it in */
    return coap_opt_put_uint(state, COAP_OPT_BLOCK2,
                             (block->blknum << 4) | block->szx);
}

static inline int coap_opt_put_observe(coap_builder_t *state, uint32_t obs)
{
    obs &= COAP_OBS_MAX_VALUE_MASK; /* trim obs down to 24 bit */
    return coap_opt_put_uint(state, COAP_OPT_OBSERVE, obs);
}

int coap_opt_put_string_with_len(coap_builder_t *state, uint16_t optnum,
                                 const char *string, size_t len, char separator);
static inline int coap_opt_put_string(coap_builder_t *state, uint16_t optnum,
                                      const char *string, char separator)
{
    return coap_opt_put_string_with_len(state, optnum,
                                        string, strlen(string), separator);
}

static inline int coap_opt_put_location_path(coap_builder_t *state,
                                             const char *location)
{
    return coap_opt_put_string(state, COAP_OPT_LOCATION_PATH,
                               location, '/');
}

static inline int coap_opt_put_location_query(coap_builder_t *state,
                                              const char *location)
{
    return coap_opt_put_string(state, COAP_OPT_LOCATION_QUERY,
                               location, '&');
}

static inline int coap_opt_put_uri_path(coap_builder_t *state, const char *uri)
{
    return coap_opt_put_string(state, COAP_OPT_URI_PATH, uri, '/');
}

static inline int coap_opt_put_uri_query(coap_builder_t *state,
                                         const char *uri_query)
{
    return coap_opt_put_string(state, COAP_OPT_URI_QUERY, uri_query, '&');
}

int coap_opt_put_uri_pathquery(coap_builder_t *state, const char *uri);

static inline int coap_opt_put_proxy_uri(coap_builder_t *state, const char *uri)
{
    return coap_opt_put_string(state, COAP_OPT_PROXY_URI, uri, '\0');
}

int coap_put_block1_ok(coap_builder_t *state, coap_block1_t *block1);

int coap_opt_put(coap_builder_t *state, uint16_t onum, const void *odata, size_t olen);

static inline int coap_opt_put_block1_raw(coap_builder_t *state,
                                          unsigned blknum, unsigned szx, int more)
{
    return coap_opt_put_uint(state, COAP_OPT_BLOCK1,
                             (blknum << 4) | szx | (more ? 0x8 : 0));
}

static inline int coap_opt_put_ct(coap_builder_t *state, uint16_t content_type)
{
    return coap_opt_put_uint(state, COAP_OPT_CONTENT_FORMAT, content_type);
}


ssize_t coap_build_udp_hdr(void *buf, size_t buf_len, uint8_t type, const void *token,
                           size_t token_len, uint8_t code, uint16_t id);
static inline ssize_t coap_build_hdr(coap_udp_hdr_t *hdr, unsigned type, const void *token,
                                     size_t token_len, unsigned code, uint16_t id)
{
    size_t fingers_crossed_size = sizeof(*hdr) + token_len;
 
    if (IS_USED(MODULE_NANOCOAP_TOKEN_EXT)) {
        /* With RFC 8974, we have an additional extended TKL
         * field of 0-4 bytes in length */
        fingers_crossed_size += 4;
    }
 
    return coap_build_udp_hdr(hdr, fingers_crossed_size, type, token, token_len, code, id);
}

ssize_t coap_build_reply(coap_pkt_t *pkt, unsigned code,
                         uint8_t *rbuf, unsigned rlen, unsigned max_data_len);

ssize_t coap_build_empty_ack(const coap_pkt_t *pkt, coap_udp_hdr_t *ack);

ssize_t coap_handle_req(coap_pkt_t *pkt, uint8_t *resp_buf, unsigned resp_buf_len,
                        coap_request_ctx_t *ctx);

ssize_t coap_tree_handler(coap_pkt_t *pkt, uint8_t *resp_buf,
                          unsigned resp_buf_len, coap_request_ctx_t *ctx,
                          const coap_resource_t *resources,
                          size_t resources_numof);

ssize_t coap_subtree_handler(coap_pkt_t *pkt, uint8_t *resp_buf,
                             size_t resp_buf_len, coap_request_ctx_t *context);

static inline coap_method_flags_t coap_method2flag(unsigned code)
{
    return (1 << (code - 1));
}

ssize_t coap_parse_udp(coap_pkt_t *pkt, uint8_t *buf, size_t len);

static inline ssize_t coap_parse(coap_pkt_t *pkt, uint8_t *buf, size_t len)
{
    return coap_parse_udp(pkt, buf, len);
}

void coap_pkt_init(coap_pkt_t *pkt, uint8_t *buf, size_t len, size_t header_len);

static inline void coap_payload_advance_bytes(coap_pkt_t *pkt, size_t len)
{
    pkt->payload += len;
    pkt->payload_len -= len;
}

ssize_t coap_payload_put_bytes(coap_pkt_t *pkt, const void *data, size_t len);

ssize_t coap_payload_put_char(coap_pkt_t *pkt, char c);

ssize_t coap_build_reply_header(coap_pkt_t *pkt, unsigned code,
                                void *buf, size_t len, uint16_t ct,
                                void **payload, size_t *payload_len_max);

ssize_t coap_reply_simple(coap_pkt_t *pkt,
                          uint8_t code,
                          uint8_t *buf, size_t len,
                          uint16_t ct,
                          const void *payload, size_t payload_len);

extern ssize_t coap_well_known_core_default_handler(coap_pkt_t *pkt, \
                                                    uint8_t *buf, size_t len,
                                                    coap_request_ctx_t *context);

#ifndef CONFIG_NANOCOAP_SERVER_WELL_KNOWN_CORE
#define CONFIG_NANOCOAP_SERVER_WELL_KNOWN_CORE !IS_USED(MODULE_GCOAP)
#endif

int coap_match_path(const coap_resource_t *resource, const char *uri);
 
#if defined(MODULE_GCOAP) || defined(DOXYGEN)
static inline bool coap_has_observe(coap_pkt_t *pkt)
{
    return pkt->observe_value != UINT32_MAX;
}

static inline void coap_clear_observe(coap_pkt_t *pkt)
{
    pkt->observe_value = UINT32_MAX;
}

static inline uint32_t coap_get_observe(coap_pkt_t *pkt)
{
    return pkt->observe_value;
}

#endif

#define COAP_WELL_KNOWN_CORE_DEFAULT_HANDLER \
    { \
        .path = "/.well-known/core", \
        .methods = COAP_GET, \
        .handler = coap_well_known_core_default_handler \
    }
 
#ifdef __cplusplus
}
#endif