tcp_client.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_TCP_TCP_CLIENT_HPP__
#define NEFORCE_NETWORK_TCP_TCP_CLIENT_HPP__

 
#include "NeForce/network/dns/dns_client.hpp"
#include "NeForce/network/ssl/ssl_socket.hpp"
NEFORCE_BEGIN_NAMESPACE__



class NEFORCE_API tcp_client_base {
public:
    using exception_handler_t = function<void(const exception&)>;    
    using connect_callback_t = function<void(const string&, ports)>; 
    using disconnect_callback_t = function<void()>;                  
 
protected:
    dns_client dns_;                
    unique_ptr<tcp_socket> socket_; 
 
    string connected_host_;                    
    ports connected_port_;                     
    int reconnect_attempts_ = 3;               
    atomic<int> current_reconnect_attempt_{0}; 
 
    milliseconds connect_timeout_{5000}; 
    milliseconds send_timeout_{5000};    
    milliseconds recv_timeout_{5000};    
    milliseconds reconnect_delay_{1000}; 
 
    bool auto_reconnect_ = false;         
    bool prefer_ipv6_ = false;            
    atomic<bool> is_reconnecting_{false}; 
 
    connect_callback_t connect_callback_;       
    disconnect_callback_t disconnect_callback_; 
    exception_handler_t exception_handler_;     

    virtual unique_ptr<tcp_socket> create_socket() = 0;

    virtual bool post_connect() { return true; }

    virtual void pre_disconnect() {}

    bool try_connect_to_ip(const string& ip, ports port);

    bool reconnect_if_needed();

    NEFORCE_ALWAYS_INLINE void handle_exception(const exception& e) const {
        if (exception_handler_) {
            exception_handler_(e);
        }
    }
 
public:
    tcp_client_base() = default;

    explicit tcp_client_base(dns_client dns) :
    dns_(_NEFORCE move(dns)) {}

    virtual ~tcp_client_base() { disconnect(); }
 
    tcp_client_base(const tcp_client_base&) = delete;
    tcp_client_base& operator=(const tcp_client_base&) = delete;
    tcp_client_base(tcp_client_base&&) noexcept = default;
    tcp_client_base& operator=(tcp_client_base&&) noexcept = default;

    void set_connect_timeout(milliseconds timeout);

    NEFORCE_NODISCARD milliseconds connect_timeout() const noexcept { return connect_timeout_; }

    void set_send_timeout(milliseconds timeout);

    NEFORCE_NODISCARD milliseconds send_timeout() const noexcept { return send_timeout_; }

    void set_recv_timeout(milliseconds timeout);

    NEFORCE_NODISCARD milliseconds recv_timeout() const noexcept { return recv_timeout_; }

    void set_auto_reconnect(bool enable, int max_attempts = 3);

    NEFORCE_NODISCARD bool is_auto_reconnect() const noexcept { return auto_reconnect_; }

    NEFORCE_NODISCARD int reconnect_attempts() const noexcept { return reconnect_attempts_; }

    NEFORCE_NODISCARD int current_reconnect_attempt() const noexcept { return current_reconnect_attempt_; }

    void set_reconnect_delay(milliseconds delay);

    NEFORCE_NODISCARD milliseconds reconnect_delay() const noexcept { return reconnect_delay_; }

    void set_prefer_ipv6(bool prefer) noexcept { prefer_ipv6_ = prefer; }

    NEFORCE_NODISCARD bool prefer_ipv6() const noexcept { return prefer_ipv6_; }

    void set_dns_server(dns_client::config cfg) { dns_.set_config(move(cfg)); }

    void set_exception_handler(exception_handler_t handler) { exception_handler_ = move(handler); }

    void set_connect_callback(connect_callback_t callback) { connect_callback_ = move(callback); }

    void set_disconnect_callback(disconnect_callback_t callback) { disconnect_callback_ = move(callback); }

    virtual bool connect(const string& host, ports port);

    void disconnect() noexcept;

    ssize_t send(const void* data, size_t length);

    ssize_t send(string_view data) { return send(data.data(), data.size()); }

    bool send_all(const void* data, size_t length);

    bool send_all(string_view data) { return send_all(data.data(), data.size()); }

    ssize_t receive(void* buffer, size_t length);

    vector<char> receive_all(size_t max_size = 0);

    bool receive_exact(memory_view<char> buffer);

    optional<string> receive_line(size_t max_length = 8192);

    NEFORCE_NODISCARD bool is_connected() const noexcept { return socket_ && socket_->is_open(); }

    NEFORCE_NODISCARD bool is_reconnecting() const noexcept { return is_reconnecting_; }

    NEFORCE_NODISCARD const string& connected_host() const noexcept { return connected_host_; }

    NEFORCE_NODISCARD ports connected_port() const noexcept { return connected_port_; }

    NEFORCE_NODISCARD tcp_socket& socket();

    NEFORCE_NODISCARD const tcp_socket& socket() const;

    NEFORCE_NODISCARD dns_client& get_dns_client() noexcept { return dns_; }

    NEFORCE_NODISCARD const dns_client& get_dns_client() const noexcept { return dns_; }
};

class NEFORCE_API tcp_client final : public tcp_client_base {
public:
    using tcp_client_base::tcp_client_base;
 
protected:
    unique_ptr<tcp_socket> create_socket() override { return make_unique<tcp_socket>(); }
};
 // TCP


class NEFORCE_API ssl_client final : public tcp_client_base {
private:
    optional<ssl_context> ssl_ctx_; 
    string sni_hostname_;           
    bool verify_peer_ = true;       
    bool ssl_initialized_ = false;  
 
protected:
    unique_ptr<tcp_socket> create_socket() override { return make_unique<ssl_socket>(); }
 
    bool post_connect() override;
    void pre_disconnect() override { ssl_initialized_ = false; }
 
public:
    ssl_client() = default;

    explicit ssl_client(ssl_context ctx);

    void set_ssl_context(ssl_context ctx);

    void set_verify_peer(bool verify);
    NEFORCE_NODISCARD bool get_verify_peer() const noexcept { return verify_peer_; }

    void set_sni_hostname(string hostname);
    NEFORCE_NODISCARD const string& sni_hostname() const noexcept { return sni_hostname_; }

    bool load_ca_file(const string& ca_file);

    bool load_ca_path(const string& ca_path);

    NEFORCE_NODISCARD string_view peer_certificate_info() const;

    NEFORCE_NODISCARD string_view cipher_name() const;

    NEFORCE_NODISCARD string_view protocol_version() const;

    NEFORCE_NODISCARD bool has_ssl_context() const noexcept { return ssl_ctx_.has_value() && ssl_ctx_->is_valid(); }

    NEFORCE_NODISCARD bool is_ssl_initialized() const noexcept { return ssl_initialized_; }

    NEFORCE_NODISCARD ssl_socket& ssl_socket_ref();

    NEFORCE_NODISCARD const ssl_socket& ssl_socket_ref() const;
};
 // SSL/TLS
 // Network
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_TCP_TCP_CLIENT_HPP__