Enum ipnetwork::IpNetwork

pub enum IpNetwork {
    V4(Ipv4Network),
    V6(Ipv6Network),
}

Represents a generic network range. This type can have two variants: the v4 and the v6 case.

Variants

V4(Ipv4Network)

V6(Ipv6Network)

Implementations

impl IpNetwork

pub fn new(ip: IpAddr, prefix: u8) -> Result<IpNetwork, IpNetworkError>

Constructs a new IpNetwork from a given IpAddr and a prefix denoting the network size. If the prefix is larger than 32 (for IPv4) or 128 (for IPv6), this will raise an IpNetworkError::InvalidPrefix error. Support for IPv6 is not complete yet.

pub fn with_netmask( netaddr: IpAddr, netmask: IpAddr ) -> Result<Self, IpNetworkError>

Constructs a new IpNetwork from a network address and a network mask.

If the netmask is not valid this will return an IpNetworkError::InvalidPrefix.

pub fn ip(&self) -> IpAddr

Returns the IP part of a given IpNetwork

pub fn prefix(&self) -> u8

Returns the prefix of the given IpNetwork

Example

use ipnetwork::IpNetwork;

assert_eq!(IpNetwork::V4("10.9.0.1".parse().unwrap()).prefix(), 32u8);
assert_eq!(IpNetwork::V4("10.9.0.32/16".parse().unwrap()).prefix(), 16u8);

assert_eq!(IpNetwork::V6("ff01::0".parse().unwrap()).prefix(), 128u8);
assert_eq!(IpNetwork::V6("ff01::0/32".parse().unwrap()).prefix(), 32u8);

pub fn network(&self) -> IpAddr

Returns the address of the network denoted by this IpNetwork. This means the lowest possible IP address inside of the network.

Examples

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

let net: IpNetwork = "10.1.9.32/16".parse().unwrap();
assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
let net: IpNetwork = "2001:db8::/96".parse().unwrap();
assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));

pub fn broadcast(&self) -> IpAddr

Returns the broadcasting address of this IpNetwork. This means the highest possible IP address inside of the network.

Examples

use std::net::Ipv4Addr;
use ipnetwork::{IpNetwork, Ipv4Network};

let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));

pub fn mask(&self) -> IpAddr

Returns the mask for this IpNetwork. That means the prefix most significant bits will be 1 and the rest 0

Example

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

let v4_net: IpNetwork = "10.9.0.1".parse().unwrap();
assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 255, 255));
let v4_net: IpNetwork = "10.9.0.32/16".parse().unwrap();
assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 0, 0));

let v6_net: IpNetwork = "ff01::0".parse().unwrap();
assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));
let v6_net: IpNetwork = "ff01::0/32".parse().unwrap();
assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));

pub fn is_ipv4(&self) -> bool

Returns true if the IP in this IpNetwork is a valid IPv4 address, false if it’s a valid IPv6 address.

Example

 use ipnetwork::IpNetwork;

 let v4: IpNetwork = IpNetwork::V4("10.9.0.32/16".parse().unwrap());
 assert_eq!(v4.is_ipv4(), true);
 assert_eq!(v4.is_ipv6(), false);

pub fn is_ipv6(&self) -> bool

Returns true if the IP in this IpNetwork is a valid IPv6 address, false if it’s a valid IPv4 address.

Example

 use ipnetwork::IpNetwork;

 let v6: IpNetwork = IpNetwork::V6("ff01::0/32".parse().unwrap());
 assert_eq!(v6.is_ipv6(), true);
 assert_eq!(v6.is_ipv4(), false);

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

Checks if a given IpAddr is in this IpNetwork

Examples

use std::net::IpAddr;
use ipnetwork::IpNetwork;

let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
let ip1: IpAddr = "127.0.0.1".parse().unwrap();
let ip2: IpAddr = "172.0.0.1".parse().unwrap();
let ip4: IpAddr = "::1".parse().unwrap();
assert!(net.contains(ip1));
assert!(!net.contains(ip2));
assert!(!net.contains(ip4));

pub fn size(&self) -> NetworkSize

Returns the number of possible host addresses in this IpAddr

Examples

use ipnetwork::{IpNetwork, NetworkSize};


let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
assert_eq!(net.size(), NetworkSize::V4(256))

pub fn iter(&self) -> IpNetworkIterator

Returns an iterator over the addresses contained in the network.

This lists all the addresses in the network range, in ascending order.

Trait Implementations

impl Clone for IpNetwork

fn clone(&self) -> IpNetwork

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IpNetwork

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IpNetwork

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for IpNetwork

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

Formats the value using the given formatter.

impl From<IpAddr> for IpNetwork

fn from(addr: IpAddr) -> IpNetwork

Converts to this type from the input type.

impl From<Ipv4Network> for IpNetwork

fn from(v4: Ipv4Network) -> IpNetwork

Converts to this type from the input type.

impl From<Ipv6Network> for IpNetwork

fn from(v6: Ipv6Network) -> IpNetwork

Converts to this type from the input type.

impl FromStr for IpNetwork

Tries to parse the given string into a IpNetwork. Will first try to parse it as an Ipv4Network and if that fails as an Ipv6Network. If both fails it will return an InvalidAddr error.

Examples

use std::net::Ipv4Addr;
use ipnetwork::{IpNetwork, Ipv4Network};

let expected = IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(10, 1, 9, 32), 16).unwrap());
let from_cidr: IpNetwork = "10.1.9.32/16".parse().unwrap();
assert_eq!(expected, from_cidr);

type Err = IpNetworkError

The associated error which can be returned from parsing.

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

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

impl Hash for IpNetwork

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 IntoIterator for &IpNetwork

type IntoIter = IpNetworkIterator

Which kind of iterator are we turning this into?

type Item = IpAddr

The type of the elements being iterated over.

fn into_iter(self) -> IpNetworkIterator

Creates an iterator from a value.

impl Ord for IpNetwork

fn cmp(&self, other: &IpNetwork) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for IpNetwork

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 PartialOrd for IpNetwork

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 Serialize for IpNetwork

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for IpNetwork

type Error = IpNetworkError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for IpNetwork

impl Eq for IpNetwork

impl StructuralPartialEq for IpNetwork