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.
 */
 
#ifndef NET_NANOCOAP_H
#define NET_NANOCOAP_H
 
#include <assert.h>
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
 
#ifdef RIOT_VERSION
#include "bitarithm.h"
#include "bitfield.h"
#include "byteorder.h"
#include "iolist.h"
#include "macros/utils.h"
#include "net/coap.h"
#include "modules.h"
#else
#include "coap.h"
#include <arpa/inet.h>
#endif
 
#if defined(MODULE_SOCK_UDP) || defined(DOXYGEN)
#include "net/sock/udp.h"
#else
typedef void sock_udp_ep_t;
#endif
 
#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_hdr_t;
 
typedef struct {
    uint16_t opt_num;           
    uint16_t offset;            
} coap_optpos_t;
 
typedef struct {
    coap_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;    
    sock_udp_ep_t *remote;              
#if defined(MODULE_GCOAP) || DOXYGEN
    uint32_t tl_type;
#endif
};
 
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);
 
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;                   
} coap_block_slicer_t;
 
#if defined(MODULE_NANOCOAP_RESOURCES) || DOXYGEN
#define NANOCOAP_RESOURCE(name) \
    XFA_CONST(coap_resources_xfa, 0) coap_resource_t CONCAT(coap_resource_, name) =
#else
extern const coap_resource_t coap_resources[];
 
extern const unsigned coap_resources_numof;
#endif
 
static inline uint8_t coap_code(unsigned cls, unsigned detail)
{
    return (cls << 5) | detail;
}
 
static inline unsigned coap_get_code_class(const coap_pkt_t *pkt)
{
    return pkt->hdr->code >> 5;
}
 
static inline unsigned coap_get_code_detail(const coap_pkt_t *pkt)
{
    return pkt->hdr->code & 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 unsigned coap_get_code_raw(const coap_pkt_t *pkt)
{
    return (unsigned)pkt->hdr->code;
}
 
static inline coap_method_t coap_get_method(const coap_pkt_t *pkt)
{
    return pkt->hdr->code;
}
 
static inline unsigned coap_get_id(const coap_pkt_t *pkt)
{
    return ntohs(pkt->hdr->id);
}
 
static inline unsigned coap_get_token_len(const coap_pkt_t *pkt)
{
    uint8_t tkl = pkt->hdr->ver_t_tkl & 0xf;
 
    if (!IS_USED(MODULE_NANOCOAP_TOKEN_EXT)) {
        return tkl;
    }
 
    void *ext = pkt->hdr + 1;
    switch (tkl) {
    case 13:
        return tkl + *(uint8_t *)ext;
    case 14:
        return tkl + 255 + byteorder_bebuftohs(ext);
    case 15:
        assert(0);
        /* fall-through */
    default:
        return tkl;
    }
}
 
static inline uint8_t *coap_hdr_data_ptr(const coap_hdr_t *hdr);
 
static inline void *coap_get_token(const coap_pkt_t *pkt)
{
    return coap_hdr_data_ptr(pkt->hdr);
}
 
static inline unsigned coap_get_total_hdr_len(const coap_pkt_t *pkt)
{
    return sizeof(coap_hdr_t) + coap_get_token_len(pkt);
}
 
static inline unsigned coap_get_total_len(const coap_pkt_t *pkt)
{
    return (uintptr_t)pkt->payload - (uintptr_t)pkt->hdr + pkt->payload_len;
}
 
static inline unsigned coap_get_type(const coap_pkt_t *pkt)
{
    return (pkt->hdr->ver_t_tkl & 0x30) >> 4;
}
 
static inline unsigned coap_get_ver(const coap_pkt_t *pkt)
{
    return (pkt->hdr->ver_t_tkl & 0x60) >> 6;
}
 
static inline uint8_t coap_hdr_tkl_ext_len(const coap_hdr_t *hdr)
{
    if (!IS_USED(MODULE_NANOCOAP_TOKEN_EXT)) {
        return 0;
    }
 
    switch (hdr->ver_t_tkl & 0xf) {
    case 13:
        return 1;
    case 14:
        return 2;
    case 15:
        assert(0);
        /* fall-through */
    default:
        return 0;
    }
}
 
static inline uint8_t *coap_hdr_data_ptr(const coap_hdr_t *hdr)
{
    return ((uint8_t *)hdr) + sizeof(coap_hdr_t) + coap_hdr_tkl_ext_len(hdr);
}
 
static inline void coap_hdr_set_code(coap_hdr_t *hdr, uint8_t code)
{
    hdr->code = code;
}
 
static inline void coap_hdr_set_type(coap_hdr_t *hdr, unsigned type)
{
    /* assert correct range of type */
    assert(!(type & ~0x3));
 
    hdr->ver_t_tkl &= ~0x30;
    hdr->ver_t_tkl |= type << 4;
}
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,
                            uint8_t *target, size_t max_len, char separator);
 
static inline ssize_t coap_get_location_path(coap_pkt_t *pkt,
                                             uint8_t *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,
                                              uint8_t *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, uint8_t *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,
                               (uint8_t *)target, max_len, '&');
}
 
bool coap_find_uri_query(coap_pkt_t *pkt, const char *key,
                         const char **value, size_t *len);
 
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, uint16_t option);
 
static inline bool coap_block1_finish(coap_block_slicer_t *slicer)
{
    return coap_block_finish(slicer, COAP_OPT_BLOCK1);
}
 
static inline bool coap_block2_finish(coap_block_slicer_t *slicer)
{
    return coap_block_finish(slicer, COAP_OPT_BLOCK2);
}
 
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);
 
size_t coap_blockwise_put_bytes(coap_block_slicer_t *slicer, uint8_t *bufpos,
                                const void *c, size_t len);
 
size_t coap_blockwise_put_char(coap_block_slicer_t *slicer, uint8_t *bufpos, 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);
size_t coap_opt_put_block(uint8_t *buf, uint16_t lastonum, coap_block_slicer_t *slicer,
                          bool more, uint16_t option);
 
static inline size_t coap_opt_put_block1(uint8_t *buf, uint16_t lastonum,
                                         coap_block_slicer_t *slicer, bool more)
{
    return coap_opt_put_block(buf, lastonum, slicer, more, COAP_OPT_BLOCK1);
}
 
static inline size_t coap_opt_put_block2(uint8_t *buf, uint16_t lastonum,
                                         coap_block_slicer_t *slicer, bool more)
{
    return coap_opt_put_block(buf, lastonum, slicer, more, COAP_OPT_BLOCK2);
}
 
size_t coap_opt_put_uint(uint8_t *buf, uint16_t lastonum, uint16_t onum,
                         uint32_t value);
 
static inline size_t coap_opt_put_block1_control(uint8_t *buf, uint16_t lastonum,
                                                 coap_block1_t *block)
{
    return coap_opt_put_uint(buf, lastonum, COAP_OPT_BLOCK1,
                             (block->blknum << 4) | block->szx | (block->more ? 0x8 : 0));
}
 
static inline size_t coap_opt_put_block2_control(uint8_t *buf, uint16_t lastonum,
                                                 coap_block1_t *block)
{
    /* block.more must be zero, so no need to 'or' it in */
    return coap_opt_put_uint(buf, lastonum, COAP_OPT_BLOCK2,
                             (block->blknum << 4) | block->szx);
}
 
size_t coap_opt_put_string_with_len(uint8_t *buf, uint16_t lastonum, uint16_t optnum,
                                    const char *string, size_t len, char separator);
static inline size_t coap_opt_put_string(uint8_t *buf, uint16_t lastonum,
                                         uint16_t optnum,
                                         const char *string, char separator)
{
    return coap_opt_put_string_with_len(buf, lastonum, optnum,
                                        string, strlen(string), separator);
}
 
static inline size_t coap_opt_put_location_path(uint8_t *buf,
                                                uint16_t lastonum,
                                                const char *location)
{
    return coap_opt_put_string(buf, lastonum, COAP_OPT_LOCATION_PATH,
                               location, '/');
}
 
static inline size_t coap_opt_put_location_query(uint8_t *buf,
                                                 uint16_t lastonum,
                                                 const char *location)
{
    return coap_opt_put_string(buf, lastonum, COAP_OPT_LOCATION_QUERY,
                               location, '&');
}
 
static inline size_t coap_opt_put_uri_path(uint8_t *buf, uint16_t lastonum,
                                           const char *uri)
{
    return coap_opt_put_string(buf, lastonum, COAP_OPT_URI_PATH, uri, '/');
}
 
static inline size_t coap_opt_put_uri_query(uint8_t *buf, uint16_t lastonum,
                                            const char *uri)
{
    return coap_opt_put_string(buf, lastonum, COAP_OPT_URI_QUERY, uri, '&');
}
 
size_t coap_opt_put_uri_pathquery(uint8_t *buf, uint16_t *lastonum, const char *uri);
 
static inline size_t coap_opt_put_proxy_uri(uint8_t *buf, uint16_t lastonum,
                                            const char *uri)
{
    return coap_opt_put_string(buf, lastonum, COAP_OPT_PROXY_URI, uri, '\0');
}
 
size_t coap_put_block1_ok(uint8_t *pkt_pos, coap_block1_t *block1, uint16_t lastonum);
 
size_t coap_put_option(uint8_t *buf, uint16_t lastonum, uint16_t onum, const void *odata, size_t olen);
 
static inline size_t coap_put_option_block1(uint8_t *buf, uint16_t lastonum,
                                            unsigned blknum, unsigned szx, int more)
{
    return coap_opt_put_uint(buf, lastonum, COAP_OPT_BLOCK1,
                             (blknum << 4) | szx | (more ? 0x8 : 0));
}
 
static inline size_t coap_put_option_ct(uint8_t *buf, uint16_t lastonum,
                                        uint16_t content_type)
{
    return coap_opt_put_uint(buf, lastonum, COAP_OPT_CONTENT_FORMAT, content_type);
}
ssize_t coap_block2_build_reply(coap_pkt_t *pkt, unsigned code,
                                uint8_t *rbuf, unsigned rlen, unsigned payload_len,
                                coap_block_slicer_t *slicer);
 
ssize_t coap_build_hdr(coap_hdr_t *hdr, unsigned type, const void *token,
                       size_t token_len, unsigned code, uint16_t id);
 
ssize_t coap_build_reply(coap_pkt_t *pkt, unsigned code,
                         uint8_t *rbuf, unsigned rlen, unsigned payload_len);
 
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));
}
 
int coap_parse(coap_pkt_t *pkt, uint8_t *buf, size_t 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,
                                int ct,
                                void **payload, size_t *payload_len_max);
 
ssize_t coap_reply_simple(coap_pkt_t *pkt,
                          unsigned code,
                          uint8_t *buf, size_t len,
                          unsigned 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, uint8_t *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
#endif /* NET_NANOCOAP_H */