Enum sqlx::types::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<IpNetwork, 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 Copy for IpNetwork

impl Debug for IpNetwork

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

Formats the value using the given formatter.

impl<'_> Decode<'_, Postgres> for IpNetwork

fn decode(
    value: PgValueRef<'_>
) -> Result<IpNetwork, Box<dyn Error + 'static + Sync + Send>>

Decode a new value of this type using a raw value from the database.

impl Display for IpNetwork

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

Formats the value using the given formatter.

impl<'_> Encode<'_, Postgres> for IpNetwork

fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull

Writes the value of self into buf without moving self.

fn size_hint(&self) -> usize

#[must_use]fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

impl Eq for IpNetwork

impl From<IpAddr> for IpNetwork

fn from(addr: IpAddr) -> IpNetwork

Performs the conversion.

impl From<Ipv4Network> for IpNetwork

fn from(v4: Ipv4Network) -> IpNetwork

Performs the conversion.

impl From<Ipv6Network> for IpNetwork

fn from(v6: Ipv6Network) -> IpNetwork

Performs the conversion.

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<IpNetwork, IpNetworkError>

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

impl Hash for IpNetwork

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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<'_> 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.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<IpNetwork> 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: &IpNetwork) -> bool

This method tests for !=.

impl PartialOrd<IpNetwork> 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: &IpNetwork) -> bool

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

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

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

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

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

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

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

impl StructuralEq for IpNetwork

impl StructuralPartialEq for IpNetwork

impl Type<Postgres> for IpNetwork

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &PgTypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.