WebsocketConnection.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * WebsocketConnection.h
 *
 ****/

#pragma once

#include "Network/TcpServer.h"
#include "../HttpConnection.h"

extern "C" {
#include "ws_parser/ws_parser.h"
}

#define WEBSOCKET_VERSION 13 // 1.3

DECLARE_FSTR(WSSTR_CONNECTION)
DECLARE_FSTR(WSSTR_UPGRADE)
DECLARE_FSTR(WSSTR_WEBSOCKET)
DECLARE_FSTR(WSSTR_HOST)
DECLARE_FSTR(WSSTR_ORIGIN)
DECLARE_FSTR(WSSTR_KEY)
DECLARE_FSTR(WSSTR_PROTOCOL)
DECLARE_FSTR(WSSTR_VERSION)
DECLARE_FSTR(WSSTR_SECRET)

class WebsocketConnection;

using WebsocketList = Vector<WebsocketConnection*>;

using WebsocketDelegate = Delegate<void(WebsocketConnection&)>;
using WebsocketMessageDelegate = Delegate<void(WebsocketConnection&, const String&)>;
using WebsocketBinaryDelegate = Delegate<void(WebsocketConnection&, uint8_t* data, size_t size)>;

enum WsConnectionState {
    eWSCS_Ready,
    eWSCS_Open,
    eWSCS_Closed,
};

struct WsFrameInfo {
    ws_frame_type_t type = WS_FRAME_TEXT;
    char* payload = nullptr;
    size_t payloadLength = 0;

    WsFrameInfo() = default;

    WsFrameInfo(ws_frame_type_t type, char* payload, size_t payloadLength)
        : type(type), payload(payload), payloadLength(payloadLength)
    {
    }
};

class WebsocketConnection
{
public:
    WebsocketConnection(HttpConnection* connection, bool isClientConnection = true);

    virtual ~WebsocketConnection()
    {
        close();
    }

    bool bind(HttpRequest& request, HttpResponse& response);

    bool send(const char* message, size_t length, ws_frame_type_t type = WS_FRAME_TEXT);

    bool send(const String& message, ws_frame_type_t type = WS_FRAME_TEXT)
    {
        return send(message.c_str(), message.length(), type);
    }

    bool send(IDataSourceStream* stream, ws_frame_type_t type = WS_FRAME_TEXT, bool useMask = false, bool isFin = true);

    static void broadcast(const char* message, size_t length, ws_frame_type_t type = WS_FRAME_TEXT);

    static void broadcast(const String& message, ws_frame_type_t type = WS_FRAME_TEXT)
    {
        broadcast(message.c_str(), message.length(), type);
    }

    bool sendString(const String& message)
    {
        return send(message, WS_FRAME_TEXT);
    }

    bool sendBinary(const uint8_t* data, size_t length)
    {
        return send(reinterpret_cast<const char*>(data), length, WS_FRAME_BINARY);
    }

    void close();

    void reset();

    void setUserData(void* userData)
    {
        this->userData = userData;
    }

    void* getUserData()
    {
        return userData;
    }

    bool operator==(const WebsocketConnection& rhs) const
    {
        return (this == &rhs);
    }

    static const WebsocketList& getActiveWebsockets()
    {
        return websocketList;
    }

    void setConnectionHandler(WebsocketDelegate handler)
    {
        wsConnect = handler;
    }

    void setMessageHandler(WebsocketMessageDelegate handler)
    {
        wsMessage = handler;
    }

    void setBinaryHandler(WebsocketBinaryDelegate handler)
    {
        wsBinary = handler;
    }
    void setPongHandler(WebsocketDelegate handler)
    {
        wsPong = handler;
    }
    void setDisconnectionHandler(WebsocketDelegate handler)
    {
        wsDisconnect = handler;
    }

    void activate();

    bool onConnected();

    HttpConnection* getConnection()
    {
        return connection;
    }

    void setConnection(HttpConnection* connection, bool isClientConnection = true)
    {
        this->connection = connection;
        this->isClientConnection = isClientConnection;
    }

    WsConnectionState getState()
    {
        return state;
    }

protected:
    // Static handlers for ws_parser
    static int staticOnDataBegin(void* userData, ws_frame_type_t type);
    static int staticOnDataPayload(void* userData, const char* at, size_t length);
    static int staticOnDataEnd(void* userData);
    static int staticOnControlBegin(void* userData, ws_frame_type_t type);
    static int staticOnControlPayload(void* userData, const char*, size_t length);
    static int staticOnControlEnd(void* userData);

    bool processFrame(TcpClient& client, char* at, int size);

protected:
    WebsocketDelegate wsConnect = nullptr;
    WebsocketMessageDelegate wsMessage = nullptr;
    WebsocketBinaryDelegate wsBinary = nullptr;
    WebsocketDelegate wsPong = nullptr;
    WebsocketDelegate wsDisconnect = nullptr;

    void* userData = nullptr;

    WsConnectionState state = eWSCS_Ready;

private:
    ws_frame_type_t frameType = WS_FRAME_TEXT;
    WsFrameInfo controlFrame;

    ws_parser_t parser;
    static const ws_parser_callbacks_t parserSettings;

    static WebsocketList websocketList;

    bool isClientConnection = true;

    HttpConnection* connection = nullptr;
    bool activated = false;
};