Struct ProxyEnv 

pub struct ProxyEnv { /* private fields */ }

Env snapshot of *_proxy / no_proxy (not a Stream; ProxyWatcher does not merge these in — except where an OS setting names them, which KDE’s ProxyType=4 does).

Lowercase beats uppercase; empty value → ProxyEntry::Disabled; port explicit, else the scheme:// default, else 80 (so all_proxy=socks5://h is 1080, http_proxy=h is 80) — the rule ProxyEndpoint::parse states. On Windows only, any other letter case the variable was actually set in (Http_Proxy) is read too, after both conventional spellings. no_proxy via parse::no_proxy. Bad *_proxy → rejected. A non-empty REQUEST_METHOD + http_proxy → Error::CgiHttpProxy. Merge with a watcher is caller-defined precedence.

Implementations

impl ProxyEnv

pub fn from_env() -> Result<Self, Error>

Read the snapshot from the current process environment.

std::env::vars panics on a variable whose name or value is not valid Unicode, so this reads std::env::vars_os instead: one unrelated variable elsewhere in the process must not be able to take the whole snapshot down. What that costs is split by half: a variable whose name is not valid Unicode is none of the ones read here, so it is dropped, while a mangled value is kept and refused — it lands in rejected rather than reading as unset.

Errors

Error::CgiHttpProxy in a CGI environment carrying an http_proxy variable. A malformed value is no longer one of these, but the two kinds are recorded apart: a dropped *_proxy endpoint lands in rejected, a dropped no_proxy entry in bypass().rejected. Reading only the first and finding it empty says nothing about the second.

pub fn from_vars<I, K, V>(vars: I) -> Result<Self, Error>

where I: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

Explicit map for tests (avoids mutating the process-global env).

let env = ProxyEnv::from_vars([
    ("HTTP_PROXY", "http://upper:8080"),
    ("http_proxy", "http://lower:8080"),
    ("no_proxy", "*.internal"),
])
.unwrap();
// Lowercase wins.
let endpoint = env.endpoint_for(Scheme::Http).unwrap();
assert_eq!(endpoint.host.to_string(), "lower");
assert!(env.bypass().matches_authority("api.internal"));

Errors

Error::CgiHttpProxy when a non-empty REQUEST_METHOD and an http_proxy are both present. Malformed values are recorded instead of returned; see from_env for which of the two lists each kind reaches.

pub fn per_scheme(&self) -> &HashMap<Scheme, ProxyEntry>

The parsed per-scheme entries. Never Unusable: a drop stays on rejected alone until to_mode files it into the ProxyMode’s map, so a snapshot and the mode built from it differ here.

pub fn bypass(&self) -> &BypassRules

The parsed no_proxy rules.

pub fn rejected(&self) -> &[RejectedValue]

Redacted *_proxy values ProxyEndpoint::parse rejected (fail-open drop, not whole-snapshot failure). Threaded into ProxyMode via to_mode. Not the no_proxy drops: those are exclusions rather than endpoints and stay on bypass().rejected. to_mode carries them across inside the BypassRules, but only on the branch that returns a Manual: a snapshot holding nothing but a no_proxy is Direct, and an exclusion list with no proxy to be excluded from does not outlive the conversion.

pub fn captured_at(&self) -> SystemTime

When the snapshot was taken. Excluded from equality comparisons.

pub fn is_empty(&self) -> bool

No *_proxy set (malformed-but-present still counts as set via rejected).

pub fn is_configured(&self) -> bool

Whether these variables specify a configuration — something the environment asked for, as opposed to something it merely mentioned.

This neither implies is_empty nor follows from it, which is why both exist. is_empty answers “was any scheme variable set”, counting a value that failed to parse and ignoring no_proxy; this one ignores the failures and counts no_proxy:

environment	is_empty	is_configured
nothing set	true	false
http_proxy=http://p:8080	false	true
http_proxy= — a deliberate direct for http	false	true
no_proxy=.corp.example alone	true	true
every scheme variable malformed	false	false

The last two rows are the ones with consequences, and both follow Chromium’s net/proxy_resolution/proxy_config_service_linux.cc. A no_proxy on its own is a configuration there — “having no rules specified only means the user explicitly asks for direct connections” — and a value that fails to parse is logged and then treated exactly as if the variable were unset. A malformed value is a diagnostic, kept in rejected; reading it as an instruction would let a typo in http_proxy mask a working OS proxy.

ProxyConfig::with_env is what acts on the distinction. to_mode does not: a no_proxy with no proxy to exclude from is still Direct, which is the same answer Chromium’s config produces once it has no proxy servers in it.

pub fn endpoint_for(&self, scheme: Scheme) -> Option<&ProxyEndpoint>

The endpoint for scheme, under the same Scheme::All fallback as ProxyMode::entry_for: All itself has none, and a Disabled entry answers None instead of falling through.

pub fn to_mode(&self) -> ProxyMode

Into ProxyMode: empty → Direct; else Manual (keeping rejected even when every scheme value failed to parse).

pub fn to_config(&self) -> ProxyConfig

Convert the snapshot into a ProxyConfig attributed to ProxyConfigSource::Env, carrying this snapshot’s captured_at rather than the time of the conversion.

Trait Implementations

impl Clone for ProxyEnv

fn clone(&self) -> ProxyEnv

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProxyEnv

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ProxyEnv

impl PartialEq for ProxyEnv

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.