Struct TrustedProxies 

pub struct TrustedProxies { /* private fields */ }

The proxies whose claims about the client address are believed: PROXY headers here, and X-Forwarded-For / Forwarded in the web layer, which should use the same value. Keep it minimal: a trusted proxy can claim any client address.

Sorted, deduplicated, at most TrustedProxies::MAX blocks. contains is a binary search over the blocks merged into disjoint ranges, IPv4 and IPv6 kept apart; it allocates nothing.

Examples

use net_io::TrustedProxies;
let proxies = TrustedProxies::parse("10.0.0.0/8, 192.168.1.10 ::1")?;
assert!(proxies.contains("10.4.5.6".parse().unwrap()));
assert!(!proxies.contains("8.8.8.8".parse().unwrap()));

Implementations

impl TrustedProxies

pub const MAX: usize = 1024

The most blocks a list holds.

pub fn new(blocks: &[Cidr]) -> Result<TrustedProxies, AddrError>

A list of these blocks (duplicates removed).

Errors

AddrError::TooMany above TrustedProxies::MAX blocks.

use net_io::{Cidr, TrustedProxies};
let p = TrustedProxies::new(&[Cidr::parse("10.0.0.0/8")?, Cidr::parse("10.0.0.0/8")?])?;
assert_eq!(p.len(), 1);

pub fn parse(text: &str) -> Result<TrustedProxies, AddrError>

Parses blocks or addresses separated by commas or whitespace (a bare address is a /32 or /128).

Errors

As Cidr::parse (with Syntax { at } counted from the start of text), AddrError::Empty when there is no entry, AddrError::TooMany.

let p = net_io::TrustedProxies::parse("127.0.0.1, ::1")?;
assert_eq!(p.len(), 2);
assert!(net_io::TrustedProxies::parse("10.0.0.1/8").is_err()); // host bits set

pub fn none() -> TrustedProxies

Trusts nobody.

assert!(net_io::TrustedProxies::none().is_empty());

pub fn loopback() -> TrustedProxies

127.0.0.0/8 and ::1/128: a proxy on the same host.

assert!(net_io::TrustedProxies::loopback().contains("127.0.0.1".parse().unwrap()));

pub fn contains(&self, ip: IpAddr) -> bool

Whether ip (normalized first, so an IPv4-mapped address matches IPv4 blocks) belongs to a trusted proxy. No allocation.

let p = net_io::TrustedProxies::parse("10.0.0.0/8")?;
assert!(p.contains("::ffff:10.1.2.3".parse().unwrap()));

pub fn len(&self) -> usize

The number of blocks.

pub fn is_empty(&self) -> bool

Whether the list is empty (trusts nobody).

pub fn iter(&self) -> impl Iterator<Item = Cidr> + '_

The blocks, sorted (IPv4 first, then by network and prefix).

Trait Implementations

impl Clone for TrustedProxies

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 TrustedProxies

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

Formats the value using the given formatter.

impl Eq for TrustedProxies

impl PartialEq for TrustedProxies

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TrustedProxies