Main namespace for all Network System components. More...

Namespaces
namespace	concepts
	C++20 concepts for compile-time type validation in network_system.

namespace	config

namespace	core

namespace	error_codes

namespace	error_codes_ext

namespace	events

namespace	experimental

namespace	facade

namespace	http

namespace	integration

namespace	interfaces

namespace	internal

namespace	metrics

namespace	policy

namespace	protocol

namespace	protocols

namespace	security

namespace	session

namespace	tracing

namespace	unified

namespace	utils
	Utility components for network_system.

Classes
class	connection_guard
	RAII guard for connection limiting. More...

class	connection_limiter
	Connection count limiter. More...

struct	message_limits
	Configurable message size limits. More...

class	message_validator
	Message validator for network input validation. More...

struct	module_version
	Version information for network_system module. More...

class	per_client_connection_limiter
	Per-client connection limiter. More...

class	rate_limiter
	Token bucket rate limiter. More...

struct	rate_limiter_config
	Configuration for rate limiter. More...

class	Result

class	session_timeout_manager

struct	simple_error

Typedefs
using	VoidResult = Result<std::monostate>

using	error_info = simple_error

Enumerations
enum class	tcp_client_callback : std::size_t { receive = 0 , connected = 1 , disconnected = 2 , error = 3 }
	Callback indices for messaging_client and secure_messaging_client. More...

enum class	tcp_server_callback : std::size_t { connection = 0 , disconnection = 1 , receive = 2 , error = 3 }
	Callback indices for messaging_server and secure_messaging_server. More...

enum class	udp_client_callback : std::size_t { receive = 0 , error = 1 }
	Callback indices for messaging_udp_client. More...

enum class	secure_udp_client_callback : std::size_t { receive = 0 , connected = 1 , disconnected = 2 , error = 3 }
	Callback indices for secure_messaging_udp_client. More...

enum class	udp_server_callback : std::size_t { receive = 0 , error = 1 }
	Callback indices for messaging_udp_server. More...

enum class	unified_udp_client_callback : std::size_t { receive = 0 , connected = 1 , disconnected = 2 , error = 3 }
	Callback indices for unified_udp_messaging_client. More...

enum class	unified_udp_server_callback : std::size_t { receive = 0 , client_connected = 1 , client_disconnected = 2 , error = 3 }
	Callback indices for unified_udp_messaging_server. More...

enum class	ws_client_callback : std::size_t { message = 0 , text_message = 1 , binary_message = 2 , connected = 3 , disconnected = 4 , error = 5 }
	Callback indices for messaging_ws_client. More...

enum class	ws_server_callback : std::size_t { connection = 0 , disconnection = 1 , message = 2 , text_message = 3 , binary_message = 4 , error = 5 }
	Callback indices for messaging_ws_server. More...

enum class	quic_client_callback : std::size_t { receive = 0 , stream_receive = 1 , connected = 2 , disconnected = 3 , error = 4 }
	Callback indices for messaging_quic_client. More...

enum class	quic_server_callback : std::size_t { connection = 0 , disconnection = 1 , receive = 2 , stream_receive = 3 , error = 4 }
	Callback indices for messaging_quic_server. More...

enum class	validation_result { ok , size_exceeded , null_byte_detected , invalid_format , invalid_character , header_count_exceeded }
	Result type for validation operations. More...

Functions
template<typename T >
Result< T >	ok (T &&value)

VoidResult	ok ()

template<typename T >
Result< T >	error (int code, const std::string &message, const std::string &source="network_system", const std::string &details="")

VoidResult	error_void (int code, const std::string &message, const std::string &source="network_system", const std::string &details="")

std::string	get_error_details (const simple_error &err)

const std::string &	get_error_source (const simple_error &err)

VoidResult	kcenon::network::initialize ()
	Initialize the network system with default production configuration.

VoidResult	initialize (const config::network_config &config)
	Initialize the network system with custom settings.

VoidResult	initialize (const config::network_system_config &config)
	Initialize the network system with external dependencies.

VoidResult	kcenon::network::shutdown ()
	Shutdown the network system.

bool	kcenon::network::is_initialized ()
	Check if network system is initialized.

template<typename E >
constexpr auto	to_index (E e) noexcept -> std::size_t
	Helper to convert enum to std::size_t for callback_manager access.

const char *	to_string (validation_result result)
	Convert validation result to string.

constexpr const char *	kcenon::network::version () noexcept
	Get the network system version string.

Variables
static std::atomic< bool >	g_initialized {false}

Detailed Description

Main namespace for all Network System components.

Typedef Documentation

◆ error_info

using kcenon::network::error_info = simple_error

Definition at line 163 of file result_types.h.

◆ VoidResult

using kcenon::network::VoidResult = Result<std::monostate>

Definition at line 162 of file result_types.h.

Enumeration Type Documentation

◆ quic_client_callback

enum class kcenon::network::quic_client_callback : std::size_t

strong

Callback indices for messaging_quic_client.

QUIC client uses callbacks for: receive, stream_receive, connected, disconnected, error.

Enumerator
receive
stream_receive
connected
disconnected
error

Definition at line 133 of file callback_indices.h.

                                : std::size_t {
    receive = 0,
    stream_receive = 1,
    connected = 2,
    disconnected = 3,
    error = 4
};

◆ quic_server_callback

enum class kcenon::network::quic_server_callback : std::size_t

strong

Callback indices for messaging_quic_server.

QUIC server uses callbacks for: connection, disconnection, receive, stream_receive, error.

Enumerator
connection
disconnection
receive
stream_receive
error

Definition at line 147 of file callback_indices.h.

                                : std::size_t {
    connection = 0,
    disconnection = 1,
    receive = 2,
    stream_receive = 3,
    error = 4
};

◆ secure_udp_client_callback

enum class kcenon::network::secure_udp_client_callback : std::size_t

strong

Callback indices for secure_messaging_udp_client.

Secure UDP client uses callbacks for: receive, connected, disconnected, error.

Enumerator
receive
connected
disconnected
error

Definition at line 51 of file callback_indices.h.

                                      : std::size_t {
    receive = 0,
    connected = 1,
    disconnected = 2,
    error = 3
};

◆ tcp_client_callback

enum class kcenon::network::tcp_client_callback : std::size_t

strong

Callback indices for messaging_client and secure_messaging_client.

These clients use callbacks for: receive, connected, disconnected, error.

Enumerator
receive
connected
disconnected
error

Definition at line 17 of file callback_indices.h.

                               : std::size_t {
    receive = 0,
    connected = 1,
    disconnected = 2,
    error = 3
};

◆ tcp_server_callback

enum class kcenon::network::tcp_server_callback : std::size_t

strong

Callback indices for messaging_server and secure_messaging_server.

These servers use callbacks for: connection, disconnection, receive, error.

Enumerator
connection
disconnection
receive
error

Definition at line 29 of file callback_indices.h.

                               : std::size_t {
    connection = 0,
    disconnection = 1,
    receive = 2,
    error = 3
};

◆ udp_client_callback

enum class kcenon::network::udp_client_callback : std::size_t

strong

Callback indices for messaging_udp_client.

UDP client uses callbacks for: receive, error.

Enumerator
receive
error

Definition at line 41 of file callback_indices.h.

                               : std::size_t {
    receive = 0,
    error = 1
};

◆ udp_server_callback

enum class kcenon::network::udp_server_callback : std::size_t

strong

Callback indices for messaging_udp_server.

UDP server uses callbacks for: receive, error.

Enumerator
receive
error

Definition at line 63 of file callback_indices.h.

                               : std::size_t {
    receive = 0,
    error = 1
};

◆ unified_udp_client_callback

enum class kcenon::network::unified_udp_client_callback : std::size_t

strong

Callback indices for unified_udp_messaging_client.

Unified UDP client uses callbacks for: receive, connected, disconnected, error. The connected/disconnected callbacks are used for DTLS handshake completion. For plain UDP, connected is called immediately after start.

Enumerator
receive
connected
disconnected
error

Definition at line 75 of file callback_indices.h.

                                       : std::size_t {
    receive = 0,
    connected = 1,
    disconnected = 2,
    error = 3
};

◆ unified_udp_server_callback

enum class kcenon::network::unified_udp_server_callback : std::size_t

strong

Callback indices for unified_udp_messaging_server.

Unified UDP server uses callbacks for: receive, client_connected, client_disconnected, error. The client_connected/client_disconnected callbacks are used for DTLS sessions. For plain UDP, only receive and error are meaningful.

Enumerator
receive
client_connected
client_disconnected
error

Definition at line 90 of file callback_indices.h.

                                       : std::size_t {
    receive = 0,
    client_connected = 1,
    client_disconnected = 2,
    error = 3
};

◆ validation_result

enum class kcenon::network::validation_result

strong

Result type for validation operations.

Enumerator
ok	Validation passed.
size_exceeded	Size limit exceeded.
null_byte_detected	NULL byte found in string.
invalid_format	Invalid data format.
invalid_character	Invalid character detected.
header_count_exceeded	Too many headers.

Examples: /home/runner/work/network_system/network_system/src/internal/utils/message_validator.h.

Definition at line 76 of file message_validator.h.

                             {
    ok,                     
    size_exceeded,          
    null_byte_detected,     
    invalid_format,         
    invalid_character,      
    header_count_exceeded   
};

◆ ws_client_callback

enum class kcenon::network::ws_client_callback : std::size_t

strong

Callback indices for messaging_ws_client.

WebSocket client uses callbacks for: message, text_message, binary_message, connected, disconnected, error.

Enumerator
message
text_message
binary_message
connected
disconnected
error

Definition at line 103 of file callback_indices.h.

                              : std::size_t {
    message = 0,
    text_message = 1,
    binary_message = 2,
    connected = 3,
    disconnected = 4,
    error = 5
};

◆ ws_server_callback

enum class kcenon::network::ws_server_callback : std::size_t

strong

Callback indices for messaging_ws_server.

WebSocket server uses callbacks for: connection, disconnection, message, text_message, binary_message, error.

Enumerator
connection
disconnection
message
text_message
binary_message
error

Definition at line 118 of file callback_indices.h.

                              : std::size_t {
    connection = 0,
    disconnection = 1,
    message = 2,
    text_message = 3,
    binary_message = 4,
    error = 5
};

Function Documentation

◆ error()

template<typename T >

Result< T > kcenon::network::error	(	int	code,
		const std::string &	message,
		const std::string &	source = "network_system",
		const std::string &	details = "" )

inline

Definition at line 229 of file result_types.h.

                                                         {
        return Result<T>(simple_error(code, message, source, details));
    }

References message.

◆ error_void()

VoidResult kcenon::network::error_void	(	int	code,
		const std::string &	message,
		const std::string &	source = "network_system",
		const std::string &	details = "" )

inline

Definition at line 235 of file result_types.h.

                                                               {
        return VoidResult(simple_error(code, message, source, details));
    }

References message.

◆ get_error_details()

std::string kcenon::network::get_error_details ( const simple_error & err )

inline

Definition at line 242 of file result_types.h.

                                                                {
        return err.details;
    }

References kcenon::network::simple_error::details.

Here is the caller graph for this function:

◆ get_error_source()

const std::string & kcenon::network::get_error_source ( const simple_error & err )

inline

Definition at line 247 of file result_types.h.

                                                                      {
        return err.source;
    }

References kcenon::network::simple_error::source.

Referenced by kcenon::network::protocols::quic::quic_crypto::derive_initial_secrets(), kcenon::network::protocols::quic::packet_protection::protect_header(), kcenon::network::protocols::quic::packet_protection::unprotect_header(), and kcenon::network::protocols::quic::quic_crypto::update_keys().

Here is the caller graph for this function:

◆ initialize() [1/3]

VoidResult kcenon::network::initialize ( )

export

Initialize the network system with default production configuration.

Initialize the network system with default configuration.

This is the simplest way to initialize the network system. It uses production-optimized defaults with internally managed resources. Equivalent to calling initialize(network_config::production()).

Returns: VoidResult - ok() on success, error on failure

Possible errors:

already_exists: Network system already initialized
internal_error: System initialization failed

See also: initialize(const config::network_config&) For custom settings; initialize(const config::network_system_config&) For external dependencies

Returns: VoidResult - ok() on success, error on failure

Possible errors:

already_exists: Network system already initialized
internal_error: System initialization failed

Definition at line 27 of file network_system.cpp.

27{ return initialize(config::network_config::production()); }

kcenon::network::initialize

VoidResult initialize()

Initialize the network system with default production configuration.

Definition network_system.cpp:27

References initialize(), and kcenon::network::config::network_config::production().

Referenced by initialize(), and initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize() [2/3]

VoidResult kcenon::network::initialize ( const config::network_config & config )

Initialize the network system with custom settings.

Use this overload to customize thread pool, logger, and monitoring settings while letting the network system manage these resources internally.

Example:

// Use predefined configuration
auto result = initialize(network_config::development());
 
// Or customize specific settings
network_config cfg;
cfg.thread_pool.worker_count = 8;
cfg.logger.min_level = log_level::debug;
auto result = initialize(cfg);

Parameters

config Configuration settings for internal resource creation

Returns: VoidResult - ok() on success, error on failure

Possible errors:

already_exists: Network system already initialized
invalid_argument: Invalid configuration values
internal_error: System initialization failed

See also: network_config For available settings and factory methods; initialize(const config::network_system_config&) For external dependencies

Definition at line 29 of file network_system.cpp.

                                                          {
  if (g_initialized.load()) {
    NETWORK_LOG_WARN("[network_system] Already initialized");
    return error_void(already_exists, "Network system already initialized", "network_system");
  }
 
  try {
    auto &ctx = core::network_context::instance();
 
    // Initialize thread pool
    if (config.thread_pool.worker_count >= 0) {
      auto thread_pool = std::make_shared<integration::basic_thread_pool>(
          config.thread_pool.worker_count == 0
              ? std::thread::hardware_concurrency()
              : config.thread_pool.worker_count);
      ctx.set_thread_pool(thread_pool);
      ctx.initialize(config.thread_pool.worker_count);
    }
 
    // Initialize logger
    // Issue #285: Uses common_system_logger_adapter when available, basic_logger otherwise
#if KCENON_WITH_COMMON_SYSTEM
    auto logger = std::make_shared<integration::common_system_logger_adapter>();
#else
    auto logger = std::make_shared<integration::basic_logger>(config.logger.min_level);
#endif
    ctx.set_logger(logger);
    integration::logger_integration_manager::instance().set_logger(logger);
 
    // Initialize monitoring
#if KCENON_WITH_MONITORING_SYSTEM
    if (config.monitoring.enabled) {
      auto monitoring =
          std::make_shared<integration::monitoring_system_adapter>(
              config.monitoring.service_name);
      // Note: monitoring_system_adapter needs start() method
      // monitoring->start();
      ctx.set_monitoring(monitoring);
    }
#else
    (void)config.monitoring; // Suppress unused parameter warning
#endif
 
    g_initialized.store(true);
    NETWORK_LOG_INFO("[network_system] Initialized successfully");
 
    return ok();
  } catch (const std::exception &e) {
    NETWORK_LOG_ERROR("[network_system] Initialization failed: " +
                      std::string(e.what()));
    return error_void(internal_error, std::string("Initialization failed: ") + e.what(), "network_system");
  }
}

References config, error_void(), g_initialized, kcenon::network::core::network_context::instance(), kcenon::network::integration::logger_integration_manager::instance(), NETWORK_LOG_ERROR, NETWORK_LOG_INFO, NETWORK_LOG_WARN, ok(), and kcenon::network::integration::logger_integration_manager::set_logger().

Here is the call graph for this function:

◆ initialize() [3/3]

VoidResult kcenon::network::initialize ( const config::network_system_config & config )

Initialize the network system with external dependencies.

Use this overload when integrating the network system with existing application infrastructure. This allows sharing thread pools, loggers, and monitoring systems with other components in your application.

Example:

// Share existing infrastructure
network_system_config cfg;
cfg.executor = my_app_thread_pool;
cfg.logger = my_app_logger;
cfg.runtime = network_config::production();
auto result = initialize(cfg);

Parameters

config Configuration with external dependencies and runtime settings

Returns: VoidResult - ok() on success, error on failure

Possible errors:

already_exists: Network system already initialized
invalid_argument: Invalid configuration or dependencies
internal_error: System initialization failed

Note: Unset dependencies (nullptr) will be created internally using the runtime configuration settings.

See also: network_system_config For dependency injection options; initialize(const config::network_config&) For standalone usage

Definition at line 83 of file network_system.cpp.

                                                                                   {
#if KCENON_WITH_COMMON_SYSTEM
  auto &ctx = core::network_context::instance();
 
  if (config_with_dependencies.executor) {
    auto pool_adapter =
        std::make_shared<integration::common_thread_pool_adapter>(
            config_with_dependencies.executor);
    ctx.set_thread_pool(pool_adapter);
  }
 
  if (config_with_dependencies.logger) {
    auto logger_adapter = std::make_shared<integration::common_logger_adapter>(
        config_with_dependencies.logger);
    ctx.set_logger(logger_adapter);
  }
 
#if KCENON_WITH_MONITORING_SYSTEM
  if (config_with_dependencies.monitor) {
    auto monitoring_adapter =
        std::make_shared<integration::common_monitoring_adapter>(
            config_with_dependencies.monitor);
    ctx.set_monitoring(monitoring_adapter);
  }
#endif
#else
  (void)config_with_dependencies;
#endif
 
  return initialize(config_with_dependencies.runtime);
}

References kcenon::network::config::network_system_config::executor, initialize(), kcenon::network::core::network_context::instance(), kcenon::network::config::network_system_config::logger, kcenon::network::config::network_system_config::monitor, and kcenon::network::config::network_system_config::runtime.

Here is the call graph for this function:

◆ is_initialized()

bool kcenon::network::is_initialized ( )

exportnoexcept

Check if network system is initialized.

Returns: true if initialized, false otherwise

Definition at line 137 of file network_system.cpp.

137{ return g_initialized.load(); }

References g_initialized.

◆ ok() [1/2]

VoidResult kcenon::network::ok ( )

inline

Examples: /home/runner/work/network_system/network_system/include/kcenon/network/types/result.h, and /home/runner/work/network_system/network_system/src/internal/utils/message_validator.h.

Definition at line 224 of file result_types.h.

                           {
        return VoidResult(std::monostate{});
    }

◆ ok() [2/2]

template<typename T >

Result< T > kcenon::network::ok ( T && value )

inline

Definition at line 220 of file result_types.h.

                                   {
        return Result<T>(std::forward<T>(value));
    }

◆ shutdown()

VoidResult kcenon::network::shutdown ( )

export

Shutdown the network system.

Returns: VoidResult - ok() on success, error on failure

Possible errors:

not_initialized: Network system not initialized
internal_error: Shutdown failed

Definition at line 115 of file network_system.cpp.

                      {
  if (!g_initialized.load()) {
    return error_void(not_initialized, "Network system not initialized", "network_system");
  }
 
  try {
    NETWORK_LOG_INFO("[network_system] Shutting down...");
 
    auto &ctx = core::network_context::instance();
    ctx.shutdown();
 
    g_initialized.store(false);
    NETWORK_LOG_INFO("[network_system] Shutdown complete");
 
    return ok();
  } catch (const std::exception &e) {
    NETWORK_LOG_ERROR("[network_system] Shutdown error: " +
                      std::string(e.what()));
    return error_void(internal_error, std::string("Shutdown failed: ") + e.what(), "network_system");
  }
}

References error_void(), g_initialized, kcenon::network::core::network_context::instance(), NETWORK_LOG_ERROR, NETWORK_LOG_INFO, and ok().

Here is the call graph for this function:

◆ to_index()

template<typename E >

auto kcenon::network::to_index ( E e ) -> std::size_t

constexprnoexcept

Helper to convert enum to std::size_t for callback_manager access.

Template Parameters

E	The enum type.

Parameters

e	The enum value.

Returns: The underlying std::size_t value.

Definition at line 162 of file callback_indices.h.

{
    static_assert(std::is_enum_v<E>, "to_index requires an enum type");
    return static_cast<std::size_t>(e);
}

◆ to_string()

const char * kcenon::network::to_string ( validation_result result )

inline

Convert validation result to string.

Examples: /home/runner/work/network_system/network_system/src/internal/utils/message_validator.h.

Definition at line 88 of file message_validator.h.

                                                       {
    switch (result) {
        case validation_result::ok:
            return "ok";
        case validation_result::size_exceeded:
            return "size_exceeded";
        case validation_result::null_byte_detected:
            return "null_byte_detected";
        case validation_result::invalid_format:
            return "invalid_format";
        case validation_result::invalid_character:
            return "invalid_character";
        case validation_result::header_count_exceeded:
            return "header_count_exceeded";
        default:
            return "unknown";
    }
}

References header_count_exceeded, invalid_character, invalid_format, null_byte_detected, ok, and size_exceeded.

◆ version()

const char * kcenon::network::version ( )

constexprexportnoexcept

Get the network system version string.

Returns: Version string in "major.minor.patch.tweak" format

Definition at line 111 of file network.cppm.

                                         {
    return module_version::string;
}

References kcenon::network::module_version::string.

Referenced by kcenon::network::protocols::quic::packet_builder::build_handshake(), kcenon::network::protocols::quic::packet_builder::build_initial(), kcenon::network::protocols::quic::packet_builder::build_retry(), kcenon::network::protocols::quic::packet_builder::build_zero_rtt(), kcenon::network::protocols::quic::initial_keys::derive(), kcenon::network::internal::http_version_to_string(), and kcenon::network::protocols::quic::packet_parser::is_version_negotiation().

Here is the caller graph for this function:

Variable Documentation

◆ g_initialized

std::atomic<bool> kcenon::network::g_initialized {false}

static

Definition at line 25 of file network_system.cpp.

25{false};

Referenced by initialize(), is_initialized(), and shutdown().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ error_info

◆ VoidResult

Enumeration Type Documentation

◆ quic_client_callback

◆ quic_server_callback

◆ secure_udp_client_callback

◆ tcp_client_callback

◆ tcp_server_callback

◆ udp_client_callback

◆ udp_server_callback

◆ unified_udp_client_callback

◆ unified_udp_server_callback

◆ validation_result

◆ ws_client_callback

◆ ws_server_callback

Function Documentation

◆ error()

◆ error_void()

◆ get_error_details()

◆ get_error_source()

◆ initialize() [1/3]

◆ initialize() [2/3]

◆ initialize() [3/3]

◆ is_initialized()

◆ ok() [1/2]

◆ ok() [2/2]

◆ shutdown()

◆ to_index()

◆ to_string()

◆ version()

Variable Documentation

◆ g_initialized