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,
};

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;
};

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;
};

/* 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;
};

enum http_compression {
        HTTP_NONE = 0,     
        HTTP_GZIP = 1,     
        HTTP_COMPRESS = 2, 
        HTTP_DEFLATE = 3,  
        HTTP_BR = 4,       
        HTTP_ZSTD = 5      
};

/* 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;
};
 
#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_FOREACH(_it) STRUCT_SECTION_FOREACH(http_content_type, _it)
 
struct http_client_ctx;

enum http_transaction_status {
        HTTP_SERVER_TRANSACTION_ABORTED = -1,
        HTTP_SERVER_REQUEST_DATA_MORE = 0,
        HTTP_SERVER_REQUEST_DATA_FINAL = 1,
        HTTP_SERVER_TRANSACTION_COMPLETE = 2,
};

enum http_header_status {
        HTTP_HEADER_STATUS_OK,      
        HTTP_HEADER_STATUS_DROPPED, 
        HTTP_HEADER_STATUS_NONE,    
};

struct http_header {
        const char *name;  
        const char *value; 
};

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_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; 
};

typedef int (*http_resource_dynamic_cb_t)(struct http_client_ctx *client,
                                          enum http_transaction_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;
};

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;
};

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,
        HTTP_SERVER_H3_STREAM_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
#define HTTP_SERVER_WS_MAX_SEC_PROTOCOL_LEN 64

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_frame {
        uint32_t length; 
        uint32_t stream_identifier; 
        uint8_t type; 
        uint8_t flags; 
        uint8_t padding_len; 
};

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 http3_stream_ctx {
        unsigned char buffer[HTTP_SERVER_CLIENT_BUFFER_SIZE];

        size_t data_len;

        struct http_resource_detail *current_detail;

        unsigned char url_buffer[HTTP_SERVER_MAX_URL_LENGTH];

        enum http_method method;

        struct http_header_capture_ctx header_capture_ctx;

        bool request_headers_pending;
};

struct http_header_name {
        const char *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_WEBSOCKET,
                   (char ws_sec_protocol[HTTP_SERVER_WS_MAX_SEC_PROTOCOL_LEN]));

        IF_ENABLED(CONFIG_HTTP_SERVER_COMPRESSION, (uint8_t supported_compression));

        struct {
#if defined(CONFIG_HTTP_SERVER_VERSION_3)
                int conn_sock;
 
#define HTTP3_SERVER_MAX_STREAMS (CONFIG_QUIC_MAX_STREAMS_UNI + CONFIG_QUIC_MAX_STREAMS_BIDI)

                int stream_sock[HTTP3_SERVER_MAX_STREAMS];

                bool headers_sent[HTTP3_SERVER_MAX_STREAMS];

                struct http3_stream_ctx streams[HTTP3_SERVER_MAX_STREAMS];
#else
                /* This is here in order to avoid adding #ifdefs in the code related
                 * to the HTTP/3.
                 */
                union {
                        int conn_sock;
                        int stream_sock[0];
                        bool headers_sent[0];
                        struct http3_stream_ctx streams[0];
                };
 
#define HTTP3_SERVER_MAX_STREAMS 0
#endif /* CONFIG_HTTP_SERVER_VERSION_3 */
        } h3;

        bool is_h3 : 1;

        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;

        bool websocket_sec_protocol_next : 1;

        IF_ENABLED(CONFIG_HTTP_SERVER_COMPRESSION, (bool accept_encoding_next: 1));

        bool expect_continuation : 1;
};

#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,                                                                 \
        }

int http_server_start(void);

int http_server_stop(void);
 
#ifdef __cplusplus
}
#endif

 
#endif