Struct ip_network::Ipv6Network

pub struct Ipv6Network { /* fields omitted */ }

IPv6 Network

Methods

impl Ipv6Network

pub const LENGTH: u8

IPv4 address length in bits.

pub fn new(     network_address: Ipv6Addr,     netmask: u8 ) -> Result<Self, IpNetworkError>

Constructs new Ipv6Network based on Ipv6Addr and netmask.

Returns error if netmask is bigger than 128 or if host bits are set in network_address.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32).unwrap();
assert_eq!(ip_network.network_address(), ip);
assert_eq!(ip_network.netmask(), 32);

pub fn new_truncate(     network_address: Ipv6Addr,     netmask: u8 ) -> Result<Self, IpNetworkError>

Constructs new Ipv6Network based on Ipv6Addr and netmask with truncating host bits from given network_address.

Returns error if netmask is bigger than 128.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 1, 0, 0);
let ip_network = Ipv6Network::new_truncate(ip, 32).unwrap();
assert_eq!(ip_network.network_address(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
assert_eq!(ip_network.netmask(), 32);

pub fn network_address(&self) -> Ipv6Addr

Returns network IP address (first address in range).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32).unwrap();
assert_eq!(ip_network.network_address(), ip);

pub fn netmask(&self) -> u8

Returns network mask.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32).unwrap();
assert_eq!(ip_network.netmask(), 32);

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

Returns true if given IPv6Addr is inside this network.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 64).unwrap();
assert!(ip_network.contains(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)));
assert!(!ip_network.contains(Ipv6Addr::new(0x2001, 0xdb9, 0, 0, 0, 0, 0, 0)));

pub fn supernet(&self) -> Option<Self>

Returns network with smaller netmask by one. If netmask is already zero, None will be returned.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap();
assert_eq!(network.supernet(), Some(Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 31).unwrap()));

pub fn subnets(&self) -> Option<Ipv6NetworkIterator>

Returns Ipv6NetworkIterator over networks with netmask bigger one. If netmask is already 128, None will be returned.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap();
let mut iterator = ip_network.subnets().unwrap();
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33).unwrap());
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33).unwrap());

Important traits for Ipv6NetworkIterator

impl Iterator for Ipv6NetworkIterator type Item = Ipv6Network;

pub fn subnets_with_prefix(&self, prefix: u8) -> Ipv6NetworkIterator

Returns Ipv6NetworkIterator over networks with defined netmask.

Panics

This method panics when prefix is bigger than 128 or when prefix is lower or equal than netmask.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap();
let mut iterator = network.subnets_with_prefix(33);
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33).unwrap());
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33).unwrap());

pub fn is_unspecified(&self) -> bool

Returns true for the special 'unspecified' network (::/128).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_unspecified());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 128).unwrap().is_unspecified());

pub fn is_loopback(&self) -> bool

Returns true if this is a loopback network (::1/128).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1), 128).unwrap().is_loopback());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_loopback());

pub fn is_global(&self) -> bool

Returns true if the address appears to be globally routable.

The following return false:

• the loopback network
• link-local, site-local, and unique local unicast networks
• interface-, link-, realm-, admin- and site-local multicast networks

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_global());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1), 128).unwrap().is_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1), 128).unwrap().is_global());

pub fn is_unique_local(&self) -> bool

Returns true if this is a part of unique local network (fc00::/7).

This property is defined in IETF RFC 4193.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0), 16).unwrap().is_unique_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_unique_local());

pub fn is_unicast_link_local(&self) -> bool

Returns true if the network is part of unicast and link-local (fe80::/10).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfe8a, 0, 0, 0, 0, 0, 0, 0), 16).unwrap().is_unicast_link_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_unicast_link_local());

pub fn is_unicast_site_local(&self) -> bool

Returns true if this is a deprecated unicast site-local network (fec0::/10).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfec2, 0, 0, 0, 0, 0, 0, 0), 16).unwrap().is_unicast_site_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_unicast_site_local());

pub fn is_documentation(&self) -> bool

Returns true if this is a part of network reserved for documentation (2001:db8::/32).

This property is defined in IETF RFC 3849.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap().is_documentation());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_documentation());

pub fn is_unicast_global(&self) -> bool

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

The following return false:

• the loopback network
• the link-local network
• the (deprecated) site-local network
• unique local network
• the unspecified network
• the network range reserved for documentation

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(!Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap().is_unicast_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_unicast_global());

pub fn is_multicast(&self) -> bool

Returns true if this is a part of multicast network (ff00::/8).

This property is defined by IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0), 8).unwrap().is_multicast());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128).unwrap().is_multicast());

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

Returns the network's multicast scope if the network is multicast.

These scopes are defined in IETF RFC 7346.

Examples

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

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

Trait Implementations

impl Ord for Ipv6Network

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl PartialEq<Ipv6Network> for IpNetwork

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<IpNetwork> for Ipv6Network

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Ipv6Network> for Ipv6Network

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

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

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

This method tests for !=.

impl From<Ipv6Network> for IpNetwork

fn from(network: Ipv6Network) -> Self

Performs the conversion.

impl From<Ipv6Addr> for Ipv6Network

fn from(ip: Ipv6Addr) -> Self

Converts Ipv6Addr to Ipv6Network with netmask 128.

impl Clone for Ipv6Network

fn clone(&self) -> Ipv6Network

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Ipv6Network

impl Eq for Ipv6Network

impl PartialOrd<Ipv6Network> for Ipv6Network

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

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Ipv6Network) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Ipv6Network) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Ipv6Network) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Ipv6Network) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Display for Ipv6Network

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

Converts Ipv6Network to string in format X:X::X/Y (CIDR notation).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap();
assert_eq!(ip_network.to_string(), "2001:db8::/32");

impl Debug for Ipv6Network

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

Formats the value using the given formatter.

impl FromStr for Ipv6Network

type Err = IpNetworkParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Ipv6Network, IpNetworkParseError>

Converts string in format X:X::X/Y (CIDR notation) to Ipv6Network.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;
use std::str::FromStr;

let ip_network = Ipv6Network::from_str("2001:db8::/32").unwrap();
assert_eq!(ip_network.network_address(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
assert_eq!(ip_network.netmask(), 32);

impl Hash for Ipv6Network

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,

Feeds a slice of this type into the given [Hasher].