kcenon::network::protocols::http2::http2_client Class Reference

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

#include <http2_client.h>

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

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

Classes
struct	pending_write

Public Member Functions
	http2_client (std::string_view client_id)
	Construct HTTP/2 client.
	~http2_client ()
	Destructor - closes connection gracefully.
	http2_client (const http2_client &)=delete
http2_client &	operator= (const http2_client &)=delete
	http2_client (http2_client &&)=delete
http2_client &	operator= (http2_client &&)=delete
auto	connect (const std::string &host, unsigned short port=443) -> VoidResult
	Connect to HTTP/2 server.
auto	disconnect () -> VoidResult
	Disconnect from server.
auto	is_connected () const -> bool
	Check if connected.
auto	get (const std::string &path, const std::vector< http_header > &headers={}) -> Result< http2_response >
	Perform HTTP/2 GET request.
auto	post (const std::string &path, const std::string &body, const std::vector< http_header > &headers={}) -> Result< http2_response >
	Perform HTTP/2 POST request.
auto	post (const std::string &path, const std::vector< uint8_t > &body, const std::vector< http_header > &headers={}) -> Result< http2_response >
	Perform HTTP/2 POST request with binary body.
auto	put (const std::string &path, const std::string &body, const std::vector< http_header > &headers={}) -> Result< http2_response >
	Perform HTTP/2 PUT request.
auto	del (const std::string &path, const std::vector< http_header > &headers={}) -> Result< http2_response >
	Perform HTTP/2 DELETE request.
auto	set_timeout (std::chrono::milliseconds timeout) -> void
	Set request timeout.
auto	get_timeout () const -> std::chrono::milliseconds
	Get current timeout.
auto	start_stream (const std::string &path, const std::vector< http_header > &headers, std::function< void(std::vector< uint8_t >)> on_data, std::function< void(std::vector< http_header >)> on_headers, std::function< void(int)> on_complete) -> Result< uint32_t >
	Start a streaming POST request.
auto	write_stream (uint32_t stream_id, const std::vector< uint8_t > &data, bool end_stream=false) -> VoidResult
	Write data to an open stream.
auto	close_stream_writer (uint32_t stream_id) -> VoidResult
	Close the write side of a stream.
auto	cancel_stream (uint32_t stream_id) -> VoidResult
	Cancel a stream.
auto	get_settings () const -> http2_settings
	Get local settings.
auto	set_settings (const http2_settings &settings) -> void
	Update local settings.

Private Member Functions
auto	send_connection_preface () -> VoidResult
auto	send_settings () -> VoidResult
auto	handle_settings_frame (const settings_frame &frame) -> VoidResult
auto	send_settings_ack () -> VoidResult
auto	send_frame (const frame &f) -> VoidResult
auto	read_next_frame () -> void
auto	write_next_frame () -> void
auto	process_frame (std::unique_ptr< frame > f) -> VoidResult
auto	allocate_stream_id () -> uint32_t
auto	get_stream (uint32_t stream_id) -> http2_stream *
auto	create_stream () -> http2_stream &
auto	close_stream (uint32_t stream_id) -> void
auto	send_request (const std::string &method, const std::string &path, const std::vector< http_header > &headers, const std::vector< uint8_t > &body) -> Result< http2_response >
auto	build_headers (const std::string &method, const std::string &path, const std::vector< http_header > &additional) -> std::vector< http_header >
auto	handle_headers_frame (const headers_frame &f) -> VoidResult
auto	handle_data_frame (const data_frame &f) -> VoidResult
auto	handle_rst_stream_frame (const rst_stream_frame &f) -> VoidResult
auto	handle_goaway_frame (const goaway_frame &f) -> VoidResult
auto	handle_window_update_frame (const window_update_frame &f) -> VoidResult
auto	handle_ping_frame (const ping_frame &f) -> VoidResult
auto	run_io () -> void
auto	stop_io () -> void

Private Attributes
std::string	client_id_
	Client identifier.
std::string	host_
	Connected host.
unsigned short	port_ = 443
	Connected port.
std::mutex	lifecycle_mutex_
std::unique_ptr< asio::io_context >	io_context_
std::unique_ptr< asio::ssl::context >	ssl_context_
std::unique_ptr< asio::ssl::stream< asio::ip::tcp::socket > >	socket_
std::unique_ptr< asio::executor_work_guard< asio::io_context::executor_type > >	work_guard_
std::future< void >	io_future_
std::mutex	io_submission_mutex_
bool	io_active_ = false
std::deque< pending_write >	pending_writes_
std::atomic< bool >	is_connected_ {false}
std::atomic< bool >	is_running_ {false}
std::atomic< bool >	goaway_received_ {false}
std::mutex	streams_mutex_
std::map< uint32_t, http2_stream >	streams_
std::atomic< uint32_t >	next_stream_id_ {1}
	Client streams are odd.
int32_t	connection_window_size_ = 65535
http2_settings	local_settings_
http2_settings	remote_settings_
hpack_encoder	encoder_
hpack_decoder	decoder_
std::atomic< std::chrono::milliseconds >	timeout_ {std::chrono::milliseconds(30000)}
std::vector< uint8_t >	read_buffer_

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

Detailed Description

HTTP/2 client with TLS support.

Thread Safety

• All public methods are thread-safe
• Multiple requests can be made concurrently (multiplexing)
• Uses single TLS connection for all requests

Features

• HTTP/2 protocol support (RFC 7540)
• HPACK header compression (RFC 7541)
• TLS 1.3 with ALPN negotiation
• Stream multiplexing
• Flow control
• Server push disabled by default

Usage Example

auto client = std::make_shared<http2_client>("my-client");
 
// Connect to server
auto connect_result = client->connect("example.com", 443);
if (!connect_result) {
    std::cerr << "Connect failed: " << connect_result.error().message << "\n";
    return;
}
 
// Simple GET request
auto response = client->get("/api/users");
if (response) {
    std::cout << "Status: " << response->status_code << "\n";
    std::cout << "Body: " << response->get_body_string() << "\n";
}
 
// POST with JSON body
std::vector<http_header> headers = {
    {"content-type", "application/json"}
};
std::string json_body = R"({"name": "John"})";
auto post_response = client->post("/api/users", json_body, headers);
 
// Disconnect
client->disconnect();

Definition at line 180 of file http2_client.h.

Constructor & Destructor Documentation

http2_client() [1/3]

kcenon::network::protocols::http2::http2_client::http2_client ( std::string_view client_id )

explicit

Construct HTTP/2 client.

Parameters

client_id

Unique client identifier for logging

Definition at line 45 of file http2_client.cpp.

        : client_id_(client_id)
        , encoder_(local_settings_.header_table_size)
        , decoder_(local_settings_.header_table_size)
    {
    }

~http2_client()

kcenon::network::protocols::http2::http2_client::~http2_client

(

)

Destructor - closes connection gracefully.

Definition at line 52 of file http2_client.cpp.

    {
        try
        {
            disconnect();
        }
        catch (...)
        {
            // Suppress exceptions in destructor
        }
    }

References disconnect().

Here is the call graph for this function:

http2_client() [2/3]

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

delete

http2_client() [3/3]

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

delete

Member Function Documentation

allocate_stream_id()

auto kcenon::network::protocols::http2::http2_client::allocate_stream_id ( ) -> uint32_t

private

Definition at line 795 of file http2_client.cpp.

    {
        uint32_t id = next_stream_id_.fetch_add(2);
        return id;
    }

build_headers()

auto kcenon::network::protocols::http2::http2_client::build_headers ( const std::string & method, const std::string & path, const std::vector< http_header > & additional ) -> std::vector<http_header>

private

Definition at line 953 of file http2_client.cpp.

    {
        std::vector<http_header> headers;
 
        // Pseudo-headers (must come first)
        headers.emplace_back(":method", method);
        headers.emplace_back(":scheme", "https");
        headers.emplace_back(":authority", host_);
        headers.emplace_back(":path", path.empty() ? "/" : path);
 
        // Standard headers
        headers.emplace_back("user-agent", "network_system/http2_client");
 
        // Additional headers
        for (const auto& h : additional)
        {
            // Skip pseudo-headers in additional
            if (!h.name.empty() && h.name[0] != ':')
            {
                headers.push_back(h);
            }
        }
 
        return headers;
    }

References kcenon::network::protocols::http2::headers.

cancel_stream()

auto kcenon::network::protocols::http2::http2_client::cancel_stream

(

uint32_t

stream_id

)

-> VoidResult

Cancel a stream.

Parameters

stream_id

Stream identifier

Returns

Success or error

Definition at line 487 of file http2_client.cpp.

    {
        if (!is_connected())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Not connected",
                              "http2_client::cancel_stream");
        }
 
        auto* stream = get_stream(stream_id);
        if (!stream)
        {
            return error_void(error_codes::common_errors::not_found,
                              "Stream not found",
                              "http2_client::cancel_stream");
        }
 
        if (stream->state == stream_state::closed)
        {
            return ok();  // Already closed
        }
 
        // Send RST_STREAM frame
        rst_stream_frame rsf(stream_id, static_cast<uint32_t>(error_code::cancel));
        auto send_result = send_frame(rsf);
        if (send_result.is_err())
        {
            return send_result;
        }
 
        stream->state = stream_state::closed;
        return ok();
    }

References kcenon::network::protocols::http2::cancel, kcenon::network::protocols::http2::closed, kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error_void(), kcenon::network::error_codes::common_errors::not_found, and kcenon::network::ok().

Here is the call graph for this function:

close_stream()

auto kcenon::network::protocols::http2::http2_client::close_stream ( uint32_t stream_id ) -> void

private

Definition at line 823 of file http2_client.cpp.

    {
        std::lock_guard<std::mutex> lock(streams_mutex_);
        auto it = streams_.find(stream_id);
        if (it != streams_.end())
        {
            it->second.state = stream_state::closed;
        }
    }

close_stream_writer()

auto kcenon::network::protocols::http2::http2_client::close_stream_writer

(

uint32_t

stream_id

)

-> VoidResult

Close the write side of a stream.

Parameters

stream_id

Stream identifier

Returns

Success or error

Definition at line 451 of file http2_client.cpp.

    {
        if (!is_connected())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Not connected",
                              "http2_client::close_stream_writer");
        }
 
        auto* stream = get_stream(stream_id);
        if (!stream)
        {
            return error_void(error_codes::common_errors::not_found,
                              "Stream not found",
                              "http2_client::close_stream_writer");
        }
 
        if (stream->state == stream_state::closed ||
            stream->state == stream_state::half_closed_local)
        {
            return ok();  // Already closed
        }
 
        // Publish the state before the peer can respond to END_STREAM.
        stream->state = stream_state::half_closed_local;
        // Send empty DATA frame with END_STREAM
        data_frame df(stream_id, {}, true);
        auto send_result = send_frame(df);
        if (send_result.is_err())
        {
            return send_result;
        }
 
        return ok();
    }

References kcenon::network::protocols::http2::closed, kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error_void(), kcenon::network::protocols::http2::half_closed_local, kcenon::network::error_codes::common_errors::not_found, and kcenon::network::ok().

Here is the call graph for this function:

connect()

auto kcenon::network::protocols::http2::http2_client::connect	(	const std::string &	host,
		unsigned short	port = 443 ) -> VoidResult

Connect to HTTP/2 server.

Parameters

host	Server hostname
port	Server port (default 443)

Returns

Success or error

Establishes TLS connection with ALPN "h2", sends connection preface, and exchanges SETTINGS frames.

Definition at line 64 of file http2_client.cpp.

    {
        std::lock_guard<std::mutex> lifecycle_lock(lifecycle_mutex_);
        // Create tracing span for connect operation
        auto span = tracing::is_tracing_enabled()
            ? std::make_optional(tracing::trace_context::create_span("http2.client.connect"))
            : std::nullopt;
        if (span)
        {
            span->set_attribute("net.peer.name", host)
                 .set_attribute("net.peer.port", static_cast<int64_t>(port))
                 .set_attribute("net.transport", "tcp")
                 .set_attribute("http.flavor", "2.0")
                 .set_attribute("client.id", client_id_);
        }
 
        if (is_connected_)
        {
            if (span)
            {
                span->set_error("Already connected");
            }
            return error_void(error_codes::common_errors::already_exists,
                              "Already connected", "http2_client::connect");
        }
 
        if (host.empty())
        {
            if (span)
            {
                span->set_error("Host cannot be empty");
            }
            return error_void(error_codes::common_errors::invalid_argument,
                              "Host cannot be empty", "http2_client::connect");
        }
 
        host_ = host;
        port_ = port;
 
        try
        {
            // A failed connection can still own a socket and work guard.
            // Release them while their original execution context is alive.
            stop_io();
            socket_.reset();
            work_guard_.reset();
            ssl_context_.reset();
            io_context_.reset();
            goaway_received_ = false;
 
            // Create I/O context
            io_context_ = std::make_unique<asio::io_context>();
 
            // Create SSL context with TLS 1.3
            ssl_context_ = std::make_unique<asio::ssl::context>(asio::ssl::context::tlsv13_client);
 
            // Set ALPN for HTTP/2
            SSL_CTX* native_ctx = ssl_context_->native_handle();
            static const unsigned char alpn_protos[] = { 2, 'h', '2' };
            SSL_CTX_set_alpn_protos(native_ctx, alpn_protos, sizeof(alpn_protos));
 
            // Verify peer certificate
            ssl_context_->set_default_verify_paths();
            ssl_context_->set_verify_mode(asio::ssl::verify_peer);
 
            // Create socket
            asio::ip::tcp::resolver resolver(*io_context_);
            auto endpoints = resolver.resolve(host, std::to_string(port));
 
            socket_ = std::make_unique<asio::ssl::stream<asio::ip::tcp::socket>>(
                *io_context_, *ssl_context_);
 
            // Set SNI hostname
            SSL_set_tlsext_host_name(socket_->native_handle(), host.c_str());
 
            // Connect TCP
            asio::connect(socket_->lowest_layer(), endpoints);
 
            // Perform SSL handshake
            socket_->handshake(asio::ssl::stream_base::client);
 
            // Verify ALPN negotiation
            const unsigned char* alpn_result = nullptr;
            unsigned int alpn_len = 0;
            SSL_get0_alpn_selected(socket_->native_handle(), &alpn_result, &alpn_len);
 
            if (alpn_len != 2 || alpn_result == nullptr ||
                std::string(reinterpret_cast<const char*>(alpn_result), alpn_len) != "h2")
            {
                socket_->lowest_layer().close();
                if (span)
                {
                    span->set_error("Server does not support HTTP/2 via ALPN");
                }
                return error_void(error_codes::network_system::connection_failed,
                                  "Server does not support HTTP/2 via ALPN",
                                  "http2_client::connect");
            }
 
            is_running_ = true;
 
            // Send connection preface
            auto preface_result = send_connection_preface();
            if (preface_result.is_err())
            {
                is_connected_ = false;
                is_running_ = false;
                if (span)
                {
                    span->set_error(preface_result.error().message);
                }
                return preface_result;
            }
 
            // Send initial SETTINGS
            auto settings_result = send_settings();
            if (settings_result.is_err())
            {
                is_connected_ = false;
                is_running_ = false;
                if (span)
                {
                    span->set_error(settings_result.error().message);
                }
                return settings_result;
            }
 
            // The server connection preface must start with a non-ACK
            // SETTINGS frame on stream zero (RFC 9113 section 3.4).
            // Bound both reads by one deadline so a partial frame cannot
            // leave connect() blocked indefinitely.
            const auto deadline = std::chrono::steady_clock::now() + timeout_.load();
            auto read_preface_bytes = [&](asio::mutable_buffer buffer) {
                asio::steady_timer timer(*io_context_, deadline);
                std::error_code read_error;
                bool expired = false;
                timer.async_wait([&](std::error_code ec) {
                    if (!ec) {
                        expired = true;
                        std::error_code ignored;
                        socket_->lowest_layer().cancel(ignored);
                    }
                });
                asio::async_read(*socket_, buffer,
                    [&](std::error_code ec, std::size_t) {
                        read_error = ec;
                        timer.cancel();
                    });
                io_context_->restart();
                io_context_->run();
                if (expired) throw std::runtime_error("Server SETTINGS timed out");
                if (read_error) throw std::system_error(read_error);
            };
            std::vector<uint8_t> initial_header(FRAME_HEADER_SIZE);
            read_preface_bytes(asio::buffer(initial_header));
            auto header = frame_header::parse(initial_header);
            if (header.is_err() || header.value().type != frame_type::settings ||
                header.value().stream_id != 0 ||
                (header.value().flags & frame_flags::ack) != 0 ||
                header.value().length > local_settings_.max_frame_size) {
                throw std::runtime_error("Invalid server SETTINGS preface");
            }
            std::vector<uint8_t> initial_payload(header.value().length);
            if (!initial_payload.empty()) read_preface_bytes(asio::buffer(initial_payload));
            initial_header.insert(initial_header.end(), initial_payload.begin(), initial_payload.end());
            auto initial_frame = frame::parse(initial_header);
            if (initial_frame.is_err()) throw std::runtime_error("Invalid server SETTINGS payload");
            auto initial_result = process_frame(std::move(initial_frame.value()));
            if (initial_result.is_err()) throw std::runtime_error(initial_result.error().message);
 
            // All subsequent SSL operations run on this one executor thread.
            // Publish the connected state while submissions are locked so no
            // caller writes synchronously between startup and the first read.
            work_guard_ = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(
                asio::make_work_guard(*io_context_));
            io_context_->restart();
            {
                std::lock_guard<std::mutex> lock(io_submission_mutex_);
                io_active_ = true;
                is_connected_ = true;
                io_future_ = std::async(std::launch::async, [this]() { run_io(); });
            }
 
            if (span)
            {
                span->set_status(tracing::span_status::ok);
            }
            return ok();
        }
        catch (const std::exception& e)
        {
            is_connected_ = false;
            is_running_ = false;
            stop_io();
            if (span)
            {
                span->set_error(std::string("Connection failed: ") + e.what());
            }
            return error_void(error_codes::network_system::connection_failed,
                              std::string("Connection failed: ") + e.what(),
                              "http2_client::connect");
        }
    }

References kcenon::network::protocols::http2::frame_flags::ack, kcenon::network::error_codes::common_errors::already_exists, kcenon::network::error_codes::network_system::connection_failed, kcenon::network::tracing::trace_context::create_span(), kcenon::network::error_void(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::tracing::is_tracing_enabled(), kcenon::network::ok(), kcenon::network::tracing::ok, kcenon::network::protocols::http2::frame::parse(), kcenon::network::protocols::http2::frame_header::parse(), and kcenon::network::protocols::http2::settings.

Here is the call graph for this function:

create_stream()

auto kcenon::network::protocols::http2::http2_client::create_stream ( ) -> http2_stream&

private

Definition at line 812 of file http2_client.cpp.

    {
        std::lock_guard<std::mutex> lock(streams_mutex_);
        uint32_t stream_id = allocate_stream_id();
        auto& stream = streams_[stream_id];
        stream.stream_id = stream_id;
        stream.state = stream_state::idle;
        stream.window_size = remote_settings_.initial_window_size;
        return stream;
    }

del()

auto kcenon::network::protocols::http2::http2_client::del	(	const std::string &	path,
		const std::vector< http_header > &	headers = {} ) -> Result<http2_response>

Perform HTTP/2 DELETE request.

Parameters

path	Request path
headers	Additional headers (optional)

Returns

Result containing response or error

Definition at line 337 of file http2_client.cpp.

    {
        return send_request("DELETE", path, headers, {});
    }

References kcenon::network::protocols::http2::headers.

disconnect()

auto kcenon::network::protocols::http2::http2_client::disconnect

(

)

-> VoidResult

Disconnect from server.

Returns

Success or error

Sends GOAWAY frame and closes connection gracefully.

Definition at line 268 of file http2_client.cpp.

    {
        std::lock_guard<std::mutex> lifecycle_lock(lifecycle_mutex_);
        if (!is_connected_)
        {
            stop_io();
            return ok();
        }
 
        try
        {
            // Send GOAWAY frame
            if (socket_ && socket_->lowest_layer().is_open())
            {
                goaway_frame goaway(next_stream_id_ - 2,
                                    static_cast<uint32_t>(error_code::no_error));
                send_frame(goaway);
            }
        }
        catch (...)
        {
            // Ignore errors during GOAWAY
        }
 
        stop_io();
 
        is_connected_ = false;
 
        return ok();
    }

References kcenon::network::protocols::http2::goaway, kcenon::network::protocols::http2::no_error, and kcenon::network::ok().

Referenced by ~http2_client().

Here is the call graph for this function:

Here is the caller graph for this function:

get()

auto kcenon::network::protocols::http2::http2_client::get	(	const std::string &	path,
		const std::vector< http_header > &	headers = {} ) -> Result<http2_response>

Perform HTTP/2 GET request.

Parameters

path	Request path (e.g., "/api/users")
headers	Additional headers (optional)

Returns

Result containing response or error

Definition at line 304 of file http2_client.cpp.

    {
        return send_request("GET", path, headers, {});
    }

References kcenon::network::protocols::http2::headers.

get_settings()

auto kcenon::network::protocols::http2::http2_client::get_settings

(

)

const -> http2_settings

Get local settings.

Returns

Current local settings

Definition at line 354 of file http2_client.cpp.

    {
        return local_settings_;
    }

References local_settings_.

get_stream()

auto kcenon::network::protocols::http2::http2_client::get_stream ( uint32_t stream_id ) -> http2_stream*

private

Definition at line 801 of file http2_client.cpp.

    {
        std::lock_guard<std::mutex> lock(streams_mutex_);
        auto it = streams_.find(stream_id);
        if (it != streams_.end())
        {
            return &it->second;
        }
        return nullptr;
    }

get_timeout()

auto kcenon::network::protocols::http2::http2_client::get_timeout

(

)

const -> std::chrono::milliseconds

Get current timeout.

Returns

Timeout duration

Definition at line 349 of file http2_client.cpp.

    {
        return timeout_.load();
    }

References timeout_.

handle_data_frame()

auto kcenon::network::protocols::http2::http2_client::handle_data_frame ( const data_frame & f ) -> VoidResult

private

Definition at line 1067 of file http2_client.cpp.

    {
        uint32_t stream_id = f.header().stream_id;
        auto* stream = get_stream(stream_id);
 
        if (!stream)
        {
            return error_void(error_codes::common_errors::not_found,
                              "Unknown stream ID",
                              "http2_client::handle_data_frame");
        }
 
        // Get data
        auto data = f.data();
 
        // For streaming, call callback immediately; otherwise buffer
        if (stream->is_streaming && stream->on_data)
        {
            stream->on_data(std::vector<uint8_t>(data.begin(), data.end()));
        }
        else
        {
            stream->response_body.insert(stream->response_body.end(),
                                         data.begin(), data.end());
        }
 
        // Update flow control window
        stream->window_size -= static_cast<int32_t>(data.size());
        connection_window_size_ -= static_cast<int32_t>(data.size());
 
        // Send WINDOW_UPDATE if needed
        if (stream->window_size < static_cast<int32_t>(DEFAULT_WINDOW_SIZE / 2))
        {
            int32_t increment = DEFAULT_WINDOW_SIZE - stream->window_size;
            window_update_frame wuf(stream_id, increment);
            send_frame(wuf);
            stream->window_size += increment;
        }
 
        if (connection_window_size_ < static_cast<int32_t>(DEFAULT_WINDOW_SIZE / 2))
        {
            int32_t increment = DEFAULT_WINDOW_SIZE - connection_window_size_;
            window_update_frame wuf(0, increment);  // Stream 0 = connection level
            send_frame(wuf);
            connection_window_size_ += increment;
        }
 
        if (f.is_end_stream())
        {
            stream->body_complete = true;
            stream->state = stream_state::closed;
 
            // Extract status code
            int status_code = 0;
            for (const auto& h : stream->response_headers)
            {
                if (h.name == ":status")
                {
                    try
                    {
                        status_code = std::stoi(h.value);
                    }
                    catch (...)
                    {
                        status_code = 0;
                    }
                    break;
                }
            }
 
            // Handle streaming vs non-streaming
            if (stream->is_streaming)
            {
                if (stream->on_complete)
                {
                    stream->on_complete(status_code);
                }
            }
            else
            {
                http2_response response;
                response.headers = stream->response_headers;
                response.body = stream->response_body;
                response.status_code = status_code;
                stream->promise.set_value(std::move(response));
            }
        }
 
        return ok();
    }

References kcenon::network::protocols::http2::http2_response::body, kcenon::network::protocols::http2::data, kcenon::network::error_void(), kcenon::network::protocols::http2::http2_response::headers, kcenon::network::error_codes::common_errors::not_found, kcenon::network::ok(), and kcenon::network::protocols::http2::http2_response::status_code.

Here is the call graph for this function:

handle_goaway_frame()

auto kcenon::network::protocols::http2::http2_client::handle_goaway_frame ( const goaway_frame & f ) -> VoidResult

private

Definition at line 1176 of file http2_client.cpp.

    {
        goaway_received_ = true;
 
        // Close all streams with ID > last_stream_id
        uint32_t last_stream = f.last_stream_id();
        {
            std::lock_guard<std::mutex> lock(streams_mutex_);
            for (auto& [id, stream] : streams_)
            {
                if (id > last_stream && stream.state != stream_state::closed)
                {
                    stream.state = stream_state::closed;
                    http2_response response;
                    response.status_code = 0;
                    stream.promise.set_value(std::move(response));
                }
            }
        }
 
        return ok();
    }

References kcenon::network::ok(), and kcenon::network::protocols::http2::http2_response::status_code.

Here is the call graph for this function:

handle_headers_frame()

auto kcenon::network::protocols::http2::http2_client::handle_headers_frame ( const headers_frame & f ) -> VoidResult

private

Definition at line 982 of file http2_client.cpp.

    {
        uint32_t stream_id = f.header().stream_id;
        auto* stream = get_stream(stream_id);
 
        if (!stream)
        {
            return error_void(error_codes::common_errors::not_found,
                              "Unknown stream ID",
                              "http2_client::handle_headers_frame");
        }
 
        // Decode headers
        auto decode_result = decoder_.decode(f.header_block());
        if (decode_result.is_err())
        {
            const auto& err = decode_result.error();
            return error_void(err.code, err.message,
                              "http2_client::handle_headers_frame",
                              get_error_details(err));
        }
 
        auto& decoded_headers = decode_result.value();
 
        // Append to stream headers
        stream->response_headers.insert(stream->response_headers.end(),
                                        decoded_headers.begin(),
                                        decoded_headers.end());
 
        if (f.is_end_headers())
        {
            stream->headers_complete = true;
 
            // Call streaming callback if set
            if (stream->is_streaming && stream->on_headers)
            {
                stream->on_headers(stream->response_headers);
            }
        }
 
        if (f.is_end_stream())
        {
            stream->body_complete = true;
            stream->state = stream_state::closed;
 
            // Extract status code
            int status_code = 0;
            for (const auto& h : stream->response_headers)
            {
                if (h.name == ":status")
                {
                    try
                    {
                        status_code = std::stoi(h.value);
                    }
                    catch (...)
                    {
                        status_code = 0;
                    }
                    break;
                }
            }
 
            // Handle streaming vs non-streaming
            if (stream->is_streaming)
            {
                if (stream->on_complete)
                {
                    stream->on_complete(status_code);
                }
            }
            else
            {
                // Build response for non-streaming
                http2_response response;
                response.headers = stream->response_headers;
                response.body = stream->response_body;
                response.status_code = status_code;
                stream->promise.set_value(std::move(response));
            }
        }
 
        return ok();
    }

References kcenon::network::protocols::http2::http2_response::body, kcenon::network::error_void(), kcenon::network::get_error_details(), kcenon::network::protocols::http2::http2_response::headers, kcenon::network::error_codes::common_errors::not_found, kcenon::network::ok(), and kcenon::network::protocols::http2::http2_response::status_code.

Here is the call graph for this function:

handle_ping_frame()

auto kcenon::network::protocols::http2::http2_client::handle_ping_frame ( const ping_frame & f ) -> VoidResult

private

Definition at line 1253 of file http2_client.cpp.

    {
        if (!f.is_ack())
        {
            // Send PING ACK
            ping_frame ack(f.opaque_data(), true);
            return send_frame(ack);
        }
        return ok();
    }

References kcenon::network::ok().

Here is the call graph for this function:

handle_rst_stream_frame()

auto kcenon::network::protocols::http2::http2_client::handle_rst_stream_frame ( const rst_stream_frame & f ) -> VoidResult

private

Definition at line 1158 of file http2_client.cpp.

    {
        uint32_t stream_id = f.header().stream_id;
        auto* stream = get_stream(stream_id);
 
        if (stream)
        {
            stream->state = stream_state::closed;
 
            // Set error response
            http2_response response;
            response.status_code = 0;  // Indicate error
            stream->promise.set_value(std::move(response));
        }
 
        return ok();
    }

References kcenon::network::ok(), and kcenon::network::protocols::http2::http2_response::status_code.

Here is the call graph for this function:

handle_settings_frame()

auto kcenon::network::protocols::http2::http2_client::handle_settings_frame ( const settings_frame & frame ) -> VoidResult

private

Definition at line 560 of file http2_client.cpp.

    {
        if (frame.is_ack())
        {
            // Our settings were acknowledged
            return ok();
        }
 
        // Apply remote settings
        for (const auto& param : frame.settings())
        {
            switch (static_cast<setting_identifier>(param.identifier))
            {
            case setting_identifier::header_table_size:
                remote_settings_.header_table_size = param.value;
                encoder_.set_max_table_size(param.value);
                break;
            case setting_identifier::enable_push:
                remote_settings_.enable_push = (param.value != 0);
                break;
            case setting_identifier::max_concurrent_streams:
                remote_settings_.max_concurrent_streams = param.value;
                break;
            case setting_identifier::initial_window_size:
                remote_settings_.initial_window_size = param.value;
                break;
            case setting_identifier::max_frame_size:
                remote_settings_.max_frame_size = param.value;
                break;
            case setting_identifier::max_header_list_size:
                remote_settings_.max_header_list_size = param.value;
                break;
            }
        }
 
        return send_settings_ack();
    }

References kcenon::network::protocols::http2::enable_push, kcenon::network::protocols::http2::header_table_size, kcenon::network::protocols::http2::initial_window_size, kcenon::network::protocols::http2::max_concurrent_streams, kcenon::network::protocols::http2::max_frame_size, kcenon::network::protocols::http2::max_header_list_size, and kcenon::network::ok().

Here is the call graph for this function:

handle_window_update_frame()

auto kcenon::network::protocols::http2::http2_client::handle_window_update_frame ( const window_update_frame & f ) -> VoidResult

private

Definition at line 1199 of file http2_client.cpp.

    {
        uint32_t stream_id = f.header().stream_id;
        int32_t increment = static_cast<int32_t>(f.window_size_increment());
 
        if (stream_id == 0)
        {
            if (connection_window_size_ > std::numeric_limits<int32_t>::max() - increment)
            {
                // RFC 9113 section 6.9.1: reject the update before arithmetic.
                goaway_frame goaway(0, static_cast<uint32_t>(error_code::flow_control_error));
                send_frame(goaway);
                goaway_received_ = true;
                is_connected_ = false;
                return error_void(static_cast<int>(error_code::flow_control_error),
                                  "Connection flow-control window overflow",
                                  "http2_client::handle_window_update_frame");
            }
            connection_window_size_ += increment;
        }
        else
        {
            auto* stream = get_stream(stream_id);
            if (stream)
            {
                if (stream->window_size > std::numeric_limits<int32_t>::max() - increment)
                {
                    rst_stream_frame reset(stream_id, static_cast<uint32_t>(error_code::flow_control_error));
                    send_frame(reset);
                    if (stream->state.exchange(stream_state::closed) != stream_state::closed)
                    {
                        if (stream->is_streaming)
                        {
                            if (stream->on_complete)
                                stream->on_complete(static_cast<int>(error_code::flow_control_error));
                        }
                        else
                        {
                            http2_response response;
                            response.status_code = 0;
                            stream->promise.set_value(std::move(response));
                        }
                    }
                    return error_void(static_cast<int>(error_code::flow_control_error),
                                      "Stream flow-control window overflow",
                                      "http2_client::handle_window_update_frame");
                }
                stream->window_size += increment;
            }
        }
 
        return ok();
    }

References kcenon::network::error_void(), kcenon::network::protocols::http2::goaway, kcenon::network::ok(), and kcenon::network::protocols::http2::http2_response::status_code.

Here is the call graph for this function:

is_connected()

auto kcenon::network::protocols::http2::http2_client::is_connected

(

)

const -> bool

Check if connected.

Returns

True if connected

Definition at line 299 of file http2_client.cpp.

    {
        return is_connected_ && !goaway_received_;
    }

References goaway_received_, and is_connected_.

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

post() [1/2]

auto kcenon::network::protocols::http2::http2_client::post	(	const std::string &	path,
		const std::string &	body,
		const std::vector< http_header > &	headers = {} ) -> Result<http2_response>

Perform HTTP/2 POST request.

Parameters

path	Request path
body	Request body as string
headers	Additional headers (optional)

Returns

Result containing response or error

Definition at line 311 of file http2_client.cpp.

    {
        std::vector<uint8_t> body_bytes(body.begin(), body.end());
        return send_request("POST", path, headers, body_bytes);
    }

References kcenon::network::protocols::http2::headers.

post() [2/2]

auto kcenon::network::protocols::http2::http2_client::post	(	const std::string &	path,
		const std::vector< uint8_t > &	body,
		const std::vector< http_header > &	headers = {} ) -> Result<http2_response>

Perform HTTP/2 POST request with binary body.

Parameters

path	Request path
body	Request body as bytes
headers	Additional headers (optional)

Returns

Result containing response or error

Definition at line 320 of file http2_client.cpp.

    {
        return send_request("POST", path, headers, body);
    }

References kcenon::network::protocols::http2::headers.

process_frame()

auto kcenon::network::protocols::http2::http2_client::process_frame ( std::unique_ptr< frame > f ) -> VoidResult

private

Definition at line 728 of file http2_client.cpp.

    {
        if (!f)
        {
            return error_void(error_codes::common_errors::invalid_argument,
                              "Null frame", "http2_client::process_frame");
        }
 
        switch (f->header().type)
        {
        case frame_type::settings:
            if (auto* sf = dynamic_cast<settings_frame*>(f.get()))
            {
                return handle_settings_frame(*sf);
            }
            break;
 
        case frame_type::headers:
            if (auto* hf = dynamic_cast<headers_frame*>(f.get()))
            {
                return handle_headers_frame(*hf);
            }
            break;
 
        case frame_type::data:
            if (auto* df = dynamic_cast<data_frame*>(f.get()))
            {
                return handle_data_frame(*df);
            }
            break;
 
        case frame_type::rst_stream:
            if (auto* rf = dynamic_cast<rst_stream_frame*>(f.get()))
            {
                return handle_rst_stream_frame(*rf);
            }
            break;
 
        case frame_type::goaway:
            if (auto* gf = dynamic_cast<goaway_frame*>(f.get()))
            {
                return handle_goaway_frame(*gf);
            }
            break;
 
        case frame_type::window_update:
            if (auto* wf = dynamic_cast<window_update_frame*>(f.get()))
            {
                return handle_window_update_frame(*wf);
            }
            break;
 
        case frame_type::ping:
            if (auto* pf = dynamic_cast<ping_frame*>(f.get()))
            {
                return handle_ping_frame(*pf);
            }
            break;
 
        default:
            // Ignore unknown frame types
            break;
        }
 
        return ok();
    }

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

Here is the call graph for this function:

put()

auto kcenon::network::protocols::http2::http2_client::put	(	const std::string &	path,
		const std::string &	body,
		const std::vector< http_header > &	headers = {} ) -> Result<http2_response>

Perform HTTP/2 PUT request.

Parameters

path	Request path
body	Request body
headers	Additional headers (optional)

Returns

Result containing response or error

Definition at line 328 of file http2_client.cpp.

    {
        std::vector<uint8_t> body_bytes(body.begin(), body.end());
        return send_request("PUT", path, headers, body_bytes);
    }

References kcenon::network::protocols::http2::headers.

read_next_frame()

auto kcenon::network::protocols::http2::http2_client::read_next_frame ( ) -> void

private

Definition at line 678 of file http2_client.cpp.

    {
        if (!is_running_) return;
        auto bytes = std::make_shared<std::vector<uint8_t>>(FRAME_HEADER_SIZE);
        asio::async_read(*socket_, asio::buffer(*bytes),
            [this, bytes](std::error_code ec, std::size_t) {
                if (ec || !is_running_)
                {
                    if (ec) is_connected_ = false;
                    return;
                }
                auto header = frame_header::parse(*bytes);
                if (header.is_err())
                {
                    is_connected_ = false;
                    return;
                }
                const auto length = header.value().length;
                bytes->resize(FRAME_HEADER_SIZE + length);
                auto complete = [this, bytes](std::error_code payload_error, std::size_t) {
                    if (payload_error || !is_running_)
                    {
                        if (payload_error) is_connected_ = false;
                        return;
                    }
                    try
                    {
                        auto parsed = frame::parse(*bytes);
                        if (parsed.is_err())
                        {
                            is_connected_ = false;
                            return;
                        }
                        process_frame(std::move(parsed.value()));
                        read_next_frame();
                    }
                    catch (...)
                    {
                        is_connected_ = false;
                    }
                };
                if (length == 0)
                    complete({}, 0);
                else
                    asio::async_read(*socket_,
                        asio::buffer(bytes->data() + FRAME_HEADER_SIZE, length),
                        std::move(complete));
            });
    }

run_io()

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

private

Definition at line 1264 of file http2_client.cpp.

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

send_connection_preface()

auto kcenon::network::protocols::http2::http2_client::send_connection_preface ( ) -> VoidResult

private

Definition at line 523 of file http2_client.cpp.

    {
        try
        {
            asio::write(*socket_,
                        asio::buffer(CONNECTION_PREFACE.data(), CONNECTION_PREFACE.size()));
            return ok();
        }
        catch (const std::exception& e)
        {
            return error_void(error_codes::network_system::send_failed,
                              std::string("Failed to send connection preface: ") + e.what(),
                              "http2_client::send_connection_preface");
        }
    }

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::error_codes::network_system::send_failed.

Here is the call graph for this function:

send_frame()

auto kcenon::network::protocols::http2::http2_client::send_frame ( const frame & f ) -> VoidResult

private

Definition at line 604 of file http2_client.cpp.

    {
        std::unique_lock<std::mutex> lock(io_submission_mutex_);
        if (!socket_ || !is_running_)
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Connection closed", "http2_client::send_frame");
        }
 
        try
        {
            auto data = f.serialize();
            if (!io_active_)
            {
                // Connection preface only: the reader has not started yet.
                asio::write(*socket_, asio::buffer(data));
                return ok();
            }
 
            auto completion = std::make_shared<std::promise<VoidResult>>();
            auto result = completion->get_future();
            const bool on_io_thread = io_context_->get_executor().running_in_this_thread();
            asio::post(*io_context_, [this, data = std::move(data), completion]() mutable {
                if (!is_running_)
                {
                    completion->set_value(error_void(
                        error_codes::network_system::connection_closed,
                        "Connection closed", "http2_client::send_frame"));
                    return;
                }
                const bool idle = pending_writes_.empty();
                pending_writes_.push_back({std::move(data), completion});
                if (idle) write_next_frame();
            });
            lock.unlock();
            // Frame handlers enqueue protocol replies without waiting on their
            // own executor. Public callers retain synchronous send results.
            return on_io_thread ? ok() : result.get();
        }
        catch (const std::exception& e)
        {
            return error_void(error_codes::network_system::send_failed,
                              std::string("Failed to send frame: ") + e.what(),
                              "http2_client::send_frame");
        }
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::protocols::http2::data, kcenon::network::error_void(), kcenon::network::protocols::http2::idle, kcenon::network::ok(), and kcenon::network::error_codes::network_system::send_failed.

Here is the call graph for this function:

send_request()

auto kcenon::network::protocols::http2::http2_client::send_request ( const std::string & method, const std::string & path, const std::vector< http_header > & headers, const std::vector< uint8_t > & body ) -> Result<http2_response>

private

Definition at line 833 of file http2_client.cpp.

    {
        // Create tracing span for HTTP request
        auto span = tracing::is_tracing_enabled()
            ? std::make_optional(tracing::trace_context::create_span("http2.request"))
            : std::nullopt;
        if (span)
        {
            span->set_attribute("http.method", method)
                 .set_attribute("http.url", "https://" + host_ + ":" + std::to_string(port_) + path)
                 .set_attribute("http.flavor", "2.0")
                 .set_attribute("http.request.body_size", static_cast<int64_t>(body.size()))
                 .set_attribute("net.peer.name", host_)
                 .set_attribute("net.peer.port", static_cast<int64_t>(port_));
        }
 
        if (!is_connected())
        {
            if (span)
            {
                span->set_error("Not connected");
            }
            return error<http2_response>(error_codes::network_system::connection_closed,
                                         "Not connected",
                                         "http2_client::send_request");
        }
 
        // Create stream
        http2_stream& stream = create_stream();
        stream.state = stream_state::open;
 
        if (span)
        {
            span->set_attribute("http2.stream_id", static_cast<int64_t>(stream.stream_id));
        }
 
        // Build headers
        auto request_headers = build_headers(method, path, headers);
        stream.request_headers = request_headers;
        stream.request_body = body;
 
        // Encode headers with HPACK
        auto encoded_headers = encoder_.encode(request_headers);
 
        // Send HEADERS frame
        bool end_stream = body.empty();
        if (end_stream) stream.state = stream_state::half_closed_local;
        headers_frame hf(stream.stream_id, std::move(encoded_headers), end_stream, true);
 
        auto send_result = send_frame(hf);
        if (send_result.is_err())
        {
            close_stream(stream.stream_id);
            const auto& err = send_result.error();
            if (span)
            {
                span->set_error(err.message);
            }
            return error<http2_response>(err.code, err.message,
                                         "http2_client::send_request",
                                         get_error_details(err));
        }
 
        // Send DATA frame if body exists
        if (!body.empty())
        {
            stream.state = stream_state::half_closed_local;
            data_frame df(stream.stream_id, std::vector<uint8_t>(body), true);
            send_result = send_frame(df);
            if (send_result.is_err())
            {
                close_stream(stream.stream_id);
                const auto& err = send_result.error();
                if (span)
                {
                    span->set_error(err.message);
                }
                return error<http2_response>(err.code, err.message,
                                             "http2_client::send_request",
                                             get_error_details(err));
            }
        }
 
        // Wait for response with timeout
        auto future = stream.promise.get_future();
        auto status = future.wait_for(timeout_.load());
 
        if (status == std::future_status::timeout)
        {
            close_stream(stream.stream_id);
            if (span)
            {
                span->set_error("Request timeout");
            }
            return error<http2_response>(error_codes::common_errors::timeout,
                                         "Request timeout",
                                         "http2_client::send_request");
        }
 
        auto response = future.get();
        if (span)
        {
            span->set_attribute("http.status_code", static_cast<int64_t>(response.status_code))
                 .set_attribute("http.response.body_size", static_cast<int64_t>(response.body.size()));
            if (response.status_code >= 400)
            {
                span->set_status(tracing::span_status::error, "HTTP " + std::to_string(response.status_code));
            }
            else
            {
                span->set_status(tracing::span_status::ok);
            }
        }
        return ok(std::move(response));
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::tracing::trace_context::create_span(), kcenon::network::error, kcenon::network::tracing::error, kcenon::network::get_error_details(), kcenon::network::protocols::http2::headers, kcenon::network::tracing::is_tracing_enabled(), kcenon::network::ok(), kcenon::network::tracing::ok, kcenon::network::protocols::http2::http2_stream::promise, kcenon::network::protocols::http2::http2_stream::request_body, kcenon::network::protocols::http2::http2_stream::request_headers, kcenon::network::protocols::http2::http2_stream::state, kcenon::network::protocols::http2::http2_stream::stream_id, and kcenon::network::error_codes::common_errors::timeout.

Here is the call graph for this function:

send_settings()

auto kcenon::network::protocols::http2::http2_client::send_settings ( ) -> VoidResult

private

Definition at line 539 of file http2_client.cpp.

    {
        std::vector<setting_parameter> params = {
            {static_cast<uint16_t>(setting_identifier::header_table_size),
             local_settings_.header_table_size},
            {static_cast<uint16_t>(setting_identifier::enable_push),
             local_settings_.enable_push ? 1u : 0u},
            {static_cast<uint16_t>(setting_identifier::max_concurrent_streams),
             local_settings_.max_concurrent_streams},
            {static_cast<uint16_t>(setting_identifier::initial_window_size),
             local_settings_.initial_window_size},
            {static_cast<uint16_t>(setting_identifier::max_frame_size),
             local_settings_.max_frame_size},
            {static_cast<uint16_t>(setting_identifier::max_header_list_size),
             local_settings_.max_header_list_size}
        };
 
        settings_frame settings(params, false);
        return send_frame(settings);
    }

References kcenon::network::protocols::http2::enable_push, kcenon::network::protocols::http2::header_table_size, kcenon::network::protocols::http2::initial_window_size, kcenon::network::protocols::http2::max_concurrent_streams, kcenon::network::protocols::http2::max_frame_size, kcenon::network::protocols::http2::max_header_list_size, and kcenon::network::protocols::http2::settings.

send_settings_ack()

auto kcenon::network::protocols::http2::http2_client::send_settings_ack ( ) -> VoidResult

private

Definition at line 598 of file http2_client.cpp.

    {
        settings_frame ack({}, true);
        return send_frame(ack);
    }

set_settings()

auto kcenon::network::protocols::http2::http2_client::set_settings

(

const http2_settings &

settings

)

-> void

Update local settings.

Parameters

settings

New settings to apply

Definition at line 359 of file http2_client.cpp.

    {
        local_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.

set_timeout()

auto kcenon::network::protocols::http2::http2_client::set_timeout

(

std::chrono::milliseconds

timeout

)

-> void

Set request timeout.

Parameters

timeout

Timeout duration

Definition at line 344 of file http2_client.cpp.

    {
        timeout_ = timeout;
    }

start_stream()

auto kcenon::network::protocols::http2::http2_client::start_stream	(	const std::string &	path,
		const std::vector< http_header > &	headers,
		std::function< void(std::vector< uint8_t >)>	on_data,
		std::function< void(std::vector< http_header >)>	on_headers,
		std::function< void(int)>	on_complete ) -> Result<uint32_t>

Start a streaming POST request.

Parameters

path	Request path
headers	Additional headers
on_data	Callback for each data chunk received
on_headers	Callback when headers are received
on_complete	Callback when stream completes (with status code)

Returns

Stream ID on success, or error

Use write_stream() to send data and close_stream_writer() when done.

Definition at line 366 of file http2_client.cpp.

    {
        if (!is_connected())
        {
            return error<uint32_t>(error_codes::network_system::connection_closed,
                                   "Not connected",
                                   "http2_client::start_stream");
        }
 
        // Create stream with callbacks
        http2_stream& stream = create_stream();
        stream.state = stream_state::open;
        stream.is_streaming = true;
        stream.on_data = std::move(on_data);
        stream.on_headers = std::move(on_headers);
        stream.on_complete = std::move(on_complete);
 
        // Build headers for POST (streaming requests use POST)
        auto request_headers = build_headers("POST", path, headers);
        stream.request_headers = request_headers;
 
        // Encode headers with HPACK
        auto encoded_headers = encoder_.encode(request_headers);
 
        // Send HEADERS frame (not end_stream since we might send more data)
        headers_frame hf(stream.stream_id, std::move(encoded_headers), false, true);
 
        auto send_result = send_frame(hf);
        if (send_result.is_err())
        {
            close_stream(stream.stream_id);
            const auto& err = send_result.error();
            return error<uint32_t>(err.code, err.message,
                                   "http2_client::start_stream",
                                   get_error_details(err));
        }
 
        uint32_t result_id = stream.stream_id;
        return ok(std::move(result_id));
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error, kcenon::network::get_error_details(), kcenon::network::protocols::http2::headers, kcenon::network::protocols::http2::http2_stream::is_streaming, kcenon::network::ok(), kcenon::network::protocols::http2::http2_stream::on_complete, kcenon::network::protocols::http2::http2_stream::on_data, kcenon::network::protocols::http2::http2_stream::on_headers, kcenon::network::protocols::http2::open, kcenon::network::protocols::http2::http2_stream::request_headers, kcenon::network::protocols::http2::http2_stream::state, and kcenon::network::protocols::http2::http2_stream::stream_id.

Here is the call graph for this function:

stop_io()

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

private

Definition at line 1270 of file http2_client.cpp.

    {
        {
            std::lock_guard<std::mutex> lock(io_submission_mutex_);
            is_running_ = false;
            is_connected_ = false;
            if (io_active_ && io_future_.valid())
            {
                // Cancel on the same executor as the SSL operations. Let run()
                // drain their handlers so every waiting writer is completed.
                asio::post(*io_context_, [this]() {
                    std::error_code ec;
                    socket_->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
                    socket_->lowest_layer().close(ec);
                    work_guard_->reset();
                });
            }
            else
            {
                if (socket_)
                {
                    std::error_code ec;
                    socket_->lowest_layer().close(ec);
                }
                if (work_guard_) work_guard_->reset();
            }
        }
 
        if (io_future_.valid()) io_future_.wait();
        std::lock_guard<std::mutex> lock(io_submission_mutex_);
        io_future_ = {};
        io_active_ = false;
        if (io_context_) io_context_->stop();
    }

write_next_frame()

auto kcenon::network::protocols::http2::http2_client::write_next_frame ( ) -> void

private

Definition at line 651 of file http2_client.cpp.

    {
        if (pending_writes_.empty()) return;
        asio::async_write(*socket_, asio::buffer(pending_writes_.front().data),
            [this](std::error_code ec, std::size_t) {
                auto completion = std::move(pending_writes_.front().completion);
                pending_writes_.pop_front();
                if (ec)
                {
                    is_connected_ = false;
                    completion->set_value(error_void(
                        error_codes::network_system::send_failed, ec.message(),
                        "http2_client::send_frame"));
                    while (!pending_writes_.empty())
                    {
                        pending_writes_.front().completion->set_value(error_void(
                            error_codes::network_system::send_failed, ec.message(),
                            "http2_client::send_frame"));
                        pending_writes_.pop_front();
                    }
                    return;
                }
                completion->set_value(ok());
                write_next_frame();
            });
    }

write_stream()

auto kcenon::network::protocols::http2::http2_client::write_stream	(	uint32_t	stream_id,
		const std::vector< uint8_t > &	data,
		bool	end_stream = false ) -> VoidResult

Write data to an open stream.

Parameters

stream_id	Stream identifier
data	Data to write
end_stream	Set to true to signal end of client data

Returns

Success or error

Definition at line 412 of file http2_client.cpp.

    {
        if (!is_connected())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Not connected",
                              "http2_client::write_stream");
        }
 
        auto* stream = get_stream(stream_id);
        if (!stream)
        {
            return error_void(error_codes::common_errors::not_found,
                              "Stream not found",
                              "http2_client::write_stream");
        }
 
        if (stream->state == stream_state::closed ||
            stream->state == stream_state::half_closed_local)
        {
            return error_void(error_codes::common_errors::internal_error,
                              "Stream not writable",
                              "http2_client::write_stream");
        }
 
        // Send DATA frame
        if (end_stream) stream->state = stream_state::half_closed_local;
        data_frame df(stream_id, std::vector<uint8_t>(data), end_stream);
        auto send_result = send_frame(df);
        if (send_result.is_err())
        {
            return send_result;
        }
 
        return ok();
    }

References kcenon::network::protocols::http2::closed, kcenon::network::error_codes::network_system::connection_closed, kcenon::network::protocols::http2::data, kcenon::network::error_void(), kcenon::network::protocols::http2::half_closed_local, kcenon::network::error_codes::common_errors::internal_error, kcenon::network::error_codes::common_errors::not_found, and kcenon::network::ok().

Here is the call graph for this function:

Member Data Documentation

client_id_

std::string kcenon::network::protocols::http2::http2_client::client_id_

private

Client identifier.

Definition at line 392 of file http2_client.h.

CONNECTION_PREFACE

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

staticconstexprprivate

Initial value:

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

Definition at line 442 of file http2_client.h.

connection_window_size_

int32_t kcenon::network::protocols::http2::http2_client::connection_window_size_ = 65535

private

Definition at line 425 of file http2_client.h.

decoder_

hpack_decoder kcenon::network::protocols::http2::http2_client::decoder_

private

Definition at line 433 of file http2_client.h.

DEFAULT_WINDOW_SIZE

size_t kcenon::network::protocols::http2::http2_client::DEFAULT_WINDOW_SIZE = 65535

staticconstexprprivate

Definition at line 445 of file http2_client.h.

encoder_

hpack_encoder kcenon::network::protocols::http2::http2_client::encoder_

private

Definition at line 432 of file http2_client.h.

FRAME_HEADER_SIZE

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

staticconstexprprivate

Definition at line 444 of file http2_client.h.

goaway_received_

std::atomic<bool> kcenon::network::protocols::http2::http2_client::goaway_received_ {false}

private

Definition at line 419 of file http2_client.h.

{false};

Referenced by is_connected().

host_

std::string kcenon::network::protocols::http2::http2_client::host_

private

Connected host.

Definition at line 393 of file http2_client.h.

io_active_

bool kcenon::network::protocols::http2::http2_client::io_active_ = false

private

Definition at line 408 of file http2_client.h.

io_context_

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

private

Definition at line 399 of file http2_client.h.

io_future_

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

private

Definition at line 403 of file http2_client.h.

io_submission_mutex_

std::mutex kcenon::network::protocols::http2::http2_client::io_submission_mutex_

private

Definition at line 407 of file http2_client.h.

is_connected_

std::atomic<bool> kcenon::network::protocols::http2::http2_client::is_connected_ {false}

private

Definition at line 417 of file http2_client.h.

{false};

Referenced by is_connected().

is_running_

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

private

Definition at line 418 of file http2_client.h.

{false};

lifecycle_mutex_

std::mutex kcenon::network::protocols::http2::http2_client::lifecycle_mutex_

private

Definition at line 398 of file http2_client.h.

local_settings_

http2_settings kcenon::network::protocols::http2::http2_client::local_settings_

private

Definition at line 428 of file http2_client.h.

Referenced by get_settings().

next_stream_id_

std::atomic<uint32_t> kcenon::network::protocols::http2::http2_client::next_stream_id_ {1}

private

Client streams are odd.

Definition at line 424 of file http2_client.h.

{1};        

pending_writes_

std::deque<pending_write> kcenon::network::protocols::http2::http2_client::pending_writes_

private

Definition at line 414 of file http2_client.h.

port_

unsigned short kcenon::network::protocols::http2::http2_client::port_ = 443

private

Connected port.

Definition at line 394 of file http2_client.h.

read_buffer_

std::vector<uint8_t> kcenon::network::protocols::http2::http2_client::read_buffer_

private

Definition at line 439 of file http2_client.h.

remote_settings_

http2_settings kcenon::network::protocols::http2::http2_client::remote_settings_

private

Definition at line 429 of file http2_client.h.

socket_

std::unique_ptr<asio::ssl::stream<asio::ip::tcp::socket> > kcenon::network::protocols::http2::http2_client::socket_

private

Definition at line 401 of file http2_client.h.

ssl_context_

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

private

Definition at line 400 of file http2_client.h.

streams_

std::map<uint32_t, http2_stream> kcenon::network::protocols::http2::http2_client::streams_

private

Definition at line 423 of file http2_client.h.

streams_mutex_

std::mutex kcenon::network::protocols::http2::http2_client::streams_mutex_

private

Definition at line 422 of file http2_client.h.

timeout_

std::atomic<std::chrono::milliseconds> kcenon::network::protocols::http2::http2_client::timeout_ {std::chrono::milliseconds(30000)}

private

Definition at line 436 of file http2_client.h.

{std::chrono::milliseconds(30000)};

Referenced by get_timeout().

work_guard_

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

private

Definition at line 402 of file http2_client.h.

---

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

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