websocket_socket.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_protocol.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <system_error>
#include <vector>
 
namespace kcenon::network::internal
{
    // Forward declaration
    class tcp_socket;
 
    enum class ws_state
    {
        connecting, 
        open,       
        closing,    
        closed      
    };
 
    class websocket_socket : public std::enable_shared_from_this<websocket_socket>
    {
    public:
        websocket_socket(std::shared_ptr<tcp_socket> socket, bool is_client);
 
        ~websocket_socket();
 
        auto async_handshake(const std::string& host, const std::string& path,
                             uint16_t port,
                             std::function<void(std::error_code)> handler) -> void;
 
        auto async_accept(std::function<void(std::error_code)> handler) -> void;
 
        auto start_read() -> void;
 
        auto async_send_text(std::string&& message,
                             std::function<void(std::error_code, std::size_t)> handler)
            -> VoidResult;
 
        auto async_send_binary(std::vector<uint8_t>&& data,
                               std::function<void(std::error_code, std::size_t)> handler)
            -> VoidResult;
 
        auto async_send_ping(std::vector<uint8_t> payload,
                             std::function<void(std::error_code)> handler) -> void;
 
        auto async_close(ws_close_code code, const std::string& reason,
                         std::function<void(std::error_code)> handler) -> void;
 
        auto state() const -> ws_state;
 
        auto is_open() const -> bool;
 
        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;
 
        auto set_error_callback(std::function<void(std::error_code)> callback) -> void;
 
    private:
        // Underlying TCP socket (reuses existing infrastructure)
        std::shared_ptr<tcp_socket> tcp_socket_;
 
        // WebSocket protocol state machine
        websocket_protocol protocol_;
        std::atomic<ws_state> state_{ws_state::connecting};
 
        // Callbacks
        std::mutex callback_mutex_;
        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_;
        std::function<void(std::error_code)> error_callback_;
 
        auto on_tcp_receive(std::span<const uint8_t> data) -> void;
 
        auto on_tcp_error(std::error_code ec) -> void;
 
        auto handle_protocol_message(const ws_message& msg) -> void;
 
        auto handle_protocol_ping(const std::vector<uint8_t>& payload) -> void;
 
        auto handle_protocol_pong(const std::vector<uint8_t>& payload) -> void;
 
        auto handle_protocol_close(ws_close_code code, const std::string& reason)
            -> void;
    };
 
} // namespace kcenon::network::internal