ssl_server.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/cpu>
#include <idfxx/error>
#include <idfxx/http/server>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
 
namespace idfxx::http {
 
class ssl_server : public server {
public:
    struct config {
        // Task
        task_priority priority = 5;                          
        size_t stack_size = 10240;                           
        std::optional<core_id> core_affinity = std::nullopt; 
 
        // Network
        uint16_t server_port = 443; 
        uint16_t ctrl_port = 32769; 
        uint16_t backlog_conn = 5;  
 
        // Limits
        uint16_t max_open_sockets = 4; 
        uint16_t max_uri_handlers = 8; 
        uint16_t max_resp_headers = 8; 
        size_t max_req_hdr_len = 0;    
        size_t max_uri_len = 0;        
 
        // Timeouts
        std::chrono::seconds recv_wait_timeout{5}; 
        std::chrono::seconds send_wait_timeout{5}; 
 
        // LRU
        bool lru_purge_enable = true; 
 
        // SO_LINGER
        bool enable_so_linger = false;          
        std::chrono::seconds linger_timeout{0}; 
 
        // Keep-alive
        bool keep_alive_enable = false;              
        std::chrono::seconds keep_alive_idle{0};     
        std::chrono::seconds keep_alive_interval{0}; 
        int keep_alive_count = 0;                    
 
        // URI matching
        bool wildcard_uri_match = false; 
 
        // Session callbacks
        std::move_only_function<result<void>(int) const> on_session_open = {};
        std::move_only_function<void(int) const> on_session_close = {};
 
        // TLS configuration
        std::string server_cert = {};                   
        std::string private_key = {};                   
        std::string client_ca_cert = {};                
        bool use_ecdsa_peripheral = false;              
        uint8_t ecdsa_key_efuse_blk = 0;                
        bool session_tickets = false;                   
        bool use_secure_element = false;                
        std::chrono::milliseconds handshake_timeout{0}; 
    };
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] explicit ssl_server(config cfg);
#endif
 
    [[nodiscard]] static result<ssl_server> make(config cfg);
 
    ~ssl_server() override = default;
 
    ssl_server(const ssl_server&) = delete;
    ssl_server& operator=(const ssl_server&) = delete;
 
    ssl_server(ssl_server&&) noexcept = default;
 
    ssl_server& operator=(ssl_server&&) noexcept = default;
 
private:
    ssl_server(
        httpd_handle_t handle,
        std::unique_ptr<server_ctx> ctx,
        std::move_only_function<result<void>(int) const> on_session_open,
        std::move_only_function<void(int) const> on_session_close
    );
};
 
} // namespace idfxx::http