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:

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_frame () -> Result< std::unique_ptr< frame > >
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::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::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::chrono::milliseconds	timeout_ {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 154 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 44 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 51 of file http2_client.cpp.

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

References disconnect(), and is_connected_.

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 685 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 846 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 430 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 713 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;
        }
    }

References kcenon::network::protocols::http2::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 395 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
        }
 
        // 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;
        }
 
        stream->state = stream_state::half_closed_local;
        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 66 of file http2_client.cpp.

    {
        // 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
        {
            // 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_connected_ = true;
            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;
            }
 
            // Start I/O thread
            work_guard_ = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(
                asio::make_work_guard(*io_context_));
 
            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;
            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::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(), and kcenon::network::tracing::ok.

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

References kcenon::network::protocols::http2::idle.

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 277 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 210 of file http2_client.cpp.

    {
        if (!is_connected_)
        {
            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 244 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 294 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 691 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 289 of file http2_client.cpp.

    {
        return timeout_;
    }

References timeout_.

handle_data_frame()

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

private

Definition at line 960 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::closed, 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 1069 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::protocols::http2::closed, 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 875 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::protocols::http2::closed, 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 1114 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 1051 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::protocols::http2::closed, 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 503 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 1092 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)
        {
            // Connection-level window update
            connection_window_size_ += increment;
        }
        else
        {
            auto* stream = get_stream(stream_id);
            if (stream)
            {
                stream->window_size += increment;
            }
        }
 
        return ok();
    }

References kcenon::network::ok().

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 239 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 251 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 260 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 618 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::protocols::http2::data, kcenon::network::error_void(), kcenon::network::protocols::http2::goaway, kcenon::network::protocols::http2::headers, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), kcenon::network::protocols::http2::ping, kcenon::network::protocols::http2::rst_stream, kcenon::network::protocols::http2::settings, and kcenon::network::protocols::http2::window_update.

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 268 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_frame()

auto kcenon::network::protocols::http2::http2_client::read_frame ( ) -> Result<std::unique_ptr<frame>>

private

Definition at line 569 of file http2_client.cpp.

    {
        if (!socket_ || !socket_->lowest_layer().is_open())
        {
            return error<std::unique_ptr<frame>>(error_codes::network_system::connection_closed,
                                                 "Connection closed",
                                                 "http2_client::read_frame");
        }
 
        try
        {
            // Read frame header (9 bytes)
            std::vector<uint8_t> header_buf(FRAME_HEADER_SIZE);
            asio::read(*socket_, asio::buffer(header_buf));
 
            auto header_result = frame_header::parse(header_buf);
            if (header_result.is_err())
            {
                const auto& err = header_result.error();
                return error<std::unique_ptr<frame>>(err.code, err.message,
                                                     "http2_client::read_frame",
                                                     get_error_details(err));
            }
 
            const auto& header = header_result.value();
 
            // Read frame payload
            std::vector<uint8_t> payload(header.length);
            if (header.length > 0)
            {
                asio::read(*socket_, asio::buffer(payload));
            }
 
            // Combine header and payload for parsing
            std::vector<uint8_t> frame_data;
            frame_data.reserve(FRAME_HEADER_SIZE + payload.size());
            frame_data.insert(frame_data.end(), header_buf.begin(), header_buf.end());
            frame_data.insert(frame_data.end(), payload.begin(), payload.end());
 
            return frame::parse(frame_data);
        }
        catch (const std::exception& e)
        {
            return error<std::unique_ptr<frame>>(error_codes::network_system::receive_failed,
                                                 std::string("Failed to read frame: ") + e.what(),
                                                 "http2_client::read_frame");
        }
    }

References kcenon::network::error_codes::network_system::connection_closed, kcenon::network::error, kcenon::network::get_error_details(), kcenon::network::protocols::http2::frame::parse(), kcenon::network::protocols::http2::frame_header::parse(), and kcenon::network::error_codes::network_system::receive_failed.

Here is the call graph for this function:

run_io()

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

private

Definition at line 1125 of file http2_client.cpp.

    {
        while (is_running_ && is_connected_)
        {
            try
            {
                auto frame_result = read_frame();
                if (frame_result.is_err())
                {
                    if (is_running_)
                    {
                        is_connected_ = false;
                    }
                    break;
                }
 
                process_frame(std::move(frame_result.value()));
            }
            catch (...)
            {
                if (is_running_)
                {
                    is_connected_ = false;
                }
                break;
            }
        }
    }

send_connection_preface()

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

private

Definition at line 466 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 547 of file http2_client.cpp.

    {
        if (!socket_ || !socket_->lowest_layer().is_open())
        {
            return error_void(error_codes::network_system::connection_closed,
                              "Connection closed", "http2_client::send_frame");
        }
 
        try
        {
            auto data = f.serialize();
            asio::write(*socket_, asio::buffer(data));
            return ok();
        }
        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::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 723 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();
        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())
        {
            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));
            }
            stream.state = stream_state::half_closed_local;
        }
        else
        {
            stream.state = stream_state::half_closed_local;
        }
 
        // Wait for response with timeout
        auto future = stream.promise.get_future();
        auto status = future.wait_for(timeout_);
 
        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::half_closed_local, kcenon::network::protocols::http2::headers, kcenon::network::tracing::is_tracing_enabled(), kcenon::network::ok(), kcenon::network::tracing::ok, kcenon::network::protocols::http2::open, 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 482 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 541 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 299 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 284 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 306 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 1154 of file http2_client.cpp.

    {
        is_running_ = false;
 
        if (work_guard_)
        {
            work_guard_->reset();
        }
 
        if (socket_ && socket_->lowest_layer().is_open())
        {
            std::error_code ec;
            socket_->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
            socket_->lowest_layer().close(ec);
        }
 
        if (io_future_.valid())
        {
            io_future_.wait_for(std::chrono::seconds(5));
        }
 
        if (io_context_)
        {
            io_context_->stop();
        }
    }

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 352 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
        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;
        }
 
        if (end_stream)
        {
            stream->state = stream_state::half_closed_local;
        }
 
        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 365 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 402 of file http2_client.h.

connection_window_size_

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

private

Definition at line 385 of file http2_client.h.

decoder_

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

private

Definition at line 393 of file http2_client.h.

DEFAULT_WINDOW_SIZE

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

staticconstexprprivate

Definition at line 405 of file http2_client.h.

encoder_

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

private

Definition at line 392 of file http2_client.h.

FRAME_HEADER_SIZE

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

staticconstexprprivate

Definition at line 404 of file http2_client.h.

goaway_received_

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

private

Definition at line 379 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 366 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 370 of file http2_client.h.

io_future_

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

private

Definition at line 374 of file http2_client.h.

is_connected_

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

private

Definition at line 377 of file http2_client.h.

{false};

Referenced by is_connected(), and ~http2_client().

is_running_

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

private

Definition at line 378 of file http2_client.h.

{false};

local_settings_

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

private

Definition at line 388 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 384 of file http2_client.h.

{1};        

port_

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

private

Connected port.

Definition at line 367 of file http2_client.h.

read_buffer_

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

private

Definition at line 399 of file http2_client.h.

remote_settings_

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

private

Definition at line 389 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 372 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 371 of file http2_client.h.

streams_

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

private

Definition at line 383 of file http2_client.h.

streams_mutex_

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

private

Definition at line 382 of file http2_client.h.

timeout_

std::chrono::milliseconds kcenon::network::protocols::http2::http2_client::timeout_ {30000}

private

Definition at line 396 of file http2_client.h.

{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 373 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