bsc::ui_util::anonymous_namespace{ProxyDetect.cpp} Namespace Reference

Functions
std::string	to_lower (std::string s)
std::string	trim (std::string s)
bool	parse_proxy_url (const std::string &raw, ProxyEndpoint &out)
void	collect_env_proxies (std::vector< ProxyEndpoint > &out)
void	collect_file_proxies (const fs::path &path, std::vector< ProxyEndpoint > &out)
void	dedup (std::vector< ProxyEndpoint > &v)
bool	host_equals (const std::string &a, const std::string &b)

Function Documentation

collect_env_proxies()

void bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::collect_env_proxies

(

std::vector< ProxyEndpoint > &

out

)

Definition at line 88 of file ProxyDetect.cpp.

                                                        {
    // Le variabili sono case-insensitive su POSIX: cerchiamo entrambe le forme.
    static const char* kVars[] = {
        "http_proxy", "HTTP_PROXY",
        "https_proxy", "HTTPS_PROXY",
        "all_proxy", "ALL_PROXY",
        "socks_proxy", "SOCKS_PROXY",
    };
    for (const char* var : kVars) {
        const char* v = std::getenv(var);
        if (!v || !*v) continue;
        ProxyEndpoint ep;
        if (parse_proxy_url(v, ep)) out.push_back(std::move(ep));
    }
}

References collect_env_proxies(), and parse_proxy_url().

Referenced by collect_env_proxies().

collect_file_proxies()

void bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::collect_file_proxies	(	const fs::path &	path,
		std::vector< ProxyEndpoint > &	out )

Definition at line 104 of file ProxyDetect.cpp.

                                                                             {
    std::error_code ec;
    if (!fs::exists(path, ec)) return;
    std::ifstream f(path);
    if (!f) return;
    std::string line;
    while (std::getline(f, line)) {
        const auto low = to_lower(line);
        // Match key=value dove key contiene "_proxy"
        auto eq = line.find('=');
        if (eq == std::string::npos) continue;
        const auto key = to_lower(trim(line.substr(0, eq)));
        if (key.find("_proxy") == std::string::npos) continue;
        // Evita ignore_proxy/no_proxy
        if (key.find("no_proxy") != std::string::npos) continue;
        ProxyEndpoint ep;
        auto val = trim(line.substr(eq + 1));
        // Spesso sono nella forma 'export KEY="val"' — il trim toglie quote.
        // Per le righe 'export foo=bar' il trim della key ci ha lasciato
        // "export foo" — accettiamo comunque.
        if (parse_proxy_url(val, ep)) out.push_back(std::move(ep));
    }
}

References collect_file_proxies(), parse_proxy_url(), to_lower(), and trim().

Referenced by collect_file_proxies().

dedup()

void bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::dedup

(

std::vector< ProxyEndpoint > &

v

)

Definition at line 129 of file ProxyDetect.cpp.

                                        {
    std::sort(v.begin(), v.end(), [](const ProxyEndpoint& a, const ProxyEndpoint& b) {
        if (a.host != b.host) return a.host < b.host;
        if (a.port != b.port) return a.port < b.port;
        return a.scheme < b.scheme;
    });
    v.erase(std::unique(v.begin(), v.end(),
                        [](const ProxyEndpoint& a, const ProxyEndpoint& b) {
        return a.host == b.host && a.port == b.port && a.scheme == b.scheme;
    }), v.end());
}

References dedup().

Referenced by dedup().

host_equals()

bool bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::host_equals	(	const std::string &	a,
		const std::string &	b )

Definition at line 141 of file ProxyDetect.cpp.

                                                         {
    const auto la = to_lower(a);
    const auto lb = to_lower(b);
    if (la == lb) return true;
    // Alias localhost
    static const std::vector<std::string> localhosts = {
        "localhost", "127.0.0.1", "::1", "0.0.0.0"
    };
    const bool a_is_local = std::find(localhosts.begin(), localhosts.end(), la) != localhosts.end();
    const bool b_is_local = std::find(localhosts.begin(), localhosts.end(), lb) != localhosts.end();
    return a_is_local && b_is_local;
}

References host_equals(), and to_lower().

Referenced by host_equals().

parse_proxy_url()

bool bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::parse_proxy_url	(	const std::string &	raw,
		ProxyEndpoint &	out )

Definition at line 40 of file ProxyDetect.cpp.

                                                               {
    auto url = trim(raw);
    if (url.empty()) return false;
 
    // scheme://
    auto scheme_end = url.find("://");
    if (scheme_end != std::string::npos) {
        out.scheme = to_lower(url.substr(0, scheme_end));
        url = url.substr(scheme_end + 3);
    } else {
        // host:port senza scheme
        out.scheme = "http";
    }
 
    // Rimuovi user:pass@
    auto at = url.find('@');
    if (at != std::string::npos) url = url.substr(at + 1);
 
    // Taglia path dopo /
    auto slash = url.find('/');
    if (slash != std::string::npos) url = url.substr(0, slash);
    if (url.empty()) return false;
 
    // host:port (gestisce anche [::1]:8080 per IPv6)
    if (url.front() == '[') {
        auto rb = url.find(']');
        if (rb == std::string::npos) return false;
        out.host = url.substr(1, rb - 1);
        if (rb + 1 < url.size() && url[rb + 1] == ':') {
            try { out.port = static_cast<std::uint16_t>(std::stoul(url.substr(rb + 2))); }
            catch (...) { return false; }
        }
    } else {
        auto colon = url.find(':');
        if (colon == std::string::npos) {
            out.host = url;
            out.port = (out.scheme == "https") ? 443 : 8080;
        } else {
            out.host = url.substr(0, colon);
            try { out.port = static_cast<std::uint16_t>(std::stoul(url.substr(colon + 1))); }
            catch (...) { return false; }
        }
    }
 
    if (out.host.empty() || out.port == 0) return false;
    return true;
}

References bsc::ui_util::ProxyEndpoint::host, parse_proxy_url(), bsc::ui_util::ProxyEndpoint::port, bsc::ui_util::ProxyEndpoint::scheme, to_lower(), and trim().

Referenced by collect_env_proxies(), collect_file_proxies(), and parse_proxy_url().

to_lower()

std::string bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::to_lower

(

std::string

s

)

Definition at line 21 of file ProxyDetect.cpp.

                                {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return s;
}

References to_lower().

Referenced by collect_file_proxies(), host_equals(), parse_proxy_url(), and to_lower().

trim()

std::string bsc::ui_util::anonymous_namespace{ProxyDetect.cpp}::trim

(

std::string

s

)

Definition at line 27 of file ProxyDetect.cpp.

                            {
    auto not_space = [](unsigned char c) { return !std::isspace(c); };
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_space));
    s.erase(std::find_if(s.rbegin(), s.rend(), not_space).base(), s.end());
    // Rimuovi eventuali quote
    if (s.size() >= 2 && (s.front() == '"' || s.front() == '\'')) {
        if (s.back() == s.front()) s = s.substr(1, s.size() - 2);
    }
    return s;
}

References trim().

Referenced by collect_file_proxies(), parse_proxy_url(), and trim().