websocket.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <functional>
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
#include <promeki/error.h>
#include <promeki/buffer.h>
#include <promeki/string.h>
#include <promeki/url.h>
#include <promeki/list.h>
#include <promeki/uniqueptr.h>
#include <promeki/sslcontext.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class TcpSocket;
class EventLoop;
class HttpRequest;
class HttpResponse;
 
class WebSocket : public ObjectBase {
                PROMEKI_OBJECT(WebSocket, ObjectBase)
        public:
                using List = ::promeki::List<WebSocket *>;
 
                enum State {
                        Disconnected, 
                        Connecting,   
                        Connected,    
                        Closing       
                };
 
                enum CloseCode : uint16_t {
                        CloseNormal = 1000,
                        CloseGoingAway = 1001,
                        CloseProtocolError = 1002,
                        CloseUnsupportedData = 1003,
                        CloseNoStatus = 1005, 
                        CloseAbnormal = 1006, 
                        CloseInvalidPayload = 1007,
                        ClosePolicyViolation = 1008,
                        CloseMessageTooBig = 1009,
                        CloseMissingExtension = 1010,
                        CloseInternalError = 1011
                };
 
                static constexpr int64_t DefaultMaxMessageBytes = 16 * 1024 * 1024;
 
                explicit WebSocket(ObjectBase *parent = nullptr);
 
                ~WebSocket() override;
 
                // ----------------------------------------------------
                // Client-side connect
                // ----------------------------------------------------
 
                Error connectToUrl(const String &url);
 
                void setRequestedSubprotocols(const String &csv) { _requestedSubprotocols = csv; }
 
                const String &requestedSubprotocols() const { return _requestedSubprotocols; }
 
                void setRequestHeader(const String &name, const String &value);
 
                void setSslContext(SslContext ctx) { _sslContext = std::move(ctx); }
 
                SslContext sslContext() const { return _sslContext; }
 
                static bool hasTlsSupport() { return SslContext::hasTlsSupport(); }
 
                // ----------------------------------------------------
                // Server-side adoption (used by HttpServer::routeWebSocket)
                // ----------------------------------------------------
 
                void adoptUpgradedSocket(TcpSocket *socket);
 
                // ----------------------------------------------------
                // Application API
                // ----------------------------------------------------
 
                Error sendTextMessage(const String &message);
 
                Error sendBinaryMessage(const Buffer &message);
 
                Error ping(const Buffer &payload = Buffer());
 
                void disconnect(uint16_t code = CloseNormal, const String &reason = String());
 
                void abort();
 
                State state() const { return _state; }
 
                bool isConnected() const { return _state == Connected; }
 
                const String &negotiatedSubprotocol() const { return _negotiatedSubprotocol; }
 
                void setMaxMessageBytes(int64_t bytes) { _maxMessageBytes = bytes; }
 
                PROMEKI_SIGNAL(connected);
 
                PROMEKI_SIGNAL(disconnected);
 
                PROMEKI_SIGNAL(textMessageReceived, String);
 
                PROMEKI_SIGNAL(binaryMessageReceived, Buffer);
 
                PROMEKI_SIGNAL(pongReceived, Buffer);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
        private:
                struct Impl;
                UniquePtr<Impl> _impl;
 
                EventLoop *_loop = nullptr;
                TcpSocket *_socket = nullptr; 
                int        _ioHandle = -1;
                State      _state = Disconnected;
                bool       _isClient = false; 
 
                Url     _url;
                String  _requestedSubprotocols;
                String  _negotiatedSubprotocol;
                String  _expectedAccept; 
                int64_t _maxMessageBytes = DefaultMaxMessageBytes;
                bool    _useTls = false;
                bool    _handshakeDone = false; 
 
                SslContext _sslContext;
 
                void onIoReady(int fd, uint32_t events);
                void readSome();
                void pumpWrite();
                void registerIo(uint32_t mask);
 
                // Client-side handshake.
                void writeClientHandshake();
                void parseClientHandshakeResponse();
 
                // Frame helpers.
                Error sendFrame(uint8_t opcode, const void *data, size_t len, bool fin = true);
                void  processIncomingBytes();
                void  handleControlFrame(uint8_t opcode, Buffer payload);
                void  handleDataMessage(uint8_t opcode, Buffer payload);
                void  enqueueClose(uint16_t code, const String &reason);
                void  finalizeClose(Error err);
 
        public:
                // Internals exposed only so HttpServer::routeWebSocket
                // can build the proper Sec-WebSocket-Accept.  Not
                // intended for application use.
                static String computeAcceptValue(const String &clientKey);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP