pub struct Ipv6Net { /* private fields */ }
Expand description
An IPv6 network address.
See IpNet
for a type encompassing both IPv4 and IPv6 network
addresses.
§Textual representation
Ipv6Net
provides a FromStr
implementation for parsing network
addresses represented in CIDR notation. See IETF RFC 4632 for the
CIDR notation.
§Examples
use std::net::Ipv6Addr;
use ipnet::Ipv6Net;
let net: Ipv6Net = "fd00::/32".parse().unwrap();
assert_eq!(Ok(net.network()), "fd00::".parse());
Implementations§
source§impl Ipv6Net
impl Ipv6Net
sourcepub const fn new(
ip: Ipv6Addr,
prefix_len: u8,
) -> Result<Ipv6Net, PrefixLenError>
pub const fn new( ip: Ipv6Addr, prefix_len: u8, ) -> Result<Ipv6Net, PrefixLenError>
Creates a new IPv6 network address from an Ipv6Addr
and prefix
length.
§Examples
use std::net::Ipv6Addr;
use ipnet::{Ipv6Net, PrefixLenError};
let net = Ipv6Net::new(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);
assert!(net.is_ok());
let bad_prefix_len = Ipv6Net::new(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);
assert_eq!(bad_prefix_len, Err(PrefixLenError));
sourcepub const fn new_assert(ip: Ipv6Addr, prefix_len: u8) -> Ipv6Net
pub const fn new_assert(ip: Ipv6Addr, prefix_len: u8) -> Ipv6Net
Creates a new IPv6 network address from an Ipv6Addr
and prefix
length. If called from a const context it will verify prefix length
at compile time. Otherwise it will panic at runtime if prefix length
is not less then or equal to 128.
§Examples
use std::net::Ipv6Addr;
use ipnet::{Ipv6Net};
// This code is verified at compile time:
const NET: Ipv6Net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);
assert_eq!(NET.prefix_len(), 24);
// This code is verified at runtime:
let net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 24);
assert_eq!(net.prefix_len(), 24);
// This code does not compile:
// const BAD_PREFIX_LEN: Ipv6Net = Ipv6Net::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);
// This code panics at runtime:
// let bad_prefix_len = Ipv6Addr::new_assert(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), 129);
sourcepub fn with_netmask(
ip: Ipv6Addr,
netmask: Ipv6Addr,
) -> Result<Ipv6Net, PrefixLenError>
pub fn with_netmask( ip: Ipv6Addr, netmask: Ipv6Addr, ) -> Result<Ipv6Net, PrefixLenError>
Creates a new IPv6 network address from an Ipv6Addr
and netmask.
§Examples
use std::net::Ipv6Addr;
use ipnet::{Ipv6Net, PrefixLenError};
let net = Ipv6Net::with_netmask(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), Ipv6Addr::from(0xffff_ff00_0000_0000_0000_0000_0000_0000));
assert!(net.is_ok());
let bad_prefix_len = Ipv6Net::with_netmask(Ipv6Addr::new(0xfd, 0, 0, 0, 0, 0, 0, 0), Ipv6Addr::from(0xffff_ff00_0000_0000_0001_0000_0000_0000));
assert_eq!(bad_prefix_len, Err(PrefixLenError));
sourcepub fn trunc(&self) -> Ipv6Net
pub fn trunc(&self) -> Ipv6Net
Returns a copy of the network with the address truncated to the prefix length.
§Examples
assert_eq!(
"fd00::1:2:3:4/16".parse::<Ipv6Net>().unwrap().trunc(),
"fd00::/16".parse().unwrap()
);
sourcepub const fn prefix_len(&self) -> u8
pub const fn prefix_len(&self) -> u8
Returns the prefix length.
sourcepub const fn max_prefix_len(&self) -> u8
pub const fn max_prefix_len(&self) -> u8
Returns the maximum valid prefix length.
sourcepub fn netmask(&self) -> Ipv6Addr
pub fn netmask(&self) -> Ipv6Addr
Returns the network mask.
§Examples
let net: Ipv6Net = "fd00::/24".parse().unwrap();
assert_eq!(Ok(net.netmask()), "ffff:ff00::".parse());
sourcepub fn hostmask(&self) -> Ipv6Addr
pub fn hostmask(&self) -> Ipv6Addr
Returns the host mask.
§Examples
let net: Ipv6Net = "fd00::/24".parse().unwrap();
assert_eq!(Ok(net.hostmask()), "::ff:ffff:ffff:ffff:ffff:ffff:ffff".parse());
sourcepub fn network(&self) -> Ipv6Addr
pub fn network(&self) -> Ipv6Addr
Returns the network address.
§Examples
let net: Ipv6Net = "fd00:1234:5678::/24".parse().unwrap();
assert_eq!(Ok(net.network()), "fd00:1200::".parse());
sourcepub fn broadcast(&self) -> Ipv6Addr
pub fn broadcast(&self) -> Ipv6Addr
Returns the last address.
Technically there is no such thing as a broadcast address for IPv6. The name is used for consistency with colloquial usage.
§Examples
let net: Ipv6Net = "fd00:1234:5678::/24".parse().unwrap();
assert_eq!(Ok(net.broadcast()), "fd00:12ff:ffff:ffff:ffff:ffff:ffff:ffff".parse());
sourcepub fn supernet(&self) -> Option<Ipv6Net>
pub fn supernet(&self) -> Option<Ipv6Net>
Returns the Ipv6Net
that contains this one.
§Examples
let n1: Ipv6Net = "fd00:ff00::/24".parse().unwrap();
let n2: Ipv6Net = "fd00:fe00::/23".parse().unwrap();
let n3: Ipv6Net = "fd00:fe00::/0".parse().unwrap();
assert_eq!(n1.supernet().unwrap(), n2);
assert_eq!(n3.supernet(), None);
sourcepub fn is_sibling(&self, other: &Ipv6Net) -> bool
pub fn is_sibling(&self, other: &Ipv6Net) -> bool
Returns true
if this network and the given network are
children of the same supernet.
§Examples
let n1: Ipv6Net = "fd00::/18".parse().unwrap();
let n2: Ipv6Net = "fd00:4000::/18".parse().unwrap();
let n3: Ipv6Net = "fd00:8000::/18".parse().unwrap();
assert!(n1.is_sibling(&n2));
assert!(!n2.is_sibling(&n3));
sourcepub fn hosts(&self) -> Ipv6AddrRange ⓘ
pub fn hosts(&self) -> Ipv6AddrRange ⓘ
Return an Iterator
over the host addresses in this network.
§Examples
let net: Ipv6Net = "fd00::/126".parse().unwrap();
assert_eq!(net.hosts().collect::<Vec<Ipv6Addr>>(), vec![
"fd00::".parse::<Ipv6Addr>().unwrap(),
"fd00::1".parse().unwrap(),
"fd00::2".parse().unwrap(),
"fd00::3".parse().unwrap(),
]);
sourcepub fn subnets(&self, new_prefix_len: u8) -> Result<Ipv6Subnets, PrefixLenError>
pub fn subnets(&self, new_prefix_len: u8) -> Result<Ipv6Subnets, PrefixLenError>
Returns an Iterator
over the subnets of this network with the
given prefix length.
§Examples
let net: Ipv6Net = "fd00::/16".parse().unwrap();
assert_eq!(net.subnets(18).unwrap().collect::<Vec<Ipv6Net>>(), vec![
"fd00::/18".parse::<Ipv6Net>().unwrap(),
"fd00:4000::/18".parse().unwrap(),
"fd00:8000::/18".parse().unwrap(),
"fd00:c000::/18".parse().unwrap(),
]);
let net: Ipv6Net = "fd00::/126".parse().unwrap();
assert_eq!(net.subnets(128).unwrap().collect::<Vec<Ipv6Net>>(), vec![
"fd00::/128".parse::<Ipv6Net>().unwrap(),
"fd00::1/128".parse().unwrap(),
"fd00::2/128".parse().unwrap(),
"fd00::3/128".parse().unwrap(),
]);
let net: Ipv6Net = "fd00::/16".parse().unwrap();
assert_eq!(net.subnets(15), Err(PrefixLenError));
let net: Ipv6Net = "fd00::/16".parse().unwrap();
assert_eq!(net.subnets(129), Err(PrefixLenError));
sourcepub fn contains<T>(&self, other: T) -> boolwhere
Self: Contains<T>,
pub fn contains<T>(&self, other: T) -> boolwhere
Self: Contains<T>,
Test if a network address contains either another network address or an IP address.
§Examples
let net: Ipv6Net = "fd00::/16".parse().unwrap();
let net_yes: Ipv6Net = "fd00::/17".parse().unwrap();
let net_no: Ipv6Net = "fd00::/15".parse().unwrap();
let ip_yes: Ipv6Addr = "fd00::1".parse().unwrap();
let ip_no: Ipv6Addr = "fd01::".parse().unwrap();
assert!(net.contains(&net));
assert!(net.contains(&net_yes));
assert!(!net.contains(&net_no));
assert!(net.contains(&ip_yes));
assert!(!net.contains(&ip_no));
sourcepub fn aggregate(networks: &Vec<Ipv6Net>) -> Vec<Ipv6Net>
pub fn aggregate(networks: &Vec<Ipv6Net>) -> Vec<Ipv6Net>
Aggregate a Vec
of Ipv6Net
s and return the result as a new
Vec
.
§Examples
let nets = vec![
"fd00::/18".parse::<Ipv6Net>().unwrap(),
"fd00:4000::/18".parse().unwrap(),
"fd00:8000::/18".parse().unwrap(),
];
assert_eq!(Ipv6Net::aggregate(&nets), vec![
"fd00::/17".parse::<Ipv6Net>().unwrap(),
"fd00:8000::/18".parse().unwrap(),
]);
Trait Implementations§
source§impl Ord for Ipv6Net
impl Ord for Ipv6Net
source§impl PartialEq for Ipv6Net
impl PartialEq for Ipv6Net
source§impl PartialOrd for Ipv6Net
impl PartialOrd for Ipv6Net
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl Copy for Ipv6Net
impl Eq for Ipv6Net
impl StructuralPartialEq for Ipv6Net
Auto Trait Implementations§
impl Freeze for Ipv6Net
impl RefUnwindSafe for Ipv6Net
impl Send for Ipv6Net
impl Sync for Ipv6Net
impl Unpin for Ipv6Net
impl UnwindSafe for Ipv6Net
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Copy,
impl<T> CloneToUninit for Twhere
T: Copy,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)