ProxyConfig Namespace Reference

Classes
struct	Settings

Enumerations
enum class	DE {   GNOME , KDE , XFCE , MATE ,   CINNAMON , LXQT , OTHER }

Functions
static bool	run (const std::vector< std::string > &args, bool silent=false)
static DE	detect ()
static void	gnome_set (const Settings &s)
static void	gnome_clear ()
static void	kde_refresh ()
static void	kde_set (const Settings &s)
static void	kde_clear ()
static void	xfce_set (const Settings &s)
static void	xfce_clear ()
static void	mate_set (const Settings &s)
static void	mate_clear ()
static void	lxqt_set (const Settings &s)
static void	env_set (const Settings &s)
static void	env_clear ()
static void	apply (const Settings &s)
static void	restore ()

Enumeration Type Documentation

DE

enum class ProxyConfig::DE

strong

Enumerator
GNOME
KDE
XFCE
MATE
CINNAMON
LXQT
OTHER

Definition at line 405 of file proxy_config.hpp.

{ GNOME, KDE, XFCE, MATE, CINNAMON, LXQT, OTHER };

Function Documentation

apply()

void ProxyConfig::apply ( const Settings & s )

static

Definition at line 571 of file proxy_config.hpp.

                                     {
    // Validate addresses before persisting them to configuration files.
    const bool valid_host = !s.host.empty() && s.host.size() <= 253 &&
        std::all_of(s.host.begin(), s.host.end(), [](unsigned char c) {
            return std::isalnum(c) || c == '.' || c == '-' || c == ':' || c == '[' || c == ']';
        });
    if (!valid_host || s.port < 1 || s.port > 65535) {
        std::cerr << "[proxy-config] refusing unsafe host or port\n";
        return;
    }
    char msg[256];
    std::snprintf(msg, sizeof(msg), _("[proxy-config] setting system proxy → %s:%d\n"),
        s.host.c_str(), s.port);
    std::cerr << msg;
 
    env_set(s);
 
    switch (detect()) {
        case DE::GNOME:
        case DE::CINNAMON: gnome_set(s); break;
        case DE::KDE:      kde_set(s);   break;
        case DE::XFCE:     xfce_set(s);  break;
        case DE::MATE:     gnome_set(s); mate_set(s); break;
        case DE::LXQT:     lxqt_set(s);  break;
        case DE::OTHER:                    break;
    }
    BrowserProxy::install_ca_all_browsers();
 
    BrowserProxy::apply({ s.host, s.port });
}

References _, BrowserProxy::apply(), apply(), CINNAMON, detect(), env_set(), GNOME, gnome_set(), ProxyConfig::Settings::host, BrowserProxy::install_ca_all_browsers(), KDE, kde_set(), LXQT, lxqt_set(), MATE, mate_set(), OTHER, ProxyConfig::Settings::port, XFCE, and xfce_set().

Referenced by apply().

detect()

DE ProxyConfig::detect ( )

static

Definition at line 407 of file proxy_config.hpp.

                   {
    const char* xdg = std::getenv("XDG_CURRENT_DESKTOP");
    if (xdg) {
        std::string d(xdg);
        for (auto& c : d) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
        if (d.find("GNOME")    != std::string::npos) return DE::GNOME;
        if (d.find("KDE")      != std::string::npos) return DE::KDE;
        if (d.find("XFCE")     != std::string::npos) return DE::XFCE;
        if (d.find("MATE")     != std::string::npos) return DE::MATE;
        if (d.find("CINNAMON") != std::string::npos) return DE::CINNAMON;
        if (d.find("LXQT")     != std::string::npos) return DE::LXQT;
    }
    if (std::getenv("KDE_FULL_SESSION"))         return DE::KDE;
    if (std::getenv("GNOME_DESKTOP_SESSION_ID")) return DE::GNOME;
    return DE::OTHER;
}

References CINNAMON, detect(), GNOME, KDE, LXQT, MATE, OTHER, and XFCE.

Referenced by apply(), detect(), and restore().

env_clear()

void ProxyConfig::env_clear ( )

static

Definition at line 553 of file proxy_config.hpp.

                        {
    unsetenv("http_proxy");
    unsetenv("HTTP_PROXY");
    unsetenv("https_proxy");
    unsetenv("HTTPS_PROXY");
    unsetenv("all_proxy");
    unsetenv("ALL_PROXY");
    unsetenv("no_proxy");
    unsetenv("NO_PROXY");
 
    const char* home = std::getenv("HOME");
    if (home) {
        std::error_code ec;
        std::filesystem::remove(
            std::filesystem::path(home) / ".config/environment.d/bastionguard-proxy.conf", ec);
    }
}

References env_clear().

Referenced by env_clear(), and restore().

env_set()

void ProxyConfig::env_set ( const Settings & s )

static

Definition at line 518 of file proxy_config.hpp.

                                       {
    const std::string val = "http://" + s.host + ":" + std::to_string(s.port);
    const char* nopx = BrowserProxy::LAN_BYPASS_NOCIDR;
 
    setenv("http_proxy",  val.c_str(), 1);
    setenv("HTTP_PROXY",  val.c_str(), 1);
    setenv("https_proxy", val.c_str(), 1);
    setenv("HTTPS_PROXY", val.c_str(), 1);
    setenv("all_proxy",   val.c_str(), 1);
    setenv("ALL_PROXY",   val.c_str(), 1);
    setenv("no_proxy",    nopx, 1);
    setenv("NO_PROXY",    nopx, 1);
 
    const char* home = std::getenv("HOME");
    if (home) {
        namespace fs = std::filesystem;
        const fs::path conf_dir = fs::path(home) / ".config/environment.d";
        std::error_code ec;
        fs::create_directories(conf_dir, ec);
        if (!ec) {
            std::ofstream f(conf_dir / "bastionguard-proxy.conf");
            if (f) {
                f << "http_proxy="  << val << "\n"
                  << "HTTP_PROXY="  << val << "\n"
                  << "https_proxy=" << val << "\n"
                  << "HTTPS_PROXY=" << val << "\n"
                  << "all_proxy="   << val << "\n"
                  << "ALL_PROXY="   << val << "\n"
                  << "no_proxy="    << nopx << "\n"
                  << "NO_PROXY="    << nopx << "\n";
            }
        }
    }
}

References env_set(), ProxyConfig::Settings::host, BrowserProxy::LAN_BYPASS_NOCIDR, and ProxyConfig::Settings::port.

Referenced by apply(), and env_set().

gnome_clear()

void ProxyConfig::gnome_clear ( )

static

Definition at line 438 of file proxy_config.hpp.

                          {
    run({"gsettings", "set", "org.gnome.system.proxy", "mode", "none"});
}

References gnome_clear(), and run().

Referenced by gnome_clear(), and restore().

gnome_set()

void ProxyConfig::gnome_set ( const Settings & s )

static

Definition at line 424 of file proxy_config.hpp.

                                         {
    const std::string port = std::to_string(s.port);
    run({"gsettings", "set", "org.gnome.system.proxy", "mode", "manual"});
    for (const char* scheme : {"http", "https"}) {
        const std::string schema = std::string("org.gnome.system.proxy.") + scheme;
        run({"gsettings", "set", schema, "host", s.host});
        run({"gsettings", "set", schema, "port", port});
    }
    run({"gsettings", "set", "org.gnome.system.proxy.socks", "host", ""});
    run({"gsettings", "set", "org.gnome.system.proxy.socks", "port", "0"});
    run({"gsettings", "set", "org.gnome.system.proxy", "ignore-hosts",
         BrowserProxy::LAN_BYPASS_GVARIANT});
}

References gnome_set(), ProxyConfig::Settings::host, BrowserProxy::LAN_BYPASS_GVARIANT, ProxyConfig::Settings::port, and run().

Referenced by apply(), and gnome_set().

kde_clear()

void ProxyConfig::kde_clear ( )

static

Definition at line 466 of file proxy_config.hpp.

                        {
    for (const char* bin : {"kwriteconfig6", "kwriteconfig5"})
        (void)run({bin, "--file", "kioslaverc", "--group", "Proxy Settings",
                   "--key", "ProxyType", "0"}, true);
    kde_refresh();
}

References kde_clear(), kde_refresh(), and run().

Referenced by kde_clear(), and restore().

kde_refresh()

void ProxyConfig::kde_refresh ( )

static

Definition at line 442 of file proxy_config.hpp.

                          {
    // Either kioclient version may be installed; failures are harmless.
    if (!run({"kioclient6", "clear"}, true))
        (void)run({"kioclient5", "clear"}, true);
}

References kde_refresh(), and run().

Referenced by kde_clear(), kde_refresh(), and kde_set().

kde_set()

void ProxyConfig::kde_set ( const Settings & s )

static

Definition at line 448 of file proxy_config.hpp.

                                       {
    const std::string hp = "http://" + s.host + ":" + std::to_string(s.port);
    for (const char* bin : {"kwriteconfig6", "kwriteconfig5"}) {
        const std::vector<std::string> common = {bin, "--file", "kioslaverc", "--group", "Proxy Settings"};
        auto set = [&](const std::string& key, const std::string& val) {
            std::vector<std::string> args = common;
            args.insert(args.end(), {"--key", key, val});
            (void)run(args, true);
        };
        set("ProxyType", "1");
        set("httpProxy", hp);
        set("httpsProxy", hp);
        set("NoProxyFor", BrowserProxy::LAN_BYPASS_CIDR);
        set("ReversedException", "false");
    }
    kde_refresh();
}

References ProxyConfig::Settings::host, kde_refresh(), kde_set(), BrowserProxy::LAN_BYPASS_CIDR, ProxyConfig::Settings::port, and run().

Referenced by apply(), and kde_set().

lxqt_set()

void ProxyConfig::lxqt_set ( const Settings & s )

static

Definition at line 503 of file proxy_config.hpp.

                                        {
    const char* home = std::getenv("HOME");
    if (!home) return;
 
    namespace fs = std::filesystem;
    std::ofstream f(fs::path(home) / ".config/lxqt/session.conf", std::ios::app);
    if (f) {
        const std::string val = "http://" + s.host + ":" + std::to_string(s.port);
        f << "\n[Environment]\n"
          << "http_proxy="  << val << "\n"
          << "https_proxy=" << val << "\n"
          << "no_proxy="    << BrowserProxy::LAN_BYPASS_NOCIDR << "\n";
    }
}

References ProxyConfig::Settings::host, BrowserProxy::LAN_BYPASS_NOCIDR, lxqt_set(), and ProxyConfig::Settings::port.

Referenced by apply(), and lxqt_set().

mate_clear()

void ProxyConfig::mate_clear ( )

static

Definition at line 499 of file proxy_config.hpp.

                         {
    (void)run({"gsettings", "set", "org.mate.network-preferences", "proxy-mode", "none"}, true);
}

References mate_clear(), and run().

Referenced by mate_clear(), and restore().

mate_set()

void ProxyConfig::mate_set ( const Settings & s )

static

Definition at line 489 of file proxy_config.hpp.

                                        {
    const std::string port = std::to_string(s.port);
    for (const auto& [key, value] : std::vector<std::pair<std::string, std::string>>{
            {"proxy-mode", "manual"}, {"http-host", s.host}, {"http-port", port},
            {"https-host", s.host}, {"https-port", port},
            {"ignore-hosts", BrowserProxy::LAN_BYPASS_GVARIANT}}) {
        (void)run({"gsettings", "set", "org.mate.network-preferences", key, value}, true);
    }
}

References ProxyConfig::Settings::host, BrowserProxy::LAN_BYPASS_GVARIANT, mate_set(), ProxyConfig::Settings::port, and run().

Referenced by apply(), and mate_set().

restore()

void ProxyConfig::restore ( )

static

Definition at line 602 of file proxy_config.hpp.

                      {
    std::cerr << _("[proxy-config] restoring system proxy\n");
 
    env_clear();
 
    switch (detect()) {
        case DE::GNOME:
        case DE::CINNAMON: gnome_clear(); break;
        case DE::KDE:      kde_clear();   break;
        case DE::XFCE:     xfce_clear();  break;
        case DE::MATE:     gnome_clear(); mate_clear(); break;
        case DE::LXQT:                      break;
        case DE::OTHER:                     break;
    }
 
    BrowserProxy::restore();
}

References _, CINNAMON, detect(), env_clear(), GNOME, gnome_clear(), KDE, kde_clear(), LXQT, MATE, mate_clear(), OTHER, BrowserProxy::restore(), restore(), XFCE, and xfce_clear().

Referenced by restore().

run()

bool ProxyConfig::run ( const std::vector< std::string > & args, bool silent = false )

static

Definition at line 397 of file proxy_config.hpp.

                                                                     {
    const auto result = bg_process::run(args, true, 256U * 1024U);
    if (!result.ok() && !silent)
        std::cerr << "[proxy-config] command failed: " << args.front() << " ("
                  << result.exit_code << ")\n";
    return result.ok();
}

References bg_process::run(), and run().

Referenced by gnome_clear(), gnome_set(), kde_clear(), kde_refresh(), kde_set(), mate_clear(), mate_set(), run(), xfce_clear(), and xfce_set().

xfce_clear()

void ProxyConfig::xfce_clear ( )

static

Definition at line 485 of file proxy_config.hpp.

                         {
    (void)run({"xfconf-query", "-c", "xfce4-settings-editor", "-p", "/Net/ProxyMode", "-s", "none"}, true);
}

References run(), and xfce_clear().

Referenced by restore(), and xfce_clear().

xfce_set()

void ProxyConfig::xfce_set ( const Settings & s )

static

Definition at line 473 of file proxy_config.hpp.

                                        {
    const std::string port = std::to_string(s.port);
    (void)run({"xfconf-query", "-c", "xfce4-settings-editor", "-p", "/Net/ProxyMode", "-s", "manual"}, true);
    for (const char* scheme : {"http", "https"}) {
        const std::string key = std::string("/Net/") + scheme + "-proxy/";
        (void)run({"xfconf-query", "-c", "xfce4-settings-editor", "-p", key + "host", "-s", s.host}, true);
        (void)run({"xfconf-query", "-c", "xfce4-settings-editor", "-p", key + "port", "-s", port}, true);
    }
    (void)run({"gsettings", "set", "org.gnome.system.proxy", "ignore-hosts",
               BrowserProxy::LAN_BYPASS_GVARIANT}, true);
}

References ProxyConfig::Settings::host, BrowserProxy::LAN_BYPASS_GVARIANT, ProxyConfig::Settings::port, run(), and xfce_set().

Referenced by apply(), and xfce_set().