ssl_stream.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_SSL_SSL_STREAM_HPP__
#define NEFORCE_NETWORK_SSL_SSL_STREAM_HPP__

 
#include "NeForce/core/async/async_stream.hpp"
#include "NeForce/core/async/cancellation_slot.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/async/use_awaitable.hpp"
#include "NeForce/network/ssl/ssl_context.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API ssl_stream final : public async_stream {
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            uintptr_t;
#else
            int;
#endif
 
private:
    struct ssl_deleter {
        void operator()(::SSL* ssl) const noexcept {
            if (ssl != nullptr) {
                ::SSL_free(ssl);
            }
        }
    };
 
    struct x509_deleter {
        void operator()(::X509* cert) const noexcept {
            if (cert != nullptr) {
                ::X509_free(cert);
            }
        }
    };
    using x509_ptr = unique_ptr<::X509, x509_deleter>;
 
    unique_ptr<::SSL, ssl_deleter> ssl_; 
    string last_error_;                  
 
    void handle_ssl_error(int ret, const char* operation);
 
public:
    ssl_stream() = default;

    explicit ssl_stream(const ssl_context& ctx) { reset(ctx); }

    ssl_stream(ssl_stream&& other) noexcept = default;

    ssl_stream& operator=(ssl_stream&& other) noexcept = default;

    void reset(const ssl_context& ctx);

    void set_fd(native_handle_type fd);

    void accept();

    bool connect();

    void close() noexcept;

    ssize_t read(void* buffer, size_t size);

    ssize_t write(const void* buffer, size_t size);

    vector<char> read_all(size_t max_size = 8192);

    bool write_all(const void* data, size_t size);

    NEFORCE_NODISCARD int pending() const;

    void set_sni_hostname(const string& hostname);

    NEFORCE_NODISCARD x509_ptr get_peer_certificate() const;

    NEFORCE_NODISCARD bool verify_peer() const;

    NEFORCE_NODISCARD string get_cipher_name() const;

    NEFORCE_NODISCARD string get_version() const;

    NEFORCE_NODISCARD string get_alpn_negotiated() const;

    NEFORCE_NODISCARD const string& last_error() const { return last_error_; }

    NEFORCE_NODISCARD bool is_valid() const noexcept { return ssl_ != nullptr; }

    explicit operator bool() const noexcept { return is_valid(); }

    NEFORCE_NODISCARD ::SSL* native_handle() const noexcept { return ssl_.get(); }

    NEFORCE_NODISCARD ::SSL* release() noexcept { return ssl_.release(); }

    void async_handshake(io_context& ctx, function<void(error_code)> handler);

    void async_handshake(io_context& ctx, cancellation_slot& slot, function<void(error_code)> handler);

    void async_read(io_context& ctx, memory_view<char> buffer, function<void(error_code, size_t)> handler) override;

    void async_read(io_context& ctx, memory_view<char> buffer, cancellation_slot& slot,
                    function<void(error_code, size_t)> handler) override;

    void async_write(io_context& ctx, memory_view<const char> buffer,
                     function<void(error_code, size_t)> handler) override;

    void async_write(io_context& ctx, memory_view<const char> buffer, cancellation_slot& slot,
                     function<void(error_code, size_t)> handler) override;

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code)>>, int> = 0>
    void async_handshake(io_context& ctx, Token&& token) {
        async_handshake(ctx, function<void(error_code)>(forward<Token>(token)));
    }

    auto async_handshake(io_context& ctx, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code)> result(use_future);
        async_handshake(ctx, function<void(error_code)>(result.get_handler()));
        return result.get();
    }

    void async_handshake(io_context& ctx, detached_t /*unused*/) {
        async_handshake(ctx, function<void(error_code)>([](error_code) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_handshake(io_context& ctx, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code)> result(use_awaitable);
        async_handshake(ctx, function<void(error_code)>(result.get_handler()));
        return result.get();
    }
#endif
};
 // SSL/TLS
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_SSL_SSL_STREAM_HPP__