service.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Meta
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_HTTP_SERVICE_H_
#define ZEPHYR_INCLUDE_NET_HTTP_SERVICE_H_

 
#include <zephyr/net/http/server.h>
#include <stdint.h>
#include <stddef.h>
 
#include <zephyr/sys/util_macro.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/net/tls_credentials.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct http_resource_desc {
        const char *resource;
        void *detail;
};

#define HTTP_RESOURCE_DEFINE(_name, _service, _resource, _detail)                                  \
        const STRUCT_SECTION_ITERABLE_ALTERNATE(http_resource_desc_##_service, http_resource_desc, \
                                                _name) = {                                         \
                .resource = _resource,                                                             \
                .detail = (void *)(_detail),                                                       \
        }

 
struct http_service_runtime_data {
        int num_clients;
};
 
struct http_service_desc;


typedef int (*http_socket_create_fn)(const struct http_service_desc *svc, int af, int proto);

enum http_version {
        HTTP_VERSION_ANY = 0,  
        HTTP_VERSION_1 = 0x01, 
        HTTP_VERSION_2 = 0x02, 
        HTTP_VERSION_3 = 0x04, 
};

enum http_h3_alt_svc_policy {
        HTTP_H3_ALT_SVC_DEFAULT = 0,
        HTTP_H3_ALT_SVC_DISABLE,
        HTTP_H3_ALT_SVC_ENABLE,
};

struct http_service_h3_config {
        enum http_h3_alt_svc_policy alt_svc_policy;
        bool enable_session_tickets;
        uint32_t max_early_data_size;
};

struct http_service_config {
        http_socket_create_fn socket_create;
        enum http_version http_ver;
        struct http_service_h3_config h3;
 
        /* If any more service-specific configuration is needed, it can be added here. */
};

 
struct http_service_desc {
        const char *host;
        uint16_t *port;
        int *fd;
        /* QUIC listening connection socket for HTTP/3. It is used to accept
         * new connections for this service.
         * Set to NULL if HTTP/3 is not supported, and set to -1 if HTTP/3 is
         * not yet initialized or enabled for this service. If HTTP/3 is supported then
         * this pointer cannot be null.
         */
        int *fd_h3;
        void *detail;
        size_t concurrent;
        size_t backlog;
        struct http_service_runtime_data *data;
        struct http_resource_desc *res_begin;
        struct http_resource_desc *res_end;
        struct http_resource_detail *res_fallback;
        const struct http_service_config *config;
#if defined(CONFIG_NET_SOCKETS_SOCKOPT_TLS)
        const sec_tag_t *sec_tag_list;
        size_t sec_tag_list_size;
#endif
};
 
#define __z_http_service_define(_name, _host, _port, _concurrent, _backlog, _detail,               \
                                _res_fallback, _res_begin, _res_end, _config, ...)                 \
        BUILD_ASSERT(_concurrent <= CONFIG_HTTP_SERVER_MAX_CLIENTS,                                \
                     "can't accept more then MAX_CLIENTS");                                        \
        BUILD_ASSERT(_backlog > 0, "backlog can't be 0");                                          \
        static int _name##_fd = -1;                                                                \
        IF_ENABLED(CONFIG_HTTP_SERVER_VERSION_3, (static int _name##_fd_h3 = -1;))                 \
        static struct http_service_runtime_data _name##_data = {0};                                \
        const STRUCT_SECTION_ITERABLE(http_service_desc, _name) = {                                \
                .host = _host,                                                                     \
                .port = (uint16_t *)(_port),                                                       \
                .fd = &_name##_fd,                                                                 \
                IF_ENABLED(CONFIG_HTTP_SERVER_VERSION_3, (.fd_h3 = &_name##_fd_h3,))               \
                .detail = (void *)(_detail),                                                       \
                .concurrent = (_concurrent),                                                       \
                .backlog = (_backlog),                                                             \
                .data = &_name##_data,                                                             \
                .res_begin = (_res_begin),                                                         \
                .res_end = (_res_end),                                                             \
                .res_fallback = (_res_fallback),                                                   \
                .config = (_config),                                                               \
                COND_CODE_1(CONFIG_NET_SOCKETS_SOCKOPT_TLS,                                        \
                            (.sec_tag_list = COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__), (NULL),  \
                                                         (GET_ARG_N(1, __VA_ARGS__))),), ())       \
                COND_CODE_1(CONFIG_NET_SOCKETS_SOCKOPT_TLS,                                        \
                            (.sec_tag_list_size = COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__), (0),\
                                             (GET_ARG_N(1, GET_ARGS_LESS_N(1, __VA_ARGS__))))), ())\
        }


#define HTTP_SERVICE_DEFINE_EMPTY(_name, _host, _port, _concurrent, _backlog, _detail,             \
                                  _res_fallback, _config)                                          \
        __z_http_service_define(_name, _host, _port, _concurrent, _backlog, _detail,               \
                                _res_fallback, NULL, NULL, _config)

#define HTTPS_SERVICE_DEFINE_EMPTY(_name, _host, _port, _concurrent, _backlog, _detail,          \
                                   _res_fallback, _config, _sec_tag_list, _sec_tag_list_size)    \
        __z_http_service_define(_name, _host, _port, _concurrent, _backlog, _detail,             \
                                _res_fallback, NULL, NULL, _config,                              \
                                _sec_tag_list, _sec_tag_list_size);                              \
        BUILD_ASSERT(IS_ENABLED(CONFIG_NET_SOCKETS_SOCKOPT_TLS),                                 \
                     "TLS is required for HTTP secure (CONFIG_NET_SOCKETS_SOCKOPT_TLS)")

#define HTTP_SERVICE_DEFINE(_name, _host, _port, _concurrent, _backlog, _detail, _res_fallback,    \
                            _config)                                                               \
        extern struct http_resource_desc _CONCAT(_http_resource_desc_##_name, _list_start)[];      \
        extern struct http_resource_desc _CONCAT(_http_resource_desc_##_name, _list_end)[];        \
        __z_http_service_define(_name, _host, _port, _concurrent, _backlog, _detail,               \
                                _res_fallback,                                                     \
                                &_CONCAT(_http_resource_desc_##_name, _list_start)[0],             \
                                &_CONCAT(_http_resource_desc_##_name, _list_end)[0], _config);

#define HTTPS_SERVICE_DEFINE(_name, _host, _port, _concurrent, _backlog, _detail,              \
                             _res_fallback, _config, _sec_tag_list, _sec_tag_list_size)        \
        extern struct http_resource_desc _CONCAT(_http_resource_desc_##_name, _list_start)[];  \
        extern struct http_resource_desc _CONCAT(_http_resource_desc_##_name, _list_end)[];    \
        __z_http_service_define(_name, _host, _port, _concurrent, _backlog, _detail,           \
                                _res_fallback,                                                 \
                                &_CONCAT(_http_resource_desc_##_name, _list_start)[0],         \
                                &_CONCAT(_http_resource_desc_##_name, _list_end)[0], _config,  \
                                _sec_tag_list, _sec_tag_list_size);                            \
        BUILD_ASSERT(IS_ENABLED(CONFIG_NET_SOCKETS_SOCKOPT_TLS),                               \
                     "TLS is required for HTTP secure (CONFIG_NET_SOCKETS_SOCKOPT_TLS)")

#define HTTP_SERVICE_COUNT(_dst) STRUCT_SECTION_COUNT(http_service_desc, _dst)

#define HTTP_SERVICE_RESOURCE_COUNT(_service) ((_service)->res_end - (_service)->res_begin)

#define HTTP_SERVICE_FOREACH(_it) STRUCT_SECTION_FOREACH(http_service_desc, _it)

#define HTTP_RESOURCE_FOREACH(_service, _it)                                                       \
        STRUCT_SECTION_FOREACH_ALTERNATE(http_resource_desc_##_service, http_resource_desc, _it)

#define HTTP_SERVICE_FOREACH_RESOURCE(_service, _it)                                               \
        for (struct http_resource_desc *_it = (_service)->res_begin; ({                            \
                     __ASSERT(_it <= (_service)->res_end, "unexpected list end location");         \
                     _it < (_service)->res_end;                                                    \
             });                                                                                   \
             _it++)
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NET_HTTP_SERVICE_H_ */