Struct Forwarded

pub struct Forwarded<'fe> {
    pub elements: Vec<ForwardedElement<'fe>>,
}

A Rust representation of the RFC 7329 Forwarded production.

Fields

elements: Vec<ForwardedElement<'fe>>

Ordered vector of forwarded-element.

Implementations

impl<'fe, 'input: 'fe> Forwarded<'fe>

pub fn new() -> Self

Builds a new Forwarded.

pub fn from_headers( headers: &'input impl AsRef<Headers>, ) -> Result<Option<Self>, ForwardedError>

Parse a list of Forwarded HTTP headers into a borrowed Forwarded instance, with X-Forwarded-* fallback.

Fallback behaviour

If no Forwarded HTTP header was set it falls back to trying to parse one of the supported kinds of X-Forwarded-* headers. See from_x_forwarded_headers for more information.

Examples

let mut request = Request::new(Get, Url::parse("http://_/")?);
request.insert_header("X-Forwarded-For", "198.51.100.46");
request.insert_header(
    "Forwarded",
    r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"#
);
let forwarded = Forwarded::from_headers(&request)?.unwrap();
//assert_eq!(forwarded.to_string(), r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"#);

let mut request = Request::new(Get, Url::parse("http://_/")?);
request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17, unknown");
let forwarded = Forwarded::from_headers(&request)?.unwrap();
assert_eq!(forwarded.to_string(), r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown"#);

let mut request = Request::new(Get, Url::parse("http://_/")?);
request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17, unknown");
request.insert_header("X-Forwarded-Proto", "https");
assert_eq!(
    Forwarded::from_headers(&request),
    Err(ForwardedError::MultipleXForwardedHeaders(vec![
        "x-forwarded-for".to_string(),
        "x-forwarded-proto".to_string()
    ])),
);

pub fn from_forwarded_header( headers: &'input impl AsRef<Headers>, ) -> Result<Option<Self>, ForwardedError>

Parses list of Forwarded HTTP headers into a borrowed Forwarded instance.

pub fn from_x_forwarded_headers( headers: &'input impl AsRef<Headers>, ) -> Result<Option<Self>, ForwardedError>

Attempt to parse non-standard X-Forwarded-* headers into a borrowed Forwarded instance.

This will only attempt to do the conversion if only one kind of X-Forwarded-* header was specified since there is no way for us to know which order the headers were added in and at which steps. This is in accordance with Section 7.4 of RFC 7239.

Supported headers

• X-Forwarded-By
• X-Forwarded-For
• X-Forwarded-Host
• X-Forwarded-Proto

pub fn parse( &mut self, input: &'input str, ) -> Result<&'input str, ForwardedError>

Parses a Forwarded HTTP header value into a borrowed Forwarded instance.

pub fn into_owned(self) -> Forwarded<'static>

Transform a borrowed Forwarded into an owned Forwarded.

Trait Implementations

impl<'fe> Clone for Forwarded<'fe>

fn clone(&self) -> Forwarded<'fe>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'fe> Debug for Forwarded<'fe>

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

Formats the value using the given formatter.

impl<'fe> Default for Forwarded<'fe>

fn default() -> Forwarded<'fe>

Returns the “default value” for a type.

impl<'fe> Display for Forwarded<'fe>

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

Formats the value using the given formatter.

impl<'input> Header for Forwarded<'input>

fn header_name(&self) -> HeaderName

Access the header’s name.

fn header_value(&self) -> HeaderValue

Access the header’s value.

fn apply_header<H: AsMut<Headers>>(&self, headers: H)

Insert the header name and header value into something that looks like a Headers map.

impl<'fe> PartialEq for Forwarded<'fe>

fn eq(&self, other: &Forwarded<'fe>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'fe> Eq for Forwarded<'fe>

impl<'fe> StructuralPartialEq for Forwarded<'fe>