nanocoap_sock.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017 Kaspar Schleiser <kaspar@schleiser.de>
 *               2018 Inria
 *               2018 Freie Universität Berlin
 *
 * 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 <stdint.h>
#include <unistd.h>
 
#include "random.h"
#include "net/nanocoap.h"
#include "net/sock/udp.h"
#include "net/sock/util.h"
#if IS_USED(MODULE_NANOCOAP_DTLS)
#include "net/credman.h"
#include "net/sock/dtls.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

#ifndef CONFIG_NANOCOAP_SOCK_DTLS_TAG
#define CONFIG_NANOCOAP_SOCK_DTLS_TAG           (0xc0ab)
#endif

#ifndef CONFIG_NANOCOAP_SERVER_BUF_SIZE
#define CONFIG_NANOCOAP_SERVER_BUF_SIZE         ((1 << (CONFIG_NANOCOAP_BLOCKSIZE_DEFAULT + 3)) \
                                                 + CONFIG_NANOCOAP_URI_MAX + 16)
#endif

#ifndef CONFIG_NANOCOAP_SERVER_STACK_SIZE
#define CONFIG_NANOCOAP_SERVER_STACK_SIZE       THREAD_STACKSIZE_DEFAULT
#endif

#ifndef CONFIG_NANOCOAP_SOCK_BLOCK_TOKEN
#define CONFIG_NANOCOAP_SOCK_BLOCK_TOKEN        (0)
#endif

#ifndef CONFIG_NANOCOAP_SOCK_EVENT_PRIO
#  define CONFIG_NANOCOAP_SOCK_EVENT_PRIO       EVENT_PRIO_MEDIUM
#endif

typedef enum {
    COAP_SOCKET_TYPE_UDP,                   
    COAP_SOCKET_TYPE_DTLS,                  
} nanocoap_socket_type_t;

typedef struct {
    sock_udp_t udp;                         
#if IS_USED(MODULE_NANOCOAP_DTLS) || defined(DOXYGEN)
    sock_dtls_t dtls;                       
    sock_dtls_session_t dtls_session;       
    nanocoap_socket_type_t type;            
#endif
    uint16_t msg_id;                        
    uint8_t hdr_buf[CONFIG_NANOCOAP_BLOCK_HEADER_MAX]; 
} nanocoap_sock_t;

typedef struct {
    nanocoap_sock_t *sock;          
    const char *path;               
    uint32_t blknum;                
    coap_method_t method;           
    uint8_t blksize;                
} coap_block_request_t;

typedef struct {
    coap_request_cb_t cb;           
    void *arg;                      
    nanocoap_sock_t sock;           
} coap_observe_client_t;

typedef struct {
    sock_udp_ep_t remote;           
    sock_udp_ep_t local;            
    uint8_t token[COAP_TOKEN_LENGTH_MAX];   
    uint8_t tkl;                    
    uint8_t no_response;            
} nanocoap_server_response_ctx_t;

int nanocoap_server_prepare_separate(nanocoap_server_response_ctx_t *ctx,
                                     coap_pkt_t *pkt, const coap_request_ctx_t *req);

bool nanocoap_server_is_remote_in_response_ctx(const nanocoap_server_response_ctx_t *ctx,
                                               const coap_request_ctx_t *req);

int nanocoap_server_send_separate(const nanocoap_server_response_ctx_t *ctx,
                                  unsigned code, unsigned type,
                                  const void *payload, size_t len);

ssize_t nanocoap_server_build_separate(const nanocoap_server_response_ctx_t *ctx,
                                       void *buf, size_t buf_len,
                                       unsigned code, unsigned type,
                                       uint16_t msg_id);

int nanocoap_server_sendv_separate(const nanocoap_server_response_ctx_t *ctx,
                                   const iolist_t *reply);

int nanocoap_register_observer(const coap_request_ctx_t *req_ctx, coap_pkt_t *req_pkt);

void nanocoap_unregister_observer(const coap_request_ctx_t *req_ctx,
                                  const coap_pkt_t *req_pkt);

void nanocoap_unregister_observer_due_to_reset(const sock_udp_ep_t *ep,
                                               uint16_t msg_id);

void nanocoap_notify_observers(const coap_resource_t *res, const iolist_t *iol);

void nanocoap_notify_observers_simple(const coap_resource_t *res, uint32_t obs,
                                      const void *payload, size_t payload_len);

static inline uint16_t nanocoap_sock_next_msg_id(nanocoap_sock_t *sock)
{
    return sock->msg_id++;
}

int nanocoap_server(sock_udp_ep_t *local, void *buf, size_t bufsize);

kernel_pid_t nanocoap_server_start(const sock_udp_ep_t *local);

static inline int nanocoap_sock_connect(nanocoap_sock_t *sock,
                                        const sock_udp_ep_t *local,
                                        const sock_udp_ep_t *remote)
{
#if IS_USED(MODULE_NANOCOAP_DTLS)
    sock->type = COAP_SOCKET_TYPE_UDP;
#endif
    sock->msg_id = random_uint32();
 
    return sock_udp_create(&sock->udp, local, remote, 0);
}
 
#if IS_USED(MODULE_NANOCOAP_DTLS) || DOXYGEN
int nanocoap_sock_dtls_connect(nanocoap_sock_t *sock, sock_udp_ep_t *local,
                               const sock_udp_ep_t *remote, credman_tag_t tag);
#endif

int nanocoap_sock_url_connect(const char *url, nanocoap_sock_t *sock);

static inline void nanocoap_sock_close(nanocoap_sock_t *sock)
{
#if IS_USED(MODULE_NANOCOAP_DTLS)
    if (sock->type == COAP_SOCKET_TYPE_DTLS) {
        sock_dtls_session_destroy(&sock->dtls, &sock->dtls_session);
        sock_dtls_close(&sock->dtls);
    }
#endif
    sock_udp_close(&sock->udp);
}

WARN_UNUSED_RESULT
int nanocoap_sock_builder_init_token(nanocoap_sock_t *sock, coap_builder_t *state,
                                     uint8_t type, uint8_t method,
                                     const void *token, size_t token_len);

WARN_UNUSED_RESULT
static inline int nanocoap_sock_builder_init(nanocoap_sock_t *sock, coap_builder_t *state,
                                             uint8_t type, uint8_t method)
{
    return nanocoap_sock_builder_init_token(sock, state, type, method, NULL, 0);
}

ssize_t nanocoap_sock_observe_url(const char *url, coap_observe_client_t *ctx,
                                  coap_request_cb_t cb, void *arg);
ssize_t nanocoap_sock_unobserve_url(const char *url, coap_observe_client_t *ctx);

ssize_t nanocoap_sock_get(nanocoap_sock_t *sock, const char *path,
                          void *response, size_t len_max);

ssize_t nanocoap_sock_get_non(nanocoap_sock_t *sock, const char *path,
                              void *response, size_t len_max);

ssize_t nanocoap_sock_put(nanocoap_sock_t *sock, const char *path,
                          const void *request, size_t len,
                          void *response, size_t len_max);

ssize_t nanocoap_sock_put_non(nanocoap_sock_t *sock, const char *path,
                              const void *request, size_t len,
                              void *response, size_t len_max);

ssize_t nanocoap_sock_put_url(const char *url,
                              const void *request, size_t len,
                              void *response, size_t len_max);

ssize_t nanocoap_sock_post(nanocoap_sock_t *sock, const char *path,
                           const void *request, size_t len,
                           void *response, size_t len_max);

ssize_t nanocoap_sock_post_non(nanocoap_sock_t *sock, const char *path,
                               const void *request, size_t len,
                               void *response, size_t len_max);

ssize_t nanocoap_sock_post_url(const char *url,
                               const void *request, size_t len,
                               void *response, size_t len_max);

ssize_t nanocoap_sock_fetch(nanocoap_sock_t *sock, const char *path,
                            const void *request, size_t len,
                            void *response, size_t len_max);

ssize_t nanocoap_sock_fetch_non(nanocoap_sock_t *sock, const char *path,
                                const void *request, size_t len,
                                void *response, size_t len_max);

ssize_t nanocoap_sock_fetch_url(const char *url,
                                const void *request, size_t len,
                                void *response, size_t len_max);

ssize_t nanocoap_sock_delete(nanocoap_sock_t *sock, const char *path);

ssize_t nanocoap_sock_delete_url(const char *url);

int nanocoap_sock_get_blockwise(nanocoap_sock_t *sock, const char *path,
                                coap_blksize_t blksize,
                                coap_blockwise_cb_t callback, void *arg);

int nanocoap_sock_get_slice(nanocoap_sock_t *sock, const char *path,
                            coap_blksize_t blksize, size_t offset,
                            void *dst, size_t len);

int nanocoap_get_blockwise_url(const char *url,
                               coap_blksize_t blksize,
                               coap_blockwise_cb_t callback, void *arg);

ssize_t nanocoap_get_blockwise_url_to_buf(const char *url,
                                          coap_blksize_t blksize,
                                          void *buf, size_t len);

ssize_t nanocoap_get_blockwise_to_buf(nanocoap_sock_t *sock, const char *path,
                                      coap_blksize_t blksize,
                                      void *buf, size_t len);

ssize_t nanocoap_sock_request(nanocoap_sock_t *sock, coap_pkt_t *pkt, size_t len);

ssize_t nanocoap_sock_request_cb(nanocoap_sock_t *sock, coap_pkt_t *pkt,
                                 coap_request_cb_t cb, void *arg);

ssize_t nanocoap_request(coap_pkt_t *pkt, const sock_udp_ep_t *local,
                         const sock_udp_ep_t *remote, size_t len);

static inline int nanocoap_block_request_connect_url(coap_block_request_t *ctx,
                                                     nanocoap_sock_t *sock,
                                                     const char *url,
                                                     coap_method_t method,
                                                     coap_blksize_t blksize)
{
    ctx->sock = sock;
    ctx->path = sock_urlpath(url);
    ctx->blknum = 0;
    ctx->method = method;
    ctx->blksize = blksize;
    return nanocoap_sock_url_connect(url, ctx->sock);
}

int nanocoap_sock_block_request(coap_block_request_t *req,
                                const void *data, size_t len, bool more,
                                coap_request_cb_t callback, void *arg);
#ifdef __cplusplus
}
#endif