WebSocket.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_WEBSOCKET_H
#define PT_HTTP_WEBSOCKET_H
 
#include <Pt/Http/Api.h>
#include <Pt/Http/WebSocketMessage.h>
#include <Pt/Http/Message.h>
#include <Pt/Connectable.h>
#include <Pt/Signal.h>
#include <string>
#include <vector>
#include <cstddef>
 
namespace Pt {
 
namespace Http {
 
class Client;
class WebSocketChannel;
 

class PT_HTTP_API WebSocket : public Pt::Connectable
{
    public:
        explicit WebSocket(Client& client);

        ~WebSocket();

        void beginConnect(const std::string& url,
                          const std::string& origin = std::string());

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

        const std::string& protocol() const
        { return _protocol; }

        Pt::Signal<WebSocket&>& connected()
        { return _connected; }

        void endConnect();

        WebSocketMessage& incoming();

        WebSocketMessage& outgoing();

        void beginSend(bool finished = true);

        MessageProgress endSend();

        void beginReceive();

        MessageProgress endReceive();

        void beginPing(const char* payload = 0, std::size_t n = 0);

        void endPing();

        void beginShutdown(unsigned code = 1000,
                           const std::string& reason = std::string());

        void endShutdown();

        void close();

        unsigned closeCode() const;

        const std::string& closeReason() const;

        Pt::Signal<WebSocket&>& inputReady()
        { return _inputReady; }

        Pt::Signal<WebSocket&>& outputReady()
        { return _outputReady; }

        Pt::Signal<WebSocket&>& pingReady()
        { return _pingReady; }

        Pt::Signal<WebSocket&>& shutdownReady()
        { return _shutdownReady; }

        Pt::Signal<WebSocket&>& closed()
        { return _closed; }

        Pt::Signal<WebSocket&, const std::string&>& pong()
        { return _pong; }

        void setMaxMessageSize(std::size_t maxSize);

        void setIdleTimeout(std::size_t ms);

        void setPingInterval(std::size_t ms);

        void setPingTimeout(std::size_t ms);

        void setCloseTimeout(std::size_t ms);
 
    private:
        void parseUrl(const std::string& url, const std::string& origin);
 
        static std::string createKey();
 
        void finishHandshake(bool failed);
 
        void onRequestSent(Client& client);
 
        void onReply(Client& client);
 
        void onInputReady();
 
        void onOutputReady();
 
        void onPingReady();
 
        void onShutdownReady();
 
        void onClosed();
 
        void onPong(const std::string& payload);
 
    private:
        Client* _client;
        WebSocketChannel* _channel;
        std::string _path;
        std::string _protocol;
        std::vector<std::string> _protocols;
        bool _error;
        bool _connecting;
        Pt::Signal<WebSocket&> _connected;
        Pt::Signal<WebSocket&> _inputReady;
        Pt::Signal<WebSocket&> _outputReady;
        Pt::Signal<WebSocket&> _pingReady;
        Pt::Signal<WebSocket&> _shutdownReady;
        Pt::Signal<WebSocket&> _closed;
        Pt::Signal<WebSocket&, const std::string&> _pong;
};
 
} // namespace Http
 
} // namespace Pt
 
#endif