Enum HostPattern 

#[non_exhaustive]
pub enum HostPattern {
    All,
    Cidr(IpNet),
    Exact {
        host: Host,
        port: Option<u16>,
    },
    Domain {
        suffix: String,
        match_self: bool,
        port: Option<u16>,
    },
    Wildcard {
        pattern: String,
        port: Option<u16>,
    },
    Local,
    SubtractImplicit,
}

A single entry of a bypass list.

Source	Variant
*	HostPattern::All (not from a macOS or GNOME list, where it names nothing)
CIDR	HostPattern::Cidr
IP / host:port	HostPattern::Exact
example.com / .example.com / *.example.com	HostPattern::Domain
192.168.*	HostPattern::Wildcard
<local>	HostPattern::Local
<-loopback>	HostPattern::SubtractImplicit

The bare-name row is the one that depends on where the list came from: a Windows list reads example.com as HostPattern::Exact, because that is what Windows matches. parse::proxy_override has the readings.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

All

Matches every host: a bare * in the list disables proxying entirely.

Cidr(IpNet)

Matches any address inside an IP network.

Exact

Literal host, optionally port-restricted.

parse reaches it only for an address literal, but parse::proxy_override reaches it for every bare name: a bare entry in a Windows list matches that name and nothing under it.

Its Display is the name alone, which is also how a suffix rule for the same domain is written. Reading that text back therefore gives this variant through proxy_override and a Domain covering the subdomains through parse::no_proxy — the same text, two rules — so a pattern displayed and re-read through the other dialect widens. Hold the value instead of its text if that matters.

Fields

host: Host

Host to match.

port: Option<u16>

Optional port restriction.

Domain

Domain suffix (stored with a leading dot).

Fields

suffix: String

Suffix (e.g. .example.com). A hand-built one without the dot names the same domain; an empty one names none and so matches nothing. Case is folded at match time, so parse’s lowercasing is a normalisation and not a precondition.

match_self: bool

Whether the bare domain matches too.

port: Option<u16>

Optional port restriction.

Wildcard

Windows-style glob with *.

A plain *.example.com is not one: it is the same rule as .example.com and parses to Domain. A leading *. does reach this variant when the rest still holds a glob (*.a*b.com), and so does the * this parse writes in front of a leading-dot glob (.*.example.com is stored as *.*.example.com).

Matched as text against the destination’s canonical spelling, so a glob written around a non-canonical address (*192.168.001.001, which arrives as 192.168.1.1) matches nothing. Unlike the other variants, such a glob is not refused during parsing and so does not reach BypassRules::rejected: * stands for the empty string as well as for text, which leaves *10.0.0.1 live and every test that separates the two cases open to a counterexample.

Fields

pattern: String

Glob pattern. parse lowercases it, and a hand-built one that is not lowercased matches the same hosts anyway: case is folded at match time.

port: Option<u16>

Optional port restriction.

Local

Windows <local> / macOS ExcludeSimpleHostnames: any host name without a dot.

SubtractImplicit

Windows <-loopback>: the one entry that takes a bypass away instead of adding one. It subtracts the implicit set — loopback and link-local, see NO_LOOPBACK_TOKEN — from every entry written before it, and from none written after it, which is why it is an entry in BypassRules::patterns and not a switch beside them. BypassRules::matches has the evaluation order.

Implementations

impl HostPattern

pub fn parse(entry: &str) -> Result<Option<Self>, Error>

Parse one bypass entry. Ok(None) for empty and for anything with no host left to match on — :8080, ., .., *..

let p = HostPattern::parse("*.example.com").unwrap().unwrap();
assert!(matches!(p, HostPattern::Domain { match_self: false, .. }));

A bare address entry is stored the way the destination side reads it, not the way it was written: 010.0.0.1 is octal (8.0.0.1) and 192.168.1 is short-form (192.168.0.1), because that is how the Host the destination carries would parse the same text.

A CIDR entry does not follow that grammar, because it is not a host: ipnet reads four decimal octets, so 010.0.0.0/8 is 10.0.0.0/8 — the block the writer meant, but not the block the same text would denote as a destination — and 192.168.1/24 and 0x0a.0.0.0/8 are errors rather than addresses. What is shared is the mapped reduction: ::ffff:10.0.0.0/104 is stored as 10.0.0.0/8, matching what destinations 10.0.0.1 and [::ffff:10.0.0.1] both become.

Errors

Error::InvalidBypassPattern for @, internal whitespace, a scheme:// prefix, a character that cannot appear in a host name (WHATWG forbidden domain code points not already rejected above), an empty label (a..b), a subdomain of an address (.10.0.0.1), a name no destination could carry (example.123), bad CIDR /, bad port, bad IPv6 brackets, or non-ASCII text with no punycode spelling.

Trait Implementations

impl Clone for HostPattern

fn clone(&self) -> HostPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HostPattern

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

Formats the value using the given formatter.

impl Display for HostPattern

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

Formats the value using the given formatter.

impl Eq for HostPattern

impl Hash for HostPattern

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for HostPattern

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for HostPattern