common_defs.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
// Use nested namespace definition (C++17)
namespace kcenon::network::internal
{
    struct socket_config
    {
        std::size_t max_pending_bytes{0};
 
        std::size_t high_water_mark{1024 * 1024};
 
        std::size_t low_water_mark{256 * 1024};
    };
 
    struct socket_metrics
    {
        std::atomic<std::size_t> total_bytes_sent{0};
        std::atomic<std::size_t> total_bytes_received{0};
        std::atomic<std::size_t> current_pending_bytes{0};
        std::atomic<std::size_t> peak_pending_bytes{0};
        std::atomic<std::size_t> backpressure_events{0};
        std::atomic<std::size_t> rejected_sends{0};
        std::atomic<std::size_t> send_count{0};
        std::atomic<std::size_t> receive_count{0};
 
        void reset()
        {
            total_bytes_sent.store(0);
            total_bytes_received.store(0);
            current_pending_bytes.store(0);
            peak_pending_bytes.store(0);
            backpressure_events.store(0);
            rejected_sends.store(0);
            send_count.store(0);
            receive_count.store(0);
        }
    };
 
    enum class data_mode : std::uint8_t {
        packet_mode = 1, 
        file_mode = 2,   
        binary_mode = 3  
    };
 
    enum class tls_version : std::uint8_t {
        tls_1_0 = 10,  
        tls_1_1 = 11,  
        tls_1_2 = 12,  
        tls_1_3 = 13   
    };
 
    enum class certificate_verification : std::uint8_t {
        none = 0,           
        verify_peer = 1,    
        verify_fail_if_no_peer_cert = 2  
    };
 
    struct tls_config {
        bool enabled = false;
 
        tls_version min_version = tls_version::tls_1_3;
 
        certificate_verification verify_mode = certificate_verification::verify_peer;
 
        std::optional<std::string> certificate_file;
 
        std::optional<std::string> private_key_file;
 
        std::optional<std::string> private_key_password;
 
        std::optional<std::string> ca_file;
 
        std::optional<std::string> ca_path;
 
        std::optional<std::string> cipher_list;
 
        std::optional<std::string> sni_hostname;
 
        bool enable_session_resumption = true;
 
        std::size_t handshake_timeout_ms = 10000;
 
        [[nodiscard]] auto is_valid() const -> bool {
            if (!enabled) {
                return true;  // Valid if disabled
            }
 
            // If verification is enabled, CA file/path is required
            if (verify_mode != certificate_verification::none) {
                if (!ca_file.has_value() && !ca_path.has_value()) {
                    return false;
                }
            }
 
            // Note: Certificate and private key validation depends on whether
            // this is a server or client configuration, which is context-dependent.
            // Server-specific validation should be done by the server class.
 
            return true;
        }
 
        [[nodiscard]] static auto insecure_for_testing() -> tls_config {
            tls_config config;
            config.enabled = true;
            config.verify_mode = certificate_verification::none;
            return config;
        }
 
        [[nodiscard]] static auto secure_defaults() -> tls_config {
            tls_config config;
            config.enabled = true;
            config.min_version = tls_version::tls_1_3;
            config.verify_mode = certificate_verification::verify_peer;
            config.enable_session_resumption = true;
            return config;
        }
 
        [[nodiscard]] static auto legacy_compatible() -> tls_config {
            tls_config config;
            config.enabled = true;
            config.min_version = tls_version::tls_1_2;
            config.verify_mode = certificate_verification::verify_peer;
            config.enable_session_resumption = true;
            return config;
        }
    };
 
    // Use inline variables for constants (C++17)
    inline constexpr std::size_t default_buffer_size = 4096;
    inline constexpr std::size_t default_timeout_ms = 5000;
    inline constexpr std::string_view default_client_id = "default_client";
    inline constexpr std::string_view default_server_id = "default_server";
 
    // TLS defaults
    inline constexpr std::string_view default_tls_cipher_list =
        "ECDHE-RSA-AES256-GCM-SHA384:"
        "ECDHE-RSA-AES128-GCM-SHA256:"
        "ECDHE-RSA-CHACHA20-POLY1305";
 
} // namespace kcenon::network::internal