kcenon::network::protocols::http2::http2_server Class Reference

HTTP/2 server with TLS support. More...

#include <http2_server.h>

Inheritance diagram for kcenon::network::protocols::http2::http2_server:

Collaboration diagram for kcenon::network::protocols::http2::http2_server:

Public Types
using	request_handler_t
	Request handler function type.
using	error_handler_t
	Error handler function type.

Public Member Functions
	http2_server (std::string_view server_id)
	Construct HTTP/2 server.
	~http2_server ()
	Destructor - stops server gracefully.
	http2_server (const http2_server &)=delete
http2_server &	operator= (const http2_server &)=delete
	http2_server (http2_server &&)=delete
http2_server &	operator= (http2_server &&)=delete
auto	start (unsigned short port) -> VoidResult
	Start HTTP/2 server without TLS (h2c - HTTP/2 cleartext)
auto	start_tls (unsigned short port, const tls_config &config) -> VoidResult
	Start HTTP/2 server with TLS.
auto	stop () -> VoidResult
	Stop the server.
auto	is_running () const -> bool
	Check if server is running.
auto	wait () -> void
	Wait for server to stop.
auto	set_request_handler (request_handler_t handler) -> void
	Set request handler.
auto	set_error_handler (error_handler_t handler) -> void
	Set error handler.
auto	set_settings (const http2_settings &settings) -> void
	Set server settings.
auto	get_settings () const -> http2_settings
	Get current settings.
auto	active_connections () const -> size_t
	Get number of active connections.
auto	active_streams () const -> size_t
	Get total number of active streams across all connections.
auto	server_id () const -> std::string_view
	Get server identifier.

Private Member Functions
auto	do_accept () -> void
auto	do_accept_tls () -> void
auto	handle_accept (std::error_code ec, asio::ip::tcp::socket socket) -> void
auto	handle_accept_tls (std::error_code ec, asio::ip::tcp::socket socket) -> void
auto	add_connection (std::shared_ptr< http2_server_connection > conn) -> void
auto	remove_connection (uint64_t connection_id) -> void
auto	cleanup_dead_connections () -> void
auto	start_cleanup_timer () -> void
auto	run_io () -> void
auto	stop_io () -> void

Private Attributes
std::string	server_id_
	Server identifier.
std::unique_ptr< asio::io_context >	io_context_
std::unique_ptr< asio::ssl::context >	ssl_context_
std::unique_ptr< asio::ip::tcp::acceptor >	acceptor_
std::unique_ptr< asio::executor_work_guard< asio::io_context::executor_type > >	work_guard_
std::future< void >	io_future_
std::atomic< bool >	is_running_ {false}
std::atomic< bool >	use_tls_ {false}
std::promise< void >	stop_promise_
std::future< void >	stop_future_
request_handler_t	request_handler_
error_handler_t	error_handler_
std::mutex	connections_mutex_
std::map< uint64_t, std::shared_ptr< http2_server_connection > >	connections_
std::atomic< uint64_t >	next_connection_id_ {1}
std::mutex	settings_mutex_
http2_settings	settings_
std::shared_ptr< hpack_encoder >	encoder_
std::shared_ptr< hpack_decoder >	decoder_
std::unique_ptr< asio::steady_timer >	cleanup_timer_

Static Private Attributes
static constexpr std::string_view	CONNECTION_PREFACE
static constexpr size_t	FRAME_HEADER_SIZE = 9

Detailed Description

HTTP/2 server with TLS support.

Thread Safety

• All public methods are thread-safe
• Request handler is called from I/O thread
• Multiple connections handled concurrently

Features

• HTTP/2 protocol support (RFC 7540)
• HPACK header compression (RFC 7541)
• TLS 1.3 with ALPN "h2" negotiation
• Stream multiplexing
• Flow control
• Connection-level and stream-level flow control

Usage Example

auto server = std::make_shared<http2_server>("my-server");
 
server->set_request_handler([](http2_server_stream& stream,
                               const http2_request& request) {
    if (request.method == "GET" && request.path == "/api/health") {
        stream.send_headers(200, {{"content-type", "application/json"}});
        stream.send_data(R"({"status": "ok"})", true);
    } else {
        stream.send_headers(404, {});
        stream.send_data("Not Found", true);
    }
});
 
// Start with TLS
tls_config config;
config.cert_file = "/path/to/cert.pem";
config.key_file = "/path/to/key.pem";
server->start_tls(8443, config);
 
// Wait for shutdown signal
server->wait();
 
// Stop server
server->stop();

Definition at line 99 of file http2_server.h.

Member Typedef Documentation

error_handler_t

using kcenon::network::protocols::http2::http2_server::error_handler_t

Initial value:

 std::function<void(
            const std::string& error_message)>

Error handler function type.

Definition at line 108 of file http2_server.h.

request_handler_t

using kcenon::network::protocols::http2::http2_server::request_handler_t

Initial value:

 std::function<void(
            http2_server_stream& stream,
            const http2_request& request)>

Request handler function type.

Definition at line 103 of file http2_server.h.

Constructor & Destructor Documentation

http2_server() [1/3]

kcenon::network::protocols::http2::http2_server::http2_server ( std::string_view server_id )

explicit

Construct HTTP/2 server.

Parameters

server_id

Unique server identifier for logging

Definition at line 16 of file http2_server.cpp.

        : server_id_(server_id)
        , stop_future_(stop_promise_.get_future())
        , encoder_(std::make_shared<hpack_encoder>(settings_.header_table_size))
        , decoder_(std::make_shared<hpack_decoder>(settings_.header_table_size))
    {
    }

~http2_server()

kcenon::network::protocols::http2::http2_server::~http2_server

(

)

Destructor - stops server gracefully.

Definition at line 24 of file http2_server.cpp.

    {
        if (is_running_) {
            stop();
        }
    }

References is_running_, and stop().

Here is the call graph for this function:

http2_server() [2/3]

kcenon::network::protocols::http2::http2_server::http2_server ( const http2_server & )

delete

http2_server() [3/3]

kcenon::network::protocols::http2::http2_server::http2_server ( http2_server && )

delete

Member Function Documentation

active_connections()

auto kcenon::network::protocols::http2::http2_server::active_connections ( ) const -> size_t

nodiscard

Get number of active connections.

Returns

Active connection count

Definition at line 243 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(const_cast<std::mutex&>(connections_mutex_));
        return connections_.size();
    }

active_streams()

auto kcenon::network::protocols::http2::http2_server::active_streams ( ) const -> size_t

nodiscard

Get total number of active streams across all connections.

Returns

Active stream count

Definition at line 249 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(const_cast<std::mutex&>(connections_mutex_));
        size_t total = 0;
        for (const auto& [id, conn] : connections_) {
            total += conn->stream_count();
        }
        return total;
    }

add_connection()

auto kcenon::network::protocols::http2::http2_server::add_connection ( std::shared_ptr< http2_server_connection > conn ) -> void

private

Definition at line 358 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(connections_mutex_);
        connections_[conn->connection_id()] = std::move(conn);
    }

cleanup_dead_connections()

auto kcenon::network::protocols::http2::http2_server::cleanup_dead_connections ( ) -> void

private

Definition at line 370 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(connections_mutex_);
        for (auto it = connections_.begin(); it != connections_.end();) {
            if (!it->second->is_alive()) {
                it = connections_.erase(it);
            } else {
                ++it;
            }
        }
    }

do_accept()

auto kcenon::network::protocols::http2::http2_server::do_accept ( ) -> void

private

Definition at line 264 of file http2_server.cpp.

    {
        if (!is_running_ || !acceptor_) {
            return;
        }
 
        acceptor_->async_accept(
            [this](std::error_code ec, asio::ip::tcp::socket socket) {
                handle_accept(ec, std::move(socket));
            });
    }

do_accept_tls()

auto kcenon::network::protocols::http2::http2_server::do_accept_tls ( ) -> void

private

Definition at line 276 of file http2_server.cpp.

    {
        if (!is_running_ || !acceptor_) {
            return;
        }
 
        acceptor_->async_accept(
            [this](std::error_code ec, asio::ip::tcp::socket socket) {
                handle_accept_tls(ec, std::move(socket));
            });
    }

get_settings()

auto kcenon::network::protocols::http2::http2_server::get_settings ( ) const -> http2_settings

nodiscard

Get current settings.

Returns

Current HTTP/2 settings

Definition at line 237 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(settings_mutex_);
        return settings_;
    }

handle_accept()

auto kcenon::network::protocols::http2::http2_server::handle_accept ( std::error_code ec, asio::ip::tcp::socket socket ) -> void

private

Definition at line 288 of file http2_server.cpp.

    {
        if (!is_running_) {
            return;
        }
 
        if (ec) {
            if (error_handler_) {
                error_handler_(std::string("Accept error: ") + ec.message());
            }
        } else {
            uint64_t conn_id = next_connection_id_++;
            auto conn = std::make_shared<http2_server_connection>(
                conn_id,
                std::move(socket),
                get_settings(),
                request_handler_,
                error_handler_);
 
            add_connection(conn);
            conn->start();
        }
 
        // Continue accepting
        do_accept();
    }

handle_accept_tls()

auto kcenon::network::protocols::http2::http2_server::handle_accept_tls ( std::error_code ec, asio::ip::tcp::socket socket ) -> void

private

Definition at line 315 of file http2_server.cpp.

    {
        if (!is_running_) {
            return;
        }
 
        if (ec) {
            if (error_handler_) {
                error_handler_(std::string("Accept error: ") + ec.message());
            }
            do_accept_tls();
            return;
        }
 
        auto tls_socket = std::make_unique<asio::ssl::stream<asio::ip::tcp::socket>>(
            std::move(socket), *ssl_context_);
 
        auto* raw_socket = tls_socket.get();
        raw_socket->async_handshake(
            asio::ssl::stream_base::server,
            [this, tls_socket = std::move(tls_socket)](std::error_code ec) mutable {
                if (ec) {
                    if (error_handler_) {
                        error_handler_(std::string("TLS handshake error: ") + ec.message());
                    }
                } else {
                    uint64_t conn_id = next_connection_id_++;
                    auto conn = std::make_shared<http2_server_connection>(
                        conn_id,
                        std::move(tls_socket),
                        get_settings(),
                        request_handler_,
                        error_handler_);
 
                    add_connection(conn);
                    conn->start();
                }
 
                // Continue accepting
                do_accept_tls();
            });
    }

is_running()

auto kcenon::network::protocols::http2::http2_server::is_running ( ) const -> bool

nodiscard

Check if server is running.

Returns

True if server is accepting connections

Definition at line 209 of file http2_server.cpp.

    {
        return is_running_;
    }

operator=() [1/2]

http2_server & kcenon::network::protocols::http2::http2_server::operator= ( const http2_server & )

delete

operator=() [2/2]

http2_server & kcenon::network::protocols::http2::http2_server::operator= ( http2_server && )

delete

remove_connection()

auto kcenon::network::protocols::http2::http2_server::remove_connection ( uint64_t connection_id ) -> void

private

Definition at line 364 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(connections_mutex_);
        connections_.erase(connection_id);
    }

run_io()

auto kcenon::network::protocols::http2::http2_server::run_io ( ) -> void

private

Definition at line 398 of file http2_server.cpp.

    {
        if (io_context_) {
            io_context_->run();
        }
    }

server_id()

auto kcenon::network::protocols::http2::http2_server::server_id ( ) const -> std::string_view

nodiscard

Get server identifier.

Returns

Server ID string

Definition at line 259 of file http2_server.cpp.

    {
        return server_id_;
    }

set_error_handler()

auto kcenon::network::protocols::http2::http2_server::set_error_handler

(

error_handler_t

handler

)

-> void

Set error handler.

Parameters

handler

Function to handle errors

Definition at line 224 of file http2_server.cpp.

    {
        error_handler_ = std::move(handler);
    }

set_request_handler()

auto kcenon::network::protocols::http2::http2_server::set_request_handler

(

request_handler_t

handler

)

-> void

Set request handler.

Parameters

handler

Function to handle incoming requests

The handler is called for each complete HTTP/2 request. Handler should not block for long periods.

Definition at line 219 of file http2_server.cpp.

    {
        request_handler_ = std::move(handler);
    }

set_settings()

auto kcenon::network::protocols::http2::http2_server::set_settings

(

const http2_settings &

settings

)

-> void

Set server settings.

Parameters

settings

HTTP/2 settings to use

Definition at line 229 of file http2_server.cpp.

    {
        std::lock_guard<std::mutex> lock(settings_mutex_);
        settings_ = settings;
        encoder_->set_max_table_size(settings.header_table_size);
        decoder_->set_max_table_size(settings.header_table_size);
    }

References kcenon::network::protocols::http2::settings.

start()

auto kcenon::network::protocols::http2::http2_server::start

(

unsigned short

port

)

-> VoidResult

Start HTTP/2 server without TLS (h2c - HTTP/2 cleartext)

Parameters

port	Port to listen on

Returns

Success or error

Note

h2c is not widely supported. Prefer start_tls() for production.

Definition at line 31 of file http2_server.cpp.

    {
        if (is_running_) {
            return error_void(
                error_codes::common_errors::already_exists,
                "Server already running",
                "http2_server");
        }
 
        try {
            stop_io();
            cleanup_timer_.reset();
            acceptor_.reset();
            ssl_context_.reset();
            io_context_ = std::make_unique<asio::io_context>();
            work_guard_ = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(
                io_context_->get_executor());
 
            acceptor_ = std::make_unique<asio::ip::tcp::acceptor>(
                *io_context_,
                asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port));
 
            use_tls_ = false;
            is_running_ = true;
 
            // Start I/O thread
            io_future_ = std::async(std::launch::async, [this]() { run_io(); });
 
            // Start accepting connections
            do_accept();
            start_cleanup_timer();
 
            return ok();
        } catch (const std::exception& e) {
            return error_void(
                error_codes::network_system::bind_failed,
                std::string("Failed to start server: ") + e.what(),
                "http2_server");
        }
    }

References kcenon::network::error_codes::common_errors::already_exists, kcenon::network::error_codes::network_system::bind_failed, kcenon::network::error_void(), and kcenon::network::ok().

Here is the call graph for this function:

start_cleanup_timer()

auto kcenon::network::protocols::http2::http2_server::start_cleanup_timer ( ) -> void

private

Definition at line 382 of file http2_server.cpp.

    {
        if (!io_context_) {
            return;
        }
 
        cleanup_timer_ = std::make_unique<asio::steady_timer>(*io_context_);
        cleanup_timer_->expires_after(std::chrono::seconds(30));
        cleanup_timer_->async_wait([this](std::error_code ec) {
            if (!ec && is_running_) {
                cleanup_dead_connections();
                start_cleanup_timer();
            }
        });
    }

start_tls()

auto kcenon::network::protocols::http2::http2_server::start_tls	(	unsigned short	port,
		const tls_config &	config ) -> VoidResult

Start HTTP/2 server with TLS.

Parameters

port	Port to listen on
config	TLS configuration

Returns

Success or error

Starts the server with TLS and ALPN "h2" negotiation.

Definition at line 72 of file http2_server.cpp.

    {
        if (is_running_) {
            return error_void(
                error_codes::common_errors::already_exists,
                "Server already running",
                "http2_server");
        }
 
        try {
            stop_io();
            cleanup_timer_.reset();
            acceptor_.reset();
            ssl_context_.reset();
            io_context_ = std::make_unique<asio::io_context>();
            work_guard_ = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(
                io_context_->get_executor());
 
            // Setup TLS context
            ssl_context_ = std::make_unique<asio::ssl::context>(asio::ssl::context::tls_server);
            ssl_context_->set_options(
                asio::ssl::context::default_workarounds |
                asio::ssl::context::no_sslv2 |
                asio::ssl::context::no_sslv3 |
                asio::ssl::context::no_tlsv1 |
                asio::ssl::context::no_tlsv1_1);
 
            ssl_context_->use_certificate_file(config.cert_file, asio::ssl::context::pem);
            ssl_context_->use_private_key_file(config.key_file, asio::ssl::context::pem);
 
            if (!config.ca_file.empty()) {
                ssl_context_->load_verify_file(config.ca_file);
            }
 
            if (config.verify_client) {
                ssl_context_->set_verify_mode(asio::ssl::verify_peer | asio::ssl::verify_fail_if_no_peer_cert);
            }
 
            // Set ALPN callback for HTTP/2
            SSL_CTX_set_alpn_select_cb(
                ssl_context_->native_handle(),
                [](SSL* /*ssl*/, const unsigned char** out, unsigned char* outlen,
                   const unsigned char* in, unsigned int inlen, void* /*arg*/) -> int {
                    // Look for "h2" in client's ALPN list
                    const unsigned char* client = in;
                    const unsigned char* end = in + inlen;
                    while (client < end) {
                        unsigned char len = *client++;
                        if (len == 2 && client + 2 <= end &&
                            client[0] == 'h' && client[1] == '2') {
                            *out = client;
                            *outlen = 2;
                            return SSL_TLSEXT_ERR_OK;
                        }
                        client += len;
                    }
                    return SSL_TLSEXT_ERR_NOACK;
                },
                nullptr);
 
            acceptor_ = std::make_unique<asio::ip::tcp::acceptor>(
                *io_context_,
                asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port));
 
            use_tls_ = true;
            is_running_ = true;
 
            // Start I/O thread
            io_future_ = std::async(std::launch::async, [this]() { run_io(); });
 
            // Start accepting connections
            do_accept_tls();
            start_cleanup_timer();
 
            return ok();
        } catch (const std::exception& e) {
            return error_void(
                error_codes::network_system::bind_failed,
                std::string("Failed to start TLS server: ") + e.what(),
                "http2_server");
        }
    }

References kcenon::network::error_codes::common_errors::already_exists, config, kcenon::network::error_void(), and kcenon::network::ok().

Here is the call graph for this function:

stop()

auto kcenon::network::protocols::http2::http2_server::stop

(

)

-> VoidResult

Stop the server.

Returns

Success or error

Sends GOAWAY to all connections and stops accepting new connections.

Definition at line 155 of file http2_server.cpp.

    {
        if (!is_running_) {
            return ok();
        }
 
        is_running_ = false;
 
        // Prevent another callback from starting, and interrupt any response
        // writer before waiting for the current callback to finish.
        if (io_context_) {
            io_context_->stop();
        }
        {
            std::lock_guard<std::mutex> lock(connections_mutex_);
            for (auto& [id, conn] : connections_) {
                conn->shutdown_transport();
            }
        }
 
        // A read or request callback can still be using a connection. Join
        // the I/O worker before closing its sockets or releasing the map.
        stop_io();
 
        // Close acceptor
        if (acceptor_ && acceptor_->is_open()) {
            std::error_code ec;
            acceptor_->close(ec);
        }
 
        // Stop all connections
        {
            std::lock_guard<std::mutex> lock(connections_mutex_);
            for (auto& [id, conn] : connections_) {
                conn->stop();
            }
            connections_.clear();
        }
 
        // Stop cleanup timer
        if (cleanup_timer_) {
            cleanup_timer_->cancel();
        }
 
        // Signal stop
        try {
            stop_promise_.set_value();
        } catch (...) {
            // Already set
        }
 
        return ok();
    }

References kcenon::network::ok().

Referenced by ~http2_server().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_io()

auto kcenon::network::protocols::http2::http2_server::stop_io ( ) -> void

private

Definition at line 405 of file http2_server.cpp.

    {
        if (work_guard_) {
            work_guard_.reset();
        }
 
        if (io_context_) {
            io_context_->stop();
        }
 
        if (io_future_.valid()) {
            io_future_.wait();
        }
    }

wait()

auto kcenon::network::protocols::http2::http2_server::wait

(

)

-> void

Wait for server to stop.

Blocks until stop() is called.

Definition at line 214 of file http2_server.cpp.

    {
        stop_future_.wait();
    }

Member Data Documentation

acceptor_

std::unique_ptr<asio::ip::tcp::acceptor> kcenon::network::protocols::http2::http2_server::acceptor_

private

Definition at line 238 of file http2_server.h.

cleanup_timer_

std::unique_ptr<asio::steady_timer> kcenon::network::protocols::http2::http2_server::cleanup_timer_

private

Definition at line 266 of file http2_server.h.

CONNECTION_PREFACE

std::string_view kcenon::network::protocols::http2::http2_server::CONNECTION_PREFACE

staticconstexprprivate

Initial value:

=
            "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"

Definition at line 269 of file http2_server.h.

connections_

std::map<uint64_t, std::shared_ptr<http2_server_connection> > kcenon::network::protocols::http2::http2_server::connections_

private

Definition at line 254 of file http2_server.h.

connections_mutex_

std::mutex kcenon::network::protocols::http2::http2_server::connections_mutex_

private

Definition at line 253 of file http2_server.h.

decoder_

std::shared_ptr<hpack_decoder> kcenon::network::protocols::http2::http2_server::decoder_

private

Definition at line 263 of file http2_server.h.

encoder_

std::shared_ptr<hpack_encoder> kcenon::network::protocols::http2::http2_server::encoder_

private

Definition at line 262 of file http2_server.h.

error_handler_

error_handler_t kcenon::network::protocols::http2::http2_server::error_handler_

private

Definition at line 250 of file http2_server.h.

FRAME_HEADER_SIZE

size_t kcenon::network::protocols::http2::http2_server::FRAME_HEADER_SIZE = 9

staticconstexprprivate

Definition at line 271 of file http2_server.h.

io_context_

std::unique_ptr<asio::io_context> kcenon::network::protocols::http2::http2_server::io_context_

private

Definition at line 236 of file http2_server.h.

io_future_

std::future<void> kcenon::network::protocols::http2::http2_server::io_future_

private

Definition at line 240 of file http2_server.h.

is_running_

std::atomic<bool> kcenon::network::protocols::http2::http2_server::is_running_ {false}

private

Definition at line 243 of file http2_server.h.

{false};

Referenced by ~http2_server().

next_connection_id_

std::atomic<uint64_t> kcenon::network::protocols::http2::http2_server::next_connection_id_ {1}

private

Definition at line 255 of file http2_server.h.

{1};

request_handler_

request_handler_t kcenon::network::protocols::http2::http2_server::request_handler_

private

Definition at line 249 of file http2_server.h.

server_id_

std::string kcenon::network::protocols::http2::http2_server::server_id_

private

Server identifier.

Definition at line 233 of file http2_server.h.

settings_

http2_settings kcenon::network::protocols::http2::http2_server::settings_

private

Definition at line 259 of file http2_server.h.

settings_mutex_

std::mutex kcenon::network::protocols::http2::http2_server::settings_mutex_

mutableprivate

Definition at line 258 of file http2_server.h.

ssl_context_

std::unique_ptr<asio::ssl::context> kcenon::network::protocols::http2::http2_server::ssl_context_

private

Definition at line 237 of file http2_server.h.

stop_future_

std::future<void> kcenon::network::protocols::http2::http2_server::stop_future_

private

Definition at line 246 of file http2_server.h.

stop_promise_

std::promise<void> kcenon::network::protocols::http2::http2_server::stop_promise_

private

Definition at line 245 of file http2_server.h.

use_tls_

std::atomic<bool> kcenon::network::protocols::http2::http2_server::use_tls_ {false}

private

Definition at line 244 of file http2_server.h.

{false};

work_guard_

std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type> > kcenon::network::protocols::http2::http2_server::work_guard_

private

Definition at line 239 of file http2_server.h.

---

The documentation for this class was generated from the following files:

• src/internal/protocols/http2/http2_server.h
• src/protocols/http2/http2_server.cpp