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 <cstddef>
 
namespace Pt {
 
namespace Http {
 
class Client;
class WebSocketConnection;
 

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());

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

        void endConnect();

        WebSocketMessage& incoming();

        WebSocketMessage& outgoing();

        void beginSend();

        MessageProgress endSend();

        void beginReceive();

        MessageProgress endReceive();

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

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

        unsigned closeCode() const;

        const std::string& closeReason() const;

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

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

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

        void setTimeout(std::size_t timeout);

        void setMaxMessageSize(std::size_t maxSize);

        void setIdleTimeout(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 onClosed();
 
    private:
        Client* _client;
        WebSocketConnection* _connection;
        std::string _path;
        bool _error;
        bool _connecting;
        Pt::Signal<WebSocket&> _connected;
        Pt::Signal<WebSocket&> _inputReady;
        Pt::Signal<WebSocket&> _outputReady;
        Pt::Signal<WebSocket&> _closed;
};
 
} // namespace Http
 
} // namespace Pt
 
#endif