Add FromStr implementation to Ipv{v,6}AddrPrefix

Author: CDirkx

library/std/src/net/ip/tests.rs

@@ -108,6 +108,68 @@ fn test_from_str_socket_addr() {
     assert_eq!(None, none);
 }
 
+#[test]
+fn test_from_str_ipv4_prefix() {
+    assert_eq!(
+        Ok(Ipv4AddrPrefix::new_unchecked(Ipv4Addr::new(127, 0, 0, 1), 16)),
+        "127.0.0.1/16".parse()
+    );
+    assert_eq!(
+        Ok(Ipv4AddrPrefix::new_unchecked(Ipv4Addr::new(255, 255, 255, 255), 32)),
+        "255.255.255.255/32".parse()
+    );
+    assert_eq!(
+        Ok(Ipv4AddrPrefix::new_unchecked(Ipv4Addr::new(0, 0, 0, 0), 0)),
+        "0.0.0.0/0".parse()
+    );
+
+    // no prefix
+    let none: Option<Ipv4AddrPrefix> = "255.0.0.1".parse().ok();
+    assert_eq!(None, none);
+    // wrong prefix separator
+    let none: Option<Ipv4AddrPrefix> = "255.0.0.1:16".parse().ok();
+    assert_eq!(None, none);
+    // prefix can not be longer than 32 bits
+    let none: Option<Ipv4AddrPrefix> = "255.0.0.1/35".parse().ok();
+    assert_eq!(None, none);
+}
+
+#[test]
+fn test_from_str_ipv6_prefix() {
+    assert_eq!(
+        Ok(Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 0)),
+        "0:0:0:0:0:0:0:0/0".parse()
+    );
+    assert_eq!(
+        Ok(Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 128)),
+        "0:0:0:0:0:0:0:1/128".parse()
+    );
+
+    assert_eq!(
+        Ok(Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 128)),
+        "::1/128".parse()
+    );
+    assert_eq!(
+        Ok(Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 0)),
+        "::/0".parse()
+    );
+
+    assert_eq!(
+        Ok(Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0x2a02, 0x6b8, 0, 0, 0, 0, 0x11, 0x11), 32)),
+        "2a02:6b8::11:11/32".parse()
+    );
+
+    // no prefix
+    let none: Option<Ipv6AddrPrefix> = "1:2:3:4::5:6:7:8".parse().ok();
+    assert_eq!(None, none);
+    // wrong prefix separator
+    let none: Option<Ipv6AddrPrefix> = "1:2:3:4::5:6:7:8:16".parse().ok();
+    assert_eq!(None, none);
+    // prefix can not be longer than 128 bits
+    let none: Option<Ipv6AddrPrefix> = "1:2:3:4::5:6:7:8/130".parse().ok();
+    assert_eq!(None, none);
+}
+
 #[test]
 fn ipv4_addr_to_string() {
     assert_eq!(Ipv4Addr::new(127, 0, 0, 1).to_string(), "127.0.0.1");
@@ -171,6 +233,19 @@ fn ipv6_addr_to_string() {
     assert_eq!("1::4:5:0:0:8", &format!("{:#?}", Ipv6Addr::new(1, 0, 0, 4, 5, 0, 0, 8)));
 }
 
+#[test]
+fn ip_prefix_to_string() {
+    assert_eq!(
+        Ipv4AddrPrefix::new_unchecked(Ipv4Addr::new(127, 0, 0, 1), 24).to_string(),
+        "127.0.0.0/24"
+    );
+    assert_eq!(
+        Ipv6AddrPrefix::new_unchecked(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7F00, 1), 96)
+            .to_string(),
+        "::ffff:0.0.0.0/96"
+    );
+}
+
 #[test]
 fn ipv4_to_ipv6() {
     assert_eq!(

library/std/src/net/parser.rs

@@ -9,7 +9,10 @@ mod tests;
 use crate::convert::TryInto as _;
 use crate::error::Error;
 use crate::fmt;
-use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+use crate::net::{
+    IpAddr, Ipv4Addr, Ipv4AddrPrefix, Ipv6Addr, Ipv6AddrPrefix, SocketAddr, SocketAddrV4,
+    SocketAddrV6,
+};
 use crate::str::FromStr;
 
 trait ReadNumberHelper: crate::marker::Sized {
@@ -231,6 +234,16 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Read a `/` followed by a prefix length in base 10.
+    fn read_prefix(&mut self, max: u32) -> Option<u32> {
+        self.read_atomically(|p| {
+            p.read_given_char('/')?;
+            let len = p.read_number(10, None)?;
+
+            if len <= max { Some(len) } else { None }
+        })
+    }
+
     /// Read a `%` followed by a scope ID in base 10.
     fn read_scope_id(&mut self) -> Option<u32> {
         self.read_atomically(|p| {
@@ -267,6 +280,24 @@ impl<'a> Parser<'a> {
             .map(SocketAddr::V4)
             .or_else(|| self.read_socket_addr_v6().map(SocketAddr::V6))
     }
+
+    /// Read an IPv4 address prefix; an address followed by a prefix length
+    fn read_addr_v4_prefix(&mut self) -> Option<Ipv4AddrPrefix> {
+        self.read_atomically(|p| {
+            let address = p.read_ipv4_addr()?;
+            let len = p.read_prefix(u32::BITS)?;
+            Some(Ipv4AddrPrefix::new_unchecked(address, len))
+        })
+    }
+
+    /// Read an IPv6 address prefix; an address followed by a prefix length
+    fn read_addr_v6_prefix(&mut self) -> Option<Ipv6AddrPrefix> {
+        self.read_atomically(|p| {
+            let address = p.read_ipv6_addr()?;
+            let len = p.read_prefix(u128::BITS)?;
+            Some(Ipv6AddrPrefix::new_unchecked(address, len))
+        })
+    }
 }
 
 #[stable(feature = "ip_addr", since = "1.7.0")]
@@ -317,11 +348,27 @@ impl FromStr for SocketAddr {
     }
 }
 
-/// An error which can be returned when parsing an IP address or a socket address.
+#[unstable(feature = "ip_prefix", issue = "86991")]
+impl FromStr for Ipv4AddrPrefix {
+    type Err = AddrParseError;
+    fn from_str(s: &str) -> Result<Ipv4AddrPrefix, AddrParseError> {
+        Parser::new(s).parse_with(|p| p.read_addr_v4_prefix())
+    }
+}
+
+#[unstable(feature = "ip_prefix", issue = "86991")]
+impl FromStr for Ipv6AddrPrefix {
+    type Err = AddrParseError;
+    fn from_str(s: &str) -> Result<Ipv6AddrPrefix, AddrParseError> {
+        Parser::new(s).parse_with(|p| p.read_addr_v6_prefix())
+    }
+}
+
+/// An error which can be returned when parsing an IP address, IP address prefix or a socket address.
 ///
 /// This error is used as the error type for the [`FromStr`] implementation for
-/// [`IpAddr`], [`Ipv4Addr`], [`Ipv6Addr`], [`SocketAddr`], [`SocketAddrV4`], and
-/// [`SocketAddrV6`].
+/// [`IpAddr`], [`Ipv4Addr`], [`Ipv6Addr`], [`Ipv4AddrPrefix`], [`Ipv6AddrPrefix`],
+/// [`SocketAddr`], [`SocketAddrV4`], and [`SocketAddrV6`].
 ///
 /// # Potential causes
 ///