ssl_session.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_ASIO_SSL_SESSION_H
#define CPPSERVER_ASIO_SSL_SESSION_H
 
#include "service.h"
 
#include "system/uuid.h"
 
namespace CppServer {
namespace Asio {
 
class SSLServer;


class SSLSession : public std::enable_shared_from_this<SSLSession>
{
    friend class SSLServer;
 
public:

    explicit SSLSession(const std::shared_ptr<SSLServer>& server);
    SSLSession(const SSLSession&) = delete;
    SSLSession(SSLSession&&) = delete;
    virtual ~SSLSession() = default;
 
    SSLSession& operator=(const SSLSession&) = delete;
    SSLSession& operator=(SSLSession&&) = delete;

    const CppCommon::UUID& id() const noexcept { return _id; }

    std::shared_ptr<SSLServer>& server() noexcept { return _server; }
    std::shared_ptr<asio::io_context>& io_context() noexcept { return _io_context; }
    asio::io_context::strand& strand() noexcept { return _strand; }
    asio::ssl::stream<asio::ip::tcp::socket>& stream() noexcept { return _stream; }
    asio::ssl::stream<asio::ip::tcp::socket>::next_layer_type& socket() noexcept { return _stream.next_layer(); }

    uint64_t bytes_pending() const noexcept { return _bytes_pending + _bytes_sending; }
    uint64_t bytes_sent() const noexcept { return _bytes_sent; }
    uint64_t bytes_received() const noexcept { return _bytes_received; }

    size_t option_receive_buffer_limit() const noexcept { return _receive_buffer_limit; }
    size_t option_receive_buffer_size() const;
    size_t option_send_buffer_limit() const noexcept { return _send_buffer_limit; }
    size_t option_send_buffer_size() const;

    bool IsConnected() const noexcept { return _connected; }
    bool IsHandshaked() const noexcept { return _handshaked; }


    virtual bool Disconnect() { return DisconnectAsync(false); }


    virtual size_t Send(const void* buffer, size_t size);

    virtual size_t Send(std::string_view text) { return Send(text.data(), text.size()); }


    virtual size_t Send(const void* buffer, size_t size, const CppCommon::Timespan& timeout);

    virtual size_t Send(std::string_view text, const CppCommon::Timespan& timeout) { return Send(text.data(), text.size(), timeout); }


    virtual bool SendAsync(const void* buffer, size_t size);

    virtual bool SendAsync(std::string_view text) { return SendAsync(text.data(), text.size()); }


    virtual size_t Receive(void* buffer, size_t size);

    virtual std::string Receive(size_t size);


    virtual size_t Receive(void* buffer, size_t size, const CppCommon::Timespan& timeout);

    virtual std::string Receive(size_t size, const CppCommon::Timespan& timeout);

    virtual void ReceiveAsync();


    void SetupReceiveBufferLimit(size_t limit) noexcept { _receive_buffer_limit = limit; }

    void SetupReceiveBufferSize(size_t size);

    void SetupSendBufferLimit(size_t limit) noexcept { _send_buffer_limit = limit; }

    void SetupSendBufferSize(size_t size);
 
protected:
    virtual void onConnecting() {}
    virtual void onConnected() {}
    virtual void onHandshaking() {}
    virtual void onHandshaked() {}
    virtual void onDisconnecting() {}
    virtual void onDisconnected() {}


    virtual void onReceived(const void* buffer, size_t size) {}

    virtual void onSent(size_t sent, size_t pending) {}


    virtual void onEmpty() {}


    virtual void onError(int error, const std::string& category, const std::string& message) {}
 
private:
    // Session Id
    CppCommon::UUID _id;
    // Server & session
    std::shared_ptr<SSLServer> _server;
    // Asio IO context
    std::shared_ptr<asio::io_context> _io_context;
    // Asio service strand for serialized handler execution
    asio::io_context::strand _strand;
    bool _strand_required;
    // Session stream
    asio::ssl::stream<asio::ip::tcp::socket> _stream;
    std::atomic<bool> _connected;
    std::atomic<bool> _handshaked;
    // Session statistic
    uint64_t _bytes_pending;
    uint64_t _bytes_sending;
    uint64_t _bytes_sent;
    uint64_t _bytes_received;
    // Receive buffer
    bool _receiving;
    size_t _receive_buffer_limit{0};
    std::vector<uint8_t> _receive_buffer;
    HandlerStorage _receive_storage;
    // Send buffer
    bool _sending;
    std::mutex _send_lock;
    size_t _send_buffer_limit{0};
    std::vector<uint8_t> _send_buffer_main;
    std::vector<uint8_t> _send_buffer_flush;
    size_t _send_buffer_flush_offset;
    HandlerStorage _send_storage;

    void Connect();
    void Disconnect(std::error_code ec);

    bool DisconnectAsync(bool dispatch);

    void TryReceive();
    void TrySend();

    void ClearBuffers();
    void ResetServer();

    void SendError(std::error_code ec);
};
 
} // namespace Asio
} // namespace CppServer
 
#endif // CPPSERVER_ASIO_SSL_SESSION_H