Struct hickory_proto::rr::rdata::aaaa::AAAA

pub struct AAAA(pub Ipv6Addr);

The DNS AAAA record type, an IPv6 address

Tuple Fields

0: Ipv6Addr

Implementations

impl AAAA

pub const fn new( a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16, ) -> Self

Construct a new AAAA record with the 128 bits of IPv6 address

Methods from Deref<Target = Ipv6Addr>

pub const BITS: u32 = 128u32

pub const LOCALHOST: Ipv6Addr = _

pub const UNSPECIFIED: Ipv6Addr = _

pub fn segments(&self) -> [u16; 8]

Returns the eight 16-bit segments that make up this address.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(),
           [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);

pub fn is_unspecified(&self) -> bool

Returns true for the special ‘unspecified’ address (::).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);

pub fn is_loopback(&self) -> bool

Returns true if this is the loopback address (::1), as defined in IETF RFC 4291 section 2.5.3.

Contrary to IPv4, in IPv6 there is only one loopback address.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false);
assert_eq!(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 reachable as specified by the IANA IPv6 Special-Purpose Address Registry. Whether or not an address is practically reachable will depend on your network configuration.

Most IPv6 addresses are globally reachable; unless they are specifically defined as not globally reachable.

Non-exhaustive list of notable addresses that are not globally reachable:

• The unspecified address (is_unspecified)
• The loopback address (is_loopback)
• IPv4-mapped addresses
• Addresses reserved for benchmarking (is_benchmarking)
• Addresses reserved for documentation (is_documentation)
• Unique local addresses (is_unique_local)
• Unicast addresses with link-local scope (is_unicast_link_local)

For the complete overview of which addresses are globally reachable, see the table at the IANA IPv6 Special-Purpose Address Registry.

Note that an address having global scope is not the same as being globally reachable, and there is no direct relation between the two concepts: There exist addresses with global scope that are not globally reachable (for example unique local addresses), and addresses that are globally reachable without having global scope (multicast addresses with non-global scope).

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// Most IPv6 addresses are globally reachable:
assert_eq!(Ipv6Addr::new(0x26, 0, 0x1c9, 0, 0, 0xafc8, 0x10, 0x1).is_global(), true);

// However some addresses have been assigned a special meaning
// that makes them not globally reachable. Some examples are:

// The unspecified address (`::`)
assert_eq!(Ipv6Addr::UNSPECIFIED.is_global(), false);

// The loopback address (`::1`)
assert_eq!(Ipv6Addr::LOCALHOST.is_global(), false);

// IPv4-mapped addresses (`::ffff:0:0/96`)
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), false);

// Addresses reserved for benchmarking (`2001:2::/48`)
assert_eq!(Ipv6Addr::new(0x2001, 2, 0, 0, 0, 0, 0, 1,).is_global(), false);

// Addresses reserved for documentation (`2001:db8::/32`)
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1).is_global(), false);

// Unique local addresses (`fc00::/7`)
assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 1).is_global(), false);

// Unicast addresses with link-local scope (`fe80::/10`)
assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 1).is_global(), false);

// For a complete overview see the IANA IPv6 Special-Purpose Address Registry.

pub fn is_unique_local(&self) -> bool

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

Returns true if this is a unique local address (fc00::/7).

This property is defined in IETF RFC 4193.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false);
assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);

pub fn is_unicast(&self) -> bool

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

Returns true if this is a unicast address, as defined by IETF RFC 4291. Any address that is not a multicast address (ff00::/8) is unicast.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// The unspecified and loopback addresses are unicast.
assert_eq!(Ipv6Addr::UNSPECIFIED.is_unicast(), true);
assert_eq!(Ipv6Addr::LOCALHOST.is_unicast(), true);

// Any address that is not a multicast address (`ff00::/8`) is unicast.
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast(), true);
assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_unicast(), false);

pub fn is_unicast_link_local(&self) -> bool

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

Returns true if the address is a unicast address with link-local scope, as defined in RFC 4291.

A unicast address has link-local scope if it has the prefix fe80::/10, as per RFC 4291 section 2.4. Note that this encompasses more addresses than those defined in RFC 4291 section 2.5.6, which describes “Link-Local IPv6 Unicast Addresses” as having the following stricter format:

| 10 bits  |         54 bits         |          64 bits           |
+----------+-------------------------+----------------------------+
|1111111010|           0             |       interface ID         |
+----------+-------------------------+----------------------------+

So while currently the only addresses with link-local scope an application will encounter are all in fe80::/64, this might change in the future with the publication of new standards. More addresses in fe80::/10 could be allocated, and those addresses will have link-local scope.

Also note that while RFC 4291 section 2.5.3 mentions about the loopback address (::1) that “it is treated as having Link-Local scope”, this does not mean that the loopback address actually has link-local scope and this method will return false on it.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

// The loopback address (`::1`) does not actually have link-local scope.
assert_eq!(Ipv6Addr::LOCALHOST.is_unicast_link_local(), false);

// Only addresses in `fe80::/10` have link-local scope.
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), false);
assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);

// Addresses outside the stricter `fe80::/64` also have link-local scope.
assert_eq!(Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0).is_unicast_link_local(), true);
assert_eq!(Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);

pub fn is_documentation(&self) -> bool

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

Returns true if this is an address reserved for documentation (2001:db8::/32).

This property is defined in IETF RFC 3849.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false);
assert_eq!(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 is an address reserved for benchmarking (2001:2::/48).

This property is defined in IETF RFC 5180, where it is mistakenly specified as covering the range 2001:0200::/48. This is corrected in IETF RFC Errata 1752 to 2001:0002::/48.

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc613, 0x0).is_benchmarking(), false);
assert_eq!(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0).is_benchmarking(), true);

pub fn is_unicast_global(&self) -> bool

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

Returns true if the address is a globally routable unicast address.

The following return false:

• the loopback address
• the link-local addresses
• unique local addresses
• the unspecified address
• the address range reserved for documentation

This method returns true for site-local addresses as per RFC 4291 section 2.5.7

The special behavior of [the site-local unicast] prefix defined in [RFC3513] must no longer
be supported in new implementations (i.e., new implementations must treat this prefix as
Global Unicast).

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);

pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope>

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

Returns the address’s multicast scope if the address is multicast.

Examples

#![feature(ip)]

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

assert_eq!(
    Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(),
    Some(Ipv6MulticastScope::Global)
);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);

pub fn is_multicast(&self) -> bool

Returns true if this is a multicast address (ff00::/8).

This property is defined by IETF RFC 4291.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);

pub fn is_ipv4_mapped(&self) -> bool

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

Returns true if the address is an IPv4-mapped address (::ffff:0:0/96).

IPv4-mapped addresses can be converted to their canonical IPv4 address with to_ipv4_mapped.

Examples

#![feature(ip)]

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

let ipv4_mapped = Ipv4Addr::new(192, 0, 2, 255).to_ipv6_mapped();
assert_eq!(ipv4_mapped.is_ipv4_mapped(), true);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x2ff).is_ipv4_mapped(), true);

assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_ipv4_mapped(), false);

pub fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>

Converts this address to an IPv4 address if it’s an IPv4-mapped address, as defined in IETF RFC 4291 section 2.5.5.2, otherwise returns None.

::ffff:a.b.c.d becomes a.b.c.d. All addresses not starting with ::ffff will return None.

Examples

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

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4_mapped(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4_mapped(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4_mapped(), None);

pub fn to_ipv4(&self) -> Option<Ipv4Addr>

Converts this address to an IPv4 address if it is either an IPv4-compatible address as defined in IETF RFC 4291 section 2.5.5.1, or an IPv4-mapped address as defined in IETF RFC 4291 section 2.5.5.2, otherwise returns None.

Note that this will return an IPv4 address for the IPv6 loopback address ::1. Use Ipv6Addr::to_ipv4_mapped to avoid this.

::a.b.c.d and ::ffff:a.b.c.d become a.b.c.d. ::1 becomes 0.0.0.1. All addresses not starting with either all zeroes or ::ffff will return None.

Examples

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

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(),
           Some(Ipv4Addr::new(0, 0, 0, 1)));

pub fn to_canonical(&self) -> IpAddr

Converts this address to an IpAddr::V4 if it is an IPv4-mapped address, otherwise it returns self wrapped in an IpAddr::V6.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).is_loopback(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1).to_canonical().is_loopback(), true);

pub fn octets(&self) -> [u8; 16]

Returns the sixteen eight-bit integers the IPv6 address consists of.

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),
           [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

Trait Implementations

impl<'r> BinDecodable<'r> for AAAA

fn read(decoder: &mut BinDecoder<'r>) -> ProtoResult<Self>

Read the type from the stream

fn from_bytes(bytes: &'r [u8]) -> ProtoResult<Self>

Returns the object in binary form

impl BinEncodable for AAAA

fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()>

Write the type to the stream

fn to_bytes(&self) -> ProtoResult<Vec<u8>>

Returns the object in binary form

impl Clone for AAAA

fn clone(&self) -> AAAA

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AAAA

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

Formats the value using the given formatter.

impl Deref for AAAA

type Target = Ipv6Addr

The resulting type after dereferencing.

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

Dereferences the value.

impl Display for AAAA

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

Formats the value using the given formatter.

impl From<AAAA> for Ipv6Addr

fn from(aaaa: AAAA) -> Self

Converts to this type from the input type.

impl From<Ipv6Addr> for AAAA

fn from(aaaa: Ipv6Addr) -> Self

Converts to this type from the input type.

impl FromStr for AAAA

type Err = AddrParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, AddrParseError>

Parses a string s to return a value of this type.

impl Hash for AAAA

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 AAAA

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl RecordData for AAAA

fn try_from_rdata(data: RData) -> Result<Self, RData>

Attempts to convert to this RecordData from the RData type, if it is not the correct type the original is returned

fn try_borrow(data: &RData) -> Option<&Self>

Attempts to borrow this RecordData from the RData type, if it is not the correct type the original is returned

fn record_type(&self) -> RecordType

Get the associated RecordType for the RecordData

fn into_rdata(self) -> RData

Converts this RecordData into generic RecordData

impl Copy for AAAA

impl Eq for AAAA

impl StructuralPartialEq for AAAA