Add Ipv{4,6}AddrMask

Author: CDirkx

Diff for: library/std/src/net/ip/mask.rs

@@ -0,0 +1,140 @@
+#![allow(missing_docs)]
+#![unstable(feature = "ip_mask", issue = "none")]
+
+use super::{Ipv4Addr, Ipv6Addr};
+use crate::fmt;
+use crate::ops;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Ipv4AddrMask {
+    mask: u32,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Ipv6AddrMask {
+    mask: u128,
+}
+
+impl Ipv4AddrMask {
+    pub const fn from_address(address: Ipv4Addr) -> Ipv4AddrMask {
+        Ipv4AddrMask { mask: u32::from_be_bytes(address.octets()) }
+    }
+
+    // 8 -> `255.0.0.0`
+    pub const fn from_prefix(len: u32) -> Ipv4AddrMask {
+        let mask = {
+            if len == 0 {
+                0
+            } else {
+                // shift will not overflow as len > 0, so u32::BITS - len < 32
+                u32::MAX << (u32::BITS - len)
+            }
+        };
+
+        Ipv4AddrMask { mask }
+    }
+
+    // 8 -> `0.0.0.255`
+    pub const fn from_suffix(len: u32) -> Ipv4AddrMask {
+        Ipv4AddrMask::from_prefix(len).invert()
+    }
+
+    // `1.2.3.4` + `255.255.255.0` -> `1.2.3.0`
+    pub const fn apply(&self, address: &Ipv4Addr) -> Ipv4Addr {
+        let masked = u32::from_be_bytes(address.octets()) & self.mask;
+        Ipv4Addr::from_u32(masked)
+    }
+
+    // `255.255.255.0` -> `0.0.0.255`
+    pub const fn invert(self) -> Ipv4AddrMask {
+        Ipv4AddrMask { mask: !self.mask }
+    }
+}
+
+impl fmt::Display for Ipv4AddrMask {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "{}", Ipv4Addr::from_u32(self.mask))
+    }
+}
+
+impl fmt::Debug for Ipv4AddrMask {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+
+impl ops::Not for Ipv4AddrMask {
+    type Output = Ipv4AddrMask;
+
+    fn not(self) -> Ipv4AddrMask {
+        self.invert()
+    }
+}
+
+impl From<Ipv4Addr> for Ipv4AddrMask {
+    fn from(address: Ipv4Addr) -> Self {
+        Ipv4AddrMask::from_address(address)
+    }
+}
+
+impl Ipv6AddrMask {
+    pub const fn from_address(address: Ipv6Addr) -> Ipv6AddrMask {
+        Ipv6AddrMask { mask: u128::from_be_bytes(address.octets()) }
+    }
+
+    // 32 -> `ffff:ffff::`
+    pub const fn from_prefix(len: u32) -> Ipv6AddrMask {
+        let mask = {
+            if len == 0 {
+                0
+            } else {
+                // shift will not overflow as len > 0, so u128::BITS - len < 128
+                u128::MAX << (u128::BITS - len)
+            }
+        };
+
+        Ipv6AddrMask { mask }
+    }
+
+    // 32 -> `0:0:ffff:ffff::ffff:ffff:ffff:fff`
+    pub const fn from_suffix(len: u32) -> Ipv6AddrMask {
+        Ipv6AddrMask::from_prefix(len).invert()
+    }
+
+    // `1:2:3:4:5:6:7:8` + `ffff:ffff::` -> `1:2::`
+    pub const fn apply(&self, address: &Ipv6Addr) -> Ipv6Addr {
+        let masked = u128::from_be_bytes(address.octets()) & self.mask;
+        Ipv6Addr::from_u128(masked)
+    }
+
+    // `ffff:ffff::` -> `0:0:ffff:ffff::ffff:ffff:ffff:fff`
+    pub const fn invert(self) -> Ipv6AddrMask {
+        Ipv6AddrMask { mask: !self.mask }
+    }
+}
+
+impl fmt::Display for Ipv6AddrMask {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "{}", Ipv6Addr::from_u128(self.mask))
+    }
+}
+
+impl fmt::Debug for Ipv6AddrMask {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+
+impl ops::Not for Ipv6AddrMask {
+    type Output = Ipv6AddrMask;
+
+    fn not(self) -> Ipv6AddrMask {
+        self.invert()
+    }
+}
+
+impl From<Ipv6Addr> for Ipv6AddrMask {
+    fn from(address: Ipv6Addr) -> Self {
+        Ipv6AddrMask::from_address(address)
+    }
+}

Diff for: library/std/src/net/ip/mod.rs

@@ -13,6 +13,9 @@ mod tests;
 mod network;
 pub use self::network::{Ipv4AddrPrefix, Ipv6AddrPrefix};
 
+mod mask;
+pub use self::mask::{Ipv4AddrMask, Ipv6AddrMask};
+
 /// An IP address, either IPv4 or IPv6.
 ///
 /// This enum can contain either an [`Ipv4Addr`] or an [`Ipv6Addr`], see their
@@ -767,6 +770,13 @@ impl Ipv4Addr {
         }
     }
 
+    // `1.2.3.4` + `255.255.255.0` -> `1.2.3.0`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn mask(&self, mask: Ipv4AddrMask) -> Ipv4Addr {
+        mask.apply(self)
+    }
+
     /// Converts this address to an IPv4-compatible [`IPv6` address].
     ///
     /// `a.b.c.d` becomes `::a.b.c.d`
@@ -1484,6 +1494,13 @@ impl Ipv6Addr {
         (self.segments()[0] & 0xff00) == 0xff00
     }
 
+    // `1:2:3:4:5:6:7:8` + `ffff:ffff::` -> `1:2::`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn mask(&self, mask: Ipv6AddrMask) -> Ipv6Addr {
+        mask.apply(self)
+    }
+
     /// Converts this address to an [`IPv4` address] if it's an "IPv4-mapped IPv6 address"
     /// defined in [IETF RFC 4291 section 2.5.5.2], otherwise returns [`None`].
     ///

Diff for: library/std/src/net/ip/network.rs

@@ -1,4 +1,4 @@
-use super::{Ipv4Addr, Ipv6Addr};
+use super::{Ipv4Addr, Ipv4AddrMask, Ipv6Addr, Ipv6AddrMask};
 use crate::error::Error;
 use crate::fmt;
 
@@ -121,13 +121,12 @@ impl Ipv4AddrPrefix {
 
     // Private constructor that assumes len <= 32.
     // Useful because `Result::unwrap` is not yet usable in const contexts, so `new` can't be used.
+    #[unstable(feature = "ip_prefix", issue = "86991")]
     pub(crate) const fn new_unchecked(address: Ipv4Addr, len: u32) -> Ipv4AddrPrefix {
-        let masked = {
-            let mask = Ipv4AddrPrefix::mask(len);
-            u32::from_be_bytes(address.octets()) & mask
-        };
+        let mask = Ipv4AddrMask::from_prefix(len);
+        let masked = address.mask(mask);
 
-        Ipv4AddrPrefix { address_raw: masked, len: len as u8 }
+        Ipv4AddrPrefix { address_raw: u32::from_be_bytes(masked.octets()), len: len as u8 }
     }
 
     /// Returns the address specifying this address prefix.
@@ -176,15 +175,18 @@ impl Ipv4AddrPrefix {
         self.len as u32
     }
 
-    // Compute the bitmask specified by a prefix length.
-    #[inline]
-    const fn mask(len: u32) -> u32 {
-        if len == 0 {
-            0
-        } else {
-            // shift will not overflow as len > 0, so u32::BITS - len < 32
-            u32::MAX << (u32::BITS - len)
-        }
+    // `192.0.2.0/24` -> `255.255.255.0`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn prefix_mask(&self) -> Ipv4AddrMask {
+        Ipv4AddrMask::from_prefix(self.len as u32)
+    }
+
+    // `192.0.2.0/24` -> `0.0.0.255`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn suffix_mask(&self) -> Ipv4AddrMask {
+        Ipv4AddrMask::from_suffix(self.len as u32)
     }
 
     /// Returns `true` if the given address is contained in the network described by this prefix,
@@ -205,8 +207,10 @@ impl Ipv4AddrPrefix {
     #[unstable(feature = "ip_prefix", issue = "86991")]
     #[inline]
     pub const fn contains(&self, address: &Ipv4Addr) -> bool {
-        let mask = Ipv4AddrPrefix::mask(self.len as u32);
-        u32::from_be_bytes(address.octets()) & mask == self.address_raw
+        let mask = self.prefix_mask();
+        let masked = address.mask(mask);
+
+        u32::from_be_bytes(masked.octets()) == self.address_raw
     }
 }
 
@@ -259,13 +263,12 @@ impl Ipv6AddrPrefix {
 
     // Private constructor that assumes len <= 128.
     // Useful because `Result::unwrap` is not yet usable in const contexts, so `new` can't be used.
+    #[unstable(feature = "ip_prefix", issue = "86991")]
     pub(crate) const fn new_unchecked(address: Ipv6Addr, len: u32) -> Ipv6AddrPrefix {
-        let masked = {
-            let mask = Ipv6AddrPrefix::mask(len);
-            u128::from_be_bytes(address.octets()) & mask
-        };
+        let mask = Ipv6AddrMask::from_prefix(len);
+        let masked = address.mask(mask);
 
-        Ipv6AddrPrefix { address_raw: masked, len: len as u8 }
+        Ipv6AddrPrefix { address_raw: u128::from_be_bytes(masked.octets()), len: len as u8 }
     }
 
     /// Returns the address specifying this address prefix.
@@ -313,14 +316,18 @@ impl Ipv6AddrPrefix {
         self.len as u32
     }
 
-    // Compute the bitmask specified by a prefix length.
-    const fn mask(len: u32) -> u128 {
-        if len == 0 {
-            0
-        } else {
-            // shift will not overflow as len > 0, so u128::BITS - len < 128
-            u128::MAX << (u128::BITS - len)
-        }
+    // `2001:db8::/32` -> `ffff:ffff::`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn prefix_mask(&self) -> Ipv6AddrMask {
+        Ipv6AddrMask::from_prefix(self.len as u32)
+    }
+
+    // `2001:db8::/32` -> `0:0:ffff:ffff::ffff:ffff:ffff:ffff`
+    #[allow(missing_docs)]
+    #[unstable(feature = "ip_mask", issue = "none")]
+    pub const fn suffix_mask(&self) -> Ipv6AddrMask {
+        Ipv6AddrMask::from_suffix(self.len as u32)
     }
 
     /// Returns `true` if the given address is contained in the network described by this prefix,
@@ -341,8 +348,10 @@ impl Ipv6AddrPrefix {
     #[unstable(feature = "ip_prefix", issue = "86991")]
     #[inline]
     pub const fn contains(&self, address: &Ipv6Addr) -> bool {
-        let mask = Ipv6AddrPrefix::mask(self.len as u32);
-        u128::from_be_bytes(address.octets()) & mask == self.address_raw
+        let mask = self.prefix_mask();
+        let masked = address.mask(mask);
+
+        u128::from_be_bytes(masked.octets()) == self.address_raw
     }
 }
 

Diff for: library/std/src/net/mod.rs

@@ -23,7 +23,8 @@ use crate::io::{self, Error, ErrorKind};
 pub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::ip::{
-    IpAddr, Ipv4Addr, Ipv4AddrPrefix, Ipv6Addr, Ipv6AddrPrefix, Ipv6MulticastScope,
+    IpAddr, Ipv4Addr, Ipv4AddrMask, Ipv4AddrPrefix, Ipv6Addr, Ipv6AddrMask, Ipv6AddrPrefix,
+    Ipv6MulticastScope,
 };
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::parser::AddrParseError;