ws.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_WS_H
#define CPPSERVER_WS_H
 
#include "server/http/http_request.h"
#include "server/http/http_response.h"
 
#include "system/uuid.h"
 
#include <array>
#include <mutex>
 
namespace CppServer {
 
namespace WS {
 
class WebSocket
{
public:
    static const uint8_t WS_FIN = 0x80;
    static const uint8_t WS_TEXT = 0x01;
    static const uint8_t WS_BINARY = 0x02;
    static const uint8_t WS_CLOSE = 0x08;
    static const uint8_t WS_PING = 0x09;
    static const uint8_t WS_PONG = 0x0A;
 
    WebSocket() { ClearWSBuffers(); InitWSNonce(); }
    WebSocket(const WebSocket&) = delete;
    WebSocket(WebSocket&&) = delete;
    ~WebSocket() = default;
 
    WebSocket& operator=(const WebSocket&) = delete;
    WebSocket& operator=(WebSocket&&) = delete;
 
    std::string_view ws_nonce() const noexcept { return std::string_view((char*)_ws_nonce.data(), _ws_nonce.size()); }
 
 
    bool PerformClientUpgrade(const HTTP::HTTPResponse& response, const CppCommon::UUID& id);
 
 
    bool PerformServerUpgrade(const HTTP::HTTPRequest& request, HTTP::HTTPResponse& response);
 
 
    void PrepareSendFrame(uint8_t opcode, bool mask, const void* buffer, size_t size, int status = 0);
 
 
    void PrepareReceiveFrame(const void* buffer, size_t size);
 
    size_t RequiredReceiveFrameSize();
 
    void ClearWSBuffers();
 
    void InitWSNonce();
 
protected:
 
    virtual void onWSConnecting(HTTP::HTTPRequest& request) {}
 
    virtual void onWSConnected(const HTTP::HTTPResponse& response) {}
 
 
    virtual bool onWSConnecting(const HTTP::HTTPRequest& request, HTTP::HTTPResponse& response) { return true; }
 
    virtual void onWSConnected(const HTTP::HTTPRequest& request) {}
 
    virtual void onWSDisconnected() {}
 
 
    virtual void onWSReceived(const void* buffer, size_t size) {}
 
 
    virtual void onWSClose(const void* buffer, size_t size, int status = 1000) {}
 
    virtual void onWSPing(const void* buffer, size_t size) {}
 
    virtual void onWSPong(const void* buffer, size_t size) {}
 
 
    virtual void onWSError(const std::string& message) {}
 
protected:
    bool _ws_handshaked{false};
 
    uint8_t _ws_opcode;
    bool _ws_frame_received{false};
    bool _ws_final_received{false};
    size_t _ws_header_size{0};
    size_t _ws_payload_size{0};
    std::vector<uint8_t> _ws_receive_frame_buffer;
    std::vector<uint8_t> _ws_receive_final_buffer;
    uint8_t _ws_receive_mask[4];
 
    std::mutex _ws_send_lock;
    std::vector<uint8_t> _ws_send_buffer;
    uint8_t _ws_send_mask[4];
 
    std::array<uint8_t, 16> _ws_nonce;
 
 
    virtual void SendResponse(const HTTP::HTTPResponse& response) {}
};
 
} // namespace WS
} // namespace CppServer
 
#endif // CPPSERVER_WS_H