use std::{
net::{IpAddr, Ipv4Addr, Ipv6Addr},
str::FromStr,
};
use thiserror::Error;
#[non_exhaustive]
#[derive(Debug, Error, PartialEq)]
pub enum IpError {
#[error("Invalid range: start address {0} is greater than end address {1}")]
InvalidRange(IpAddr, IpAddr),
#[error("Invalid CIDR prefix: {0}")]
InvalidPrefix(u8),
#[error("Failed to parse IP address: {0}")]
AddrParse(#[from] std::net::AddrParseError),
#[error("Invalid IP range format: {0}")]
InvalidFormat(String),
#[error("Invalid prefix number format: {0}")]
PrefixParse(#[from] std::num::ParseIntError),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Ipv4Range {
start_addr: Ipv4Addr,
end_addr: Ipv4Addr,
}
impl Ipv4Range {
pub fn new(start: Ipv4Addr, end: Ipv4Addr) -> Result<Self, IpError> {
if u32::from(start) <= u32::from(end) {
Ok(Self {
start_addr: start,
end_addr: end,
})
} else {
Err(IpError::InvalidRange(IpAddr::V4(start), IpAddr::V4(end)))
}
}
pub fn iter(&self) -> impl Iterator<Item = IpAddr> {
let start: u32 = self.start_addr.into();
let end: u32 = self.end_addr.into();
(start..=end).map(|ip| IpAddr::V4(Ipv4Addr::from(ip)))
}
pub const fn single(addr: Ipv4Addr) -> Self {
Self {
start_addr: addr,
end_addr: addr,
}
}
pub fn start_addr(&self) -> Ipv4Addr {
self.start_addr
}
pub fn end_addr(&self) -> Ipv4Addr {
self.end_addr
}
pub fn extend_end_to(&mut self, end: Ipv4Addr) {
if end > self.end_addr {
self.end_addr = end;
}
}
pub fn contains(&self, ip: &Ipv4Addr) -> bool {
(u32::from(self.start_addr)..=u32::from(self.end_addr)).contains(&u32::from(*ip))
}
#[allow(clippy::len_without_is_empty)]
pub fn len(&self) -> u64 {
let s_u32: u64 = u32::from(self.start_addr) as u64;
let e_u32: u64 = u32::from(self.end_addr) as u64;
(e_u32 - s_u32) + 1
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Ipv6Range {
start_addr: Ipv6Addr,
end_addr: Ipv6Addr,
zone: Option<u32>,
}
impl Ipv6Range {
pub fn new(start: Ipv6Addr, end: Ipv6Addr) -> Result<Self, IpError> {
Self::scoped(start, end, None)
}
pub fn scoped(start: Ipv6Addr, end: Ipv6Addr, zone: Option<u32>) -> Result<Self, IpError> {
if u128::from(start) <= u128::from(end) {
Ok(Self {
start_addr: start,
end_addr: end,
zone,
})
} else {
Err(IpError::InvalidRange(IpAddr::V6(start), IpAddr::V6(end)))
}
}
pub const fn single(addr: Ipv6Addr) -> Self {
Self {
start_addr: addr,
end_addr: addr,
zone: None,
}
}
pub fn start_addr(&self) -> Ipv6Addr {
self.start_addr
}
pub fn end_addr(&self) -> Ipv6Addr {
self.end_addr
}
pub fn extend_end_to(&mut self, end: Ipv6Addr) {
if end > self.end_addr {
self.end_addr = end;
}
}
pub fn zone(&self) -> Option<u32> {
self.zone
}
pub fn is_ambiguous(&self) -> bool {
self.zone.is_none() && self.start_addr.is_unicast_link_local()
}
pub fn iter(&self) -> impl Iterator<Item = IpAddr> {
let start: u128 = self.start_addr.into();
let end: u128 = self.end_addr.into();
(start..=end).map(|ip| IpAddr::V6(Ipv6Addr::from(ip)))
}
pub fn contains(&self, ip: &Ipv6Addr) -> bool {
(u128::from(self.start_addr)..=u128::from(self.end_addr)).contains(&u128::from(*ip))
}
#[allow(clippy::len_without_is_empty)]
pub fn len(&self) -> u128 {
let s_u128: u128 = u128::from(self.start_addr);
let e_u128: u128 = u128::from(self.end_addr);
(e_u128 - s_u128).saturating_add(1)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum IpRange {
V4(Ipv4Range),
V6(Ipv6Range),
}
impl IpRange {
pub fn start_addr(&self) -> IpAddr {
match self {
IpRange::V4(r) => IpAddr::V4(r.start_addr),
IpRange::V6(r) => IpAddr::V6(r.start_addr),
}
}
pub fn end_addr(&self) -> IpAddr {
match self {
IpRange::V4(r) => IpAddr::V4(r.end_addr),
IpRange::V6(r) => IpAddr::V6(r.end_addr),
}
}
pub fn contains(&self, ip: &IpAddr) -> bool {
match (self, ip) {
(IpRange::V4(r), IpAddr::V4(ip)) => r.contains(ip),
(IpRange::V6(r), IpAddr::V6(ip)) => r.contains(ip),
_ => false,
}
}
#[allow(clippy::len_without_is_empty)]
pub fn len(&self) -> u128 {
match self {
IpRange::V4(r) => r.len() as u128,
IpRange::V6(r) => r.len(),
}
}
}
impl FromStr for IpRange {
type Err = IpError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.trim();
if let Some(pos) = s.find('/') {
let ip = s[..pos].parse::<IpAddr>()?;
let prefix = s[pos + 1..].parse::<u8>()?;
return cidr_range(ip, prefix);
}
if let Some(pos) = s.find('-') {
let start_str = s[..pos].trim();
let end_str = s[pos + 1..].trim();
if let Ok(start) = start_str.parse::<Ipv4Addr>() {
let end = expand_v4_end(start, end_str)
.ok_or_else(|| IpError::InvalidFormat(s.to_string()))?;
return Ok(IpRange::V4(Ipv4Range::new(start, end)?));
} else if let Ok(start) = start_str.parse::<Ipv6Addr>() {
let end = end_str.parse::<Ipv6Addr>()?;
return Ok(IpRange::V6(Ipv6Range::new(start, end)?));
}
return Err(IpError::InvalidFormat(s.to_string()));
}
match s.parse::<IpAddr>()? {
IpAddr::V4(v4) => Ok(IpRange::V4(Ipv4Range::single(v4))),
IpAddr::V6(v6) => Ok(IpRange::V6(Ipv6Range::single(v6))),
}
}
}
fn expand_v4_end(start: Ipv4Addr, end_str: &str) -> Option<Ipv4Addr> {
if let Ok(full) = end_str.parse::<Ipv4Addr>() {
return Some(full);
}
let suffix: Vec<u8> = end_str
.split('.')
.map(|part| part.parse::<u8>())
.collect::<Result<_, _>>()
.ok()?;
if suffix.is_empty() || suffix.len() > 4 {
return None;
}
let mut octets = start.octets();
octets[4 - suffix.len()..].copy_from_slice(&suffix);
Some(Ipv4Addr::from(octets))
}
pub fn cidr_range(ip: IpAddr, prefix: u8) -> Result<IpRange, IpError> {
match ip {
IpAddr::V4(v4) => {
if prefix > 32 {
return Err(IpError::InvalidPrefix(prefix));
}
let ip_u32 = u32::from(v4);
let mask = if prefix == 0 {
0
} else {
!u32::MAX.checked_shr(prefix as u32).unwrap_or(0)
};
let network = ip_u32 & mask;
let broadcast = ip_u32 | !mask;
Ok(IpRange::V4(
Ipv4Range::new(Ipv4Addr::from(network), Ipv4Addr::from(broadcast)).unwrap(),
))
}
IpAddr::V6(v6) => {
if prefix > 128 {
return Err(IpError::InvalidPrefix(prefix));
}
let ip_u128 = u128::from(v6);
let mask = if prefix == 0 {
0
} else {
!u128::MAX.checked_shr(prefix as u32).unwrap_or(0)
};
let network = ip_u128 & mask;
let broadcast = ip_u128 | !mask;
Ok(IpRange::V6(
Ipv6Range::new(Ipv6Addr::from(network), Ipv6Addr::from(broadcast)).unwrap(),
))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_range_holds_both_its_bounds_and_nothing_outside_them() {
let v4 =
Ipv4Range::new(Ipv4Addr::new(172, 16, 0, 10), Ipv4Addr::new(172, 16, 0, 20)).unwrap();
assert!(v4.contains(&Ipv4Addr::new(172, 16, 0, 10)));
assert!(v4.contains(&Ipv4Addr::new(172, 16, 0, 20)));
assert!(!v4.contains(&Ipv4Addr::new(172, 16, 0, 9)));
assert!(!v4.contains(&Ipv4Addr::new(172, 16, 0, 21)));
let v6 = Ipv6Range::new(Ipv6Addr::from(100), Ipv6Addr::from(200)).unwrap();
assert_eq!(v6.len(), 101, "inclusive at both ends");
assert!(v6.contains(&Ipv6Addr::from(100)));
assert!(v6.contains(&Ipv6Addr::from(200)));
assert!(!v6.contains(&Ipv6Addr::from(201)));
}
#[test]
fn the_extremes_of_each_address_space_saturate_rather_than_wrap() {
let top_of_v4 = Ipv4Range::new(
Ipv4Addr::new(255, 255, 255, 254),
Ipv4Addr::new(255, 255, 255, 255),
)
.unwrap();
assert_eq!(top_of_v4.len(), 2);
let sixty_four = cidr_range(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 64).unwrap();
assert_eq!(sixty_four.len(), 1u128 << 64);
let everything = cidr_range(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0).unwrap();
assert_eq!(everything.len(), u128::MAX, "saturated, never zero");
}
#[test]
fn iteration_yields_every_address_in_ascending_order() {
let v4 = Ipv4Range::new(Ipv4Addr::new(1, 1, 1, 1), Ipv4Addr::new(1, 1, 1, 3)).unwrap();
assert_eq!(
v4.iter().collect::<Vec<_>>(),
[
IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)),
IpAddr::V4(Ipv4Addr::new(1, 1, 1, 2)),
IpAddr::V4(Ipv4Addr::new(1, 1, 1, 3)),
]
);
let v6 = Ipv6Range::new(Ipv6Addr::from(1), Ipv6Addr::from(3)).unwrap();
assert_eq!(
v6.iter().collect::<Vec<_>>(),
[
IpAddr::V6(Ipv6Addr::from(1)),
IpAddr::V6(Ipv6Addr::from(2)),
IpAddr::V6(Ipv6Addr::from(3)),
]
);
}
#[test]
fn every_written_form_names_the_range_it_says_it_does() {
for (written, first, last) in [
("8.8.8.8", "8.8.8.8", "8.8.8.8"),
("10.0.0.0/24", "10.0.0.0", "10.0.0.255"),
("192.168.1.5/24", "192.168.1.0", "192.168.1.255"),
("1.1.1.1-1.1.1.5", "1.1.1.1", "1.1.1.5"),
("10.0.0.1-50", "10.0.0.1", "10.0.0.50"),
("192.168.1.1-2.254", "192.168.1.1", "192.168.2.254"),
("::1", "::1", "::1"),
("::1/120", "::", "::ff"),
("2001:db8::1-2001:db8::5", "2001:db8::1", "2001:db8::5"),
] {
let range: IpRange = written.parse().unwrap_or_else(|e| panic!("{written}: {e}"));
assert_eq!(range.start_addr().to_string(), first, "{written} starts");
assert_eq!(range.end_addr().to_string(), last, "{written} ends");
}
}
#[test]
fn a_range_can_only_be_built_in_order() {
let low = Ipv4Addr::new(10, 0, 0, 1);
let high = Ipv4Addr::new(10, 0, 0, 5);
assert!(matches!(
Ipv4Range::new(high, low),
Err(IpError::InvalidRange(_, _))
));
assert!(matches!(
Ipv6Range::new(Ipv6Addr::from(2), Ipv6Addr::from(1)),
Err(IpError::InvalidRange(_, _))
));
let range = Ipv4Range::new(low, high).expect("in order");
assert_eq!(range.len(), 5);
assert_eq!(range.iter().count() as u64, range.len());
}
#[test]
fn extending_a_range_never_inverts_it() {
let mut range =
Ipv4Range::new(Ipv4Addr::new(10, 0, 0, 1), Ipv4Addr::new(10, 0, 0, 5)).unwrap();
range.extend_end_to(Ipv4Addr::new(10, 0, 0, 9));
assert_eq!(range.end_addr(), Ipv4Addr::new(10, 0, 0, 9));
range.extend_end_to(Ipv4Addr::new(10, 0, 0, 2));
assert_eq!(range.end_addr(), Ipv4Addr::new(10, 0, 0, 9));
assert!(range.end_addr() >= range.start_addr());
assert_eq!(range.iter().count() as u64, range.len());
}
#[test]
fn an_error_names_the_input_that_produced_it() {
let prefix_err = IpError::InvalidPrefix(40);
assert_eq!(format!("{prefix_err}"), "Invalid CIDR prefix: 40");
let range_err = IpError::InvalidRange(
IpAddr::V4(Ipv4Addr::new(1, 1, 1, 2)),
IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)),
);
assert!(format!("{range_err}").contains("is greater than"));
}
}
#[cfg(test)]
mod property_tests {
use super::*;
use proptest::prelude::*;
fn any_ipv4() -> impl Strategy<Value = Ipv4Addr> {
proptest::prelude::any::<u32>().prop_map(Ipv4Addr::from)
}
fn any_ipv6() -> impl Strategy<Value = Ipv6Addr> {
proptest::prelude::any::<u128>().prop_map(Ipv6Addr::from)
}
fn any_ipv4_range() -> impl Strategy<Value = Ipv4Range> {
(any_ipv4(), 0..5000u32).prop_map(|(start, len)| {
let start_u32 = u32::from(start);
let end_u32 = start_u32.saturating_add(len);
Ipv4Range::new(start, Ipv4Addr::from(end_u32)).unwrap()
})
}
fn any_ipv6_range() -> impl Strategy<Value = Ipv6Range> {
(any_ipv6(), 0..5000u128).prop_map(|(start, len)| {
let start_u128 = u128::from(start);
let end_u128 = start_u128.saturating_add(len);
Ipv6Range::new(start, Ipv6Addr::from(end_u128)).unwrap()
})
}
proptest::proptest! {
#[test]
fn ipv4_range_invariant(a in any_ipv4(), b in any_ipv4()) {
let start = std::cmp::min(a, b);
let end = std::cmp::max(a, b);
let range = Ipv4Range::new(start, end).unwrap();
prop_assert!(range.contains(&start));
prop_assert!(range.contains(&end));
prop_assert_eq!(range.len(), (u32::from(end) - u32::from(start)) as u64 + 1);
}
#[test]
fn ipv6_range_invariant(a in any_ipv6(), b in any_ipv6()) {
let start = std::cmp::min(a, b);
let end = std::cmp::max(a, b);
let range = Ipv6Range::new(start, end).unwrap();
prop_assert!(range.contains(&start));
prop_assert!(range.contains(&end));
prop_assert_eq!(range.len(), (u128::from(end) - u128::from(start)) + 1);
}
#[test]
fn ipv4_iterator_consistency(range in any_ipv4_range()) {
prop_assert_eq!(range.iter().count() as u64, range.len());
}
#[test]
fn ipv6_iterator_consistency(range in any_ipv6_range()) {
prop_assert_eq!(range.iter().count() as u128, range.len());
}
#[test]
fn cidr_v4_roundtrip(v4 in any_ipv4(), prefix in 1..=32u8) {
let range = cidr_range(IpAddr::V4(v4), prefix).unwrap();
prop_assert_eq!(range.len(), 1u128 << (32 - prefix));
}
#[test]
fn cidr_v6_roundtrip(v6 in any_ipv6(), prefix in 1..=128u8) {
let range = cidr_range(IpAddr::V6(v6), prefix).unwrap();
prop_assert_eq!(range.len(), 1u128 << (128 - prefix));
}
}
}