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_UPGRADE)
DECLARE_FSTR(WSSTR_WEBSOCKET)
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;
};
 
class WebsocketConnection
{
public:
    WebsocketConnection(HttpConnection* connection = nullptr, 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* source, 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);
 
    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;
    WebsocketMessageDelegate wsMessage;
    WebsocketBinaryDelegate wsBinary;
    WebsocketDelegate wsPong;
    WebsocketDelegate wsDisconnect;
 
    void* userData = nullptr;
 
    WsConnectionState state;
 
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;
 
    HttpConnection* connection = nullptr;
    bool isClientConnection;
    bool activated = false;
};