websocket_protocol.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "internal/websocket/websocket_frame.h"
 
#include <cstdint>
#include <functional>
#include <span>
#include <string>
#include <vector>
 
namespace kcenon::network::internal
{
    enum class ws_message_type
    {
        text,   
        binary  
    };
 
    struct ws_message
    {
        ws_message_type type;      
        std::vector<uint8_t> data; 
 
        auto as_text() const -> std::string;
 
        auto as_binary() const -> const std::vector<uint8_t>&;
    };
 
    enum class ws_close_code : uint16_t
    {
        normal = 1000,            
        going_away = 1001,        
        protocol_error = 1002,    
        unsupported_data = 1003,  
        invalid_frame = 1007,     
        policy_violation = 1008,  
        message_too_big = 1009,   
        internal_error = 1011     
    };
 
    class websocket_protocol
    {
    public:
        explicit websocket_protocol(bool is_client);
 
        auto process_data(std::span<const uint8_t> data) -> void;
 
        auto create_text_message(std::string&& text) -> std::vector<uint8_t>;
 
        auto create_binary_message(std::vector<uint8_t>&& data)
            -> std::vector<uint8_t>;
 
        auto create_ping(std::vector<uint8_t>&& payload = {})
            -> std::vector<uint8_t>;
 
        auto create_pong(std::vector<uint8_t>&& payload = {})
            -> std::vector<uint8_t>;
 
        auto create_close(ws_close_code code, std::string&& reason = "")
            -> std::vector<uint8_t>;
 
        auto set_message_callback(std::function<void(const ws_message&)> callback)
            -> void;
 
        auto set_ping_callback(
            std::function<void(const std::vector<uint8_t>&)> callback) -> void;
 
        auto set_pong_callback(
            std::function<void(const std::vector<uint8_t>&)> callback) -> void;
 
        auto set_close_callback(
            std::function<void(ws_close_code, const std::string&)> callback) -> void;
 
    private:
        bool is_client_;                            
        std::vector<uint8_t> buffer_;               
        std::vector<uint8_t> fragmented_message_;   
        ws_opcode fragmented_type_;                 
 
        // Callbacks
        std::function<void(const ws_message&)> message_callback_;
        std::function<void(const std::vector<uint8_t>&)> ping_callback_;
        std::function<void(const std::vector<uint8_t>&)> pong_callback_;
        std::function<void(ws_close_code, const std::string&)> close_callback_;
 
        auto process_frames() -> void;
 
        auto handle_data_frame(const ws_frame_header& header,
                               const std::vector<uint8_t>& payload) -> void;
 
        auto handle_control_frame(const ws_frame_header& header,
                                  const std::vector<uint8_t>& payload) -> void;
 
        auto handle_ping(const std::vector<uint8_t>& payload) -> void;
 
        auto handle_pong(const std::vector<uint8_t>& payload) -> void;
 
        auto handle_close(const std::vector<uint8_t>& payload) -> void;
 
        static auto is_valid_utf8(const std::vector<uint8_t>& data) -> bool;
    };
 
} // namespace kcenon::network::internal