WebSocketService.h

/* Copyright (C) 2015 by Laurentiu-Gheorghe Crisan
   Copyright (C) 2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_HTTP_WEBSOCKETSERVICE_H
#define PT_HTTP_WEBSOCKETSERVICE_H
 
#include <Pt/Http/Api.h>
#include <Pt/Http/Service.h>
#include <Pt/Http/WebSocketSession.h>
#include <Pt/Allocator.h>
#include <Pt/Connectable.h>
#include <string>
#include <vector>
#include <cstddef>
 
namespace Pt {
 
namespace Http {
 
class Request;
class Reply;
class Responder;
class Stream;
class WebSocketServlet;

class PT_HTTP_API WebSocketService : public Service
                                   , public Connectable
{
    friend class WebSocketSession;
    friend class WebSocketServlet;
 
    public:
        WebSocketService();

        ~WebSocketService();

        const std::vector<std::string>& protocols() const
        { return _protocols; }

        void addProtocol(const std::string& name);

        void clearProtocols();

        std::size_t maxSockets() const
        { return _maxSockets; }

        void setMaxSockets(std::size_t n)
        { _maxSockets = n; }

        std::size_t idleTimeout() const
        { return _idleTimeout; }

        void setIdleTimeout(std::size_t ms)
        { _idleTimeout = ms; }

        std::size_t pingInterval() const
        { return _pingInterval; }

        void setPingInterval(std::size_t ms)
        { _pingInterval = ms; }

        std::size_t pingTimeout() const
        { return _pingTimeout; }

        void setPingTimeout(std::size_t ms)
        { _pingTimeout = ms; }

        std::size_t closeTimeout() const
        { return _closeTimeout; }

        void setCloseTimeout(std::size_t ms)
        { _closeTimeout = ms; }

        std::size_t maxMessageSize() const
        { return _maxMessageSize; }

        void setMaxMessageSize(std::size_t n)
        { _maxMessageSize = n; }

        bool hasServlet() const
        { return _servlet != 0; }

        std::size_t socketCount() const
        { return _socketCount; }

        WebSocketSession* getSession(Stream& stream,
                                     const Request& request,
                                     const Reply& reply);

        void releaseSession(WebSocketSession* session);
 
    protected:
        virtual Responder* onGetResponder(const Request&);

        virtual void onReleaseResponder(Responder* responder);

        virtual void onUpgrade(Stream& stream,
                               const Request& request,
                               const Reply& reply) final;
 
    protected:
        virtual WebSocketSession* onGetSession(Stream& stream,
                                               const Request& request,
                                               const Reply& reply) = 0;

        virtual void onReleaseSession(WebSocketSession* session) = 0;
 
    private:
        void attach(WebSocketServlet& servlet);
 
        void detach(WebSocketServlet& servlet);
 
        WebSocketServlet* servlet()
        { return _servlet; }

        void close(WebSocketSession& session);
 
    private:
        WebSocketServlet*        _servlet;
        std::size_t              _socketCount;
        std::size_t              _maxSockets;
        std::size_t              _idleTimeout;
        std::size_t              _pingInterval;
        std::size_t              _pingTimeout;
        std::size_t              _closeTimeout;
        std::size_t              _maxMessageSize;
        std::vector<std::string> _protocols;
};

template <typename S, typename Alloc = Allocator>
class BasicWebSocketService : public WebSocketService
{
    public:
        BasicWebSocketService()
        { }

        ~BasicWebSocketService()
        { }
 
    protected:
        virtual WebSocketSession* onGetSession(Stream& stream,
                                               const Request& /*request*/,
                                               const Reply& reply)
        {
            void* memory = _alloc.allocate(sizeof(S));
            return new(memory) S(*this, stream, reply);
        }
 
        virtual void onReleaseSession(WebSocketSession* session)
        {
            session->~WebSocketSession();
            _alloc.deallocate(session, sizeof(S));
        }
 
    private:
        Alloc _alloc;
};
 
} // namespace Http
 
} // namespace Pt
 
#endif