ssl_server.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_ASIO_SSL_SERVER_H
#define CPPSERVER_ASIO_SSL_SERVER_H
 
#include "ssl_context.h"
#include "ssl_session.h"
 
#include "system/uuid.h"
 
#include <map>
#include <mutex>
#include <shared_mutex>
#include <vector>
 
namespace CppServer {
namespace Asio {
 
 
class SSLServer : public std::enable_shared_from_this<SSLServer>
{
    friend class SSLSession;
 
public:
 
    SSLServer(const std::shared_ptr<Service>& service, const std::shared_ptr<SSLContext>& context, int port, InternetProtocol protocol = InternetProtocol::IPv4);
 
    SSLServer(const std::shared_ptr<Service>& service, const std::shared_ptr<SSLContext>& context, const std::string& address, int port);
 
    SSLServer(const std::shared_ptr<Service>& service, const std::shared_ptr<SSLContext>& context, const asio::ip::tcp::endpoint& endpoint);
    SSLServer(const SSLServer&) = delete;
    SSLServer(SSLServer&&) = delete;
    virtual ~SSLServer() = default;
 
    SSLServer& operator=(const SSLServer&) = delete;
    SSLServer& operator=(SSLServer&&) = delete;
 
    const CppCommon::UUID& id() const noexcept { return _id; }
 
    std::shared_ptr<Service>& service() noexcept { return _service; }
    std::shared_ptr<asio::io_service>& io_service() noexcept { return _io_service; }
    asio::io_service::strand& strand() noexcept { return _strand; }
    std::shared_ptr<SSLContext>& context() noexcept { return _context; }
    asio::ip::tcp::endpoint& endpoint() noexcept { return _endpoint; }
    asio::ip::tcp::acceptor& acceptor() noexcept { return _acceptor; }
 
    const std::string& address() const noexcept { return _address; }
    int port() const noexcept { return _port; }
 
    uint64_t connected_sessions() const noexcept { return _sessions.size(); }
    uint64_t bytes_pending() const noexcept { return _bytes_pending; }
    uint64_t bytes_sent() const noexcept { return _bytes_sent; }
    uint64_t bytes_received() const noexcept { return _bytes_received; }
 
    bool option_keep_alive() const noexcept { return _option_keep_alive; }
    bool option_no_delay() const noexcept { return _option_no_delay; }
    bool option_reuse_address() const noexcept { return _option_reuse_address; }
    bool option_reuse_port() const noexcept { return _option_reuse_port; }
 
    bool IsStarted() const noexcept { return _started; }
 
 
    virtual bool Start();
 
    virtual bool Stop();
 
    virtual bool Restart();
 
 
    virtual bool Multicast(const void* buffer, size_t size);
 
    virtual bool Multicast(std::string_view text) { return Multicast(text.data(), text.size()); }
 
 
    virtual bool DisconnectAll();
 
 
    std::shared_ptr<SSLSession> FindSession(const CppCommon::UUID& id);
 
 
    void SetupKeepAlive(bool enable) noexcept { _option_keep_alive = enable; }
 
    void SetupNoDelay(bool enable) noexcept { _option_no_delay = enable; }
 
    void SetupReuseAddress(bool enable) noexcept { _option_reuse_address = enable; }
 
    void SetupReusePort(bool enable) noexcept { _option_reuse_port = enable; }
 
protected:
 
    virtual std::shared_ptr<SSLSession> CreateSession(const std::shared_ptr<SSLServer>& server) { return std::make_shared<SSLSession>(server); }
 
protected:
    virtual void onStarted() {}
    virtual void onStopped() {}
 
 
    virtual void onConnected(std::shared_ptr<SSLSession>& session) {}
 
    virtual void onHandshaked(std::shared_ptr<SSLSession>& session) {}
 
    virtual void onDisconnected(std::shared_ptr<SSLSession>& session) {}
 
 
    virtual void onError(int error, const std::string& category, const std::string& message) {}
 
protected:
    // Server sessions
    std::shared_mutex _sessions_lock;
    std::map<CppCommon::UUID, std::shared_ptr<SSLSession>> _sessions;
 
private:
    // Server Id
    CppCommon::UUID _id;
    // Asio service
    std::shared_ptr<Service> _service;
    // Asio IO service
    std::shared_ptr<asio::io_service> _io_service;
    // Asio service strand for serialized handler execution
    asio::io_service::strand _strand;
    bool _strand_required;
    // Server address, scheme & port
    std::string _address;
    int _port;
    // Server SSL context, endpoint, acceptor and socket
    std::shared_ptr<SSLContext> _context;
    std::shared_ptr<SSLSession> _session;
    asio::ip::tcp::endpoint _endpoint;
    asio::ip::tcp::acceptor _acceptor;
    std::atomic<bool> _started;
    HandlerStorage _acceptor_storage;
    // Server statistic
    uint64_t _bytes_pending;
    uint64_t _bytes_sent;
    uint64_t _bytes_received;
    // Options
    bool _option_keep_alive;
    bool _option_no_delay;
    bool _option_reuse_address;
    bool _option_reuse_port;
 
    void Accept();
 
    void RegisterSession();
 
    void UnregisterSession(const CppCommon::UUID& id);
 
    void ClearBuffers();
 
    void SendError(std::error_code ec);
};
 
} // namespace Asio
} // namespace CppServer
 
#endif // CPPSERVER_ASIO_SSL_SERVER_H