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 or macOS list reads example.com as HostPattern::Exact, because that is what both match. 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 or macOS list matches that name and nothing under it.

Its Display is the name alone, also used for a suffix rule for the same domain. Parsing that text with proxy_override returns this variant, while parse::no_proxy returns a Domain that also covers subdomains. Retaining the value avoids widening the rule by displaying it and re-parsing it with the other dialect.

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 does not reach BypassRules::rejected: * can match an empty string, so *10.0.0.1 remains valid, and tests that distinguish these cases admit counterexamples.

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>: any host name without a dot, and no IP literal. The macOS switch is BypassRules::exclude_simple_hostnames, which also takes a dot-less IPv6 literal.

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’s IPv4 address follows the same grammar when it has four parts, as Chromium’s does: 010.0.0.0/8 is 8.0.0.0/8 and 0x0a.0.0.0/8 is 10.0.0.0/8. curl and Go read neither as a block. A short form (192.168.1/24) is an error rather than an address. A mapped-spelling block (::ffff:10.0.0.0/104) is stored as written; BypassRules::matches reads it as 10.0.0.0/8 while BypassRules::ipv4_mapped_as_ipv4 is set.

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) -> Self

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for HostPattern