Struct ip_network::Ipv4Network

pub struct Ipv4Network { /* fields omitted */ }

IPv4 Network

Methods

impl Ipv4Network

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

Constructs new Ipv4Network based on Ipv4Addr and netmask.

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

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn from_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 biger than 32.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn get_network_address(&self) -> Ipv4Addr

Returns network IP address (first address in range).

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn get_broadcast_address(&self) -> Ipv4Addr

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

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn get_netmask(&self) -> u8

Returns network mask as integer.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn get_full_netmask(&self) -> Ipv4Addr

Returns network mask in IP address format.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

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

Returns true if given IP address is inside this network.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

let ip_network = Ipv4Network::from(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)));

fn hosts(&self) -> Ipv4RangeIterator

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

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut hosts = Ipv4Network::from(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));

fn supernet(&self) -> Self

Returns network with smaller netmask by one.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

fn subnets(&self) -> Ipv4NetworkIterator

Returns Ipv4NetworkIterator over networks with bigger netmask by one.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

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

Returns Ipv4NetworkIterator over networks with defined netmask.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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 ipnetwork::Ipv4Network;

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

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

Trait Implementations

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

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

Formats the value using the given formatter.

impl Eq for Ipv4Network

impl PartialEq for Ipv4Network

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

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

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

This method tests for !=.

impl Hash for Ipv4Network

fn hash<__H: Hasher>(&self, __arg_0: &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].

impl PartialOrd for Ipv4Network

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

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

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

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

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

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

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

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

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

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

impl Ord for Ipv4Network

fn cmp(&self, __arg_0: &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 Display for Ipv4Network

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

Converts Ipv4Network to string in format X.X.X.X/Y.

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

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

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 to Ipv4Network.

Examples

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

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

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

Examples

use std::net::Ipv4Addr;
use ipnetwork::Ipv4Network;

let ip = Ipv4Addr::new(192, 168, 1, 0);
let mut iter = Ipv4Network::from(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));