Struct ip_network::Ipv6Network

pub struct Ipv6Network { /* private fields */ }

IPv6 Network.

Implementations

impl Ipv6Network

pub const LENGTH: u8 = 128u8

IPv6 address length in bits.

pub const DEFAULT_ROUTE: Self = _

Default route that contains all IP addresses, IP network ::/0

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)?;
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)?;
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)?;
assert_eq!(ip_network.network_address(), ip);

pub fn last_address(&self) -> Ipv6Addr

Returns last IP address in range. Similar as broadcast_address for IPv4.

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)?;
assert_eq!(ip_network.last_address(), Ipv6Addr::new(0x2001, 0xdb8, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));

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)?;
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)?;
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)?;
assert_eq!(network.supernet(), Some(Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 31)?));

pub fn subnets(&self) -> Ipv6NetworkIterator

Returns Ipv6NetworkIterator over networks with netmask bigger one. If netmask is already 128, empty iterator 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)?;
let mut iterator = ip_network.subnets();
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33)?);
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33)?);

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

Returns Ipv6NetworkIterator over networks with defined netmask. Because len() method returns usize and number of networks can be bigger than usize, you can use real_len() method to get exact number of networks.

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)?;
let mut iterator = network.subnets_with_prefix(33);
assert_eq!(2, iterator.real_len());
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33)?);
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33)?);

pub fn is_default_route(&self) -> bool

Returns true for the default route network (::/0), that contains all IPv6 addresses.

Examples

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

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 0)?.is_default_route());

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)?.is_unspecified());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 128)?.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)?.is_loopback());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_global());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1), 128)?.is_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1), 128)?.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)?.is_unique_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_unicast_link_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_unicast_site_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_documentation());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_unicast_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.is_multicast());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.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)?.multicast_scope(),
                             Some(Ipv6MulticastScope::Global));
assert_eq!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.multicast_scope(), None);

pub fn from_str_truncate(s: &str) -> Result<Self, IpNetworkParseError>

Converts string in format X:X::X/Y (CIDR notation) to Ipv6Network, but truncating host bits.

Examples

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

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

pub fn collapse_addresses(addresses: &[Self]) -> Vec<Self>

Return an iterator of the collapsed Ipv6Networks.

Implementation of this method was inspired by Python ipaddress.collapse_addresses

Examples

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

let collapsed = Ipv6Network::collapse_addresses(&[
    Ipv6Network::from_str("2001::/120")?,
    Ipv6Network::from_str("2001::/96")?,
]);

assert_eq!(Ipv6Network::from_str("2001::/96")?, collapsed[0]);

Trait Implementations

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 Debug for Ipv6Network

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

Formats the value using the given formatter.

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)?;
assert_eq!(ip_network.to_string(), "2001:db8::/32");

impl From<Ipv6Addr> for Ipv6Network

fn from(ip: Ipv6Addr) -> Self

Converts Ipv6Addr to Ipv6Network with netmask 128.

impl From<Ipv6Network> for IpNetwork

fn from(network: Ipv6Network) -> Self

Converts to this type from the input type.

impl FromStr for Ipv6Network

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")?;
assert_eq!(ip_network.network_address(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
assert_eq!(ip_network.netmask(), 32);

type Err = IpNetworkParseError

The associated error which can be returned from parsing.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Ipv6Network

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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 ==.

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 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 ==.

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 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: &Rhs) -> bool

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

impl PartialOrd<IpNetwork> for Ipv6Network

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Ipv6Network> for IpNetwork

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: &Rhs) -> bool

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

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

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

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

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

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

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

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: &Rhs) -> bool

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

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

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

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

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

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

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

impl Copy for Ipv6Network

impl Eq for Ipv6Network

impl StructuralEq for Ipv6Network