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 "byteorder.h"
#include "net/coap.h"
#else
#include "coap.h"
#include <arpa/inet.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_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_QS_MAX
#define CONFIG_NANOCOAP_QS_MAX             (64)
#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 *token;                                   
    uint8_t *payload;                                 
    uint16_t payload_len;                             
    uint16_t options_len;                             
    coap_optpos_t options[CONFIG_NANOCOAP_NOPTS_MAX]; 
#ifdef MODULE_GCOAP
    uint32_t observe_value;                           
#endif
} coap_pkt_t;

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

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 struct {
    size_t offset;                  
    uint32_t blknum;                
    unsigned szx;                   
    int more;                       
} coap_block1_t;

typedef struct {
    size_t start;                   
    size_t end;                     
    size_t cur;                     
    uint8_t *opt;                   
} coap_block_slicer_t;

extern const coap_resource_t coap_resources[];

extern const unsigned coap_resources_numof;


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

static inline unsigned coap_get_code_class(coap_pkt_t *pkt)
{
    return pkt->hdr->code >> 5;
}

static inline unsigned coap_get_code_detail(coap_pkt_t *pkt)
{
    return pkt->hdr->code & 0x1f;
}

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

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

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

static inline unsigned coap_get_token_len(const coap_pkt_t *pkt)
{
    return (pkt->hdr->ver_t_tkl & 0xf);
}

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_type(coap_pkt_t *pkt)
{
    return (pkt->hdr->ver_t_tkl & 0x30) >> 4;
}

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

static inline uint8_t *coap_hdr_data_ptr(coap_hdr_t *hdr)
{
    return ((uint8_t *)hdr) + sizeof(coap_hdr_t);
}

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;
}
unsigned coap_get_content_type(coap_pkt_t *pkt);

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

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

static inline ssize_t coap_get_location_path(const 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(const 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(const 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(const coap_pkt_t *pkt, uint8_t *target)
{
    return coap_opt_get_string(pkt, COAP_OPT_URI_QUERY, target,
                               CONFIG_NANOCOAP_URI_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(const coap_pkt_t *pkt, unsigned opt_num, uint8_t **value);
static inline ssize_t coap_get_proxy_uri(const 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);

void coap_block_finish(coap_block_slicer_t *slicer, uint16_t option);

static inline void coap_block1_finish(coap_block_slicer_t *slicer)
{
    coap_block_finish(slicer, COAP_OPT_BLOCK1);
}

static inline void coap_block2_finish(coap_block_slicer_t *slicer)
{
    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 uint8_t *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, unsigned *szx);

static inline unsigned coap_szx2size(unsigned szx)
{
    return (1 << (szx + 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_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 uint8_t *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, '/');
}

ssize_t coap_opt_finish(coap_pkt_t *pkt, uint16_t flags);
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(uint8_t *buf, uint16_t lastonum, uint16_t optnum,
                           const char *string, char 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, '&');
}

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 uint8_t *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, uint8_t *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);

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

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_reply_simple(coap_pkt_t *pkt,
                          unsigned code,
                          uint8_t *buf, size_t len,
                          unsigned ct,
                          const uint8_t *payload, uint8_t payload_len);

extern ssize_t coap_well_known_core_default_handler(coap_pkt_t *pkt, \
                                                    uint8_t *buf, size_t len,
                                                    void *context);
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 */