public inbox for pve-devel@lists.proxmox.com
 help / color / mirror / Atom feed
From: Stefan Hanreich <s.hanreich@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [pve-devel] [PATCH proxmox-ve-rs v3 02/21] ve-config: move types to proxmox-network-types
Date: Thu, 22 May 2025 18:16:23 +0200	[thread overview]
Message-ID: <20250522161731.537011-8-s.hanreich@proxmox.com> (raw)
In-Reply-To: <20250522161731.537011-1-s.hanreich@proxmox.com>

Some of the types defined in this crate have been moved to
proxmox-network-types so they can be re-used across crates. This is a
preparation for the fabrics patch series, where those types will get
used by addtional, new, crates.

Remove the types that have been moved and adjust the imports for them
accordingly. This patch has no functional changes, except for one in
the firewall ipset type. There we had a blanket From implementation:

  impl<T: Into<Cidr>> From<T> for IpsetAddress

This is no longer possible due to the orphan rule, so it has been
replaced with a simple From<Cidr> implementation. All call sites that
used the blanket implementation for the trait have been adjusted as
well.

Signed-off-by: Stefan Hanreich <s.hanreich@proxmox.com>
---
 Cargo.toml                                    |    2 +
 proxmox-ve-config/Cargo.toml                  |    1 +
 proxmox-ve-config/debian/control              |    2 +
 proxmox-ve-config/src/firewall/cluster.rs     |    3 +-
 proxmox-ve-config/src/firewall/ct_helper.rs   |    2 +-
 proxmox-ve-config/src/firewall/host.rs        |    4 +-
 .../src/firewall/types/address.rs             | 1394 +----------------
 proxmox-ve-config/src/firewall/types/alias.rs |    2 +-
 proxmox-ve-config/src/firewall/types/ipset.rs |    8 +-
 proxmox-ve-config/src/firewall/types/mod.rs   |    1 -
 proxmox-ve-config/src/firewall/types/rule.rs  |    5 +-
 .../src/firewall/types/rule_match.rs          |    6 +-
 proxmox-ve-config/src/guest/vm.rs             |   96 +-
 proxmox-ve-config/src/host/utils.rs           |    2 +-
 proxmox-ve-config/src/sdn/config.rs           |    9 +-
 proxmox-ve-config/src/sdn/ipam.rs             |   11 +-
 proxmox-ve-config/src/sdn/mod.rs              |    3 +-
 proxmox-ve-config/tests/sdn/main.rs           |   11 +-
 18 files changed, 62 insertions(+), 1500 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index dc7f312..b6e6df7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,3 +15,5 @@ homepage = "https://proxmox.com"
 exclude = [ "debian" ]
 rust-version = "1.82"
 
+[workspace.dependencies]
+proxmox-network-types = { version = "0.1" }
diff --git a/proxmox-ve-config/Cargo.toml b/proxmox-ve-config/Cargo.toml
index e998b45..72fb627 100644
--- a/proxmox-ve-config/Cargo.toml
+++ b/proxmox-ve-config/Cargo.toml
@@ -18,6 +18,7 @@ serde_plain = "1"
 serde_with = "3"
 proxmox-serde = { version = "0.1.2", features = [ "perl" ]}
 
+proxmox-network-types = { workspace = true }
 proxmox-schema = "4"
 proxmox-sys = "0.6.4"
 proxmox-sortable-macro = "0.1.3"
diff --git a/proxmox-ve-config/debian/control b/proxmox-ve-config/debian/control
index 2c43724..b76904a 100644
--- a/proxmox-ve-config/debian/control
+++ b/proxmox-ve-config/debian/control
@@ -9,6 +9,7 @@ Build-Depends-Arch: cargo:native <!nocheck>,
  librust-anyhow-1+default-dev <!nocheck>,
  librust-log-0.4+default-dev <!nocheck>,
  librust-nix-0.26+default-dev <!nocheck>,
+ librust-proxmox-network-types-0.1+default-dev <!nocheck>,
  librust-proxmox-schema-4+default-dev <!nocheck>,
  librust-proxmox-serde-0.1+default-dev (>= 0.1.2-~~) <!nocheck>,
  librust-proxmox-serde-0.1+perl-dev (>= 0.1.2-~~) <!nocheck>,
@@ -35,6 +36,7 @@ Depends:
  librust-anyhow-1+default-dev,
  librust-log-0.4+default-dev,
  librust-nix-0.26+default-dev,
+ librust-proxmox-network-types-0.1+default-dev,
  librust-proxmox-schema-4+default-dev,
  librust-proxmox-serde-0.1+default-dev (>= 0.1.2-~~),
  librust-proxmox-serde-0.1+perl-dev (>= 0.1.2-~~),
diff --git a/proxmox-ve-config/src/firewall/cluster.rs b/proxmox-ve-config/src/firewall/cluster.rs
index a775cd9..d588302 100644
--- a/proxmox-ve-config/src/firewall/cluster.rs
+++ b/proxmox-ve-config/src/firewall/cluster.rs
@@ -134,6 +134,8 @@ pub struct Options {
 
 #[cfg(test)]
 mod tests {
+    use proxmox_network_types::ip_address::Cidr;
+
     use crate::firewall::types::{
         address::IpList,
         alias::{AliasName, AliasScope},
@@ -143,7 +145,6 @@ mod tests {
         rule_match::{
             Icmpv6, Icmpv6Code, IpAddrMatch, IpMatch, Ports, Protocol, RuleMatch, Tcp, Udp,
         },
-        Cidr,
     };
 
     use super::*;
diff --git a/proxmox-ve-config/src/firewall/ct_helper.rs b/proxmox-ve-config/src/firewall/ct_helper.rs
index 40e4fee..57fe9aa 100644
--- a/proxmox-ve-config/src/firewall/ct_helper.rs
+++ b/proxmox-ve-config/src/firewall/ct_helper.rs
@@ -3,7 +3,7 @@ use serde::Deserialize;
 use std::collections::HashMap;
 use std::sync::OnceLock;
 
-use crate::firewall::types::address::Family;
+use proxmox_network_types::ip_address::Family;
 use crate::firewall::types::rule_match::{Ports, Protocol, Tcp, Udp};
 
 #[derive(Clone, Debug, Deserialize)]
diff --git a/proxmox-ve-config/src/firewall/host.rs b/proxmox-ve-config/src/firewall/host.rs
index f7b02f9..d749442 100644
--- a/proxmox-ve-config/src/firewall/host.rs
+++ b/proxmox-ve-config/src/firewall/host.rs
@@ -4,13 +4,15 @@ use std::net::IpAddr;
 use anyhow::{bail, Error};
 use serde::Deserialize;
 
+use proxmox_network_types::ip_address::Cidr;
+
 use crate::host::utils::{host_ips, network_interface_cidrs};
 use proxmox_sys::nodename;
 
 use crate::firewall::parse;
 use crate::firewall::types::log::LogLevel;
 use crate::firewall::types::rule::Direction;
-use crate::firewall::types::{Alias, Cidr, Rule};
+use crate::firewall::types::{Alias, Rule};
 
 /// default setting for the enabled key
 pub const HOST_ENABLED_DEFAULT: bool = true;
diff --git a/proxmox-ve-config/src/firewall/types/address.rs b/proxmox-ve-config/src/firewall/types/address.rs
index c218d37..3ed255c 100644
--- a/proxmox-ve-config/src/firewall/types/address.rs
+++ b/proxmox-ve-config/src/firewall/types/address.rs
@@ -1,600 +1,9 @@
-use std::fmt::{self, Display};
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::fmt;
 use std::ops::Deref;
 
-use anyhow::{bail, format_err, Error};
-use serde_with::{DeserializeFromStr, SerializeDisplay};
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Family {
-    V4,
-    V6,
-}
-
-impl Family {
-    pub fn is_ipv4(&self) -> bool {
-        *self == Self::V4
-    }
-
-    pub fn is_ipv6(&self) -> bool {
-        *self == Self::V6
-    }
-}
-
-impl fmt::Display for Family {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Family::V4 => f.write_str("Ipv4"),
-            Family::V6 => f.write_str("Ipv6"),
-        }
-    }
-}
-
-#[derive(
-    Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Hash, SerializeDisplay, DeserializeFromStr,
-)]
-pub enum Cidr {
-    Ipv4(Ipv4Cidr),
-    Ipv6(Ipv6Cidr),
-}
-
-impl Cidr {
-    pub fn new_v4(addr: impl Into<Ipv4Addr>, mask: u8) -> Result<Self, Error> {
-        Ok(Cidr::Ipv4(Ipv4Cidr::new(addr, mask)?))
-    }
-
-    pub fn new_v6(addr: impl Into<Ipv6Addr>, mask: u8) -> Result<Self, Error> {
-        Ok(Cidr::Ipv6(Ipv6Cidr::new(addr, mask)?))
-    }
-
-    pub const fn family(&self) -> Family {
-        match self {
-            Cidr::Ipv4(_) => Family::V4,
-            Cidr::Ipv6(_) => Family::V6,
-        }
-    }
-
-    pub fn is_ipv4(&self) -> bool {
-        matches!(self, Cidr::Ipv4(_))
-    }
-
-    pub fn is_ipv6(&self) -> bool {
-        matches!(self, Cidr::Ipv6(_))
-    }
-
-    pub fn contains_address(&self, ip: &IpAddr) -> bool {
-        match (self, ip) {
-            (Cidr::Ipv4(cidr), IpAddr::V4(ip)) => cidr.contains_address(ip),
-            (Cidr::Ipv6(cidr), IpAddr::V6(ip)) => cidr.contains_address(ip),
-            _ => false,
-        }
-    }
-}
-
-impl fmt::Display for Cidr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Ipv4(ip) => f.write_str(ip.to_string().as_str()),
-            Self::Ipv6(ip) => f.write_str(ip.to_string().as_str()),
-        }
-    }
-}
-
-impl std::str::FromStr for Cidr {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Error> {
-        if let Ok(ip) = s.parse::<Ipv4Cidr>() {
-            return Ok(Cidr::Ipv4(ip));
-        }
-
-        if let Ok(ip) = s.parse::<Ipv6Cidr>() {
-            return Ok(Cidr::Ipv6(ip));
-        }
-
-        bail!("invalid ip address or CIDR: {s:?}");
-    }
-}
-
-impl From<Ipv4Cidr> for Cidr {
-    fn from(cidr: Ipv4Cidr) -> Self {
-        Cidr::Ipv4(cidr)
-    }
-}
-
-impl From<Ipv6Cidr> for Cidr {
-    fn from(cidr: Ipv6Cidr) -> Self {
-        Cidr::Ipv6(cidr)
-    }
-}
-
-impl From<IpAddr> for Cidr {
-    fn from(value: IpAddr) -> Self {
-        match value {
-            IpAddr::V4(addr) => Ipv4Cidr::from(addr).into(),
-            IpAddr::V6(addr) => Ipv6Cidr::from(addr).into(),
-        }
-    }
-}
-
-const IPV4_LENGTH: u8 = 32;
-
-#[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Hash, DeserializeFromStr)]
-pub struct Ipv4Cidr {
-    addr: Ipv4Addr,
-    mask: u8,
-}
-
-impl Ipv4Cidr {
-    pub fn new(addr: impl Into<Ipv4Addr>, mask: u8) -> Result<Self, Error> {
-        if mask > 32 {
-            bail!("mask out of range for ipv4 cidr ({mask})");
-        }
-
-        Ok(Self {
-            addr: addr.into(),
-            mask,
-        })
-    }
-
-    pub fn contains_address(&self, other: &Ipv4Addr) -> bool {
-        let bits = u32::from_be_bytes(self.addr.octets());
-        let other_bits = u32::from_be_bytes(other.octets());
-
-        let shift_amount: u32 = IPV4_LENGTH.saturating_sub(self.mask).into();
-
-        bits.checked_shr(shift_amount).unwrap_or(0)
-            == other_bits.checked_shr(shift_amount).unwrap_or(0)
-    }
-
-    pub fn address(&self) -> &Ipv4Addr {
-        &self.addr
-    }
-
-    pub fn mask(&self) -> u8 {
-        self.mask
-    }
-}
-
-impl<T: Into<Ipv4Addr>> From<T> for Ipv4Cidr {
-    fn from(value: T) -> Self {
-        Self {
-            addr: value.into(),
-            mask: 32,
-        }
-    }
-}
-
-impl std::str::FromStr for Ipv4Cidr {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Error> {
-        Ok(match s.find('/') {
-            None => Self {
-                addr: s.parse()?,
-                mask: 32,
-            },
-            Some(pos) => {
-                let mask: u8 = s[(pos + 1)..]
-                    .parse()
-                    .map_err(|_| format_err!("invalid mask in ipv4 cidr: {s:?}"))?;
-
-                Self::new(s[..pos].parse::<Ipv4Addr>()?, mask)?
-            }
-        })
-    }
-}
-
-impl fmt::Display for Ipv4Cidr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}/{}", &self.addr, self.mask)
-    }
-}
-
-const IPV6_LENGTH: u8 = 128;
-
-#[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Hash, DeserializeFromStr)]
-pub struct Ipv6Cidr {
-    addr: Ipv6Addr,
-    mask: u8,
-}
-
-impl Ipv6Cidr {
-    pub fn new(addr: impl Into<Ipv6Addr>, mask: u8) -> Result<Self, Error> {
-        if mask > IPV6_LENGTH {
-            bail!("mask out of range for ipv6 cidr");
-        }
-
-        Ok(Self {
-            addr: addr.into(),
-            mask,
-        })
-    }
-
-    pub fn contains_address(&self, other: &Ipv6Addr) -> bool {
-        let bits = u128::from_be_bytes(self.addr.octets());
-        let other_bits = u128::from_be_bytes(other.octets());
-
-        let shift_amount: u32 = IPV6_LENGTH.saturating_sub(self.mask).into();
-
-        bits.checked_shr(shift_amount).unwrap_or(0)
-            == other_bits.checked_shr(shift_amount).unwrap_or(0)
-    }
-
-    pub fn address(&self) -> &Ipv6Addr {
-        &self.addr
-    }
-
-    pub fn mask(&self) -> u8 {
-        self.mask
-    }
-}
-
-impl std::str::FromStr for Ipv6Cidr {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Error> {
-        Ok(match s.find('/') {
-            None => Self {
-                addr: s.parse()?,
-                mask: 128,
-            },
-            Some(pos) => {
-                let mask: u8 = s[(pos + 1)..]
-                    .parse()
-                    .map_err(|_| format_err!("invalid mask in ipv6 cidr: {s:?}"))?;
-
-                Self::new(s[..pos].parse::<Ipv6Addr>()?, mask)?
-            }
-        })
-    }
-}
-
-impl fmt::Display for Ipv6Cidr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}/{}", &self.addr, self.mask)
-    }
-}
-
-impl<T: Into<Ipv6Addr>> From<T> for Ipv6Cidr {
-    fn from(addr: T) -> Self {
-        Self {
-            addr: addr.into(),
-            mask: 128,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub enum IpRangeError {
-    MismatchedFamilies,
-    StartGreaterThanLast,
-    InvalidFormat,
-}
-
-impl std::error::Error for IpRangeError {}
-
-impl Display for IpRangeError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(match self {
-            IpRangeError::MismatchedFamilies => "mismatched ip address families",
-            IpRangeError::StartGreaterThanLast => "start is greater than last",
-            IpRangeError::InvalidFormat => "invalid ip range format",
-        })
-    }
-}
-
-/// Represents a range of IPv4 or IPv6 addresses.
-///
-/// For more information see [`AddressRange`]
-#[derive(
-    Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, SerializeDisplay, DeserializeFromStr,
-)]
-pub enum IpRange {
-    V4(AddressRange<Ipv4Addr>),
-    V6(AddressRange<Ipv6Addr>),
-}
-
-impl IpRange {
-    /// Returns the family of the IpRange.
-    pub fn family(&self) -> Family {
-        match self {
-            IpRange::V4(_) => Family::V4,
-            IpRange::V6(_) => Family::V6,
-        }
-    }
-
-    /// Creates a new [`IpRange`] from two [`IpAddr`].
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if start and last IP address are not from the same family.
-    pub fn new(start: impl Into<IpAddr>, last: impl Into<IpAddr>) -> Result<Self, IpRangeError> {
-        match (start.into(), last.into()) {
-            (IpAddr::V4(start), IpAddr::V4(last)) => Self::new_v4(start, last),
-            (IpAddr::V6(start), IpAddr::V6(last)) => Self::new_v6(start, last),
-            _ => Err(IpRangeError::MismatchedFamilies),
-        }
-    }
-
-    /// construct a new Ipv4 Range
-    pub fn new_v4(
-        start: impl Into<Ipv4Addr>,
-        last: impl Into<Ipv4Addr>,
-    ) -> Result<Self, IpRangeError> {
-        Ok(IpRange::V4(AddressRange::new_v4(start, last)?))
-    }
-
-    pub fn new_v6(
-        start: impl Into<Ipv6Addr>,
-        last: impl Into<Ipv6Addr>,
-    ) -> Result<Self, IpRangeError> {
-        Ok(IpRange::V6(AddressRange::new_v6(start, last)?))
-    }
-
-    /// Converts an IpRange into the minimal amount of CIDRs.
-    ///
-    /// see the concrete implementations of [`AddressRange<Ipv4Addr>`] or [`AddressRange<Ipv6Addr>`]
-    /// respectively
-    pub fn to_cidrs(&self) -> Vec<Cidr> {
-        match self {
-            IpRange::V4(range) => range.to_cidrs().into_iter().map(Cidr::from).collect(),
-            IpRange::V6(range) => range.to_cidrs().into_iter().map(Cidr::from).collect(),
-        }
-    }
-}
-
-impl std::str::FromStr for IpRange {
-    type Err = IpRangeError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Ok(range) = s.parse() {
-            return Ok(IpRange::V4(range));
-        }
-
-        if let Ok(range) = s.parse() {
-            return Ok(IpRange::V6(range));
-        }
-
-        Err(IpRangeError::InvalidFormat)
-    }
-}
-
-impl fmt::Display for IpRange {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            IpRange::V4(range) => range.fmt(f),
-            IpRange::V6(range) => range.fmt(f),
-        }
-    }
-}
-
-/// Represents a range of IP addresses from start to last.
-///
-/// This type is for encapsulation purposes for the [`IpRange`] enum and should be instantiated via
-/// that enum.
-///
-/// # Invariants
-///
-/// * start and last have the same IP address family
-/// * start is less than or equal to last
-///
-/// # Textual representation
-///
-/// Two IP addresses separated by a hyphen, e.g.: `127.0.0.1-127.0.0.255`
-#[derive(
-    Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, SerializeDisplay, DeserializeFromStr,
-)]
-pub struct AddressRange<T> {
-    start: T,
-    last: T,
-}
-
-impl AddressRange<Ipv4Addr> {
-    pub(crate) fn new_v4(
-        start: impl Into<Ipv4Addr>,
-        last: impl Into<Ipv4Addr>,
-    ) -> Result<AddressRange<Ipv4Addr>, IpRangeError> {
-        let (start, last) = (start.into(), last.into());
-
-        if start > last {
-            return Err(IpRangeError::StartGreaterThanLast);
-        }
-
-        Ok(Self { start, last })
-    }
-
-    /// Returns the minimum amount of CIDRs that exactly represent the range
-    ///
-    /// The idea behind this algorithm is as follows:
-    ///
-    /// Start iterating with current = start of the IP range
-    ///
-    /// Find two netmasks
-    /// * The largest CIDR that the current IP can be the first of
-    /// * The largest CIDR that *only* contains IPs from current - last
-    ///
-    /// Add the smaller of the two CIDRs to our result and current to the first IP that is in
-    /// the range but not in the CIDR we just added. Proceed until we reached the last of the IP
-    /// range.
-    ///
-    pub fn to_cidrs(&self) -> Vec<Ipv4Cidr> {
-        let mut cidrs = Vec::new();
-
-        let mut current = u32::from_be_bytes(self.start.octets());
-        let last = u32::from_be_bytes(self.last.octets());
-
-        if current == last {
-            // valid Ipv4 since netmask is 32
-            cidrs.push(Ipv4Cidr::new(current, 32).unwrap());
-            return cidrs;
-        }
-
-        // special case this, since this is the only possibility of overflow
-        // when calculating delta_min_mask - makes everything a lot easier
-        if current == u32::MIN && last == u32::MAX {
-            // valid Ipv4 since it is `0.0.0.0/0`
-            cidrs.push(Ipv4Cidr::new(current, 0).unwrap());
-            return cidrs;
-        }
-
-        while current <= last {
-            // netmask of largest CIDR that current IP can be the first of
-            // cast is safe, because trailing zeroes can at most be 32
-            let current_max_mask = IPV4_LENGTH - (current.trailing_zeros() as u8);
-
-            // netmask of largest CIDR that *only* contains IPs of the remaining range
-            // is at most 32 due to unwrap_or returning 32 and ilog2 being at most 31
-            let delta_min_mask = ((last - current) + 1) // safe due to special case above
-                .checked_ilog2() // should never occur due to special case, but for good measure
-                .map(|mask| IPV4_LENGTH - mask as u8)
-                .unwrap_or(IPV4_LENGTH);
-
-            // at most 32, due to current/delta being at most 32
-            let netmask = u8::max(current_max_mask, delta_min_mask);
-
-            // netmask is at most 32, therefore safe to unwrap
-            cidrs.push(Ipv4Cidr::new(current, netmask).unwrap());
-
-            let delta = 2u32.saturating_pow((IPV4_LENGTH - netmask).into());
-
-            if let Some(result) = current.checked_add(delta) {
-                current = result
-            } else {
-                // we reached the end of IP address space
-                break;
-            }
-        }
-
-        cidrs
-    }
-}
-
-impl AddressRange<Ipv6Addr> {
-    pub(crate) fn new_v6(
-        start: impl Into<Ipv6Addr>,
-        last: impl Into<Ipv6Addr>,
-    ) -> Result<AddressRange<Ipv6Addr>, IpRangeError> {
-        let (start, last) = (start.into(), last.into());
-
-        if start > last {
-            return Err(IpRangeError::StartGreaterThanLast);
-        }
-
-        Ok(Self { start, last })
-    }
-
-    /// Returns the minimum amount of CIDRs that exactly represent the [`AddressRange`].
-    ///
-    /// This function works analogous to the IPv4 version, please refer to the respective
-    /// documentation of [`AddressRange<Ipv4Addr>`]
-    pub fn to_cidrs(&self) -> Vec<Ipv6Cidr> {
-        let mut cidrs = Vec::new();
-
-        let mut current = u128::from_be_bytes(self.start.octets());
-        let last = u128::from_be_bytes(self.last.octets());
-
-        if current == last {
-            // valid Ipv6 since netmask is 128
-            cidrs.push(Ipv6Cidr::new(current, 128).unwrap());
-            return cidrs;
-        }
-
-        // special case this, since this is the only possibility of overflow
-        // when calculating delta_min_mask - makes everything a lot easier
-        if current == u128::MIN && last == u128::MAX {
-            // valid Ipv6 since it is `::/0`
-            cidrs.push(Ipv6Cidr::new(current, 0).unwrap());
-            return cidrs;
-        }
-
-        while current <= last {
-            // netmask of largest CIDR that current IP can be the first of
-            // cast is safe, because trailing zeroes can at most be 128
-            let current_max_mask = IPV6_LENGTH - (current.trailing_zeros() as u8);
-
-            // netmask of largest CIDR that *only* contains IPs of the remaining range
-            // is at most 128 due to unwrap_or returning 128 and ilog2 being at most 31
-            let delta_min_mask = ((last - current) + 1) // safe due to special case above
-                .checked_ilog2() // should never occur due to special case, but for good measure
-                .map(|mask| IPV6_LENGTH - mask as u8)
-                .unwrap_or(IPV6_LENGTH);
-
-            // at most 128, due to current/delta being at most 128
-            let netmask = u8::max(current_max_mask, delta_min_mask);
-
-            // netmask is at most 128, therefore safe to unwrap
-            cidrs.push(Ipv6Cidr::new(current, netmask).unwrap());
-
-            let delta = 2u128.saturating_pow((IPV6_LENGTH - netmask).into());
-
-            if let Some(result) = current.checked_add(delta) {
-                current = result
-            } else {
-                // we reached the end of IP address space
-                break;
-            }
-        }
-
-        cidrs
-    }
-}
-
-impl<T> AddressRange<T> {
-    pub fn start(&self) -> &T {
-        &self.start
-    }
-
-    pub fn last(&self) -> &T {
-        &self.last
-    }
-}
-
-impl std::str::FromStr for AddressRange<Ipv4Addr> {
-    type Err = IpRangeError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Some((start, last)) = s.split_once('-') {
-            let start_address = start
-                .parse::<Ipv4Addr>()
-                .map_err(|_| IpRangeError::InvalidFormat)?;
-
-            let last_address = last
-                .parse::<Ipv4Addr>()
-                .map_err(|_| IpRangeError::InvalidFormat)?;
-
-            return Self::new_v4(start_address, last_address);
-        }
-
-        Err(IpRangeError::InvalidFormat)
-    }
-}
-
-impl std::str::FromStr for AddressRange<Ipv6Addr> {
-    type Err = IpRangeError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Some((start, last)) = s.split_once('-') {
-            let start_address = start
-                .parse::<Ipv6Addr>()
-                .map_err(|_| IpRangeError::InvalidFormat)?;
-
-            let last_address = last
-                .parse::<Ipv6Addr>()
-                .map_err(|_| IpRangeError::InvalidFormat)?;
-
-            return Self::new_v6(start_address, last_address);
-        }
-
-        Err(IpRangeError::InvalidFormat)
-    }
-}
-
-impl<T: fmt::Display> fmt::Display for AddressRange<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}-{}", self.start, self.last)
-    }
-}
+use anyhow::{bail, Error};
+use proxmox_network_types::ip_address::{Cidr, Family, IpRange};
+use serde_with::DeserializeFromStr;
 
 #[derive(Clone, Debug)]
 #[cfg_attr(test, derive(Eq, PartialEq))]
@@ -741,84 +150,6 @@ impl IpList {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::net::{Ipv4Addr, Ipv6Addr};
-
-    #[test]
-    fn test_v4_cidr() {
-        let mut cidr: Ipv4Cidr = "0.0.0.0/0".parse().expect("valid IPv4 CIDR");
-
-        assert_eq!(cidr.addr, Ipv4Addr::new(0, 0, 0, 0));
-        assert_eq!(cidr.mask, 0);
-
-        assert!(cidr.contains_address(&Ipv4Addr::new(0, 0, 0, 0)));
-        assert!(cidr.contains_address(&Ipv4Addr::new(255, 255, 255, 255)));
-
-        cidr = "192.168.100.1".parse().expect("valid IPv4 CIDR");
-
-        assert_eq!(cidr.addr, Ipv4Addr::new(192, 168, 100, 1));
-        assert_eq!(cidr.mask, 32);
-
-        assert!(cidr.contains_address(&Ipv4Addr::new(192, 168, 100, 1)));
-        assert!(!cidr.contains_address(&Ipv4Addr::new(192, 168, 100, 2)));
-        assert!(!cidr.contains_address(&Ipv4Addr::new(192, 168, 100, 0)));
-
-        cidr = "10.100.5.0/24".parse().expect("valid IPv4 CIDR");
-
-        assert_eq!(cidr.mask, 24);
-
-        assert!(cidr.contains_address(&Ipv4Addr::new(10, 100, 5, 0)));
-        assert!(cidr.contains_address(&Ipv4Addr::new(10, 100, 5, 1)));
-        assert!(cidr.contains_address(&Ipv4Addr::new(10, 100, 5, 100)));
-        assert!(cidr.contains_address(&Ipv4Addr::new(10, 100, 5, 255)));
-        assert!(!cidr.contains_address(&Ipv4Addr::new(10, 100, 4, 255)));
-        assert!(!cidr.contains_address(&Ipv4Addr::new(10, 100, 6, 0)));
-
-        "0.0.0.0/-1".parse::<Ipv4Cidr>().unwrap_err();
-        "0.0.0.0/33".parse::<Ipv4Cidr>().unwrap_err();
-        "256.256.256.256/10".parse::<Ipv4Cidr>().unwrap_err();
-
-        "fe80::1/64".parse::<Ipv4Cidr>().unwrap_err();
-        "qweasd".parse::<Ipv4Cidr>().unwrap_err();
-        "".parse::<Ipv4Cidr>().unwrap_err();
-    }
-
-    #[test]
-    fn test_v6_cidr() {
-        let mut cidr: Ipv6Cidr = "abab::1/64".parse().expect("valid IPv6 CIDR");
-
-        assert_eq!(cidr.addr, Ipv6Addr::new(0xABAB, 0, 0, 0, 0, 0, 0, 1));
-        assert_eq!(cidr.mask, 64);
-
-        assert!(cidr.contains_address(&Ipv6Addr::new(0xABAB, 0, 0, 0, 0, 0, 0, 0)));
-        assert!(cidr.contains_address(&Ipv6Addr::new(
-            0xABAB, 0, 0, 0, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA
-        )));
-        assert!(cidr.contains_address(&Ipv6Addr::new(
-            0xABAB, 0, 0, 0, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF
-        )));
-        assert!(!cidr.contains_address(&Ipv6Addr::new(0xABAB, 0, 0, 1, 0, 0, 0, 0)));
-        assert!(!cidr.contains_address(&Ipv6Addr::new(
-            0xABAA, 0, 0, 0, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF
-        )));
-
-        cidr = "eeee::1".parse().expect("valid IPv6 CIDR");
-
-        assert_eq!(cidr.mask, 128);
-
-        assert!(cidr.contains_address(&Ipv6Addr::new(0xEEEE, 0, 0, 0, 0, 0, 0, 1)));
-        assert!(!cidr.contains_address(&Ipv6Addr::new(
-            0xEEED, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF
-        )));
-        assert!(!cidr.contains_address(&Ipv6Addr::new(0xEEEE, 0, 0, 0, 0, 0, 0, 0)));
-
-        "eeee::1/-1".parse::<Ipv6Cidr>().unwrap_err();
-        "eeee::1/129".parse::<Ipv6Cidr>().unwrap_err();
-        "gggg::1/64".parse::<Ipv6Cidr>().unwrap_err();
-
-        "192.168.0.1".parse::<Ipv6Cidr>().unwrap_err();
-        "qweasd".parse::<Ipv6Cidr>().unwrap_err();
-        "".parse::<Ipv6Cidr>().unwrap_err();
-    }
 
     #[test]
     fn test_parse_ip_entry() {
@@ -942,721 +273,4 @@ mod tests {
         ])
         .expect_err("cannot mix ip families in ip list");
     }
-
-    #[test]
-    fn test_ip_range() {
-        IpRange::new([10, 0, 0, 2], [10, 0, 0, 1]).unwrap_err();
-
-        IpRange::new(
-            [0x2001, 0x0db8, 0, 0, 0, 0, 0, 0x1000],
-            [0x2001, 0x0db8, 0, 0, 0, 0, 0, 0],
-        )
-        .unwrap_err();
-
-        let v4_range = IpRange::new([10, 0, 0, 0], [10, 0, 0, 100]).unwrap();
-        assert_eq!(v4_range.family(), Family::V4);
-
-        let v6_range = IpRange::new(
-            [0x2001, 0x0db8, 0, 0, 0, 0, 0, 0],
-            [0x2001, 0x0db8, 0, 0, 0, 0, 0, 0x1000],
-        )
-        .unwrap();
-        assert_eq!(v6_range.family(), Family::V6);
-
-        "10.0.0.1-10.0.0.100".parse::<IpRange>().unwrap();
-        "2001:db8::1-2001:db8::f".parse::<IpRange>().unwrap();
-
-        "10.0.0.1-2001:db8::1000".parse::<IpRange>().unwrap_err();
-        "2001:db8::1-192.168.0.2".parse::<IpRange>().unwrap_err();
-
-        "10.0.0.1-10.0.0.0".parse::<IpRange>().unwrap_err();
-        "2001:db8::1-2001:db8::0".parse::<IpRange>().unwrap_err();
-    }
-
-    #[test]
-    fn test_ipv4_to_cidrs() {
-        let range = AddressRange::new_v4([192, 168, 0, 100], [192, 168, 0, 100]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([192, 168, 0, 100], 32).unwrap()],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([192, 168, 0, 100], [192, 168, 0, 200]).unwrap();
-
-        assert_eq!(
-            [
-                Ipv4Cidr::new([192, 168, 0, 100], 30).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 104], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 112], 28).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 128], 26).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 192], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 200], 32).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([192, 168, 0, 101], [192, 168, 0, 200]).unwrap();
-
-        assert_eq!(
-            [
-                Ipv4Cidr::new([192, 168, 0, 101], 32).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 102], 31).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 104], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 112], 28).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 128], 26).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 192], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 200], 32).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([192, 168, 0, 101], [192, 168, 0, 101]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([192, 168, 0, 101], 32).unwrap()],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([192, 168, 0, 101], [192, 168, 0, 201]).unwrap();
-
-        assert_eq!(
-            [
-                Ipv4Cidr::new([192, 168, 0, 101], 32).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 102], 31).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 104], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 112], 28).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 128], 26).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 192], 29).unwrap(),
-                Ipv4Cidr::new([192, 168, 0, 200], 31).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([192, 168, 0, 0], [192, 168, 0, 255]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([192, 168, 0, 0], 24).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([0, 0, 0, 0], [255, 255, 255, 255]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([0, 0, 0, 0], 0).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([0, 0, 0, 1], [255, 255, 255, 255]).unwrap();
-
-        assert_eq!(
-            [
-                Ipv4Cidr::new([0, 0, 0, 1], 32).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 2], 31).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 4], 30).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 8], 29).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 16], 28).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 32], 27).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 64], 26).unwrap(),
-                Ipv4Cidr::new([0, 0, 0, 128], 25).unwrap(),
-                Ipv4Cidr::new([0, 0, 1, 0], 24).unwrap(),
-                Ipv4Cidr::new([0, 0, 2, 0], 23).unwrap(),
-                Ipv4Cidr::new([0, 0, 4, 0], 22).unwrap(),
-                Ipv4Cidr::new([0, 0, 8, 0], 21).unwrap(),
-                Ipv4Cidr::new([0, 0, 16, 0], 20).unwrap(),
-                Ipv4Cidr::new([0, 0, 32, 0], 19).unwrap(),
-                Ipv4Cidr::new([0, 0, 64, 0], 18).unwrap(),
-                Ipv4Cidr::new([0, 0, 128, 0], 17).unwrap(),
-                Ipv4Cidr::new([0, 1, 0, 0], 16).unwrap(),
-                Ipv4Cidr::new([0, 2, 0, 0], 15).unwrap(),
-                Ipv4Cidr::new([0, 4, 0, 0], 14).unwrap(),
-                Ipv4Cidr::new([0, 8, 0, 0], 13).unwrap(),
-                Ipv4Cidr::new([0, 16, 0, 0], 12).unwrap(),
-                Ipv4Cidr::new([0, 32, 0, 0], 11).unwrap(),
-                Ipv4Cidr::new([0, 64, 0, 0], 10).unwrap(),
-                Ipv4Cidr::new([0, 128, 0, 0], 9).unwrap(),
-                Ipv4Cidr::new([1, 0, 0, 0], 8).unwrap(),
-                Ipv4Cidr::new([2, 0, 0, 0], 7).unwrap(),
-                Ipv4Cidr::new([4, 0, 0, 0], 6).unwrap(),
-                Ipv4Cidr::new([8, 0, 0, 0], 5).unwrap(),
-                Ipv4Cidr::new([16, 0, 0, 0], 4).unwrap(),
-                Ipv4Cidr::new([32, 0, 0, 0], 3).unwrap(),
-                Ipv4Cidr::new([64, 0, 0, 0], 2).unwrap(),
-                Ipv4Cidr::new([128, 0, 0, 0], 1).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([0, 0, 0, 0], [255, 255, 255, 254]).unwrap();
-
-        assert_eq!(
-            [
-                Ipv4Cidr::new([0, 0, 0, 0], 1).unwrap(),
-                Ipv4Cidr::new([128, 0, 0, 0], 2).unwrap(),
-                Ipv4Cidr::new([192, 0, 0, 0], 3).unwrap(),
-                Ipv4Cidr::new([224, 0, 0, 0], 4).unwrap(),
-                Ipv4Cidr::new([240, 0, 0, 0], 5).unwrap(),
-                Ipv4Cidr::new([248, 0, 0, 0], 6).unwrap(),
-                Ipv4Cidr::new([252, 0, 0, 0], 7).unwrap(),
-                Ipv4Cidr::new([254, 0, 0, 0], 8).unwrap(),
-                Ipv4Cidr::new([255, 0, 0, 0], 9).unwrap(),
-                Ipv4Cidr::new([255, 128, 0, 0], 10).unwrap(),
-                Ipv4Cidr::new([255, 192, 0, 0], 11).unwrap(),
-                Ipv4Cidr::new([255, 224, 0, 0], 12).unwrap(),
-                Ipv4Cidr::new([255, 240, 0, 0], 13).unwrap(),
-                Ipv4Cidr::new([255, 248, 0, 0], 14).unwrap(),
-                Ipv4Cidr::new([255, 252, 0, 0], 15).unwrap(),
-                Ipv4Cidr::new([255, 254, 0, 0], 16).unwrap(),
-                Ipv4Cidr::new([255, 255, 0, 0], 17).unwrap(),
-                Ipv4Cidr::new([255, 255, 128, 0], 18).unwrap(),
-                Ipv4Cidr::new([255, 255, 192, 0], 19).unwrap(),
-                Ipv4Cidr::new([255, 255, 224, 0], 20).unwrap(),
-                Ipv4Cidr::new([255, 255, 240, 0], 21).unwrap(),
-                Ipv4Cidr::new([255, 255, 248, 0], 22).unwrap(),
-                Ipv4Cidr::new([255, 255, 252, 0], 23).unwrap(),
-                Ipv4Cidr::new([255, 255, 254, 0], 24).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 0], 25).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 128], 26).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 192], 27).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 224], 28).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 240], 29).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 248], 30).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 252], 31).unwrap(),
-                Ipv4Cidr::new([255, 255, 255, 254], 32).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([0, 0, 0, 0], [0, 0, 0, 0]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([0, 0, 0, 0], 32).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v4([255, 255, 255, 255], [255, 255, 255, 255]).unwrap();
-
-        assert_eq!(
-            [Ipv4Cidr::new([255, 255, 255, 255], 32).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-    }
-
-    #[test]
-    fn test_ipv6_to_cidrs() {
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1000],
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1000],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1000], 128).unwrap()],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1000],
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2000],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1000], 116).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2000], 128).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001],
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2000],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001], 128).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1002], 127).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1004], 126).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1008], 125).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1010], 124).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1020], 123).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1040], 122).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1080], 121).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1100], 120).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1200], 119).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1400], 118).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1800], 117).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2000], 128).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001],
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001], 128).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001],
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2001],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1001], 128).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1002], 127).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1004], 126).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1008], 125).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1010], 124).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1020], 123).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1040], 122).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1080], 121).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1100], 120).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1200], 119).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1400], 118).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x1800], 117).unwrap(),
-                Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0x2000], 127).unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0],
-            [0x2001, 0x0DB8, 0, 0, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new([0x2001, 0x0DB8, 0, 0, 0, 0, 0, 0], 64).unwrap()],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0, 0, 0, 0, 0, 0, 0, 0],
-            [
-                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new([0, 0, 0, 0, 0, 0, 0, 0], 0).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0, 0, 0, 0, 0, 0, 0, 0x0001],
-            [
-                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [
-                "::1/128".parse::<Ipv6Cidr>().unwrap(),
-                "::2/127".parse::<Ipv6Cidr>().unwrap(),
-                "::4/126".parse::<Ipv6Cidr>().unwrap(),
-                "::8/125".parse::<Ipv6Cidr>().unwrap(),
-                "::10/124".parse::<Ipv6Cidr>().unwrap(),
-                "::20/123".parse::<Ipv6Cidr>().unwrap(),
-                "::40/122".parse::<Ipv6Cidr>().unwrap(),
-                "::80/121".parse::<Ipv6Cidr>().unwrap(),
-                "::100/120".parse::<Ipv6Cidr>().unwrap(),
-                "::200/119".parse::<Ipv6Cidr>().unwrap(),
-                "::400/118".parse::<Ipv6Cidr>().unwrap(),
-                "::800/117".parse::<Ipv6Cidr>().unwrap(),
-                "::1000/116".parse::<Ipv6Cidr>().unwrap(),
-                "::2000/115".parse::<Ipv6Cidr>().unwrap(),
-                "::4000/114".parse::<Ipv6Cidr>().unwrap(),
-                "::8000/113".parse::<Ipv6Cidr>().unwrap(),
-                "::1:0/112".parse::<Ipv6Cidr>().unwrap(),
-                "::2:0/111".parse::<Ipv6Cidr>().unwrap(),
-                "::4:0/110".parse::<Ipv6Cidr>().unwrap(),
-                "::8:0/109".parse::<Ipv6Cidr>().unwrap(),
-                "::10:0/108".parse::<Ipv6Cidr>().unwrap(),
-                "::20:0/107".parse::<Ipv6Cidr>().unwrap(),
-                "::40:0/106".parse::<Ipv6Cidr>().unwrap(),
-                "::80:0/105".parse::<Ipv6Cidr>().unwrap(),
-                "::100:0/104".parse::<Ipv6Cidr>().unwrap(),
-                "::200:0/103".parse::<Ipv6Cidr>().unwrap(),
-                "::400:0/102".parse::<Ipv6Cidr>().unwrap(),
-                "::800:0/101".parse::<Ipv6Cidr>().unwrap(),
-                "::1000:0/100".parse::<Ipv6Cidr>().unwrap(),
-                "::2000:0/99".parse::<Ipv6Cidr>().unwrap(),
-                "::4000:0/98".parse::<Ipv6Cidr>().unwrap(),
-                "::8000:0/97".parse::<Ipv6Cidr>().unwrap(),
-                "::1:0:0/96".parse::<Ipv6Cidr>().unwrap(),
-                "::2:0:0/95".parse::<Ipv6Cidr>().unwrap(),
-                "::4:0:0/94".parse::<Ipv6Cidr>().unwrap(),
-                "::8:0:0/93".parse::<Ipv6Cidr>().unwrap(),
-                "::10:0:0/92".parse::<Ipv6Cidr>().unwrap(),
-                "::20:0:0/91".parse::<Ipv6Cidr>().unwrap(),
-                "::40:0:0/90".parse::<Ipv6Cidr>().unwrap(),
-                "::80:0:0/89".parse::<Ipv6Cidr>().unwrap(),
-                "::100:0:0/88".parse::<Ipv6Cidr>().unwrap(),
-                "::200:0:0/87".parse::<Ipv6Cidr>().unwrap(),
-                "::400:0:0/86".parse::<Ipv6Cidr>().unwrap(),
-                "::800:0:0/85".parse::<Ipv6Cidr>().unwrap(),
-                "::1000:0:0/84".parse::<Ipv6Cidr>().unwrap(),
-                "::2000:0:0/83".parse::<Ipv6Cidr>().unwrap(),
-                "::4000:0:0/82".parse::<Ipv6Cidr>().unwrap(),
-                "::8000:0:0/81".parse::<Ipv6Cidr>().unwrap(),
-                "::1:0:0:0/80".parse::<Ipv6Cidr>().unwrap(),
-                "::2:0:0:0/79".parse::<Ipv6Cidr>().unwrap(),
-                "::4:0:0:0/78".parse::<Ipv6Cidr>().unwrap(),
-                "::8:0:0:0/77".parse::<Ipv6Cidr>().unwrap(),
-                "::10:0:0:0/76".parse::<Ipv6Cidr>().unwrap(),
-                "::20:0:0:0/75".parse::<Ipv6Cidr>().unwrap(),
-                "::40:0:0:0/74".parse::<Ipv6Cidr>().unwrap(),
-                "::80:0:0:0/73".parse::<Ipv6Cidr>().unwrap(),
-                "::100:0:0:0/72".parse::<Ipv6Cidr>().unwrap(),
-                "::200:0:0:0/71".parse::<Ipv6Cidr>().unwrap(),
-                "::400:0:0:0/70".parse::<Ipv6Cidr>().unwrap(),
-                "::800:0:0:0/69".parse::<Ipv6Cidr>().unwrap(),
-                "::1000:0:0:0/68".parse::<Ipv6Cidr>().unwrap(),
-                "::2000:0:0:0/67".parse::<Ipv6Cidr>().unwrap(),
-                "::4000:0:0:0/66".parse::<Ipv6Cidr>().unwrap(),
-                "::8000:0:0:0/65".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:1::/64".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:2::/63".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:4::/62".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:8::/61".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:10::/60".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:20::/59".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:40::/58".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:80::/57".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:100::/56".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:200::/55".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:400::/54".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:800::/53".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:1000::/52".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:2000::/51".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:4000::/50".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:0:8000::/49".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:1::/48".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:2::/47".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:4::/46".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:8::/45".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:10::/44".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:20::/43".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:40::/42".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:80::/41".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:100::/40".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:200::/39".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:400::/38".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:800::/37".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:1000::/36".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:2000::/35".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:4000::/34".parse::<Ipv6Cidr>().unwrap(),
-                "0:0:8000::/33".parse::<Ipv6Cidr>().unwrap(),
-                "0:1::/32".parse::<Ipv6Cidr>().unwrap(),
-                "0:2::/31".parse::<Ipv6Cidr>().unwrap(),
-                "0:4::/30".parse::<Ipv6Cidr>().unwrap(),
-                "0:8::/29".parse::<Ipv6Cidr>().unwrap(),
-                "0:10::/28".parse::<Ipv6Cidr>().unwrap(),
-                "0:20::/27".parse::<Ipv6Cidr>().unwrap(),
-                "0:40::/26".parse::<Ipv6Cidr>().unwrap(),
-                "0:80::/25".parse::<Ipv6Cidr>().unwrap(),
-                "0:100::/24".parse::<Ipv6Cidr>().unwrap(),
-                "0:200::/23".parse::<Ipv6Cidr>().unwrap(),
-                "0:400::/22".parse::<Ipv6Cidr>().unwrap(),
-                "0:800::/21".parse::<Ipv6Cidr>().unwrap(),
-                "0:1000::/20".parse::<Ipv6Cidr>().unwrap(),
-                "0:2000::/19".parse::<Ipv6Cidr>().unwrap(),
-                "0:4000::/18".parse::<Ipv6Cidr>().unwrap(),
-                "0:8000::/17".parse::<Ipv6Cidr>().unwrap(),
-                "1::/16".parse::<Ipv6Cidr>().unwrap(),
-                "2::/15".parse::<Ipv6Cidr>().unwrap(),
-                "4::/14".parse::<Ipv6Cidr>().unwrap(),
-                "8::/13".parse::<Ipv6Cidr>().unwrap(),
-                "10::/12".parse::<Ipv6Cidr>().unwrap(),
-                "20::/11".parse::<Ipv6Cidr>().unwrap(),
-                "40::/10".parse::<Ipv6Cidr>().unwrap(),
-                "80::/9".parse::<Ipv6Cidr>().unwrap(),
-                "100::/8".parse::<Ipv6Cidr>().unwrap(),
-                "200::/7".parse::<Ipv6Cidr>().unwrap(),
-                "400::/6".parse::<Ipv6Cidr>().unwrap(),
-                "800::/5".parse::<Ipv6Cidr>().unwrap(),
-                "1000::/4".parse::<Ipv6Cidr>().unwrap(),
-                "2000::/3".parse::<Ipv6Cidr>().unwrap(),
-                "4000::/2".parse::<Ipv6Cidr>().unwrap(),
-                "8000::/1".parse::<Ipv6Cidr>().unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [0, 0, 0, 0, 0, 0, 0, 0],
-            [
-                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE,
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [
-                "::/1".parse::<Ipv6Cidr>().unwrap(),
-                "8000::/2".parse::<Ipv6Cidr>().unwrap(),
-                "c000::/3".parse::<Ipv6Cidr>().unwrap(),
-                "e000::/4".parse::<Ipv6Cidr>().unwrap(),
-                "f000::/5".parse::<Ipv6Cidr>().unwrap(),
-                "f800::/6".parse::<Ipv6Cidr>().unwrap(),
-                "fc00::/7".parse::<Ipv6Cidr>().unwrap(),
-                "fe00::/8".parse::<Ipv6Cidr>().unwrap(),
-                "ff00::/9".parse::<Ipv6Cidr>().unwrap(),
-                "ff80::/10".parse::<Ipv6Cidr>().unwrap(),
-                "ffc0::/11".parse::<Ipv6Cidr>().unwrap(),
-                "ffe0::/12".parse::<Ipv6Cidr>().unwrap(),
-                "fff0::/13".parse::<Ipv6Cidr>().unwrap(),
-                "fff8::/14".parse::<Ipv6Cidr>().unwrap(),
-                "fffc::/15".parse::<Ipv6Cidr>().unwrap(),
-                "fffe::/16".parse::<Ipv6Cidr>().unwrap(),
-                "ffff::/17".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:8000::/18".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:c000::/19".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:e000::/20".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:f000::/21".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:f800::/22".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fc00::/23".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fe00::/24".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ff00::/25".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ff80::/26".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffc0::/27".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffe0::/28".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fff0::/29".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fff8::/30".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fffc::/31".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:fffe::/32".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff::/33".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:8000::/34".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:c000::/35".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:e000::/36".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:f000::/37".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:f800::/38".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fc00::/39".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fe00::/40".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ff00::/41".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ff80::/42".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffc0::/43".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffe0::/44".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fff0::/45".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fff8::/46".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fffc::/47".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:fffe::/48".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff::/49".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:8000::/50".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:c000::/51".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:e000::/52".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:f000::/53".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:f800::/54".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fc00::/55".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fe00::/56".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ff00::/57".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ff80::/58".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffc0::/59".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffe0::/60".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fff0::/61".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fff8::/62".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fffc::/63".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:fffe::/64".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff::/65".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:8000::/66".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:c000::/67".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:e000::/68".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:f000::/69".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:f800::/70".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fc00::/71".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fe00::/72".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ff00::/73".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ff80::/74".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ffc0::/75".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ffe0::/76".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fff0::/77".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fff8::/78".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fffc::/79".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:fffe::/80".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ffff::/81".parse::<Ipv6Cidr>().unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:8000::/82"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:c000::/83"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:e000::/84"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:f000::/85"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:f800::/86"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fc00::/87"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fe00::/88"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ff00::/89"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ff80::/90"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffc0::/91"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffe0::/92"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fff0::/93"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fff8::/94"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fffc::/95"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:fffe::/96"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff::/97"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:8000:0/98"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:c000:0/99"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:e000:0/100"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:f000:0/101"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:f800:0/102"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fc00:0/103"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fe00:0/104"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0/105"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ff80:0/106"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffc0:0/107"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffe0:0/108"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fff0:0/109"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fff8:0/110"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fffc:0/111"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0/112"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0/113"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:8000/114"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:c000/115"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:e000/116"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:f000/117"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:f800/118"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00/119"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fe00/120"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00/121"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff80/122"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffc0/123"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffe0/124"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0/125"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff8/126"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc/127"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-                "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe/128"
-                    .parse::<Ipv6Cidr>()
-                    .unwrap(),
-            ],
-            range.to_cidrs().as_slice()
-        );
-
-        let range =
-            AddressRange::new_v6([0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]).unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new([0, 0, 0, 0, 0, 0, 0, 0], 128).unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-
-        let range = AddressRange::new_v6(
-            [
-                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-            ],
-            [
-                0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
-            ],
-        )
-        .unwrap();
-
-        assert_eq!(
-            [Ipv6Cidr::new(
-                [0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
-                128
-            )
-            .unwrap(),],
-            range.to_cidrs().as_slice()
-        );
-    }
 }
diff --git a/proxmox-ve-config/src/firewall/types/alias.rs b/proxmox-ve-config/src/firewall/types/alias.rs
index 7bc2fb8..a463e52 100644
--- a/proxmox-ve-config/src/firewall/types/alias.rs
+++ b/proxmox-ve-config/src/firewall/types/alias.rs
@@ -2,10 +2,10 @@ use std::fmt::Display;
 use std::str::FromStr;
 
 use anyhow::{bail, format_err, Error};
+use proxmox_network_types::ip_address::Cidr;
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 
 use crate::firewall::parse::{match_name, match_non_whitespace};
-use crate::firewall::types::address::Cidr;
 
 #[derive(Debug, Clone)]
 #[cfg_attr(test, derive(Eq, PartialEq))]
diff --git a/proxmox-ve-config/src/firewall/types/ipset.rs b/proxmox-ve-config/src/firewall/types/ipset.rs
index fe5a930..2aaf261 100644
--- a/proxmox-ve-config/src/firewall/types/ipset.rs
+++ b/proxmox-ve-config/src/firewall/types/ipset.rs
@@ -3,10 +3,10 @@ use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
 
 use anyhow::{bail, format_err, Error};
+use proxmox_network_types::ip_address::{Cidr, IpRange};
 use serde_with::DeserializeFromStr;
 
 use crate::firewall::parse::match_non_whitespace;
-use crate::firewall::types::address::{Cidr, IpRange};
 use crate::firewall::types::alias::AliasName;
 use crate::guest::vm::NetworkConfig;
 
@@ -112,9 +112,9 @@ impl FromStr for IpsetAddress {
     }
 }
 
-impl<T: Into<Cidr>> From<T> for IpsetAddress {
-    fn from(cidr: T) -> Self {
-        IpsetAddress::Cidr(cidr.into())
+impl From<Cidr> for IpsetAddress {
+    fn from(cidr: Cidr) -> Self {
+        IpsetAddress::Cidr(cidr)
     }
 }
 
diff --git a/proxmox-ve-config/src/firewall/types/mod.rs b/proxmox-ve-config/src/firewall/types/mod.rs
index 8fd551e..567b302 100644
--- a/proxmox-ve-config/src/firewall/types/mod.rs
+++ b/proxmox-ve-config/src/firewall/types/mod.rs
@@ -7,7 +7,6 @@ pub mod port;
 pub mod rule;
 pub mod rule_match;
 
-pub use address::Cidr;
 pub use alias::Alias;
 pub use group::Group;
 pub use ipset::Ipset;
diff --git a/proxmox-ve-config/src/firewall/types/rule.rs b/proxmox-ve-config/src/firewall/types/rule.rs
index 2c8f49c..b6b83d2 100644
--- a/proxmox-ve-config/src/firewall/types/rule.rs
+++ b/proxmox-ve-config/src/firewall/types/rule.rs
@@ -247,13 +247,14 @@ impl FromStr for RuleGroup {
 
 #[cfg(test)]
 mod tests {
+    use proxmox_network_types::ip_address::{Cidr, IpRange};
+
     use crate::firewall::types::{
-        address::{IpEntry, IpList, IpRange},
+        address::{IpEntry, IpList},
         alias::{AliasName, AliasScope},
         ipset::{IpsetName, IpsetScope},
         log::LogLevel,
         rule_match::{Icmp, IcmpCode, IpAddrMatch, IpMatch, Ports, Protocol, Udp},
-        Cidr,
     };
 
     use super::*;
diff --git a/proxmox-ve-config/src/firewall/types/rule_match.rs b/proxmox-ve-config/src/firewall/types/rule_match.rs
index 94d8624..3256497 100644
--- a/proxmox-ve-config/src/firewall/types/rule_match.rs
+++ b/proxmox-ve-config/src/firewall/types/rule_match.rs
@@ -7,10 +7,11 @@ use serde::Deserialize;
 use anyhow::{bail, format_err, Error};
 use serde::de::IntoDeserializer;
 
+use proxmox_network_types::ip_address::Family;
 use proxmox_sortable_macro::sortable;
 
 use crate::firewall::parse::{match_name, match_non_whitespace, SomeStr};
-use crate::firewall::types::address::{Family, IpList};
+use crate::firewall::types::address::IpList;
 use crate::firewall::types::alias::AliasName;
 use crate::firewall::types::ipset::IpsetName;
 use crate::firewall::types::log::LogLevel;
@@ -770,7 +771,8 @@ impl fmt::Display for Icmpv6Code {
 
 #[cfg(test)]
 mod tests {
-    use crate::firewall::types::{alias::AliasScope::Guest, Cidr};
+    use proxmox_network_types::ip_address::Cidr;
+    use crate::firewall::types::alias::AliasScope::Guest;
 
     use super::*;
 
diff --git a/proxmox-ve-config/src/guest/vm.rs b/proxmox-ve-config/src/guest/vm.rs
index d656a61..34b9075 100644
--- a/proxmox-ve-config/src/guest/vm.rs
+++ b/proxmox-ve-config/src/guest/vm.rs
@@ -1,82 +1,18 @@
-use core::fmt::Display;
+use std::collections::HashMap;
 use std::io;
 use std::str::FromStr;
-use std::{collections::HashMap, net::Ipv6Addr};
-
-use proxmox_schema::property_string::PropertyString;
-use proxmox_sortable_macro::sortable;
 
 use anyhow::{bail, Error};
-use proxmox_schema::{ApiType, BooleanSchema, KeyAliasInfo, ObjectSchema, StringSchema};
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 
-use crate::firewall::parse::match_digits;
-use crate::firewall::types::address::{Ipv4Cidr, Ipv6Cidr};
-
-#[derive(Clone, Copy, Debug, DeserializeFromStr, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct MacAddress([u8; 6]);
-
-static LOCAL_PART: [u8; 8] = [0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
-static EUI64_MIDDLE_PART: [u8; 2] = [0xFF, 0xFE];
-
-impl MacAddress {
-    pub fn new(address: [u8; 6]) -> Self {
-        Self(address)
-    }
-
-    /// generates a link local IPv6-address according to RFC 4291 (Appendix A)
-    pub fn eui64_link_local_address(&self) -> Ipv6Addr {
-        let head = &self.0[..3];
-        let tail = &self.0[3..];
-
-        let mut eui64_address: Vec<u8> = LOCAL_PART
-            .iter()
-            .chain(head.iter())
-            .chain(EUI64_MIDDLE_PART.iter())
-            .chain(tail.iter())
-            .copied()
-            .collect();
-
-        // we need to flip the 7th bit of the first eui64 byte
-        eui64_address[8] ^= 0x02;
-
-        Ipv6Addr::from(
-            TryInto::<[u8; 16]>::try_into(eui64_address).expect("is an u8 array with 16 entries"),
-        )
-    }
-}
-
-impl FromStr for MacAddress {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let split = s.split(':');
-
-        let parsed = split
-            .into_iter()
-            .map(|elem| u8::from_str_radix(elem, 16))
-            .collect::<Result<Vec<u8>, _>>()
-            .map_err(Error::msg)?;
-
-        if parsed.len() != 6 {
-            bail!("Invalid amount of elements in MAC address!");
-        }
-
-        let address = &parsed.as_slice()[0..6];
-        Ok(Self(address.try_into().unwrap()))
-    }
-}
+use proxmox_network_types::ip_address::{Ipv4Cidr, Ipv6Cidr};
+use proxmox_network_types::mac_address::MacAddress;
+use proxmox_schema::property_string::PropertyString;
+use proxmox_schema::{ApiType, BooleanSchema, KeyAliasInfo, ObjectSchema, StringSchema};
+use proxmox_sortable_macro::sortable;
 
-impl Display for MacAddress {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{:<02X}:{:<02X}:{:<02X}:{:<02X}:{:<02X}:{:<02X}",
-            self.0[0], self.0[1], self.0[2], self.0[3], self.0[4], self.0[5]
-        )
-    }
-}
+use crate::firewall::parse::match_digits;
 
 /// All possible models of network devices for both QEMU and LXC guests.
 #[derive(Debug, Clone, Copy, DeserializeFromStr)]
@@ -410,6 +346,8 @@ impl NetworkConfig {
 
 #[cfg(test)]
 mod tests {
+    use std::net::Ipv6Addr;
+
     use super::*;
 
     #[test]
@@ -458,7 +396,7 @@ mod tests {
             network_device,
             NetworkDevice::Qemu(QemuNetworkDevice {
                 model: NetworkDeviceModel::VirtIO,
-                mac_address: MacAddress([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
+                mac_address: MacAddress::new([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
                 firewall: Some(true),
             })
         );
@@ -471,7 +409,7 @@ mod tests {
             network_device,
             NetworkDevice::Qemu(QemuNetworkDevice {
                 model: NetworkDeviceModel::VirtIO,
-                mac_address: MacAddress([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
+                mac_address: MacAddress::new([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
                 firewall: None,
             })
         );
@@ -486,7 +424,7 @@ mod tests {
             network_device,
             NetworkDevice::Qemu(QemuNetworkDevice {
                 model: NetworkDeviceModel::VirtIO,
-                mac_address: MacAddress([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
+                mac_address: MacAddress::new([0xAA, 0xAA, 0xAA, 0x17, 0x19, 0x81]),
                 firewall: Some(true),
             })
         );
@@ -502,7 +440,7 @@ mod tests {
             network_device,
             NetworkDevice::Lxc(LxcNetworkDevice {
                 ty: NetworkDeviceModel::Veth,
-                mac_address: MacAddress([0xAA, 0xAA, 0xAA, 0xE2, 0x3E, 0x24]),
+                mac_address: MacAddress::new([0xAA, 0xAA, 0xAA, 0xE2, 0x3E, 0x24]),
                 firewall: Some(false),
                 ip: Some(LxcIpv4Addr::Dhcp),
                 ip6: None,
@@ -592,7 +530,7 @@ vmgenid: 706fbe99-d28b-4047-a9cd-3677c859ca8a"
             network_config.network_devices()[&0],
             NetworkDevice::Qemu(QemuNetworkDevice {
                 model: NetworkDeviceModel::VirtIO,
-                mac_address: MacAddress([0xAA, 0xBB, 0xCC, 0xF2, 0xFE, 0x75]),
+                mac_address: MacAddress::new([0xAA, 0xBB, 0xCC, 0xF2, 0xFE, 0x75]),
                 firewall: None,
             })
         );
@@ -620,7 +558,7 @@ unprivileged: 1"
             network_config.network_devices()[&0],
             NetworkDevice::Lxc(LxcNetworkDevice {
                 ty: NetworkDeviceModel::Veth,
-                mac_address: MacAddress([0xBC, 0x24, 0x11, 0x47, 0x83, 0x11]),
+                mac_address: MacAddress::new([0xBC, 0x24, 0x11, 0x47, 0x83, 0x11]),
                 firewall: Some(true),
                 ip: Some(LxcIpv4Addr::Dhcp),
                 ip6: Some(LxcIpv6Addr::Auto),
@@ -631,7 +569,7 @@ unprivileged: 1"
             network_config.network_devices()[&2],
             NetworkDevice::Lxc(LxcNetworkDevice {
                 ty: NetworkDeviceModel::Veth,
-                mac_address: MacAddress([0xBC, 0x24, 0x11, 0x47, 0x83, 0x12]),
+                mac_address: MacAddress::new([0xBC, 0x24, 0x11, 0x47, 0x83, 0x12]),
                 firewall: Some(false),
                 ip: Some(LxcIpv4Addr::Ip(
                     Ipv4Cidr::from_str("123.123.123.123/24").expect("valid ipv4")
@@ -644,7 +582,7 @@ unprivileged: 1"
             network_config.network_devices()[&5],
             NetworkDevice::Lxc(LxcNetworkDevice {
                 ty: NetworkDeviceModel::Veth,
-                mac_address: MacAddress([0xBC, 0x24, 0x11, 0x47, 0x83, 0x13]),
+                mac_address: MacAddress::new([0xBC, 0x24, 0x11, 0x47, 0x83, 0x13]),
                 firewall: Some(true),
                 ip: None,
                 ip6: Some(LxcIpv6Addr::Ip(
diff --git a/proxmox-ve-config/src/host/utils.rs b/proxmox-ve-config/src/host/utils.rs
index b1dc8e9..3dee72b 100644
--- a/proxmox-ve-config/src/host/utils.rs
+++ b/proxmox-ve-config/src/host/utils.rs
@@ -1,6 +1,6 @@
 use std::net::{IpAddr, ToSocketAddrs};
 
-use crate::firewall::types::Cidr;
+use proxmox_network_types::ip_address::Cidr;
 
 use nix::sys::socket::{AddressFamily, SockaddrLike};
 use proxmox_sys::nodename;
diff --git a/proxmox-ve-config/src/sdn/config.rs b/proxmox-ve-config/src/sdn/config.rs
index 880efc2..898121c 100644
--- a/proxmox-ve-config/src/sdn/config.rs
+++ b/proxmox-ve-config/src/sdn/config.rs
@@ -6,17 +6,16 @@ use std::{
     str::FromStr,
 };
 
+use proxmox_network_types::ip_address::{Cidr, IpRange, IpRangeError};
 use proxmox_schema::{property_string::PropertyString, ApiType, ObjectSchema, StringSchema};
-
 use serde::Deserialize;
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 
 use crate::{
     common::Allowlist,
     firewall::types::{
-        address::{IpRange, IpRangeError},
         ipset::{IpsetEntry, IpsetName, IpsetScope},
-        Cidr, Ipset,
+        Ipset,
     },
     sdn::{SdnNameError, SubnetName, VnetName, ZoneName},
 };
@@ -587,10 +586,10 @@ impl SdnConfig {
                     ipset_all_wo_gateway.push((*subnet.cidr()).into());
 
                     if let Some(gateway) = subnet.gateway {
-                        let gateway_nomatch = IpsetEntry::new(gateway, true, None);
+                        let gateway_nomatch = IpsetEntry::new(Cidr::from(gateway), true, None);
                         ipset_all_wo_gateway.push(gateway_nomatch);
 
-                        ipset_gateway.push(gateway.into());
+                        ipset_gateway.push(Cidr::from(gateway).into());
                     }
 
                     ipset_dhcp.extend(subnet.dhcp_range.iter().cloned().map(IpsetEntry::from));
diff --git a/proxmox-ve-config/src/sdn/ipam.rs b/proxmox-ve-config/src/sdn/ipam.rs
index 598b835..9c6985b 100644
--- a/proxmox-ve-config/src/sdn/ipam.rs
+++ b/proxmox-ve-config/src/sdn/ipam.rs
@@ -7,13 +7,16 @@ use std::{
 
 use serde::Deserialize;
 
+use proxmox_network_types::ip_address::Cidr;
+use proxmox_network_types::mac_address::MacAddress;
+
 use crate::{
     common::Allowlist,
     firewall::types::{
-        ipset::{IpsetEntry, IpsetScope},
-        Cidr, Ipset,
+        ipset::IpsetScope,
+        Ipset,
     },
-    guest::{types::Vmid, vm::MacAddress},
+    guest::types::Vmid,
     sdn::{SdnNameError, SubnetName, ZoneName},
 };
 
@@ -339,7 +342,7 @@ impl Ipam {
                     .or_insert_with(|| {
                         Ipset::from_parts(IpsetScope::Sdn, format!("guest-ipam-{}", entry.vmid))
                     })
-                    .push(IpsetEntry::from(entry.ip));
+                    .push(Cidr::from(entry.ip).into());
 
                 acc
             })
diff --git a/proxmox-ve-config/src/sdn/mod.rs b/proxmox-ve-config/src/sdn/mod.rs
index c8dc724..cde6fed 100644
--- a/proxmox-ve-config/src/sdn/mod.rs
+++ b/proxmox-ve-config/src/sdn/mod.rs
@@ -3,10 +3,9 @@ pub mod ipam;
 
 use std::{error::Error, fmt::Display, str::FromStr};
 
+use proxmox_network_types::ip_address::Cidr;
 use serde_with::DeserializeFromStr;
 
-use crate::firewall::types::Cidr;
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum SdnNameError {
     Empty,
diff --git a/proxmox-ve-config/tests/sdn/main.rs b/proxmox-ve-config/tests/sdn/main.rs
index 1815bec..2ab0e5c 100644
--- a/proxmox-ve-config/tests/sdn/main.rs
+++ b/proxmox-ve-config/tests/sdn/main.rs
@@ -3,18 +3,17 @@ use std::{
     str::FromStr,
 };
 
-use proxmox_ve_config::{
-    firewall::types::{address::IpRange, Cidr},
-    guest::vm::MacAddress,
-    sdn::{
+use proxmox_network_types::ip_address::{Cidr, IpRange};
+use proxmox_network_types::mac_address::MacAddress;
+
+use proxmox_ve_config::sdn::{
         config::{
             RunningConfig, SdnConfig, SdnConfigError, SubnetConfig, VnetConfig, ZoneConfig,
             ZoneType,
         },
         ipam::{Ipam, IpamDataVm, IpamEntry, IpamJson},
         SubnetName, VnetName, ZoneName,
-    },
-};
+    };
 
 #[test]
 fn parse_running_config() {
-- 
2.39.5


_______________________________________________
pve-devel mailing list
pve-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel


  parent reply	other threads:[~2025-05-22 16:22 UTC|newest]

Thread overview: 79+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2025-05-22 16:16 [pve-devel] [PATCH access-control/cluster/docs/gui-tests/manager/network/proxmox{, -firewall, -ve-rs, -perl-rs, -widget-toolkit} v3 00/75] Add SDN Fabrics Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox v3 1/4] network-types: initial commit Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox v3 2/4] network-types: make cidr and mac-address types usable by the api Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox v3 3/4] network-types: add api types for ipv4/6 Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox v3 4/4] api-macro: add allof schema to enum Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-firewall v3 1/1] firewall: nftables: migrate to proxmox-network-types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 01/21] config: use proxmox_serde perl helpers Stefan Hanreich
2025-05-22 16:16 ` Stefan Hanreich [this message]
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 03/21] sdn-types: initial commit Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 04/21] frr: create proxmox-frr crate Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 05/21] frr: add common frr types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 06/21] frr: add openfabric types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 07/21] frr: add ospf types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 08/21] frr: add route-map types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 09/21] frr: add generic types over openfabric and ospf Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 10/21] config: sdn: fabrics: add section types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 11/21] config: sdn: fabrics: add node " Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 12/21] config: sdn: fabrics: add interface name struct Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 13/21] config: sdn: fabrics: add openfabric properties Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 14/21] config: sdn: fabrics: add ospf properties Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 15/21] config: sdn: fabrics: add api types Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 16/21] config: sdn: fabrics: add section config Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 17/21] config: sdn: fabrics: add fabric config Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 18/21] common: sdn: fabrics: implement validation Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 19/21] sdn: fabrics: config: add conversion from / to section config Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 20/21] sdn: fabrics: implement FRR configuration generation Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-ve-rs v3 21/21] ve-config: add integrations tests Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-perl-rs v3 1/5] pve-rs: Add PVE::RS::SDN::Fabrics module Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-perl-rs v3 2/5] pve-rs: sdn: fabrics: add api methods Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-perl-rs v3 3/5] pve-rs: sdn: fabrics: add frr config generation Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-perl-rs v3 4/5] pve-rs: sdn: fabrics: add helper to generate ifupdown2 configuration Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH proxmox-perl-rs v3 5/5] pve-rs: sdn: fabrics: add helper for network API endpoint Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-cluster v3 1/1] cfs: add fabrics.cfg to observed files Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-access-control v3 1/1] permissions: add ACL paths for SDN fabrics Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 01/21] sdn: fix value returned by pending_config Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 02/21] debian: add dependency to proxmox-perl-rs Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 03/21] fabrics: add fabrics module Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 04/21] refactor: controller: move frr methods into helper Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 05/21] frr: add new helpers for reloading frr configuration Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 06/21] controllers: define new api for frr config generation Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 07/21] sdn: add frr config generation helpers Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 08/21] sdn: api: add check for rewriting frr configuration Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 09/21] test: isis: add test for standalone configuration Stefan Hanreich
2025-05-22 16:16 ` [pve-devel] [PATCH pve-network v3 10/21] sdn: frr: add daemon status to frr helper Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 11/21] sdn: commit fabrics config to running configuration Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 12/21] fabrics: generate ifupdown configuration Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 13/21] fabrics: add jsonschema for fabrics and nodes Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 14/21] api: fabrics: add root-level module Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 15/21] api: fabrics: add fabric submodule Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 16/21] api: fabrics: add node submodule Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 17/21] api: fabrics: add fabricnode submodule Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 18/21] controller: evpn: add fabrics integration Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 19/21] zone: vxlan: " Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 20/21] test: fabrics: add test cases for ospf and openfabric + evpn Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-network v3 21/21] frr: bump frr config version to 10.2.2 Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH proxmox-widget-toolkit v3 1/1] network selector: add type parameter Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 01/18] api: use new sdn config generation functions Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 02/18] ui: fabrics: add model definitions for fabrics Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 03/18] fabric: add common interface panel Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 04/18] fabric: add OpenFabric interface properties Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 05/18] fabric: add OSPF " Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 06/18] fabric: add generic node edit panel Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 07/18] fabric: add OpenFabric node edit Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 08/18] fabric: add OSPF " Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 09/18] fabric: add generic fabric edit panel Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 10/18] fabric: add OpenFabric " Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 11/18] fabric: add OSPF " Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 12/18] fabrics: Add main FabricView Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 13/18] utils: avoid line-break in pending changes message Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 14/18] ui: permissions: add ACL path for fabrics Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 15/18] api: network: add include_sdn / fabric type Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 16/18] ui: add sdn networks to ceph / migration Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 17/18] ui: sdn: add evpn controller fabric integration Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-manager v3 18/18] ui: sdn: vxlan: add fabric property Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-gui-tests v3 1/1] pve: add sdn/fabrics screenshots Stefan Hanreich
2025-05-22 16:17 ` [pve-devel] [PATCH pve-docs v3 1/1] fabrics: add initial documentation for sdn fabrics Stefan Hanreich
2025-06-12 15:01 ` [pve-devel] [PATCH access-control/cluster/docs/gui-tests/manager/network/proxmox{, -firewall, -ve-rs, -perl-rs, -widget-toolkit} v3 00/75] Add SDN Fabrics Hannes Duerr
2025-06-26  7:04   ` Gabriel Goller
2025-06-26  8:02     ` Stefan Hanreich

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20250522161731.537011-8-s.hanreich@proxmox.com \
    --to=s.hanreich@proxmox.com \
    --cc=pve-devel@lists.proxmox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal