Struct ProxyEndpoint 

#[non_exhaustive]
pub struct ProxyEndpoint {
    pub scheme_hint: Option<ProxyScheme>,
    pub host: Host,
    pub port: u16,
    pub auth: Option<ProxyAuth>,
}

Concrete proxy address. IPv6 brackets resolved at parse; use authority. #[non_exhaustive] — construct via new / parse.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

scheme_hint: Option<ProxyScheme>

Wire protocol hint when the source named one.

host: Host

Proxy host.

port: u16

Proxy port.

auth: Option<ProxyAuth>

Embedded credentials, if any.

Implementations

impl ProxyEndpoint

pub fn new(host: Host, port: u16) -> Self

Build an endpoint from an already-parsed host and port.

pub fn with_scheme_hint(self, scheme: ProxyScheme) -> Self

Set the scheme hint (builder style).

pub fn with_auth(self, auth: ProxyAuth) -> Self

Set the credentials (builder style).

pub fn parse(input: &str, default_port: u16) -> Result<Self, Error>

Parse a proxy address in any of the shapes operating systems store.

host, host:port, [::1]:8080, user:pass@host[:port], or any of those behind a scheme://. Credentials do not need the scheme: the userinfo split happens after the optional prefix, so a bare user:pass@host carries a secret just as a scheme:// one does. The last @ is the delimiter, as in WHATWG’s authority state, so user@corp.example:pw@proxy:8080 keeps an email address as the user name. Port: explicit, else scheme default, else default_port. A path, query or fragment is accepted and dropped, so http://proxy:8080/ and http://proxy:8080 are the same endpoint; nothing after the authority survives.

let ep = ProxyEndpoint::parse("socks5://[::1]", 80).unwrap();
assert_eq!(ep.scheme_hint, Some(ProxyScheme::Socks5));
assert_eq!(ep.port, 1080);
assert_eq!(ep.authority(), "[::1]:1080");

Errors

Error::InvalidProxyServer if the input is not a usable address, or Error::UnsupportedProxyScheme for a scheme:// prefix this crate does not model. Never Error::InvalidProxyUrl: that one belongs to the callers that parse an AutoConfigURL-style value, not to an address.

U+FFFD anywhere in the authority — credentials included — is one of the unusable addresses. It is what a lossy byte-to-text conversion leaves behind, and this crate’s platform readers convert that way so that a value they could not decode is refused here instead of reading as unset. A path or query is dropped before the check, so the character is only refused where the answer is built from it.

pub fn authority(&self) -> String

The host:port form, with IPv6 hosts re-bracketed.

Trait Implementations

impl Clone for ProxyEndpoint

fn clone(&self) -> ProxyEndpoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProxyEndpoint

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

Formats the value using the given formatter.

impl Display for ProxyEndpoint

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

Formats the value using the given formatter.

impl Eq for ProxyEndpoint

impl Hash for ProxyEndpoint

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 ProxyEndpoint

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ProxyEndpoint