Struct IPv4Network 

pub struct IPv4Network { /* private fields */ }

An Internet Protocol Version 4 Network, an IPv4Address and a Netmask/CIDR.

Implementations

impl IPv4Network

pub fn from_cidr( network_id: IPv4Address, cidr: u8, ) -> Result<IPv4Network, NetworkError>

Creates a new IPv4Network with the specified CIDR number.

Example

 let addr = IPv4Address::from_be_bytes(&[127,0,0,0]);
 let network = IPv4Network::from_cidr(addr, 16).unwrap();

 assert_eq!("127.0.0.0/16", format!("{network}"));

pub fn from_address_count( network_id: IPv4Address, address_count: u32, ) -> Result<IPv4Network, NetworkError>

Creates a new IPv4Network from a specified power-of-two count of network addresses. This is semantically equivalent to a CIDR, using 2^(32-cidr). For a /24 network, use 256.

Example

 let addr = IPv4Address::from_be_bytes(&[127,0,0,0]);
 let network = IPv4Network::from_address_count(addr, 256).unwrap();

 assert_eq!("127.0.0.0/24", format!("{network}"));

pub fn from_network_mask( network_id: IPv4Address, network_mask: u32, ) -> Result<IPv4Network, NetworkError>

Creates a new IPv4Network using the specified network ID and network Mask.

Example

 let addr = IPv4Address::from_be_bytes(&[127,0,0,0]);
 let network = IPv4Network::from_network_mask(addr, 0xFFFFFF00).unwrap();

 assert_eq!("127.0.0.0/24", format!("{network}"));

pub fn from_host_mask( network_id: IPv4Address, host_mask: u32, ) -> Result<IPv4Network, NetworkError>

Creates an IPv4Network from a network ID and host mask. A host mask is the inverted form of a network mask. If a /24 is represented by 0xFFFFFF00, then the equivalent host mask is 0x000000FF

Example

 let addr = IPv4Address::from_be_bytes(&[127,0,0,0]);
 let network = IPv4Network::from_host_mask(addr, 0x000000FF).unwrap();

 assert_eq!("127.0.0.0/24", format!("{network}"));

pub fn from_net_and_cidr( network_id: &[u8; 4], cidr: u8, ) -> Result<IPv4Network, NetworkError>

Creates a IPv4Network using the specified IPv4 Network ID and the specified CIDR.

Example

let network = IPv4Network::from_net_and_cidr(&[127,0,0,0], 24).unwrap();

assert_eq!("127.0.0.0/24", format!("{network}"));

pub fn is_network_address(&self, address: IPv4Address) -> bool

Returns true if the specified address is the network address for this network.

Example

let net_addr = IPv4Address::from(&[127,0,0,0]);
let host_addr = IPv4Address::from(&[127,0,0,1]);
let network = IPv4Network::from_cidr(net_addr, 24).unwrap();

assert_eq!(true, network.is_network_address(net_addr));
assert_eq!(false, network.is_network_address(host_addr));

pub fn is_broadcast_address(&self, address: IPv4Address) -> bool

Returns true if the specified address is the broadcast address for this network.

Example

let net_addr = IPv4Address::from(&[127,0,0,0]);
let broadcast = IPv4Address::from(&[127,0,0,255]);
let network = IPv4Network::from_cidr(net_addr, 24).unwrap();

assert_eq!(true, network.is_broadcast_address(broadcast));
assert_eq!(false, network.is_broadcast_address(net_addr));

pub fn is_private_address(&self) -> bool

Returns true if this address represents a private address range, in 10.0.0.0/8 or 172.16.0.0/12 or 192.168.0.0/16

Example

let home_network = IPv4Network::from_net_and_cidr(&[192,168,0,0], 24).unwrap();
assert_eq!(true, home_network.is_private_address());

let enterprise_network = IPv4Network::from_net_and_cidr(&[10,10,0,0], 16).unwrap();
assert_eq!(true, enterprise_network.is_private_address());

let hotel_network = IPv4Network::from_net_and_cidr(&[172,20,0,0], 14).unwrap();
assert_eq!(true, hotel_network.is_private_address());

let quad_eight = IPv4Network::from_net_and_cidr(&[8,8,8,8], 32).unwrap();
assert_eq!(false, quad_eight.is_private_address());

pub fn is_link_local(&self) -> bool

Returns true if this network address represents a link-local address, in 169.254.0.0/16

Example

let link_local = IPv4Network::from_net_and_cidr(&[169,254,55,228], 32).unwrap();
assert_eq!(true, link_local.is_link_local());

let quad_eight = IPv4Network::from_net_and_cidr(&[8,8,8,8], 32).unwrap();
assert_eq!(false, quad_eight.is_link_local());

pub fn is_loopback(&self) -> bool

Returns true if this network address represents a loopback address, in 127.0.0.0/8

Example

let loopback = IPv4Network::from_net_and_cidr(&[127,0,0,53], 32).unwrap();
assert_eq!(true, loopback.is_loopback());

let quad_eight = IPv4Network::from_net_and_cidr(&[8,8,8,8], 32).unwrap();
assert_eq!(false, quad_eight.is_loopback());

pub fn is_shared_carrier_nat(&self) -> bool

Returns true if this network represents a carrier-grade NAT address, in 100.64.0.0/10

Example

let carrier_nat = IPv4Network::from_net_and_cidr(&[100,80,0,0], 12).unwrap();
assert_eq!(true, carrier_nat.is_shared_carrier_nat());

let quad_eight = IPv4Network::from_net_and_cidr(&[8,8,8,8], 32).unwrap();
assert_eq!(false, quad_eight.is_shared_carrier_nat());

pub fn host_in_network(&self, host: IPv4Address) -> bool

pub fn get_network_address(&self) -> IPv4Address

pub fn get_broadcast_address(&self) -> IPv4Address

Trait Implementations

impl Clone for IPv4Network

fn clone(&self) -> IPv4Network

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IPv4Network

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

Formats the value using the given formatter.

impl Display for IPv4Network

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

Formats the value using the given formatter.

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

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 IPv4Network

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

impl Eq for IPv4Network

impl StructuralPartialEq for IPv4Network