Struct Ipv4Net

pub struct Ipv4Net { /* private fields */ }

An IPv4 network address.

See IpNet for a type encompassing both IPv4 and IPv6 network addresses.

Textual representation

Ipv4Net provides a FromStr implementation for parsing network addresses represented in CIDR notation. See IETF RFC 4632 for the CIDR notation.

Examples

use ipnet::Ipv4Net;

let net: Ipv4Net = "10.1.1.0/24".parse().unwrap();
assert_eq!(Ok(net.network()), "10.1.1.0".parse());

Implementations

impl Ipv4Net

pub const fn new( ip: Ipv4Addr, prefix_len: u8, ) -> Result<Ipv4Net, PrefixLenError>

Creates a new IPv4 network address from an Ipv4Addr and prefix length.

Examples

use std::net::Ipv4Addr;
use ipnet::{Ipv4Net, PrefixLenError};

let net = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 24);
assert!(net.is_ok());

let bad_prefix_len = Ipv4Net::new(Ipv4Addr::new(10, 1, 1, 0), 33);
assert_eq!(bad_prefix_len, Err(PrefixLenError));

pub const fn new_assert(ip: Ipv4Addr, prefix_len: u8) -> Ipv4Net

Creates a new IPv4 network address from an Ipv4Addr 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 32.

Examples

use std::net::Ipv4Addr;
use ipnet::{Ipv4Net};

// This code is verified at compile time:
const NET: Ipv4Net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 24);
assert_eq!(NET.prefix_len(), 24);

// This code is verified at runtime:
let net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 24);
assert_eq!(NET.prefix_len(), 24);

// This code does not compile:
// const BAD_PREFIX_LEN: Ipv4Net = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 33);

// This code panics at runtime:
// let bad_prefix_len = Ipv4Net::new_assert(Ipv4Addr::new(10, 1, 1, 0), 33);

pub fn with_netmask( ip: Ipv4Addr, netmask: Ipv4Addr, ) -> Result<Ipv4Net, PrefixLenError>

Creates a new IPv4 network address from an Ipv4Addr and netmask.

Examples

use std::net::Ipv4Addr;
use ipnet::{Ipv4Net, PrefixLenError};

let net = Ipv4Net::with_netmask(Ipv4Addr::new(10, 1, 1, 0), Ipv4Addr::new(255, 255, 255, 0));
assert!(net.is_ok());

let bad_prefix_len = Ipv4Net::with_netmask(Ipv4Addr::new(10, 1, 1, 0), Ipv4Addr::new(255, 255, 0, 1));
assert_eq!(bad_prefix_len, Err(PrefixLenError));

pub fn trunc(&self) -> Ipv4Net

Returns a copy of the network with the address truncated to the prefix length.

Examples

assert_eq!(
    "192.168.12.34/16".parse::<Ipv4Net>().unwrap().trunc(),
    "192.168.0.0/16".parse().unwrap()
);

pub const fn addr(&self) -> Ipv4Addr

Returns the address.

pub const fn prefix_len(&self) -> u8

Returns the prefix length.

pub const fn max_prefix_len(&self) -> u8

Returns the maximum valid prefix length.

pub fn netmask(&self) -> Ipv4Addr

Returns the network mask.

Examples

let net: Ipv4Net = "10.1.0.0/20".parse().unwrap();
assert_eq!(Ok(net.netmask()), "255.255.240.0".parse());

pub fn hostmask(&self) -> Ipv4Addr

Returns the host mask.

Examples

let net: Ipv4Net = "10.1.0.0/20".parse().unwrap();
assert_eq!(Ok(net.hostmask()), "0.0.15.255".parse());

pub fn network(&self) -> Ipv4Addr

Returns the network address.

Examples

let net: Ipv4Net = "172.16.123.123/16".parse().unwrap();
assert_eq!(Ok(net.network()), "172.16.0.0".parse());

pub fn broadcast(&self) -> Ipv4Addr

Returns the broadcast address.

Examples

let net: Ipv4Net = "172.16.0.0/22".parse().unwrap();
assert_eq!(Ok(net.broadcast()), "172.16.3.255".parse());

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

Returns the Ipv4Net that contains this one.

Examples

let n1: Ipv4Net = "172.16.1.0/24".parse().unwrap();
let n2: Ipv4Net = "172.16.0.0/23".parse().unwrap();
let n3: Ipv4Net = "172.16.0.0/0".parse().unwrap();

assert_eq!(n1.supernet().unwrap(), n2);
assert_eq!(n3.supernet(), None);

pub fn is_sibling(&self, other: &Ipv4Net) -> bool

Returns true if this network and the given network are children of the same supernet.

Examples

let n1: Ipv4Net = "10.1.0.0/24".parse().unwrap();
let n2: Ipv4Net = "10.1.1.0/24".parse().unwrap();
let n3: Ipv4Net = "10.1.2.0/24".parse().unwrap();

assert!(n1.is_sibling(&n2));
assert!(!n2.is_sibling(&n3));

pub fn hosts(&self) -> Ipv4AddrRange

Return an Iterator over the host addresses in this network.

If the prefix length is less than 31 both the network address and broadcast address are excluded. These are only valid host addresses when the prefix length is 31.

Examples

let net: Ipv4Net = "10.0.0.0/30".parse().unwrap();
assert_eq!(net.hosts().collect::<Vec<Ipv4Addr>>(), vec![
    "10.0.0.1".parse::<Ipv4Addr>().unwrap(),
    "10.0.0.2".parse().unwrap(),
]);

let net: Ipv4Net = "10.0.0.0/31".parse().unwrap();
assert_eq!(net.hosts().collect::<Vec<Ipv4Addr>>(), vec![
    "10.0.0.0".parse::<Ipv4Addr>().unwrap(),
    "10.0.0.1".parse().unwrap(),
]);

pub fn subnets(&self, new_prefix_len: u8) -> Result<Ipv4Subnets, PrefixLenError>

Returns an Iterator over the subnets of this network with the given prefix length.

Examples

let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
assert_eq!(net.subnets(26).unwrap().collect::<Vec<Ipv4Net>>(), vec![
    "10.0.0.0/26".parse::<Ipv4Net>().unwrap(),
    "10.0.0.64/26".parse().unwrap(),
    "10.0.0.128/26".parse().unwrap(),
    "10.0.0.192/26".parse().unwrap(),
]);

let net: Ipv4Net = "10.0.0.0/30".parse().unwrap();
assert_eq!(net.subnets(32).unwrap().collect::<Vec<Ipv4Net>>(), vec![
    "10.0.0.0/32".parse::<Ipv4Net>().unwrap(),
    "10.0.0.1/32".parse().unwrap(),
    "10.0.0.2/32".parse().unwrap(),
    "10.0.0.3/32".parse().unwrap(),
]);

let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
assert_eq!(net.subnets(23), Err(PrefixLenError));

let net: Ipv4Net = "10.0.0.0/24".parse().unwrap();
assert_eq!(net.subnets(33), Err(PrefixLenError));

pub fn contains<T>(&self, other: T) -> bool

where Ipv4Net: Contains<T>,

Test if a network address contains either another network address or an IP address.

Examples

let net: Ipv4Net = "192.168.0.0/24".parse().unwrap();
let net_yes: Ipv4Net = "192.168.0.0/25".parse().unwrap();
let net_no: Ipv4Net = "192.168.0.0/23".parse().unwrap();
let ip_yes: Ipv4Addr = "192.168.0.1".parse().unwrap();
let ip_no: Ipv4Addr = "192.168.1.0".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));

pub fn aggregate(networks: &Vec<Ipv4Net>) -> Vec<Ipv4Net>

Aggregate a Vec of Ipv4Nets and return the result as a new Vec.

Examples

let nets = vec![
    "10.0.0.0/24".parse::<Ipv4Net>().unwrap(),
    "10.0.1.0/24".parse().unwrap(),
    "10.0.2.0/24".parse().unwrap(),
];

assert_eq!(Ipv4Net::aggregate(&nets), vec![
    "10.0.0.0/23".parse::<Ipv4Net>().unwrap(),
    "10.0.2.0/24".parse().unwrap(),
]);

Trait Implementations

impl Clone for Ipv4Net

fn clone(&self) -> Ipv4Net

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv4Net

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

Formats the value using the given formatter.

impl Default for Ipv4Net

fn default() -> Ipv4Net

Returns the “default value” for a type.

impl Display for Ipv4Net

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

Formats the value using the given formatter.

impl From<Ipv4Addr> for Ipv4Net

fn from(addr: Ipv4Addr) -> Ipv4Net

Converts to this type from the input type.

impl From<Ipv4Net> for IpNet

fn from(net: Ipv4Net) -> IpNet

Converts to this type from the input type.

impl FromStr for Ipv4Net

type Err = AddrParseError

The associated error which can be returned from parsing.

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

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

impl Hash for Ipv4Net

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

where __H: Hasher,

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 Ipv4Net

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Ipv4Net

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Ipv4Net

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Ipv4Net

impl Eq for Ipv4Net

impl StructuralPartialEq for Ipv4Net