websocket.hpp

 
//
// Copyright 2024 Realm Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
#ifndef CPPREALM_NETWORKING_WEBSOCKET_HPP
#define CPPREALM_NETWORKING_WEBSOCKET_HPP
 
#include <cpprealm/internal/bridge/status.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
 
#ifndef REALMCXX_VERSION_MAJOR
#include <cpprealm/version_numbers.hpp>
#endif
 
#include <chrono>
#include <optional>
 
namespace realm {
    namespace sync {
        class SyncSocketProvider;
        struct WebSocketInterface;
        struct WebSocketObserver;
    }
 
    namespace util {
        class Logger;
    }
}
 
namespace realm::networking {
 
    struct websocket_endpoint {
        std::vector<std::string> protocols;
        std::string url;
    };
 
    enum class websocket_err_codes {
        ok = 1000,
        going_away = 1001,
        protocol_error = 1002,
        unsupported_data = 1003,
        websocket_reserved = 1004,
        no_status_received = 1005,
        abnormal_closure = 1006,
        invalid_payload_data = 1007,
        policy_violation = 1008,
        message_too_big = 1009,
        invalid_extension = 1010,
        invalid_server_error = 1011,
        TLS_handshake_failed = 1015,
 
        unauthorized = 4001,
        forbidden = 4002,
        moved_permanently = 4003,
        client_too_old = 4004,
        client_too_new = 4005,
        protocol_mismatch = 4006,
 
        resolve_failed = 4400,
        connection_failed = 4401,
        read_error = 4402,
        write_error = 4403,
        retry_error = 4404,
        fatal_error = 4405,
    };
 
    using status = ::realm::internal::bridge::status;
    struct websocket_interface;
    struct websocket_observer;
 
    class sync_socket_provider {
    public:
 
        using FunctionHandler = std::function<void(status)>;
 
        struct timer {
            virtual ~timer() = default;
            virtual void cancel() = 0;
        };
 
        using sync_timer = std::unique_ptr<sync_socket_provider::timer>;
 
        virtual ~sync_socket_provider() = default;
 
        virtual std::unique_ptr<websocket_interface> connect(std::unique_ptr<websocket_observer> observer,
                                                             websocket_endpoint && endpoint) = 0;
 
        virtual void post(FunctionHandler&& handler) = 0;
 
        virtual sync_timer create_timer(std::chrono::milliseconds delay, FunctionHandler&& handler) = 0;
    };
 
    struct websocket_interface {
        virtual ~websocket_interface() = default;
 
        using FunctionHandler = std::function<void(status)>;
 
        virtual void async_write_binary(std::string_view data, FunctionHandler&& handler) = 0;
    };
 
    struct websocket_observer {
        virtual ~websocket_observer() = default;
 
        virtual void websocket_connected_handler(const std::string& protocol) = 0;
 
        virtual void websocket_error_handler() = 0;
 
        virtual bool websocket_binary_message_received(std::string_view data) = 0;
 
        virtual bool websocket_closed_handler(bool was_clean, websocket_err_codes error_code,
                                              std::string_view message) = 0;
    };
 
    struct default_socket_provider : public sync_socket_provider {
        struct configuration {
            std::optional<std::map<std::string, std::string>> custom_http_headers;
            std::optional<::realm::internal::bridge::realm::sync_config::proxy_config> proxy_config;
 
            using SSLVerifyCallback = bool(const std::string& server_address,
                                           internal::bridge::realm::sync_config::proxy_config::port_type server_port,
                                           const char* pem_data, size_t pem_size, int preverify_ok, int depth);
            bool client_validate_ssl = true;
            std::optional<std::string> ssl_trust_certificate_path;
            std::function<SSLVerifyCallback> ssl_verify_callback;
        };
        default_socket_provider();
        default_socket_provider(const configuration& c);
        ~default_socket_provider() = default;
 
        std::unique_ptr<websocket_interface> connect(std::unique_ptr<websocket_observer>, websocket_endpoint &&) override;
        void post(FunctionHandler&&) override;
        sync_timer create_timer(std::chrono::milliseconds delay, FunctionHandler&&) override;
 
    protected:
        configuration m_configuration;
    private:
        void initialize();
        std::unique_ptr<::realm::sync::SyncSocketProvider> m_provider;
    };
}
 
#endif //CPPREALM_NETWORKING_WEBSOCKET_HPP