ProxyConfig.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CRYPTOX_DATA_CONNECTION_PROXY_CONFIG_HPP_INCLUDED
#define _CRYPTOX_DATA_CONNECTION_PROXY_CONFIG_HPP_INCLUDED

 
namespace cryptox {

    struct ProxyConfig {
        std::string proxy_server; 
        std::string proxy_auth;   
        ProxyType   proxy_type;   
        bool        use = false;  

        ProxyConfig()
            : proxy_type(ProxyType::HTTP) {}

        ProxyConfig(std::string server, std::string auth, ProxyType type)
            : proxy_server(std::move(server)), proxy_auth(std::move(auth)), proxy_type(type) {}

        void set_proxy(const std::string& ip, int port, ProxyType type) {
            proxy_server = ip + ":" + std::to_string(port);
            proxy_type = type;
        }

        void set_proxy(
            const std::string& ip,
            int port,
            const std::string& username,
            const std::string& password,
            ProxyType type = ProxyType::HTTP) {
            set_proxy(ip, port);
            set_proxy_auth(username, password);
            proxy_type = type;
        }

        void set_proxy_auth(const std::string& username, const std::string& password) {
            proxy_auth = username + ":" + password;
        }
        
        std::string get_ip() const {
            auto pos = proxy_server.find(':');
            if (pos == std::string::npos) return {};
            return proxy_server.substr(0, pos);
        }

        int get_port() const {
            auto pos = proxy_server.find(':');
            if (pos == std::string::npos) return 0;
            try {
                return std::stoi(proxy_server.substr(pos + 1));
            } catch (...) {
                return 0;
            }
        }

        std::string get_username() const {
            auto pos = proxy_auth.find(':');
            if (pos == std::string::npos) return {};
            return proxy_auth.substr(0, pos);
        }

        std::string get_password() const {
            auto pos = proxy_auth.find(':');
            if (pos == std::string::npos || pos + 1 >= proxy_auth.size()) return {};
            return proxy_auth.substr(pos + 1);
        }

        bool is_valid() const {
            return !proxy_server.empty() && !proxy.get_ip().empty() && proxy.get_port() != 0;
        }
    };

    inline void to_json(nlohmann::json& j, const ProxyConfig& config) {
        j = nlohmann::json{
            {"proxy_server", config.proxy_server},
            {"proxy_auth", config.proxy_auth},
            {"proxy_type", config.proxy_type},
            {"use", config.use}
        };
    }

    inline void from_json(const nlohmann::json& j, ProxyConfig& config) {
        if (j.contains("proxy_server")) config.proxy_server = j.at("proxy_server").get<std::string>();
        if (j.contains("proxy_auth"))   config.proxy_auth   = j.at("proxy_auth").get<std::string>();
        if (j.contains("proxy_type"))   config.proxy_type   = j.at("proxy_type").get<ProxyType>();
        if (j.contains("use"))          config.use          = j.at("use").get<bool>();
    }
 
} // namespace cryptox
 
#endif // _CRYPTOX_DATA_CONNECTION_PROXY_CONFIG_HPP_INCLUDED