Remove ipnetwork from the public API

examples/add_rules.rs

@@ -6,7 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use pfctl::{ipnetwork, FilterRuleBuilder, PfCtl, RedirectRuleBuilder, ScrubRuleBuilder};
+use pfctl::{FilterRuleBuilder, IpNetwork, PfCtl, RedirectRuleBuilder, ScrubRuleBuilder};
 use std::net::Ipv4Addr;
 
 static ANCHOR_NAME: &str = "test.anchor";
@@ -67,10 +67,10 @@ fn main() {
         .unwrap();
 
     // Block packets from the entire 10.0.0.0/8 private network.
-    let private_net = ipnetwork::Ipv4Network::new(Ipv4Addr::new(10, 0, 0, 0), 8).unwrap();
+    let private_net = IpNetwork::new(Ipv4Addr::new(10, 0, 0, 0), 8);
     let block_a_private_net_rule = FilterRuleBuilder::default()
         .action(pfctl::FilterRuleAction::Drop(pfctl::DropAction::Drop))
-        .from(pfctl::Ip::from(ipnetwork::IpNetwork::V4(private_net)))
+        .from(pfctl::Ip::from(private_net))
         .build()
         .unwrap();
 

src/lib.rs

@@ -68,8 +68,6 @@ use std::{
     slice,
 };
 
-pub use ipnetwork;
-
 mod ffi;
 
 #[macro_use]

src/rule/ip.rs

@@ -12,7 +12,6 @@ use crate::{
     pooladdr::{PoolAddr, PoolAddrList},
     AddrFamily, Result,
 };
-use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
@@ -26,14 +25,13 @@ impl Ip {
     pub fn get_af(&self) -> AddrFamily {
         match *self {
             Ip::Any => AddrFamily::Any,
-            Ip::Net(IpNetwork::V4(_)) => AddrFamily::Ipv4,
-            Ip::Net(IpNetwork::V6(_)) => AddrFamily::Ipv6,
+            Ip::Net(network) => network.get_af(),
         }
     }
 
     /// Returns `Ip::Any` represented an as an `IpNetwork`, used for ffi.
     fn any_ffi_repr() -> IpNetwork {
-        IpNetwork::V6(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 0).unwrap())
+        IpNetwork::new(Ipv6Addr::UNSPECIFIED, 0)
     }
 
     /// Returns PoolAddrList initialized with receiver
@@ -42,6 +40,53 @@ impl Ip {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct IpNetwork(ipnetwork::IpNetwork);
+
+impl IpNetwork {
+    pub fn new(ip: impl Into<IpAddr>, prefix: u8) -> IpNetwork {
+        Self::new_checked(ip.into(), prefix).unwrap()
+    }
+
+    pub const fn new_checked(ip: IpAddr, prefix: u8) -> Option<IpNetwork> {
+        match ip {
+            IpAddr::V4(ipv4_addr) => Self::v4(ipv4_addr, prefix),
+            IpAddr::V6(ipv6_addr) => Self::v6(ipv6_addr, prefix),
+        }
+    }
+
+    /// Create an IPv4 network.
+    pub const fn v4(ip: Ipv4Addr, prefix: u8) -> Option<IpNetwork> {
+        let Some(network) = ipnetwork::Ipv4Network::new_checked(ip, prefix) else {
+            return None;
+        };
+        Some(IpNetwork(ipnetwork::IpNetwork::V4(network)))
+    }
+
+    /// Create an IPv6 network.
+    pub const fn v6(ip: Ipv6Addr, prefix: u8) -> Option<IpNetwork> {
+        let Some(network) = ipnetwork::Ipv6Network::new_checked(ip, prefix) else {
+            return None;
+        };
+        Some(IpNetwork(ipnetwork::IpNetwork::V6(network)))
+    }
+
+    pub fn ip(&self) -> IpAddr {
+        self.0.ip()
+    }
+
+    pub fn mask(&self) -> IpAddr {
+        self.0.mask()
+    }
+
+    const fn get_af(&self) -> AddrFamily {
+        match self.0 {
+            ipnetwork::IpNetwork::V4(_) => AddrFamily::Ipv4,
+            ipnetwork::IpNetwork::V6(_) => AddrFamily::Ipv6,
+        }
+    }
+}
+
 impl From<IpNetwork> for Ip {
     fn from(net: IpNetwork) -> Self {
         Ip::Net(net)
@@ -50,13 +95,13 @@ impl From<IpNetwork> for Ip {
 
 impl From<Ipv4Addr> for Ip {
     fn from(ip: Ipv4Addr) -> Self {
-        Ip::Net(IpNetwork::V4(Ipv4Network::new(ip, 32).unwrap()))
+        Ip::from(IpNetwork::v4(ip, 32).unwrap())
     }
 }
 
 impl From<Ipv6Addr> for Ip {
     fn from(ip: Ipv6Addr) -> Self {
-        Ip::Net(IpNetwork::V6(Ipv6Network::new(ip, 128).unwrap()))
+        Ip::from(IpNetwork::v6(ip, 128).unwrap())
     }
 }
 

src/rule/mod.rs

@@ -10,7 +10,6 @@ use crate::{
     conversion::{CopyTo, TryCopyTo},
     ffi, Error, ErrorInternal, Result,
 };
-use ipnetwork::IpNetwork;
 use std::{
     net::{IpAddr, Ipv4Addr, Ipv6Addr},
     ops::Deref,