server.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, Emna Rekik
 * Copyright (c) 2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_HTTP_SERVER_H_
#define ZEPHYR_INCLUDE_NET_HTTP_SERVER_H_
 
#include <stdint.h>
 
#include <zephyr/kernel.h>
#include <zephyr/net/http/parser.h>
#include <zephyr/net/http/hpack.h>
#include <zephyr/net/http/status.h>
#include <zephyr/net/socket.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(CONFIG_HTTP_SERVER)
#define HTTP_SERVER_CLIENT_BUFFER_SIZE   CONFIG_HTTP_SERVER_CLIENT_BUFFER_SIZE
#define HTTP_SERVER_MAX_STREAMS          CONFIG_HTTP_SERVER_MAX_STREAMS
#define HTTP_SERVER_MAX_CONTENT_TYPE_LEN CONFIG_HTTP_SERVER_MAX_CONTENT_TYPE_LENGTH
#define HTTP_SERVER_MAX_URL_LENGTH       CONFIG_HTTP_SERVER_MAX_URL_LENGTH
#define HTTP_SERVER_MAX_HEADER_LEN       CONFIG_HTTP_SERVER_MAX_HEADER_LEN
#else
#define HTTP_SERVER_CLIENT_BUFFER_SIZE   0
#define HTTP_SERVER_MAX_STREAMS          0
#define HTTP_SERVER_MAX_CONTENT_TYPE_LEN 0
#define HTTP_SERVER_MAX_URL_LENGTH       0
#define HTTP_SERVER_MAX_HEADER_LEN       0
#endif
 
#if defined(CONFIG_HTTP_SERVER_CAPTURE_HEADERS)
#define HTTP_SERVER_CAPTURE_HEADER_BUFFER_SIZE CONFIG_HTTP_SERVER_CAPTURE_HEADER_BUFFER_SIZE
#define HTTP_SERVER_CAPTURE_HEADER_COUNT       CONFIG_HTTP_SERVER_CAPTURE_HEADER_COUNT
#else
#define HTTP_SERVER_CAPTURE_HEADER_BUFFER_SIZE 0
#define HTTP_SERVER_CAPTURE_HEADER_COUNT       0
#endif
 
#define HTTP2_PREFACE "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 
enum http_resource_type {
        HTTP_RESOURCE_TYPE_STATIC,
 
        HTTP_RESOURCE_TYPE_STATIC_FS,
 
        HTTP_RESOURCE_TYPE_DYNAMIC,
 
        HTTP_RESOURCE_TYPE_WEBSOCKET,
};
enum http_resource_type {…};
 
struct http_resource_detail {
        uint32_t bitmask_of_supported_http_methods;
 
        enum http_resource_type type;
 
        int path_len;
 
        const char *content_encoding;
 
        const char *content_type;
};
struct http_resource_detail {…};
 
BUILD_ASSERT(NUM_BITS(
             sizeof(((struct http_resource_detail *)0)->bitmask_of_supported_http_methods))
             >= (HTTP_METHOD_END_VALUE - 1));
struct http_resource_detail_static {
        struct http_resource_detail common;
 
        const void *static_data;
 
        size_t static_data_len;
};
struct http_resource_detail_static {…};
 
/* Make sure that the common is the first in the struct. */
BUILD_ASSERT(offsetof(struct http_resource_detail_static, common) == 0);
struct http_resource_detail_static_fs {
        struct http_resource_detail common;
 
        const char *fs_path;
};
struct http_resource_detail_static_fs {…};
 
enum http_compression {
        HTTP_NONE = 0,     
        HTTP_GZIP = 1,     
        HTTP_COMPRESS = 2, 
        HTTP_DEFLATE = 3,  
        HTTP_BR = 4,       
        HTTP_ZSTD = 5      
};
enum http_compression {…};
 
/* Make sure that the common is the first in the struct. */
BUILD_ASSERT(offsetof(struct http_resource_detail_static_fs, common) == 0);
struct http_content_type {
        const char *extension;
        size_t extension_len;
        const char *content_type;
};
struct http_content_type {…};
 
#define HTTP_SERVER_CONTENT_TYPE(_extension, _content_type)                                        \
        const STRUCT_SECTION_ITERABLE(http_content_type, _extension) = {                           \
                .extension = STRINGIFY(_extension),                                                \
                .extension_len = sizeof(STRINGIFY(_extension)) - 1,                                \
                .content_type = _content_type,                                                     \
        };
#define HTTP_SERVER_CONTENT_TYPE(_extension, _content_type)                                        \ …
 
#define HTTP_SERVER_CONTENT_TYPE_FOREACH(_it) STRUCT_SECTION_FOREACH(http_content_type, _it)
 
struct http_client_ctx;
 
enum http_data_status {
        HTTP_SERVER_DATA_ABORTED = -1,
        HTTP_SERVER_DATA_MORE = 0,
        HTTP_SERVER_DATA_FINAL = 1,
};
enum http_data_status {…};
 
enum http_header_status {
        HTTP_HEADER_STATUS_OK,      
        HTTP_HEADER_STATUS_DROPPED, 
        HTTP_HEADER_STATUS_NONE,    
};
enum http_header_status {…};
 
struct http_header {
        const char *name;  
        const char *value; 
};
struct http_header {…};
 
struct http_request_ctx {
        uint8_t *data;                          
        size_t data_len;                        
        struct http_header *headers;            
        size_t header_count;                    
        enum http_header_status headers_status; 
};
struct http_request_ctx {…};
 
struct http_response_ctx {
        enum http_status status;           
        const struct http_header *headers; 
        size_t header_count;               
        const uint8_t *body;               
        size_t body_len;                   
        bool final_chunk; 
};
struct http_response_ctx {…};
 
typedef int (*http_resource_dynamic_cb_t)(struct http_client_ctx *client,
                                          enum http_data_status status,
                                          const struct http_request_ctx *request_ctx,
                                          struct http_response_ctx *response_ctx,
                                          void *user_data);
 
struct http_resource_detail_dynamic {
        struct http_resource_detail common;
 
        http_resource_dynamic_cb_t cb;
 
        struct http_client_ctx *holder;
 
        void *user_data;
};
struct http_resource_detail_dynamic {…};
 
BUILD_ASSERT(offsetof(struct http_resource_detail_dynamic, common) == 0);
typedef int (*http_resource_websocket_cb_t)(int ws_socket, struct http_request_ctx *request_ctx,
                                            void *user_data);
 
struct http_resource_detail_websocket {
        struct http_resource_detail common;
 
        int ws_sock;
 
        http_resource_websocket_cb_t cb;
 
        uint8_t *data_buffer;
 
        size_t data_buffer_len;
 
        void *user_data;
};
struct http_resource_detail_websocket {…};
 
BUILD_ASSERT(offsetof(struct http_resource_detail_websocket, common) == 0);
enum http2_stream_state {
        HTTP2_STREAM_IDLE,
        HTTP2_STREAM_RESERVED_LOCAL,
        HTTP2_STREAM_RESERVED_REMOTE,
        HTTP2_STREAM_OPEN,
        HTTP2_STREAM_HALF_CLOSED_LOCAL,
        HTTP2_STREAM_HALF_CLOSED_REMOTE,
        HTTP2_STREAM_CLOSED
};
 
enum http_server_state {
        HTTP_SERVER_FRAME_HEADER_STATE,
        HTTP_SERVER_PREFACE_STATE,
        HTTP_SERVER_REQUEST_STATE,
        HTTP_SERVER_FRAME_DATA_STATE,
        HTTP_SERVER_FRAME_HEADERS_STATE,
        HTTP_SERVER_FRAME_SETTINGS_STATE,
        HTTP_SERVER_FRAME_PRIORITY_STATE,
        HTTP_SERVER_FRAME_WINDOW_UPDATE_STATE,
        HTTP_SERVER_FRAME_CONTINUATION_STATE,
        HTTP_SERVER_FRAME_PING_STATE,
        HTTP_SERVER_FRAME_RST_STREAM_STATE,
        HTTP_SERVER_FRAME_GOAWAY_STATE,
        HTTP_SERVER_FRAME_PADDING_STATE,
        HTTP_SERVER_DONE_STATE,
};
 
enum http1_parser_state {
        HTTP1_INIT_HEADER_STATE,
        HTTP1_WAITING_HEADER_STATE,
        HTTP1_RECEIVING_HEADER_STATE,
        HTTP1_RECEIVED_HEADER_STATE,
        HTTP1_RECEIVING_DATA_STATE,
        HTTP1_MESSAGE_COMPLETE_STATE,
};
 
#define HTTP_SERVER_INITIAL_WINDOW_SIZE 65536
#define HTTP_SERVER_WS_MAX_SEC_KEY_LEN 32
 
struct http2_stream_ctx {
        int stream_id; 
        enum http2_stream_state stream_state; 
        int window_size; 
        struct http_resource_detail *current_detail;
 
        bool headers_sent : 1;
 
        bool end_stream_sent : 1;
};
struct http2_stream_ctx {…};
 
struct http2_frame {
        uint32_t length; 
        uint32_t stream_identifier; 
        uint8_t type; 
        uint8_t flags; 
        uint8_t padding_len; 
};
struct http2_frame {…};
 
struct http_header_capture_ctx {
        unsigned char buffer[HTTP_SERVER_CAPTURE_HEADER_BUFFER_SIZE];
 
        struct http_header headers[HTTP_SERVER_CAPTURE_HEADER_COUNT];
 
        enum http_header_status status;
 
        size_t count;
 
        size_t cursor;
 
        struct http2_stream_ctx *current_stream;
 
        bool store_next_value;
};
struct http_header_name {
        const char *name; 
};
struct http_header_name {…};
 
struct http_client_ctx {
        int fd;
 
        const struct http_service_desc *service;
 
        unsigned char buffer[HTTP_SERVER_CLIENT_BUFFER_SIZE];
 
        unsigned char *cursor;
 
        size_t data_len;
 
        int window_size;
 
        enum http_server_state server_state;
 
        struct http2_frame current_frame;
 
        struct http_resource_detail *current_detail;
 
        struct http2_stream_ctx *current_stream;
 
        struct http_hpack_header_buf header_field;
 
        struct http2_stream_ctx streams[HTTP_SERVER_MAX_STREAMS];
 
        struct http_parser_settings parser_settings;
 
        struct http_parser parser;
 
        struct http_header_capture_ctx header_capture_ctx;
 
        unsigned char url_buffer[HTTP_SERVER_MAX_URL_LENGTH];
 
        unsigned char content_type[HTTP_SERVER_MAX_CONTENT_TYPE_LEN];
 
        unsigned char header_buffer[HTTP_SERVER_MAX_HEADER_LEN];
 
        size_t content_len;
 
        enum http_method method;
 
        enum http1_parser_state parser_state;
 
        int http1_frag_data_len;
 
        struct k_work_delayable inactivity_timer;
 
        IF_ENABLED(CONFIG_WEBSOCKET, (uint8_t ws_sec_key[HTTP_SERVER_WS_MAX_SEC_KEY_LEN]));
        IF_ENABLED(CONFIG_HTTP_SERVER_COMPRESSION, (uint8_t supported_compression));
        bool preface_sent : 1;
 
        bool http1_headers_sent : 1;
 
        bool has_upgrade_header : 1;
 
        bool http2_upgrade : 1;
 
        bool websocket_upgrade : 1;
 
        bool websocket_sec_key_next : 1;
 
        IF_ENABLED(CONFIG_HTTP_SERVER_COMPRESSION, (bool accept_encoding_next: 1));
 
        bool expect_continuation : 1;
};
struct http_client_ctx {…};
 
#define HTTP_SERVER_REGISTER_HEADER_CAPTURE(_id, _header)                                          \
        BUILD_ASSERT(sizeof(_header) <= CONFIG_HTTP_SERVER_MAX_HEADER_LEN,                         \
                     "Header is too long to be captured, try increasing "                          \
                     "CONFIG_HTTP_SERVER_MAX_HEADER_LEN");                                         \
        static const char *const _id##_str = _header;                                              \
        static const STRUCT_SECTION_ITERABLE(http_header_name, _id) = {                            \
                .name = _id##_str,                                                                 \
        }
#define HTTP_SERVER_REGISTER_HEADER_CAPTURE(_id, _header)                                          \ …
 
int http_server_start(void);
 
int http_server_stop(void);
 
#ifdef __cplusplus
}
#endif
 
#endif