Struct NormalizedIpAddr 

pub struct NormalizedIpAddr(IpAddr);

The last 64 bits of IPv6 addresess may vary a lot even when coming from the same client, and taking the full IPv6 for IP bans is thus useless.

This newtype ensures that all the last 64 bits of an IPv6 address are set to zero to counter this.

Tuple Fields

0: IpAddr

Methods from Deref<Target = IpAddr>

pub fn is_unspecified(&self) -> bool

Returns true for the special ‘unspecified’ address.

See the documentation for Ipv4Addr::is_unspecified() and Ipv6Addr::is_unspecified() for more details.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)).is_unspecified(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).is_unspecified(), true);

pub fn is_loopback(&self) -> bool

Returns true if this is a loopback address.

See the documentation for Ipv4Addr::is_loopback() and Ipv6Addr::is_loopback() for more details.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).is_loopback(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1)).is_loopback(), true);

pub fn is_global(&self) -> bool

🔬This is a nightly-only experimental API. (ip)

Returns true if the address appears to be globally routable.

See the documentation for Ipv4Addr::is_global() and Ipv6Addr::is_global() for more details.

Examples

#![feature(ip)]

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(80, 9, 12, 3)).is_global(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1)).is_global(), true);

pub fn is_multicast(&self) -> bool

Returns true if this is a multicast address.

See the documentation for Ipv4Addr::is_multicast() and Ipv6Addr::is_multicast() for more details.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(224, 254, 0, 0)).is_multicast(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0)).is_multicast(), true);

pub fn is_documentation(&self) -> bool

🔬This is a nightly-only experimental API. (ip)

Returns true if this address is in a range designated for documentation.

See the documentation for Ipv4Addr::is_documentation() and Ipv6Addr::is_documentation() for more details.

Examples

#![feature(ip)]

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_documentation(), true);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_documentation(),
    true
);

pub fn is_benchmarking(&self) -> bool

🔬This is a nightly-only experimental API. (ip)

Returns true if this address is in a range designated for benchmarking.

See the documentation for Ipv4Addr::is_benchmarking() and Ipv6Addr::is_benchmarking() for more details.

Examples

#![feature(ip)]

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(198, 19, 255, 255)).is_benchmarking(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0)).is_benchmarking(), true);

pub fn is_ipv4(&self) -> bool

Returns true if this address is an IPv4 address, and false otherwise.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv4(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv4(), false);

pub fn is_ipv6(&self) -> bool

Returns true if this address is an IPv6 address, and false otherwise.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv6(), false);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv6(), true);

pub fn to_canonical(&self) -> IpAddr

Converts this address to an IpAddr::V4 if it is an IPv4-mapped IPv6 address, otherwise returns self as-is.

Examples

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let localhost_v4 = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(IpAddr::V4(localhost_v4).to_canonical(), localhost_v4);
assert_eq!(IpAddr::V6(localhost_v4.to_ipv6_mapped()).to_canonical(), localhost_v4);
assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).to_canonical().is_loopback(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).is_loopback(), false);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).to_canonical().is_loopback(), true);

pub fn as_octets(&self) -> &[u8]

🔬This is a nightly-only experimental API. (ip_as_octets)

Returns the eight-bit integers this address consists of as a slice.

Examples

#![feature(ip_as_octets)]

use std::net::{Ipv4Addr, Ipv6Addr, IpAddr};

assert_eq!(IpAddr::V4(Ipv4Addr::LOCALHOST).as_octets(), &[127, 0, 0, 1]);
assert_eq!(IpAddr::V6(Ipv6Addr::LOCALHOST).as_octets(),
           &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])

Trait Implementations

impl Clone for NormalizedIpAddr

fn clone(&self) -> NormalizedIpAddr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedIpAddr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NormalizedIpAddr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<IpAddr> for NormalizedIpAddr

fn from(ip: IpAddr) -> Self

Converts to this type from the input type.

impl Hash for NormalizedIpAddr

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 NormalizedIpAddr

fn eq(&self, other: &NormalizedIpAddr) -> 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 Serialize for NormalizedIpAddr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Deref for NormalizedIpAddr

type Target = IpAddr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Copy for NormalizedIpAddr

impl Eq for NormalizedIpAddr

impl StructuralPartialEq for NormalizedIpAddr