kcenon::network::internal Namespace Reference

Namespaces
namespace	adapters

Classes
struct	cookie
	Represents an HTTP cookie. More...
class	dtls_socket
	A wrapper around ASIO UDP socket with OpenSSL DTLS encryption. More...
struct	http_error
	Structured HTTP error information. More...
class	http_error_response
	Builder for HTTP error responses. More...
class	http_parser
	Parser and serializer for HTTP messages (requests and responses) More...
struct	http_request
	Represents an HTTP request message. More...
struct	http_response
	Represents an HTTP response message. More...
struct	multipart_file
	Represents a file uploaded via multipart/form-data. More...
struct	parse_error
	Detailed HTTP parsing error information. More...
class	quic_socket
	A QUIC socket that wraps UDP and integrates QUIC packet protection. More...
class	secure_tcp_socket
	A lightweight wrapper around asio::ssl::stream<asio::ip::tcp::socket>, enabling asynchronous TLS/SSL encrypted read and write operations. More...
struct	socket_config
	Configuration for TCP socket backpressure control. More...
struct	socket_metrics
	Runtime metrics for socket monitoring. More...
class	tcp_socket
	A lightweight wrapper around asio::ip::tcp::socket, enabling asynchronous read and write operations. More...
struct	tls_config
	Configuration for TLS/SSL connections. More...
class	udp_socket
	A lightweight wrapper around asio::ip::udp::socket, enabling asynchronous datagram operations. More...
class	websocket_frame
	Provides WebSocket frame encoding and decoding functionality. More...
class	websocket_handshake
	Implements WebSocket HTTP/1.1 upgrade handshake (RFC 6455). More...
class	websocket_protocol
	WebSocket protocol handler for message processing. More...
class	websocket_socket
	WebSocket framing layer built on top of tcp_socket. More...
struct	ws_frame_header
	Represents a decoded WebSocket frame header. More...
struct	ws_handshake_result
	Result of a WebSocket handshake operation. More...
struct	ws_message
	Represents a complete WebSocket message. More...

Typedefs
template<typename T >
using	Result = ::kcenon::network::Result<T>
using	VoidResult = ::kcenon::network::VoidResult
using	error_info = ::kcenon::network::error_info

Enumerations
enum class	http_error_code {   bad_request = 400 , unauthorized = 401 , payment_required = 402 , forbidden = 403 ,   not_found = 404 , method_not_allowed = 405 , not_acceptable = 406 , proxy_authentication_required = 407 ,   request_timeout = 408 , conflict = 409 , gone = 410 , length_required = 411 ,   precondition_failed = 412 , payload_too_large = 413 , uri_too_long = 414 , unsupported_media_type = 415 ,   range_not_satisfiable = 416 , expectation_failed = 417 , im_a_teapot = 418 , misdirected_request = 421 ,   unprocessable_entity = 422 , locked = 423 , failed_dependency = 424 , too_early = 425 ,   upgrade_required = 426 , precondition_required = 428 , too_many_requests = 429 , request_header_fields_too_large = 431 ,   unavailable_for_legal_reasons = 451 , internal_server_error = 500 , not_implemented = 501 , bad_gateway = 502 ,   service_unavailable = 503 , gateway_timeout = 504 , http_version_not_supported = 505 , variant_also_negotiates = 506 ,   insufficient_storage = 507 , loop_detected = 508 , not_extended = 510 , network_authentication_required = 511 }
	Standard HTTP error codes (RFC 7231) More...
enum class	parse_error_type {   invalid_method , invalid_uri , invalid_version , invalid_header ,   incomplete_headers , incomplete_body , body_too_large , header_too_large ,   malformed_request }
	Types of HTTP parsing errors. More...
enum class	http_method {   HTTP_GET , HTTP_POST , HTTP_PUT , HTTP_DELETE ,   HTTP_HEAD , HTTP_OPTIONS , HTTP_PATCH , HTTP_CONNECT ,   HTTP_TRACE }
	HTTP request methods (verbs) More...
enum class	http_version { HTTP_1_0 , HTTP_1_1 , HTTP_2_0 }
	HTTP protocol version. More...
enum class	quic_role : uint8_t { client = 0 , server = 1 }
	Role of the QUIC endpoint (client or server) More...
enum class	quic_connection_state : uint8_t {   idle = 0 , handshake_start = 1 , handshake = 2 , connected = 3 ,   closing = 4 , draining = 5 , closed = 6 }
	QUIC connection state machine states. More...
enum class	data_mode : std::uint8_t { packet_mode = 1 , file_mode = 2 , binary_mode = 3 }
	Represents a simple enumeration for differentiating data transmission modes. More...
enum class	tls_version : std::uint8_t { tls_1_0 = 10 , tls_1_1 = 11 , tls_1_2 = 12 , tls_1_3 = 13 }
	TLS protocol versions. More...
enum class	certificate_verification : std::uint8_t { none = 0 , verify_peer = 1 , verify_fail_if_no_peer_cert = 2 }
	Certificate verification modes. More...
enum class	ws_opcode : uint8_t {   continuation = 0x0 , text = 0x1 , binary = 0x2 , close = 0x8 ,   ping = 0x9 , pong = 0xA }
	WebSocket frame operation codes as defined in RFC 6455. More...
enum class	ws_message_type { text , binary }
	Type of WebSocket message. More...
enum class	ws_close_code : uint16_t {   normal = 1000 , going_away = 1001 , protocol_error = 1002 , unsupported_data = 1003 ,   invalid_frame = 1007 , policy_violation = 1008 , message_too_big = 1009 , internal_error = 1011 }
	WebSocket close status codes (RFC 6455 Section 7.4). More...
enum class	ws_state { connecting , open , closing , closed }
	WebSocket connection state (RFC 6455 Section 7). More...

Functions
auto	get_error_status_text (http_error_code code) -> std::string_view
	Get status text for HTTP error code.
auto	http_method_to_string (http_method method) -> std::string
	Convert HTTP method enum to string.
auto	string_to_http_method (const std::string &method_str) -> ::kcenon::network::internal::Result< http_method >
	Convert string to HTTP method enum.
auto	http_version_to_string (http_version version) -> std::string
	Convert HTTP version enum to string.
auto	string_to_http_version (const std::string &version_str) -> ::kcenon::network::internal::Result< http_version >
	Convert string to HTTP version enum.
auto	get_status_message (int status_code) -> std::string
	Get HTTP status message for a status code.
static auto	escape_json_string (const std::string &input) -> std::string
static auto	escape_html_string (const std::string &input) -> std::string
const char *	openssl_version_string () noexcept
	Get OpenSSL version string.
std::string	get_openssl_error () noexcept
	Get last OpenSSL error as string.
void	clear_openssl_errors () noexcept
	Clear all OpenSSL errors from the thread's error queue.

Variables
constexpr std::size_t	default_buffer_size = 4096
constexpr std::size_t	default_timeout_ms = 5000
constexpr std::string_view	default_client_id = "default_client"
constexpr std::string_view	default_server_id = "default_server"
constexpr std::string_view	default_tls_cipher_list

Typedef Documentation

error_info

using kcenon::network::internal::error_info = ::kcenon::network::error_info

Definition at line 171 of file result_types.h.

Result

template<typename T >

using kcenon::network::internal::Result = ::kcenon::network::Result<T>

Definition at line 169 of file result_types.h.

VoidResult

using kcenon::network::internal::VoidResult = ::kcenon::network::VoidResult

Definition at line 170 of file result_types.h.

Enumeration Type Documentation

certificate_verification

enum class kcenon::network::internal::certificate_verification : std::uint8_t

strong

Certificate verification modes.

Enumerator
none	No verification (insecure, testing only)
verify_peer	Verify peer certificate
verify_fail_if_no_peer_cert	Fail if peer doesn't provide cert

Definition at line 124 of file common_defs.h.

                                        : std::uint8_t {
        none = 0,           
        verify_peer = 1,    
        verify_fail_if_no_peer_cert = 2  
    };

data_mode

enum class kcenon::network::internal::data_mode : std::uint8_t

strong

Represents a simple enumeration for differentiating data transmission modes.

A higher-level code might use these to switch between packet-based, file-based, or binary data logic. They are optional stubs and can be extended as needed.

Enumerator
packet_mode	Regular messaging/packet mode.
file_mode	File transfer mode.
binary_mode	Raw binary data mode.

Definition at line 100 of file common_defs.h.

                         : std::uint8_t {
        packet_mode = 1, 
        file_mode = 2,   
        binary_mode = 3  
    };

http_error_code

enum class kcenon::network::internal::http_error_code

strong

Standard HTTP error codes (RFC 7231)

Enumerator
bad_request
unauthorized
payment_required
forbidden
not_found
method_not_allowed
not_acceptable
proxy_authentication_required
request_timeout
conflict
gone
length_required
precondition_failed
payload_too_large
uri_too_long
unsupported_media_type
range_not_satisfiable
expectation_failed
im_a_teapot
misdirected_request
unprocessable_entity
locked
failed_dependency
too_early
upgrade_required
precondition_required
too_many_requests
request_header_fields_too_large
unavailable_for_legal_reasons
internal_server_error
not_implemented
bad_gateway
service_unavailable
gateway_timeout
http_version_not_supported
variant_also_negotiates
insufficient_storage
loop_detected
not_extended
network_authentication_required

Definition at line 19 of file http_error.h.

    {
        // Client Errors (4xx)
        bad_request = 400,
        unauthorized = 401,
        payment_required = 402,
        forbidden = 403,
        not_found = 404,
        method_not_allowed = 405,
        not_acceptable = 406,
        proxy_authentication_required = 407,
        request_timeout = 408,
        conflict = 409,
        gone = 410,
        length_required = 411,
        precondition_failed = 412,
        payload_too_large = 413,
        uri_too_long = 414,
        unsupported_media_type = 415,
        range_not_satisfiable = 416,
        expectation_failed = 417,
        im_a_teapot = 418,
        misdirected_request = 421,
        unprocessable_entity = 422,
        locked = 423,
        failed_dependency = 424,
        too_early = 425,
        upgrade_required = 426,
        precondition_required = 428,
        too_many_requests = 429,
        request_header_fields_too_large = 431,
        unavailable_for_legal_reasons = 451,
 
        // Server Errors (5xx)
        internal_server_error = 500,
        not_implemented = 501,
        bad_gateway = 502,
        service_unavailable = 503,
        gateway_timeout = 504,
        http_version_not_supported = 505,
        variant_also_negotiates = 506,
        insufficient_storage = 507,
        loop_detected = 508,
        not_extended = 510,
        network_authentication_required = 511
    };

http_method

enum class kcenon::network::internal::http_method

strong

HTTP request methods (verbs)

Note: Uses HTTP_ prefix to avoid conflicts with Windows macros (DELETE)

Enumerator
HTTP_GET
HTTP_POST
HTTP_PUT
HTTP_DELETE
HTTP_HEAD
HTTP_OPTIONS
HTTP_PATCH
HTTP_CONNECT
HTTP_TRACE

Definition at line 23 of file http_types.h.

    {
        HTTP_GET,
        HTTP_POST,
        HTTP_PUT,
        HTTP_DELETE,
        HTTP_HEAD,
        HTTP_OPTIONS,
        HTTP_PATCH,
        HTTP_CONNECT,
        HTTP_TRACE
    };

http_version

enum class kcenon::network::internal::http_version

strong

HTTP protocol version.

Enumerator
HTTP_1_0
HTTP_1_1
HTTP_2_0

Definition at line 40 of file http_types.h.

    {
        HTTP_1_0,
        HTTP_1_1,
        HTTP_2_0
    };

parse_error_type

enum class kcenon::network::internal::parse_error_type

strong

Types of HTTP parsing errors.

Enumerator
invalid_method
invalid_uri
invalid_version
invalid_header
incomplete_headers
incomplete_body
body_too_large
header_too_large
malformed_request

Definition at line 116 of file http_error.h.

    {
        invalid_method,
        invalid_uri,
        invalid_version,
        invalid_header,
        incomplete_headers,
        incomplete_body,
        body_too_large,
        header_too_large,
        malformed_request
    };

quic_connection_state

enum class kcenon::network::internal::quic_connection_state : uint8_t

strong

QUIC connection state machine states.

Enumerator
idle	Not yet started.
handshake_start	Initiating handshake.
handshake	Handshake in progress.
connected	Connection established.
closing	Closing connection.
draining	Draining period before close.
closed	Connection closed.

Definition at line 40 of file quic_socket.h.

    {
        idle = 0,              
        handshake_start = 1,   
        handshake = 2,         
        connected = 3,         
        closing = 4,           
        draining = 5,          
        closed = 6             
    };

quic_role

enum class kcenon::network::internal::quic_role : uint8_t

strong

Role of the QUIC endpoint (client or server)

Enumerator
client
server

Definition at line 30 of file quic_socket.h.

    {
        client = 0,
        server = 1
    };

tls_version

enum class kcenon::network::internal::tls_version : std::uint8_t

strong

TLS protocol versions.

Specifies which TLS version to use for secure connections. Modern applications should use TLS 1.2 or 1.3.

Enumerator
tls_1_0	TLS 1.0 (deprecated, insecure)
tls_1_1	TLS 1.1 (deprecated, insecure)
tls_1_2	TLS 1.2 (secure, widely supported)
tls_1_3	TLS 1.3 (most secure, recommended)

Definition at line 113 of file common_defs.h.

                           : std::uint8_t {
        tls_1_0 = 10,  
        tls_1_1 = 11,  
        tls_1_2 = 12,  
        tls_1_3 = 13   
    };

ws_close_code

enum class kcenon::network::internal::ws_close_code : uint16_t

strong

WebSocket close status codes (RFC 6455 Section 7.4).

These codes indicate the reason for closing the WebSocket connection.

Enumerator
normal	Normal closure.
going_away	Endpoint is going away.
protocol_error	Protocol error.
unsupported_data	Unsupported data type.
invalid_frame	Invalid frame payload data.
policy_violation	Policy violation.
message_too_big	Message too large.
internal_error	Internal server error.

Definition at line 60 of file websocket_protocol.h.

    {
        normal = 1000,            
        going_away = 1001,        
        protocol_error = 1002,    
        unsupported_data = 1003,  
        invalid_frame = 1007,     
        policy_violation = 1008,  
        message_too_big = 1009,   
        internal_error = 1011     
    };

ws_message_type

enum class kcenon::network::internal::ws_message_type

strong

Type of WebSocket message.

WebSocket supports two types of data messages: text (UTF-8) and binary.

Enumerator
text	Text message (UTF-8 encoded)
binary	Binary message.

Definition at line 23 of file websocket_protocol.h.

    {
        text,   
        binary  
    };

ws_opcode

enum class kcenon::network::internal::ws_opcode : uint8_t

strong

WebSocket frame operation codes as defined in RFC 6455.

These opcodes indicate the type of data contained in a WebSocket frame. The values are from the WebSocket protocol specification.

Enumerator
continuation	Continuation frame.
text	Text frame (UTF-8 encoded)
binary	Binary frame.
close	Connection close frame.
ping	Ping frame.
pong	Pong frame.

Definition at line 21 of file websocket_frame.h.

    {
        continuation = 0x0,  
        text = 0x1,          
        binary = 0x2,        
        close = 0x8,         
        ping = 0x9,          
        pong = 0xA           
    };

ws_state

enum class kcenon::network::internal::ws_state

strong

WebSocket connection state (RFC 6455 Section 7).

Tracks the lifecycle of a WebSocket connection from initial connection through the closing handshake.

Enumerator
connecting	Handshake in progress.
open	Connection established and ready.
closing	Close handshake initiated.
closed	Connection closed.

Definition at line 32 of file websocket_socket.h.

    {
        connecting, 
        open,       
        closing,    
        closed      
    };

Function Documentation

clear_openssl_errors()

void kcenon::network::internal::clear_openssl_errors ( )

inlinenoexcept

Clear all OpenSSL errors from the thread's error queue.

This should be called before operations where you want to check for fresh errors.

Definition at line 115 of file openssl_compat.h.

{
    ERR_clear_error();
}

escape_html_string()

static auto kcenon::network::internal::escape_html_string ( const std::string & input ) -> std::string

static

Definition at line 151 of file http_error.cpp.

{
    std::ostringstream oss;
    for (char c : input)
    {
        switch (c)
        {
        case '&':
            oss << "&amp;";
            break;
        case '<':
            oss << "&lt;";
            break;
        case '>':
            oss << "&gt;";
            break;
        case '"':
            oss << "&quot;";
            break;
        case '\'':
            oss << "&#39;";
            break;
        default:
            oss << c;
            break;
        }
    }
    return oss.str();
}

Referenced by kcenon::network::internal::http_error_response::build_html_error().

Here is the caller graph for this function:

escape_json_string()

static auto kcenon::network::internal::escape_json_string ( const std::string & input ) -> std::string

static

Definition at line 106 of file http_error.cpp.

{
    std::ostringstream oss;
    for (char c : input)
    {
        switch (c)
        {
        case '"':
            oss << "\\\"";
            break;
        case '\\':
            oss << "\\\\";
            break;
        case '\b':
            oss << "\\b";
            break;
        case '\f':
            oss << "\\f";
            break;
        case '\n':
            oss << "\\n";
            break;
        case '\r':
            oss << "\\r";
            break;
        case '\t':
            oss << "\\t";
            break;
        default:
            if (static_cast<unsigned char>(c) < 0x20)
            {
                oss << "\\u" << std::hex << std::setw(4) << std::setfill('0')
                    << static_cast<int>(c);
            }
            else
            {
                oss << c;
            }
            break;
        }
    }
    return oss.str();
}

Referenced by kcenon::network::internal::http_error_response::build_json_error().

Here is the caller graph for this function:

get_error_status_text()

auto kcenon::network::internal::get_error_status_text

(

http_error_code

code

)

-> std::string_view

Get status text for HTTP error code.

Parameters

code	HTTP error code

Returns

Status text (e.g., "Not Found")

Definition at line 13 of file http_error.cpp.

{
    switch (code)
    {
        // Client Errors (4xx)
    case http_error_code::bad_request:
        return "Bad Request";
    case http_error_code::unauthorized:
        return "Unauthorized";
    case http_error_code::payment_required:
        return "Payment Required";
    case http_error_code::forbidden:
        return "Forbidden";
    case http_error_code::not_found:
        return "Not Found";
    case http_error_code::method_not_allowed:
        return "Method Not Allowed";
    case http_error_code::not_acceptable:
        return "Not Acceptable";
    case http_error_code::proxy_authentication_required:
        return "Proxy Authentication Required";
    case http_error_code::request_timeout:
        return "Request Timeout";
    case http_error_code::conflict:
        return "Conflict";
    case http_error_code::gone:
        return "Gone";
    case http_error_code::length_required:
        return "Length Required";
    case http_error_code::precondition_failed:
        return "Precondition Failed";
    case http_error_code::payload_too_large:
        return "Payload Too Large";
    case http_error_code::uri_too_long:
        return "URI Too Long";
    case http_error_code::unsupported_media_type:
        return "Unsupported Media Type";
    case http_error_code::range_not_satisfiable:
        return "Range Not Satisfiable";
    case http_error_code::expectation_failed:
        return "Expectation Failed";
    case http_error_code::im_a_teapot:
        return "I'm a teapot";
    case http_error_code::misdirected_request:
        return "Misdirected Request";
    case http_error_code::unprocessable_entity:
        return "Unprocessable Entity";
    case http_error_code::locked:
        return "Locked";
    case http_error_code::failed_dependency:
        return "Failed Dependency";
    case http_error_code::too_early:
        return "Too Early";
    case http_error_code::upgrade_required:
        return "Upgrade Required";
    case http_error_code::precondition_required:
        return "Precondition Required";
    case http_error_code::too_many_requests:
        return "Too Many Requests";
    case http_error_code::request_header_fields_too_large:
        return "Request Header Fields Too Large";
    case http_error_code::unavailable_for_legal_reasons:
        return "Unavailable For Legal Reasons";
 
        // Server Errors (5xx)
    case http_error_code::internal_server_error:
        return "Internal Server Error";
    case http_error_code::not_implemented:
        return "Not Implemented";
    case http_error_code::bad_gateway:
        return "Bad Gateway";
    case http_error_code::service_unavailable:
        return "Service Unavailable";
    case http_error_code::gateway_timeout:
        return "Gateway Timeout";
    case http_error_code::http_version_not_supported:
        return "HTTP Version Not Supported";
    case http_error_code::variant_also_negotiates:
        return "Variant Also Negotiates";
    case http_error_code::insufficient_storage:
        return "Insufficient Storage";
    case http_error_code::loop_detected:
        return "Loop Detected";
    case http_error_code::not_extended:
        return "Not Extended";
    case http_error_code::network_authentication_required:
        return "Network Authentication Required";
    default:
        return "Unknown Error";
    }
}

References bad_gateway, bad_request, conflict, expectation_failed, failed_dependency, forbidden, gateway_timeout, gone, http_version_not_supported, im_a_teapot, insufficient_storage, internal_server_error, length_required, locked, loop_detected, method_not_allowed, misdirected_request, network_authentication_required, not_acceptable, not_extended, not_found, not_implemented, payload_too_large, payment_required, precondition_failed, precondition_required, proxy_authentication_required, range_not_satisfiable, request_header_fields_too_large, request_timeout, service_unavailable, too_early, too_many_requests, unauthorized, unavailable_for_legal_reasons, unprocessable_entity, unsupported_media_type, upgrade_required, uri_too_long, and variant_also_negotiates.

Referenced by kcenon::network::internal::http_error_response::build_html_error(), kcenon::network::internal::http_error_response::build_json_error(), and kcenon::network::internal::http_error_response::make_error().

Here is the caller graph for this function:

get_openssl_error()

std::string kcenon::network::internal::get_openssl_error ( )

inlinenoexcept

Get last OpenSSL error as string.

Returns

Human-readable error message

This function works consistently across OpenSSL versions.

Definition at line 97 of file openssl_compat.h.

{
    unsigned long err = ERR_get_error();
    if (err == 0)
    {
        return "No OpenSSL error";
    }
    char buf[256];
    ERR_error_string_n(err, buf, sizeof(buf));
    return std::string(buf);
}

get_status_message()

auto kcenon::network::internal::get_status_message

(

int

status_code

)

-> std::string

Get HTTP status message for a status code.

Parameters

status_code

HTTP status code

Returns

Status message (e.g., "OK" for 200)

Definition at line 177 of file http_types.cpp.

    {
        switch (status_code)
        {
            // 1xx Informational
            case 100: return "Continue";
            case 101: return "Switching Protocols";
 
            // 2xx Success
            case 200: return "OK";
            case 201: return "Created";
            case 202: return "Accepted";
            case 203: return "Non-Authoritative Information";
            case 204: return "No Content";
            case 205: return "Reset Content";
            case 206: return "Partial Content";
 
            // 3xx Redirection
            case 300: return "Multiple Choices";
            case 301: return "Moved Permanently";
            case 302: return "Found";
            case 303: return "See Other";
            case 304: return "Not Modified";
            case 307: return "Temporary Redirect";
            case 308: return "Permanent Redirect";
 
            // 4xx Client Error
            case 400: return "Bad Request";
            case 401: return "Unauthorized";
            case 402: return "Payment Required";
            case 403: return "Forbidden";
            case 404: return "Not Found";
            case 405: return "Method Not Allowed";
            case 406: return "Not Acceptable";
            case 407: return "Proxy Authentication Required";
            case 408: return "Request Timeout";
            case 409: return "Conflict";
            case 410: return "Gone";
            case 411: return "Length Required";
            case 412: return "Precondition Failed";
            case 413: return "Payload Too Large";
            case 414: return "URI Too Long";
            case 415: return "Unsupported Media Type";
            case 416: return "Range Not Satisfiable";
            case 417: return "Expectation Failed";
            case 429: return "Too Many Requests";
 
            // 5xx Server Error
            case 500: return "Internal Server Error";
            case 501: return "Not Implemented";
            case 502: return "Bad Gateway";
            case 503: return "Service Unavailable";
            case 504: return "Gateway Timeout";
            case 505: return "HTTP Version Not Supported";
 
            default:  return "Unknown";
        }
    }

Referenced by kcenon::network::internal::http_parser::parse_status_line().

Here is the caller graph for this function:

http_method_to_string()

auto kcenon::network::internal::http_method_to_string

(

http_method

method

)

-> std::string

Convert HTTP method enum to string.

Parameters

method

HTTP method enum value

Returns

Method as string (e.g., "GET", "POST")

Definition at line 114 of file http_types.cpp.

    {
        switch (method)
        {
            case http_method::HTTP_GET:     return "GET";
            case http_method::HTTP_POST:    return "POST";
            case http_method::HTTP_PUT:     return "PUT";
            case http_method::HTTP_DELETE:  return "DELETE";
            case http_method::HTTP_HEAD:    return "HEAD";
            case http_method::HTTP_OPTIONS: return "OPTIONS";
            case http_method::HTTP_PATCH:   return "PATCH";
            case http_method::HTTP_CONNECT: return "CONNECT";
            case http_method::HTTP_TRACE:   return "TRACE";
            default:                        return "GET";
        }
    }

References HTTP_CONNECT, HTTP_DELETE, HTTP_GET, HTTP_HEAD, HTTP_OPTIONS, HTTP_PATCH, HTTP_POST, HTTP_PUT, and HTTP_TRACE.

Referenced by kcenon::network::internal::http_parser::serialize_request().

Here is the caller graph for this function:

http_version_to_string()

auto kcenon::network::internal::http_version_to_string

(

http_version

version

)

-> std::string

Convert HTTP version enum to string.

Parameters

version

HTTP version enum value

Returns

Version as string (e.g., "HTTP/1.1")

Definition at line 153 of file http_types.cpp.

    {
        switch (version)
        {
            case http_version::HTTP_1_0: return "HTTP/1.0";
            case http_version::HTTP_1_1: return "HTTP/1.1";
            case http_version::HTTP_2_0: return "HTTP/2.0";
            default:                     return "HTTP/1.1";
        }
    }

References HTTP_1_0, HTTP_1_1, HTTP_2_0, and kcenon::network::version().

Referenced by kcenon::network::internal::http_parser::serialize_chunked_response(), kcenon::network::internal::http_parser::serialize_request(), and kcenon::network::internal::http_parser::serialize_response().

Here is the call graph for this function:

Here is the caller graph for this function:

openssl_version_string()

const char * kcenon::network::internal::openssl_version_string ( )

inlinenoexcept

Get OpenSSL version string.

Returns

Human-readable OpenSSL version string

Definition at line 86 of file openssl_compat.h.

{
    return OpenSSL_version(OPENSSL_VERSION);
}

string_to_http_method()

auto kcenon::network::internal::string_to_http_method

(

const std::string &

method_str

)

-> ::kcenon::network::internal::Result<http_method>

Convert string to HTTP method enum.

Parameters

method_str

Method string (e.g., "GET", "POST")

Returns

Result containing HTTP method enum value, or error if invalid

Possible errors:

• invalid_argument: Unknown HTTP method string

Definition at line 131 of file http_types.cpp.

    {
        auto upper_method = method_str;
        std::transform(upper_method.begin(), upper_method.end(), upper_method.begin(),
            [](unsigned char c) { return std::toupper(c); });
 
        if (upper_method == "GET")     return ::kcenon::network::ok(http_method::HTTP_GET);
        if (upper_method == "POST")    return ::kcenon::network::ok(http_method::HTTP_POST);
        if (upper_method == "PUT")     return ::kcenon::network::ok(http_method::HTTP_PUT);
        if (upper_method == "DELETE")  return ::kcenon::network::ok(http_method::HTTP_DELETE);
        if (upper_method == "HEAD")    return ::kcenon::network::ok(http_method::HTTP_HEAD);
        if (upper_method == "OPTIONS") return ::kcenon::network::ok(http_method::HTTP_OPTIONS);
        if (upper_method == "PATCH")   return ::kcenon::network::ok(http_method::HTTP_PATCH);
        if (upper_method == "CONNECT") return ::kcenon::network::ok(http_method::HTTP_CONNECT);
        if (upper_method == "TRACE")   return ::kcenon::network::ok(http_method::HTTP_TRACE);
 
        return ::kcenon::network::error<http_method>(
            ::kcenon::network::error_codes::common_errors::invalid_argument,
            "Unknown HTTP method: " + method_str,
            "http_types");
    }

References HTTP_CONNECT, HTTP_DELETE, HTTP_GET, HTTP_HEAD, HTTP_OPTIONS, HTTP_PATCH, HTTP_POST, HTTP_PUT, HTTP_TRACE, and kcenon::network::error_codes::common_errors::invalid_argument.

Referenced by kcenon::network::internal::http_parser::parse_request_line().

Here is the caller graph for this function:

string_to_http_version()

auto kcenon::network::internal::string_to_http_version

(

const std::string &

version_str

)

-> ::kcenon::network::internal::Result<http_version>

Convert string to HTTP version enum.

Parameters

version_str

Version string (e.g., "HTTP/1.1")

Returns

Result containing HTTP version enum value, or error if invalid

Possible errors:

• invalid_argument: Unknown HTTP version string

Definition at line 164 of file http_types.cpp.

    {
        if (version_str == "HTTP/1.0") return ::kcenon::network::ok(http_version::HTTP_1_0);
        if (version_str == "HTTP/1.1") return ::kcenon::network::ok(http_version::HTTP_1_1);
        if (version_str == "HTTP/2.0") return ::kcenon::network::ok(http_version::HTTP_2_0);
        if (version_str == "HTTP/2")   return ::kcenon::network::ok(http_version::HTTP_2_0);
 
        return ::kcenon::network::error<http_version>(
            ::kcenon::network::error_codes::common_errors::invalid_argument,
            "Unknown HTTP version: " + version_str,
            "http_types");
    }

References HTTP_1_0, HTTP_1_1, HTTP_2_0, and kcenon::network::error_codes::common_errors::invalid_argument.

Referenced by kcenon::network::internal::http_parser::parse_request_line(), and kcenon::network::internal::http_parser::parse_status_line().

Here is the caller graph for this function:

Variable Documentation

default_buffer_size

std::size_t kcenon::network::internal::default_buffer_size = 4096

inlineconstexpr

Definition at line 280 of file common_defs.h.

default_client_id

std::string_view kcenon::network::internal::default_client_id = "default_client"

inlineconstexpr

Definition at line 282 of file common_defs.h.

default_server_id

std::string_view kcenon::network::internal::default_server_id = "default_server"

inlineconstexpr

Definition at line 283 of file common_defs.h.

default_timeout_ms

std::size_t kcenon::network::internal::default_timeout_ms = 5000

inlineconstexpr

Definition at line 281 of file common_defs.h.

default_tls_cipher_list

std::string_view kcenon::network::internal::default_tls_cipher_list

inlineconstexpr

Initial value:

=
        "ECDHE-RSA-AES256-GCM-SHA384:"
        "ECDHE-RSA-AES128-GCM-SHA256:"
        "ECDHE-RSA-CHACHA20-POLY1305"

Definition at line 286 of file common_defs.h.