Enum IpAddr

pub enum IpAddr

An IP address, either IPv4 or IPv6.

This enum can contain either an Ipv4Addr or an Ipv6Addr, see their respective documentation for more details.

Examples

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

let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

assert_eq!("127.0.0.1".parse(), Ok(localhost_v4));
assert_eq!("::1".parse(), Ok(localhost_v6));

assert_eq!(localhost_v4.is_ipv6(), false);
assert_eq!(localhost_v4.is_ipv4(), true);

Variants

V4(Ipv4Addr)

An IPv4 address.

V6(Ipv6Addr)

An IPv6 address.

Implementations

impl IpAddr

fn parse_ascii(b: &[u8]) -> Result<Self, AddrParseError>

Parse an IP address from a slice of bytes.

#![feature(addr_parse_ascii)]

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

let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

assert_eq!(IpAddr::parse_ascii(b"127.0.0.1"), Ok(localhost_v4));
assert_eq!(IpAddr::parse_ascii(b"::1"), Ok(localhost_v6));

impl IpAddr

const 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);

const fn unspecified_from(this: Self) -> Self

Returns the unspecified IP address for the same IP version.

Returns 0.0.0.0 for IPv4 and :: for IPv6.

Use this method when you must bind a socket to an unspecified local address that uses the same IP version as a remote address.

Examples

#![feature(addr_unspecified_from)]
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let ipv4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
assert_eq!(IpAddr::unspecified_from(ipv4), IpAddr::V4(Ipv4Addr::UNSPECIFIED));

let ipv6 = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
assert_eq!(IpAddr::unspecified_from(ipv6), IpAddr::V6(Ipv6Addr::UNSPECIFIED));

const 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);

const fn is_global(&self) -> bool

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

const 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);

const fn is_documentation(&self) -> bool

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

const fn is_benchmarking(&self) -> bool

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

const 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);

const 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);

const 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);

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

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 IpAddr

fn clone(&self) -> Self

impl Copy for IpAddr

impl Debug for IpAddr

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

impl Display for IpAddr

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

impl Eq for IpAddr

fn assert_fields_are_eq(&self)

impl From<Ipv4Addr> for IpAddr

fn from(ipv4: Ipv4Addr) -> IpAddr

Copies this address to a new IpAddr::V4.

Examples

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

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

assert_eq!(
    IpAddr::V4(addr),
    IpAddr::from(addr)
)

impl From<Ipv6Addr> for IpAddr

fn from(ipv6: Ipv6Addr) -> IpAddr

Copies this address to a new IpAddr::V6.

Examples

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

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);

impl From<[u16; 8]> for IpAddr

fn from(segments: [u16; 8]) -> IpAddr

Creates an IpAddr::V6 from an eight element 16-bit array.

Examples

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

let addr = IpAddr::from([
    0x20du16, 0x20cu16, 0x20bu16, 0x20au16,
    0x209u16, 0x208u16, 0x207u16, 0x206u16,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x20d, 0x20c, 0x20b, 0x20a,
        0x209, 0x208, 0x207, 0x206,
    )),
    addr
);

impl From<[u8; 16]> for IpAddr

fn from(octets: [u8; 16]) -> IpAddr

Creates an IpAddr::V6 from a sixteen element byte array.

Examples

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

let addr = IpAddr::from([
    0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,
    0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x1918, 0x1716, 0x1514, 0x1312,
        0x1110, 0x0f0e, 0x0d0c, 0x0b0a,
    )),
    addr
);

impl From<[u8; 4]> for IpAddr

fn from(octets: [u8; 4]) -> IpAddr

Creates an IpAddr::V4 from a four element byte array.

Examples

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

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);

impl FromStr for IpAddr

type Err = AddrParseError;
fn from_str(s: &str) -> Result<IpAddr, AddrParseError>

impl Hash for IpAddr

fn hash<__H: Hasher>(&self, state: &mut __H)

impl Ord for IpAddr

fn cmp(&self, other: &Self) -> Ordering

impl PartialEq for IpAddr

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

impl PartialEq<Ipv4Addr> for IpAddr

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

impl PartialEq<Ipv6Addr> for IpAddr

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

impl PartialOrd for IpAddr

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

impl PartialOrd<Ipv4Addr> for IpAddr

fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>

impl PartialOrd<Ipv6Addr> for IpAddr

fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>

impl StructuralPartialEq for IpAddr

impl TrivialClone for IpAddr

Auto Trait Implementations

impl Freeze for IpAddr

impl RefUnwindSafe for IpAddr

impl Send for IpAddr

impl Sync for IpAddr

impl Unpin for IpAddr

impl UnsafeUnpin for IpAddr

impl UnwindSafe for IpAddr

Blanket Implementations

impl<T> Any for IpAddr where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for IpAddr where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for IpAddr where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for IpAddr where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for IpAddr

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Printable for IpAddr where T: Copy + Debug,

impl<T> SizeHint for IpAddr where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for IpAddr

impl<T, U> Into<U> for IpAddr where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for IpAddr where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for IpAddr where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>