Struct ip_network::Ipv4Network

pub struct Ipv4Network { /* fields omitted */ }

IPv4 Network

Methods

impl Ipv4Network

pub const LENGTH: u8

IPv4 address length in bits.

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

Constructs new Ipv4Network based on Ipv4Addr and netmask.

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

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.network_address(), Ipv4Addr::new(192, 168, 1, 0));
assert_eq!(ip_network.netmask(), 24);

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

Constructs new Ipv4Network based on Ipv4Addr and netmask with truncating host bits from given network_address.

Returns error if netmask is bigger than 32.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new_truncate(Ipv4Addr::new(192, 168, 1, 100), 24).unwrap();
assert_eq!(ip_network.network_address(), Ipv4Addr::new(192, 168, 1, 0));
assert_eq!(ip_network.netmask(), 24);

pub fn network_address(&self) -> Ipv4Addr

Returns network IP address (first address in range).

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.network_address(), Ipv4Addr::new(192, 168, 1, 0));

pub fn broadcast_address(&self) -> Ipv4Addr

Returns broadcast address of network (last address in range).

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.broadcast_address(), Ipv4Addr::new(192, 168, 1, 255));

pub fn netmask(&self) -> u8

Returns network mask as integer.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.netmask(), 24);

pub fn full_netmask(&self) -> Ipv4Addr

Returns network mask as IPv4 address.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.full_netmask(), Ipv4Addr::new(255, 255, 255, 0));

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

Returns true if given IPv4Addr is inside this network.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert!(ip_network.contains(Ipv4Addr::new(192, 168, 1, 2)));
assert!(!ip_network.contains(Ipv4Addr::new(192, 168, 2, 2)));

Important traits for Ipv4RangeIterator

impl Iterator for Ipv4RangeIterator type Item = Ipv4Addr;

pub fn hosts(&self) -> Ipv4RangeIterator

Returns iterator over host IP addresses in range (without network and broadcast address).

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut hosts = Ipv4Network::new(ip, 24).unwrap().hosts();
assert_eq!(hosts.next().unwrap(), Ipv4Addr::new(192, 168, 1, 1));
assert_eq!(hosts.last().unwrap(), Ipv4Addr::new(192, 168, 1, 254));

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::Ipv4Addr;
use ip_network::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut hosts = Ipv4Network::new(ip, 24).unwrap();
assert_eq!(hosts.supernet(), Some(Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 23).unwrap()));

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

Returns Ipv4NetworkIterator over networks with bigger netmask by one. If netmask is already 32, None will be returned.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
let mut iterator = ip_network.subnets().unwrap();
assert_eq!(iterator.next().unwrap(), Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 25).unwrap());
assert_eq!(iterator.last().unwrap(), Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 128), 25).unwrap());

Important traits for Ipv4NetworkIterator

impl Iterator for Ipv4NetworkIterator type Item = Ipv4Network;

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

Returns Ipv4NetworkIterator over networks with defined netmask.

Panics

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

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut iterator = Ipv4Network::new(ip, 24).unwrap().subnets_with_prefix(25);
assert_eq!(iterator.next().unwrap(), Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 25).unwrap());
assert_eq!(iterator.last().unwrap(), Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 128), 25).unwrap());

pub fn is_unspecified(&self) -> bool

Returns true for the special 'unspecified' network (0.0.0.0/32).

This property is defined in UNIX Network Programming, Second Edition, W. Richard Stevens, p. 891; see also ip7.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(0, 0, 0, 0), 32).unwrap();
assert!(ip_network.is_unspecified());

pub fn is_loopback(&self) -> bool

Returns true if this network is inside loopback address range (127.0.0.0/8).

This property is defined by IETF RFC 1122.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 0), 8).unwrap();
assert!(ip_network.is_loopback());

pub fn is_broadcast(&self) -> bool

Returns true if this is a broadcast network (255.255.255.255/32).

A broadcast address has all octets set to 255 as defined in IETF RFC 919.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(255, 255, 255, 255), 32).unwrap();
assert!(ip_network.is_broadcast());

pub fn is_private(&self) -> bool

Returns true if this whole network range is inside private address ranges.

The private address ranges are defined in IETF RFC 1918 and include:

• 10.0.0.0/8
• 172.16.0.0/12
• 192.168.0.0/16

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert!(ip_network.is_private());

pub fn is_link_local(&self) -> bool

Returns true if the network is is inside link-local range (169.254.0.0/16).

This property is defined by IETF RFC 3927.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(169, 254, 1, 0), 24).unwrap();
assert!(ip_network.is_link_local());

pub fn is_multicast(&self) -> bool

Returns true if this whole network is inside multicast address range (224.0.0.0/4).

Multicast network addresses have a most significant octet between 224 and 239, and is defined by IETF RFC 5771.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(224, 168, 1, 0), 24).unwrap();
assert!(ip_network.is_multicast());

pub fn is_documentation(&self) -> bool

Returns true if this network is in a range designated for documentation.

This is defined in IETF RFC 5737:

• 192.0.2.0/24 (TEST-NET-1)
• 198.51.100.0/24 (TEST-NET-2)
• 203.0.113.0/24 (TEST-NET-3)

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 0, 2, 0), 24).unwrap();
assert!(ip_network.is_documentation());

pub fn is_global(&self) -> bool

Returns true if the network appears to be globally routable. See iana-ipv4-special-registry.

The following return false:

• private address (10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16)
• the loopback address (127.0.0.0/8)
• the link-local address (169.254.0.0/16)
• the broadcast address (255.255.255.255/32)
• test addresses used for documentation (192.0.2.0/24, 198.51.100.0/24 and 203.0.113.0/24)
• the unspecified address (0.0.0.0/32)

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

assert!(!Ipv4Network::new(Ipv4Addr::new(10, 254, 0, 0), 16).unwrap().is_global());
assert!(!Ipv4Network::new(Ipv4Addr::new(192, 168, 10, 65), 32).unwrap().is_global());
assert!(!Ipv4Network::new(Ipv4Addr::new(172, 16, 10, 65), 32).unwrap().is_global());
assert!(!Ipv4Network::new(Ipv4Addr::new(0, 0, 0, 0), 32).unwrap().is_global());
assert!(Ipv4Network::new(Ipv4Addr::new(80, 9, 12, 3), 32).unwrap().is_global());

pub fn summarize_address_range(first: Ipv4Addr, last: Ipv4Addr) -> Vec<Self>

Trait Implementations

impl Ord for Ipv4Network

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

fn eq(&self, other: &Ipv4Network) -> 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 Ipv4Network

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<Ipv4Network> for Ipv4Network

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

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

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

This method tests for !=.

impl From<Ipv4Network> for IpNetwork

fn from(network: Ipv4Network) -> Self

Performs the conversion.

impl From<Ipv4Addr> for Ipv4Network

fn from(ip: Ipv4Addr) -> Self

Converts Ipv4Addr to Ipv4Network with netmask 32.

impl Clone for Ipv4Network

fn clone(&self) -> Ipv4Network

Returns a copy of the value.

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

Performs copy-assignment from source.

impl IntoIterator for Ipv4Network

type Item = Ipv4Addr

The type of the elements being iterated over.

type IntoIter = Ipv4RangeIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Returns iterator over all IP addresses in range including network and broadcast addresses.

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut iter = Ipv4Network::new(ip, 24).unwrap().into_iter();
assert_eq!(iter.next().unwrap(), Ipv4Addr::new(192, 168, 1, 0));
assert_eq!(iter.next().unwrap(), Ipv4Addr::new(192, 168, 1, 1));
assert_eq!(iter.last().unwrap(), Ipv4Addr::new(192, 168, 1, 255));

impl Copy for Ipv4Network

impl Eq for Ipv4Network

impl PartialOrd<Ipv4Network> for Ipv4Network

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

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

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

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

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

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

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

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

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

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

impl Display for Ipv4Network

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

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

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;

let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap();
assert_eq!(ip_network.to_string(), "192.168.1.0/24");

impl Debug for Ipv4Network

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

Formats the value using the given formatter.

impl FromStr for Ipv4Network

type Err = IpNetworkParseError

The associated error which can be returned from parsing.

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

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

Examples

use std::net::Ipv4Addr;
use ip_network::Ipv4Network;
use std::str::FromStr;

let ip_network = Ipv4Network::from_str("192.168.1.0/24").unwrap();
assert_eq!(ip_network.network_address(), Ipv4Addr::new(192, 168, 1, 0));
assert_eq!(ip_network.netmask(), 24);

impl Hash for Ipv4Network

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