Merge pull request #98 from achanda/release-0.15

Uprev for a new release

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ipnetwork"
-version = "0.14.0" # When updating version, also modify html_root_url in the lib.rs
+version = "0.15.0" # When updating version, also modify html_root_url in the lib.rs
 authors = ["Abhishek Chanda <abhishek.becs@gmail.com>", "Linus Färnstrand <faern@faern.net>"]
 description = "A library to work with IP CIDRs in Rust, heavily WIP"
 license = "Apache-2.0"
@@ -9,6 +9,7 @@ keywords = ["network", "ip", "address"]
 readme = "README.md"
 documentation = "https://docs.rs/ipnetwork/"
 categories = ["network-programming", "os"]
+edition = "2018"
 
 [dependencies]
 clippy = {version = "0.0.302", optional = true}
@@ -17,6 +18,7 @@ serde = ">=0.8.0, <2.0"
 [dev-dependencies]
 serde_json = "1.0"
 serde_derive = ">=0.8.0, <2.0"
+criterion = "0.3.0"
 
 [badges]
 travis-ci = { repository = "achanda/ipnetwork" }
@@ -24,3 +26,7 @@ travis-ci = { repository = "achanda/ipnetwork" }
 [features]
 default = []
 dev = ["clippy"]
+
+[[bench]]
+name = "parse_bench"
+harness = false

benches/parse_bench.rs

@@ -0,0 +1,32 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use ipnetwork::{Ipv4Network, Ipv6Network};
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+fn parse_ipv4_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv4", |b| b.iter(|| {
+        "127.1.0.0/24".parse::<Ipv4Network>().unwrap()
+    }));
+}
+
+fn parse_ipv6_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv6", |b| b.iter(|| {
+        "FF01:0:0:17:0:0:0:2/64".parse::<Ipv6Network>().unwrap()
+    }));
+}
+
+fn contains_ipv4_benchmark(c: &mut Criterion) {
+    c.bench_function("contains ipv4", |b| b.iter(|| {
+        let cidr = "74.125.227.0/25".parse::<Ipv4Network>().unwrap();
+        cidr.contains(Ipv4Addr::new(74, 125, 227, 4))
+    }));
+}
+
+fn contains_ipv6_benchmark(c: &mut Criterion) {
+    c.bench_function("contains ipv6", |b| b.iter(|| {
+        let cidr = "FF01:0:0:17:0:0:0:2/65".parse::<Ipv6Network>().unwrap();
+        cidr.contains(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0x7fff, 0, 0, 0x2))
+    }));
+}
+
+criterion_group!(benches, parse_ipv4_benchmark, parse_ipv6_benchmark, contains_ipv4_benchmark, contains_ipv6_benchmark);
+criterion_main!(benches);

src/common.rs

@@ -1,5 +1,4 @@
-use std::error::Error;
-use std::fmt;
+use std::{error::Error, fmt};
 
 /// Represents a bunch of errors that can occur while working with a `IpNetwork`
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -10,8 +9,8 @@ pub enum IpNetworkError {
 }
 
 impl fmt::Display for IpNetworkError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use IpNetworkError::*;
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use crate::IpNetworkError::*;
         match *self {
             InvalidAddr(ref s) => write!(f, "invalid address: {}", s),
             InvalidPrefix => write!(f, "invalid prefix"),
@@ -22,7 +21,7 @@ impl fmt::Display for IpNetworkError {
 
 impl Error for IpNetworkError {
     fn description(&self) -> &str {
-        use IpNetworkError::*;
+        use crate::IpNetworkError::*;
         match *self {
             InvalidAddr(_) => "address is invalid",
             InvalidPrefix => "prefix is invalid",
@@ -32,16 +31,23 @@ impl Error for IpNetworkError {
 }
 
 pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
-    let parts = cidr.split('/').collect::<Vec<&str>>();
-    if parts.len() == 1 {
-        Ok((parts[0], None))
-    } else if parts.len() == 2 {
-        Ok((parts[0], Some(parts[1])))
-    } else {
-        Err(IpNetworkError::InvalidCidrFormat(format!(
+    // Try to find a single slash
+    if let Some(sep) = cidr.find('/') {
+        let (ip, prefix) = cidr.split_at(sep);
+        // Error if cidr has multiple slashes
+        if prefix[1..].find('/').is_some() {
+            return Err(IpNetworkError::InvalidCidrFormat(format!(
             "CIDR must contain a single '/': {}",
             cidr
-        )))
+            )));
+        }
+        else {
+            // Handle the case when cidr has exactly one slash
+            return Ok((ip, Some(&prefix[1..])));
+        }
+    } else {
+        // Handle the case when cidr does not have a slash
+        return Ok((cidr, None));
     }
 }
 

src/ipv4.rs

@@ -1,10 +1,6 @@
-use std::fmt;
-use std::net::Ipv4Addr;
-use std::str::FromStr;
-
+use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-use common::{cidr_parts, parse_prefix, IpNetworkError};
+use std::{fmt, net::Ipv4Addr, str::FromStr};
 
 const IPV4_BITS: u8 = 32;
 
@@ -20,8 +16,8 @@ impl<'de> Deserialize<'de> for Ipv4Network {
     where
         D: Deserializer<'de>,
     {
-        let s = <&str>::deserialize(deserializer)?;
-        Ipv4Network::from_str(s).map_err(de::Error::custom)
+        let s = <String>::deserialize(deserializer)?;
+        Ipv4Network::from_str(&s).map_err(de::Error::custom)
     }
 }
 
@@ -62,6 +58,27 @@ impl Ipv4Network {
         self.prefix
     }
 
+    /// Checks if the given `Ipv4Network` is a subnet of the other.
+    pub fn is_subnet_of(self, other: Ipv4Network) -> bool {
+        other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
+    }
+
+    /// Checks if the given `Ipv4Network` is a supernet of the other.
+    pub fn is_supernet_of(self, other: Ipv4Network) -> bool {
+        other.is_subnet_of(self)
+    }
+
+    /// Checks if the given `Ipv4Network` is partly contained in other.
+    pub fn overlaps(self, other: Ipv4Network) -> bool {
+        other.contains(self.ip()) || (
+            other.contains(self.broadcast()) || (
+                self.contains(other.ip()) || (
+                    self.contains(other.broadcast())
+                )
+            )
+        )
+    }
+
     /// Returns the mask for this `Ipv4Network`.
     /// That means the `prefix` most significant bits will be 1 and the rest 0
     ///
@@ -131,8 +148,8 @@ impl Ipv4Network {
     /// assert!(!net.contains(Ipv4Addr::new(127, 0, 1, 70)));
     /// ```
     pub fn contains(&self, ip: Ipv4Addr) -> bool {
-        let net = u32::from(self.network());
-        let mask = u32::from(self.mask());
+        let mask = !(0xffff_ffff as u64 >> self.prefix) as u32;
+        let net = u32::from(self.addr) & mask;
         (u32::from(ip) & mask) == net
     }
 
@@ -183,7 +200,7 @@ impl Ipv4Network {
 }
 
 impl fmt::Display for Ipv4Network {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}/{}", self.ip(), self.prefix())
     }
 }
@@ -454,4 +471,47 @@ mod test {
         fn assert_sync<T: Sync>() {}
         assert_sync::<Ipv4Network>();
     }
+
+    // Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
+    #[test]
+    fn test_is_subnet_of() {
+        let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
+
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.1.0/24".parse().unwrap()), false);
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.0.0/24".parse().unwrap()), true);
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.1.0/24".parse().unwrap()), false);
+        test_cases.insert(("10.0.1.0/24".parse().unwrap(), "10.0.0.0/30".parse().unwrap()), false);
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(src.is_subnet_of(dest), *val, "testing with {} and {}", src, dest);
+        }
+    }
+
+    #[test]
+    fn test_is_supernet_of() {
+        let mut test_cases: HashMap<(Ipv4Network, Ipv4Network), bool> = HashMap::new();
+
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.1.0/24".parse().unwrap()), false);
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.0.0/24".parse().unwrap()), false);
+        test_cases.insert(("10.0.0.0/30".parse().unwrap(), "10.0.1.0/24".parse().unwrap()), false);
+        test_cases.insert(("10.0.0.0/24".parse().unwrap(), "10.0.0.0/30".parse().unwrap()), true);
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(src.is_supernet_of(dest), *val, "testing with {} and {}", src, dest);
+        }
+    }
+
+    #[test]
+    fn test_overlaps() {
+        let other: Ipv4Network = "1.2.3.0/30".parse().unwrap();
+        let other2: Ipv4Network = "1.2.2.0/24".parse().unwrap();
+        let other3: Ipv4Network = "1.2.2.64/26".parse().unwrap();
+
+        let skynet: Ipv4Network = "1.2.3.0/24".parse().unwrap();
+        assert_eq!(skynet.overlaps(other), true);
+        assert_eq!(skynet.overlaps(other2), false);
+        assert_eq!(other2.overlaps(other3), true);
+    }
 }

src/ipv6.rs

@@ -1,11 +1,6 @@
-use std::cmp;
-use std::fmt;
-use std::net::Ipv6Addr;
-use std::str::FromStr;
-
+use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-use common::{cidr_parts, parse_prefix, IpNetworkError};
+use std::{cmp, fmt, net::Ipv6Addr, str::FromStr};
 
 const IPV6_BITS: u8 = 128;
 const IPV6_SEGMENT_BITS: u8 = 16;
@@ -22,8 +17,8 @@ impl<'de> Deserialize<'de> for Ipv6Network {
     where
         D: Deserializer<'de>,
     {
-        let s = <&str>::deserialize(deserializer)?;
-        Ipv6Network::from_str(s).map_err(de::Error::custom)
+        let s = <String>::deserialize(deserializer)?;
+        Ipv6Network::from_str(&s).map_err(de::Error::custom)
     }
 }
 
@@ -111,6 +106,27 @@ impl Ipv6Network {
         self.prefix
     }
 
+    /// Checks if the given `Ipv6Network` is a subnet of the other.
+    pub fn is_subnet_of(self, other: Ipv6Network) -> bool {
+        other.ip() <= self.ip() && other.broadcast() >= self.broadcast()
+    }
+
+    /// Checks if the given `Ipv6Network` is a supernet of the other.
+    pub fn is_supernet_of(self, other: Ipv6Network) -> bool {
+        other.is_subnet_of(self)
+    }
+
+    /// Checks if the given `Ipv6Network` is partly contained in other.
+    pub fn overlaps(self, other: Ipv6Network) -> bool {
+        other.contains(self.ip()) || (
+            other.contains(self.broadcast()) || (
+                self.contains(other.ip()) || (
+                    self.contains(other.broadcast())
+                )
+            )
+        )
+    }
+
     /// Returns the mask for this `Ipv6Network`.
     /// That means the `prefix` most significant bits will be 1 and the rest 0
     ///
@@ -222,7 +238,7 @@ impl Iterator for Ipv6NetworkIterator {
 }
 
 impl fmt::Display for Ipv6Network {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}/{}", self.ip(), self.prefix())
     }
 }
@@ -265,6 +281,7 @@ pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use std::collections::HashMap;
     use std::net::Ipv6Addr;
 
     #[test]
@@ -436,4 +453,43 @@ mod test {
         fn assert_sync<T: Sync>() {}
         assert_sync::<Ipv6Network>();
     }
+
+    // Tests from cpython https://github.com/python/cpython/blob/e9bc4172d18db9c182d8e04dd7b033097a994c06/Lib/test/test_ipaddress.py
+    #[test]
+    fn test_is_subnet_of() {
+        let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
+
+        test_cases.insert(("2000:999::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), false);
+        test_cases.insert(("2000:aaa::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), true);
+        test_cases.insert(("2000:bbb::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), false);
+        test_cases.insert(("2000:aaa::/48".parse().unwrap(), "2000:aaa::/56".parse().unwrap()), false);
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(src.is_subnet_of(dest), *val, "testing with {} and {}", src, dest);
+        }
+    }
+
+    #[test]
+    fn test_is_supernet_of() {
+        let mut test_cases: HashMap<(Ipv6Network, Ipv6Network), bool> = HashMap::new();
+
+        test_cases.insert(("2000:999::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), false);
+        test_cases.insert(("2000:aaa::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), false);
+        test_cases.insert(("2000:bbb::/56".parse().unwrap(), "2000:aaa::/48".parse().unwrap()), false);
+        test_cases.insert(("2000:aaa::/48".parse().unwrap(), "2000:aaa::/56".parse().unwrap()), true);
+
+        for (key, val) in test_cases.iter() {
+            let (src, dest) = (key.0, key.1);
+            assert_eq!(src.is_supernet_of(dest), *val, "testing with {} and {}", src, dest);
+        }
+    }
+
+    #[test]
+    fn test_overlaps() {
+        let other: Ipv6Network = "2001:DB8:ACAD::1/64".parse().unwrap();
+        let other2: Ipv6Network = "2001:DB8:ACAD::20:2/64".parse().unwrap();
+
+        assert_eq!(other2.overlaps(other), true);
+    }
 }

src/lib.rs

@@ -4,24 +4,18 @@
 #![cfg_attr(feature = "dev", feature(plugin))]
 #![cfg_attr(feature = "dev", plugin(clippy))]
 #![crate_type = "lib"]
-#![doc(html_root_url = "https://docs.rs/ipnetwork/0.14.0")]
+#![doc(html_root_url = "https://docs.rs/ipnetwork/0.15.0")]
 
-extern crate serde;
-
-use std::fmt;
-use std::net::IpAddr;
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use std::{fmt, net::IpAddr, str::FromStr};
 
 mod common;
 mod ipv4;
 mod ipv6;
 
-use std::str::FromStr;
-
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-pub use common::IpNetworkError;
-pub use ipv4::{ipv4_mask_to_prefix, Ipv4Network};
-pub use ipv6::{ipv6_mask_to_prefix, Ipv6Network};
+pub use crate::common::IpNetworkError;
+pub use crate::ipv4::{ipv4_mask_to_prefix, Ipv4Network};
+pub use crate::ipv6::{ipv6_mask_to_prefix, Ipv6Network};
 
 /// Represents a generic network range. This type can have two variants:
 /// the v4 and the v6 case.
@@ -200,6 +194,10 @@ impl IpNetwork {
         }
     }
 
+    // TODO(abhishek) when TryFrom is stable, implement it for IpNetwork to
+    // variant conversions. Then use that to implement a generic is_subnet_of
+    // is_supernet_of, overlaps
+
     /// Checks if a given `IpAddr` is in this `IpNetwork`
     ///
     /// # Examples
@@ -292,7 +290,7 @@ impl From<IpAddr> for IpNetwork {
 }
 
 impl fmt::Display for IpNetwork {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             IpNetwork::V4(net) => net.fmt(f),
             IpNetwork::V6(net) => net.fmt(f),

tests/test_json.rs

@@ -1,16 +1,7 @@
-extern crate serde;
-
-extern crate serde_json;
-
-#[macro_use]
-extern crate serde_derive;
-
-extern crate ipnetwork;
-
 #[cfg(test)]
 mod tests {
-
     use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
+    use serde_derive::{Deserialize, Serialize};
     use std::net::{Ipv4Addr, Ipv6Addr};
 
     #[test]