coap_service.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Basalte bv
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_COAP_SERVICE_H_
#define ZEPHYR_INCLUDE_NET_COAP_SERVICE_H_
 
#include <zephyr/net/coap.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/net/tls_credentials.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define COAP_SERVICE_AUTOSTART          BIT(0)
 
struct coap_service_data {
        int sock_fd;
        struct coap_observer observers[CONFIG_COAP_SERVICE_OBSERVERS];
        struct coap_pending pending[CONFIG_COAP_SERVICE_PENDING_MESSAGES];
};
 
struct coap_service {
        const char *name;
        const char *host;
        uint16_t *port;
        uint8_t flags;
        struct coap_resource *res_begin;
        struct coap_resource *res_end;
        struct coap_service_data *data;
#if defined(CONFIG_NET_SOCKETS_ENABLE_DTLS)
        const sec_tag_t *sec_tag_list;
        size_t sec_tag_list_size;
#endif
};
 
#if defined(CONFIG_NET_SOCKETS_ENABLE_DTLS)
#define __z_coap_service_secure(_sec_tag_list, _sec_tag_list_size)                              \
                .sec_tag_list = _sec_tag_list,                                                  \
                .sec_tag_list_size = _sec_tag_list_size,
#else
#define __z_coap_service_secure(...)
#endif
 
#define __z_coap_service_define(_name, _host, _port, _flags, _res_begin, _res_end,              \
                                _sec_tag_list, _sec_tag_list_size)                              \
        static struct coap_service_data _CONCAT(coap_service_data_, _name) = {                  \
                .sock_fd = -1,                                                                  \
        };                                                                                      \
        const STRUCT_SECTION_ITERABLE(coap_service, _name) = {                                  \
                .name = STRINGIFY(_name),                                                       \
                .host = _host,                                                                  \
                .port = (uint16_t *)(_port),                                                    \
                .flags = _flags,                                                                \
                .res_begin = (_res_begin),                                                      \
                .res_end = (_res_end),                                                          \
                .data = &_CONCAT(coap_service_data_, _name),                                    \
                __z_coap_service_secure(_sec_tag_list, _sec_tag_list_size)                      \
        }
 
#define COAP_RESOURCE_DEFINE(_name, _service, ...)                                              \
        STRUCT_SECTION_ITERABLE_ALTERNATE(_CONCAT(coap_resource_, _service), coap_resource,     \
                                          _name) = __VA_ARGS__
#define COAP_RESOURCE_DEFINE(_name, _service, ...)                                              \ …
 
#define COAP_SERVICE_DEFINE(_name, _host, _port, _flags)                                        \
        extern struct coap_resource _CONCAT(_CONCAT(_coap_resource_, _name), _list_start)[];    \
        extern struct coap_resource _CONCAT(_CONCAT(_coap_resource_, _name), _list_end)[];      \
        __z_coap_service_define(_name, _host, _port, _flags,                                    \
                                &_CONCAT(_CONCAT(_coap_resource_, _name), _list_start)[0],      \
                                &_CONCAT(_CONCAT(_coap_resource_, _name), _list_end)[0],        \
                                NULL, 0)
#define COAP_SERVICE_DEFINE(_name, _host, _port, _flags)                                        \ …
 
#define COAPS_SERVICE_DEFINE(_name, _host, _port, _flags, _sec_tag_list, _sec_tag_list_size)    \
        BUILD_ASSERT(IS_ENABLED(CONFIG_NET_SOCKETS_ENABLE_DTLS),                                \
                     "DTLS is required for CoAP secure (CONFIG_NET_SOCKETS_ENABLE_DTLS)");      \
        extern struct coap_resource _CONCAT(_CONCAT(_coap_resource_, _name), _list_start)[];    \
        extern struct coap_resource _CONCAT(_CONCAT(_coap_resource_, _name), _list_end)[];      \
        __z_coap_service_define(_name, _host, _port, _flags,                                    \
                                &_CONCAT(_CONCAT(_coap_resource_, _name), _list_start)[0],      \
                                &_CONCAT(_CONCAT(_coap_resource_, _name), _list_end)[0],        \
                                _sec_tag_list, _sec_tag_list_size)
#define COAPS_SERVICE_DEFINE(_name, _host, _port, _flags, _sec_tag_list, _sec_tag_list_size)    \ …
 
#define COAP_SERVICE_COUNT(_dst) STRUCT_SECTION_COUNT(coap_service, _dst)
 
#define COAP_SERVICE_RESOURCE_COUNT(_service) ((_service)->res_end - (_service)->res_begin)
 
#define COAP_SERVICE_HAS_RESOURCE(_service, _resource)                                          \
        ((_service)->res_begin <= _resource && _resource < (_service)->res_end)
#define COAP_SERVICE_HAS_RESOURCE(_service, _resource)                                          \ …
 
#define COAP_SERVICE_FOREACH(_it) STRUCT_SECTION_FOREACH(coap_service, _it)
 
#define COAP_RESOURCE_FOREACH(_service, _it)                                                    \
        STRUCT_SECTION_FOREACH_ALTERNATE(_CONCAT(coap_resource_, _service), coap_resource, _it)
#define COAP_RESOURCE_FOREACH(_service, _it)                                                    \ …
 
#define COAP_SERVICE_FOREACH_RESOURCE(_service, _it)                                            \
        for (struct coap_resource *_it = (_service)->res_begin; ({                              \
                __ASSERT(_it <= (_service)->res_end, "unexpected list end location");           \
                _it < (_service)->res_end;                                                      \
        }); _it++)
#define COAP_SERVICE_FOREACH_RESOURCE(_service, _it)                                            \ …
 
int coap_service_start(const struct coap_service *service);
 
int coap_service_stop(const struct coap_service *service);
 
int coap_service_is_running(const struct coap_service *service);
 
int coap_service_send(const struct coap_service *service, const struct coap_packet *cpkt,
                      const struct sockaddr *addr, socklen_t addr_len,
                      const struct coap_transmission_parameters *params);
 
int coap_resource_send(const struct coap_resource *resource, const struct coap_packet *cpkt,
                       const struct sockaddr *addr, socklen_t addr_len,
                       const struct coap_transmission_parameters *params);
 
int coap_resource_parse_observe(struct coap_resource *resource, const struct coap_packet *request,
                                const struct sockaddr *addr);
 
int coap_resource_remove_observer_by_addr(struct coap_resource *resource,
                                          const struct sockaddr *addr);
 
int coap_resource_remove_observer_by_token(struct coap_resource *resource,
                                           const uint8_t *token, uint8_t token_len);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_COAP_SERVICE_H_ */