[][src]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)

Methods

impl IpNetwork[src]

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

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 ip(&self) -> IpAddr[src]

Returns the IP part of a given IpNetwork

pub fn prefix(&self) -> u8[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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))

Trait Implementations

impl Eq for IpNetwork[src]

impl Clone for IpNetwork[src]

impl PartialOrd<IpNetwork> for IpNetwork[src]

impl PartialEq<IpNetwork> for IpNetwork[src]

impl Ord for IpNetwork[src]

impl From<Ipv4Network> for IpNetwork[src]

impl From<Ipv6Network> for IpNetwork[src]

impl From<IpAddr> for IpNetwork[src]

impl Copy for IpNetwork[src]

impl Hash for IpNetwork[src]

impl Debug for IpNetwork[src]

impl Display for IpNetwork[src]

impl FromStr for IpNetwork[src]

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.

impl Serialize for IpNetwork[src]

impl<'de> Deserialize<'de> for IpNetwork[src]

Auto Trait Implementations

impl Send for IpNetwork

impl Unpin for IpNetwork

impl Sync for IpNetwork

impl UnwindSafe for IpNetwork

impl RefUnwindSafe for IpNetwork

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]