Uprev for a new release

Cleanup comment on IPv6 implementation

.github/workflows/rust.yml

@@ -0,0 +1,28 @@
+name: Rust
+
+on:
+  pull_request:
+    branches: 
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: [stable, beta, nightly]
+    steps:
+    - uses: hecrj/setup-rust-action@v1
+      with:
+        rust-version: ${{ matrix.rust }}
+    - uses: actions/checkout@master
+      with:
+        ref: ${{ github.ref }}
+    - name: Show current git branch
+      run: git branch
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Build docs
+      run: cargo doc --verbose

.travis.yml

@@ -9,6 +9,8 @@ env:
     - FEATURES: default
 
 script:
+  - cargo build --verbose --no-default-features
+  - cargo test --verbose --no-default-features
   - cargo build --verbose
   - cargo test --verbose
   - cargo build --release --verbose

Cargo.toml

@@ -1,19 +1,18 @@
 [package]
 name = "ipnetwork"
-version = "0.15.0" # When updating version, also modify html_root_url in the lib.rs
+version = "0.16.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"
+description = "A library to work with IP CIDRs in Rust"
 license = "Apache-2.0"
 repository = "https://github.com/achanda/ipnetwork"
-keywords = ["network", "ip", "address"]
+keywords = ["network", "ip", "address", "cidr"]
 readme = "README.md"
-documentation = "https://docs.rs/ipnetwork/"
-categories = ["network-programming", "os"]
+categories = ["network-programming", "parser-implementations"]
 edition = "2018"
 
 [dependencies]
 clippy = {version = "0.0.302", optional = true}
-serde = ">=0.8.0, <2.0"
+serde = { version = ">=0.8.0, <2.0", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"
@@ -22,9 +21,10 @@ criterion = "0.3.0"
 
 [badges]
 travis-ci = { repository = "achanda/ipnetwork" }
+maintenance = { status = "passively-maintained" }
 
 [features]
-default = []
+default = ["serde"]
 dev = ["clippy"]
 
 [[bench]]

benches/parse_bench.rs

@@ -2,31 +2,48 @@ 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_ipv4_prefix_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv4 prefix", |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()
-    }));
+    c.bench_function("parse ipv6", |b| {
+        b.iter(|| "FF01:0:0:17:0:0:0:2/64".parse::<Ipv6Network>().unwrap())
+    });
+}
+
+fn parse_ipv4_netmask_benchmark(c: &mut Criterion) {
+    c.bench_function("parse ipv4 netmask", |b| {
+        b.iter(|| "127.1.0.0/255.255.255.0".parse::<Ipv4Network>().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))
-    }));
+    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))
-    }));
+    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_group!(
+    benches,
+    parse_ipv4_prefix_benchmark,
+    parse_ipv6_benchmark,
+    parse_ipv4_netmask_benchmark,
+    contains_ipv4_benchmark,
+    contains_ipv6_benchmark
+);
 criterion_main!(benches);

src/common.rs

@@ -37,11 +37,10 @@ pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
         // Error if cidr has multiple slashes
         if prefix[1..].find('/').is_some() {
             return Err(IpNetworkError::InvalidCidrFormat(format!(
-            "CIDR must contain a single '/': {}",
-            cidr
+                "CIDR must contain a single '/': {}",
+                cidr
             )));
-        }
-        else {
+        } else {
             // Handle the case when cidr has exactly one slash
             return Ok((ip, Some(&prefix[1..])));
         }

src/ipv4.rs

@@ -1,5 +1,4 @@
 use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 use std::{fmt, net::Ipv4Addr, str::FromStr};
 
 const IPV4_BITS: u8 = 32;
@@ -11,20 +10,22 @@ pub struct Ipv4Network {
     prefix: u8,
 }
 
-impl<'de> Deserialize<'de> for Ipv4Network {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Ipv4Network {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
         let s = <String>::deserialize(deserializer)?;
-        Ipv4Network::from_str(&s).map_err(de::Error::custom)
+        Ipv4Network::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for Ipv4Network {
+#[cfg(feature = "serde")]
+impl serde::Serialize for Ipv4Network {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
         serializer.serialize_str(&self.to_string())
     }
@@ -32,6 +33,7 @@ impl Serialize for Ipv4Network {
 
 impl Ipv4Network {
     /// Constructs a new `Ipv4Network` from any `Ipv4Addr` and a prefix denoting the network size.
+    ///
     /// If the prefix is larger than 32 this will return an `IpNetworkError::InvalidPrefix`.
     pub fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
         if prefix > IPV4_BITS {
@@ -41,13 +43,31 @@ impl Ipv4Network {
         }
     }
 
+    /// Constructs a new `Ipv4Network` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(
+        netaddr: Ipv4Addr,
+        netmask: Ipv4Addr,
+    ) -> Result<Ipv4Network, IpNetworkError> {
+        let prefix = ipv4_mask_to_prefix(netmask)?;
+        let net = Self {
+            addr: netaddr,
+            prefix,
+        };
+        Ok(net)
+    }
+
     /// Returns an iterator over `Ipv4Network`. Each call to `next` will return the next
     /// `Ipv4Addr` in the given network. `None` will be returned when there are no more
     /// addresses.
     pub fn iter(&self) -> Ipv4NetworkIterator {
         let start = u32::from(self.network());
-        let end = start + self.size();
-        Ipv4NetworkIterator { next: start, end }
+        let end = start + (self.size() - 1);
+        Ipv4NetworkIterator {
+            next: Some(start),
+            end,
+        }
     }
 
     pub fn ip(&self) -> Ipv4Addr {
@@ -70,13 +90,9 @@ impl Ipv4Network {
 
     /// 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())
-                )
-            )
-        )
+        other.contains(self.ip())
+            || (other.contains(self.broadcast())
+                || (self.contains(other.ip()) || (self.contains(other.broadcast()))))
     }
 
     /// Returns the mask for this `Ipv4Network`.
@@ -225,7 +241,13 @@ impl FromStr for Ipv4Network {
         let addr = Ipv4Addr::from_str(addr_str)
             .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
         let prefix = match prefix_str {
-            Some(v) => parse_prefix(v, IPV4_BITS)?,
+            Some(v) => {
+                if let Ok(netmask) = Ipv4Addr::from_str(v) {
+                    ipv4_mask_to_prefix(netmask)?
+                } else {
+                    parse_prefix(v, IPV4_BITS)?
+                }
+            }
             None => IPV4_BITS,
         };
         Ipv4Network::new(addr, prefix)
@@ -241,8 +263,9 @@ impl From<Ipv4Addr> for Ipv4Network {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Ipv4NetworkIterator {
-    next: u32,
+    next: Option<u32>,
     end: u32,
 }
 
@@ -250,17 +273,26 @@ impl Iterator for Ipv4NetworkIterator {
     type Item = Ipv4Addr;
 
     fn next(&mut self) -> Option<Ipv4Addr> {
-        if self.next < self.end {
-            let next = Ipv4Addr::from(self.next as u32);
-            self.next += 1;
-            Some(next)
-        } else {
+        let next = self.next?;
+        self.next = if next == self.end {
             None
-        }
+        } else {
+            Some(next + 1)
+        };
+        Some(next.into())
+    }
+}
+
+impl IntoIterator for &'_ Ipv4Network {
+    type IntoIter = Ipv4NetworkIterator;
+    type Item = Ipv4Addr;
+    fn into_iter(self) -> Ipv4NetworkIterator {
+        self.iter()
     }
 }
 
 /// Converts a `Ipv4Addr` network mask into a prefix.
+///
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ipv4_mask_to_prefix(mask: Ipv4Addr) -> Result<u8, IpNetworkError> {
     let mask = u32::from(mask);
@@ -446,6 +478,22 @@ mod test {
         assert_eq!(prefix, 25);
     }
 
+    /// Parse netmask as well as prefix
+    #[test]
+    fn parse_netmask() {
+        let from_netmask: Ipv4Network = "192.168.1.0/255.255.255.0".parse().unwrap();
+        let from_prefix: Ipv4Network = "192.168.1.0/24".parse().unwrap();
+        assert_eq!(from_netmask, from_prefix);
+    }
+
+    #[test]
+    fn parse_netmask_broken_v4() {
+        assert_eq!(
+            "192.168.1.0/255.0.255.0".parse::<Ipv4Network>(),
+            Err(IpNetworkError::InvalidPrefix)
+        );
+    }
+
     #[test]
     fn invalid_v4_mask_to_prefix() {
         let mask = Ipv4Addr::new(255, 0, 255, 0);
@@ -453,6 +501,24 @@ mod test {
         assert!(prefix.is_err());
     }
 
+    #[test]
+    fn ipv4network_with_netmask() {
+        {
+            // Positive test-case.
+            let addr = Ipv4Addr::new(127, 0, 0, 1);
+            let mask = Ipv4Addr::new(255, 0, 0, 0);
+            let net = Ipv4Network::with_netmask(addr, mask).unwrap();
+            let expected = Ipv4Network::new(Ipv4Addr::new(127, 0, 0, 1), 8).unwrap();
+            assert_eq!(net, expected);
+        }
+        {
+            // Negative test-case.
+            let addr = Ipv4Addr::new(127, 0, 0, 1);
+            let mask = Ipv4Addr::new(255, 0, 255, 0);
+            Ipv4Network::with_netmask(addr, mask).unwrap_err();
+        }
+    }
+
     #[test]
     fn ipv4network_from_ipv4addr() {
         let net = Ipv4Network::from(Ipv4Addr::new(127, 0, 0, 1));
@@ -477,14 +543,44 @@ mod 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);
+        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);
+            assert_eq!(
+                src.is_subnet_of(dest),
+                *val,
+                "testing with {} and {}",
+                src,
+                dest
+            );
         }
     }
 
@@ -492,14 +588,44 @@ mod 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);
+        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);
+            assert_eq!(
+                src.is_supernet_of(dest),
+                *val,
+                "testing with {} and {}",
+                src,
+                dest
+            );
         }
     }
 
@@ -514,4 +640,22 @@ mod test {
         assert_eq!(skynet.overlaps(other2), false);
         assert_eq!(other2.overlaps(other3), true);
     }
+
+    #[test]
+    fn edges() {
+        let low: Ipv4Network = "0.0.0.0/24".parse().unwrap();
+        let low_addrs: Vec<Ipv4Addr> = low.iter().collect();
+        assert_eq!(256, low_addrs.len());
+        assert_eq!("0.0.0.0".parse::<Ipv4Addr>().unwrap(), low_addrs[0]);
+        assert_eq!("0.0.0.255".parse::<Ipv4Addr>().unwrap(), low_addrs[255]);
+
+        let high: Ipv4Network = "255.255.255.0/24".parse().unwrap();
+        let high_addrs: Vec<Ipv4Addr> = high.iter().collect();
+        assert_eq!(256, high_addrs.len());
+        assert_eq!("255.255.255.0".parse::<Ipv4Addr>().unwrap(), high_addrs[0]);
+        assert_eq!(
+            "255.255.255.255".parse::<Ipv4Addr>().unwrap(),
+            high_addrs[255]
+        );
+    }
 }

src/ipv6.rs

@@ -1,5 +1,4 @@
 use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 use std::{cmp, fmt, net::Ipv6Addr, str::FromStr};
 
 const IPV6_BITS: u8 = 128;
@@ -12,20 +11,22 @@ pub struct Ipv6Network {
     prefix: u8,
 }
 
-impl<'de> Deserialize<'de> for Ipv6Network {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Ipv6Network {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
         let s = <String>::deserialize(deserializer)?;
-        Ipv6Network::from_str(&s).map_err(de::Error::custom)
+        Ipv6Network::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for Ipv6Network {
+#[cfg(feature = "serde")]
+impl serde::Serialize for Ipv6Network {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
         serializer.serialize_str(&self.to_string())
     }
@@ -33,6 +34,7 @@ impl Serialize for Ipv6Network {
 
 impl Ipv6Network {
     /// Constructs a new `Ipv6Network` from any `Ipv6Addr` and a prefix denoting the network size.
+    ///
     /// If the prefix is larger than 128 this will return an `IpNetworkError::InvalidPrefix`.
     pub fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
         if prefix > IPV6_BITS {
@@ -42,6 +44,18 @@ impl Ipv6Network {
         }
     }
 
+    /// Constructs a new `Ipv6Network` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(netaddr: Ipv6Addr, netmask: Ipv6Addr) -> Result<Self, IpNetworkError> {
+        let prefix = ipv6_mask_to_prefix(netmask)?;
+        let net = Self {
+            addr: netaddr,
+            prefix,
+        };
+        Ok(net)
+    }
+
     /// Returns an iterator over `Ipv6Network`. Each call to `next` will return the next
     /// `Ipv6Addr` in the given network. `None` will be returned when there are no more
     /// addresses.
@@ -57,7 +71,7 @@ impl Ipv6Network {
         let end: u128 = dec | mask;
 
         Ipv6NetworkIterator {
-            next: start,
+            next: Some(start),
             end: end,
         }
     }
@@ -118,13 +132,9 @@ impl Ipv6Network {
 
     /// 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())
-                )
-            )
-        )
+        other.contains(self.ip())
+            || (other.contains(self.broadcast())
+                || (self.contains(other.ip()) || (self.contains(other.broadcast()))))
     }
 
     /// Returns the mask for this `Ipv6Network`.
@@ -218,8 +228,9 @@ impl From<Ipv6Addr> for Ipv6Network {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Ipv6NetworkIterator {
-    next: u128,
+    next: Option<u128>,
     end: u128,
 }
 
@@ -227,13 +238,21 @@ impl Iterator for Ipv6NetworkIterator {
     type Item = Ipv6Addr;
 
     fn next(&mut self) -> Option<Ipv6Addr> {
-        if self.next <= self.end {
-            let next = Ipv6Addr::from(self.next);
-            self.next += 1;
-            Some(next)
-        } else {
+        let next = self.next?;
+        self.next = if next == self.end {
             None
-        }
+        } else {
+            Some(next + 1)
+        };
+        Some(next.into())
+    }
+}
+
+impl IntoIterator for &'_ Ipv6Network {
+    type IntoIter = Ipv6NetworkIterator;
+    type Item = Ipv6Addr;
+    fn into_iter(self) -> Ipv6NetworkIterator {
+        self.iter()
     }
 }
 
@@ -247,7 +266,7 @@ impl fmt::Display for Ipv6Network {
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ipv6_mask_to_prefix(mask: Ipv6Addr) -> Result<u8, IpNetworkError> {
     let mask = mask.segments();
-    let mut mask_iter = mask.into_iter();
+    let mut mask_iter = mask.iter();
 
     // Count the number of set bits from the start of the address
     let mut prefix = 0;
@@ -290,6 +309,14 @@ mod test {
         assert_eq!(cidr.prefix(), 24);
     }
 
+    #[test]
+    fn parse_netmask_broken_v6() {
+        assert_eq!(
+            "FF01:0:0:17:0:0:0:2/255.255.255.0".parse::<Ipv6Network>(),
+            Err(IpNetworkError::InvalidPrefix)
+        );
+    }
+
     #[test]
     fn create_v6_invalid_prefix() {
         let cidr = Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 129);
@@ -370,6 +397,25 @@ mod test {
         assert!(prefix.is_err());
     }
 
+    #[test]
+    fn ipv6network_with_netmask() {
+        {
+            // Positive test-case.
+            let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
+            let mask = Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0, 0, 0, 0, 0);
+            let net = Ipv6Network::with_netmask(addr, mask).unwrap();
+            let expected =
+                Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 48).unwrap();
+            assert_eq!(net, expected);
+        }
+        {
+            // Negative test-case.
+            let addr = Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2);
+            let mask = Ipv6Addr::new(0, 0, 0xffff, 0xffff, 0, 0, 0, 0);
+            Ipv6Network::with_netmask(addr, mask).unwrap_err();
+        }
+    }
+
     #[test]
     fn iterator_v6() {
         let cidr: Ipv6Network = "2001:db8::/126".parse().unwrap();
@@ -459,14 +505,44 @@ mod 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);
+        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);
+            assert_eq!(
+                src.is_subnet_of(dest),
+                *val,
+                "testing with {} and {}",
+                src,
+                dest
+            );
         }
     }
 
@@ -474,14 +550,44 @@ mod 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);
+        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);
+            assert_eq!(
+                src.is_supernet_of(dest),
+                *val,
+                "testing with {} and {}",
+                src,
+                dest
+            );
         }
     }
 
@@ -492,4 +598,17 @@ mod test {
 
         assert_eq!(other2.overlaps(other), true);
     }
+
+    #[test]
+    fn edges() {
+        let low: Ipv6Network = "::0/120".parse().unwrap();
+        let low_addrs: Vec<Ipv6Addr> = low.iter().collect();
+        assert_eq!(256, low_addrs.len());
+
+        let high: Ipv6Network = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00/120"
+            .parse()
+            .unwrap();
+        let high_addrs: Vec<Ipv6Addr> = high.iter().collect();
+        assert_eq!(256, high_addrs.len());
+    }
 }

src/lib.rs

@@ -1,12 +1,10 @@
 //! The `ipnetwork` crate provides a set of APIs to work with IP CIDRs in
-//! Rust. Implementation for IPv4 is more or less stable, IPv6 implementation
-//! is still WIP.
+//! Rust.
 #![cfg_attr(feature = "dev", feature(plugin))]
 #![cfg_attr(feature = "dev", plugin(clippy))]
 #![crate_type = "lib"]
-#![doc(html_root_url = "https://docs.rs/ipnetwork/0.15.0")]
+#![doc(html_root_url = "https://docs.rs/ipnetwork/0.16.0")]
 
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 use std::{fmt, net::IpAddr, str::FromStr};
 
 mod common;
@@ -14,7 +12,9 @@ mod ipv4;
 mod ipv6;
 
 pub use crate::common::IpNetworkError;
+use crate::ipv4::Ipv4NetworkIterator;
 pub use crate::ipv4::{ipv4_mask_to_prefix, Ipv4Network};
+use crate::ipv6::Ipv6NetworkIterator;
 pub use crate::ipv6::{ipv6_mask_to_prefix, Ipv6Network};
 
 /// Represents a generic network range. This type can have two variants:
@@ -25,20 +25,22 @@ pub enum IpNetwork {
     V6(Ipv6Network),
 }
 
-impl<'de> Deserialize<'de> for IpNetwork {
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IpNetwork {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: Deserializer<'de>,
+        D: serde::Deserializer<'de>,
     {
         let s = <String>::deserialize(deserializer)?;
-        IpNetwork::from_str(&s).map_err(de::Error::custom)
+        IpNetwork::from_str(&s).map_err(serde::de::Error::custom)
     }
 }
 
-impl Serialize for IpNetwork {
+#[cfg(feature = "serde")]
+impl serde::Serialize for IpNetwork {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: Serializer,
+        S: serde::Serializer,
     {
         serializer.serialize_str(&self.to_string())
     }
@@ -63,6 +65,14 @@ impl IpNetwork {
         }
     }
 
+    /// Constructs a new `IpNetwork` from a network address and a network mask.
+    ///
+    /// If the netmask is not valid this will return an `IpNetworkError::InvalidPrefix`.
+    pub fn with_netmask(netaddr: IpAddr, netmask: IpAddr) -> Result<Self, IpNetworkError> {
+        let prefix = ip_mask_to_prefix(netmask)?;
+        Self::new(netaddr, prefix)
+    }
+
     /// Returns the IP part of a given `IpNetwork`
     pub fn ip(&self) -> IpAddr {
         match *self {
@@ -239,6 +249,17 @@ impl IpNetwork {
             IpNetwork::V6(ref ip) => NetworkSize::V6(ip.size()),
         }
     }
+
+    /// Returns an iterator over the addresses contained in the network.
+    ///
+    /// This lists all the addresses in the network range, in ascending order.
+    pub fn iter(&self) -> IpNetworkIterator {
+        let inner = match self {
+            IpNetwork::V4(ip) => IpNetworkIteratorInner::V4(ip.iter()),
+            IpNetwork::V6(ip) => IpNetworkIteratorInner::V6(ip.iter()),
+        };
+        IpNetworkIterator { inner }
+    }
 }
 
 /// Tries to parse the given string into a `IpNetwork`. Will first try to parse
@@ -298,6 +319,34 @@ impl fmt::Display for IpNetwork {
     }
 }
 
+#[derive(Clone, Debug)]
+enum IpNetworkIteratorInner {
+    V4(Ipv4NetworkIterator),
+    V6(Ipv6NetworkIterator),
+}
+
+pub struct IpNetworkIterator {
+    inner: IpNetworkIteratorInner,
+}
+
+impl Iterator for IpNetworkIterator {
+    type Item = IpAddr;
+    fn next(&mut self) -> Option<IpAddr> {
+        match &mut self.inner {
+            IpNetworkIteratorInner::V4(iter) => iter.next().map(IpAddr::V4),
+            IpNetworkIteratorInner::V6(iter) => iter.next().map(IpAddr::V6),
+        }
+    }
+}
+
+impl IntoIterator for &'_ IpNetwork {
+    type IntoIter = IpNetworkIterator;
+    type Item = IpAddr;
+    fn into_iter(self) -> IpNetworkIterator {
+        self.iter()
+    }
+}
+
 /// Converts a `IpAddr` network mask into a prefix.
 /// If the mask is invalid this will return an `IpNetworkError::InvalidPrefix`.
 pub fn ip_mask_to_prefix(mask: IpAddr) -> Result<u8, IpNetworkError> {
@@ -310,11 +359,13 @@ pub fn ip_mask_to_prefix(mask: IpAddr) -> Result<u8, IpNetworkError> {
 #[cfg(test)]
 mod test {
     #[test]
+    #[cfg(feature = "serde")]
     fn deserialize_from_serde_json_value() {
         use super::*;
         let network = IpNetwork::from_str("0.0.0.0/0").unwrap();
-        let val: serde_json::value::Value = serde_json::from_str(&serde_json::to_string(&network).unwrap()).unwrap();
-        let _deser: IpNetwork =
-            serde_json::from_value(val).expect("Fails to deserialize from json_value::value::Value");
+        let val: serde_json::value::Value =
+            serde_json::from_str(&serde_json::to_string(&network).unwrap()).unwrap();
+        let _deser: IpNetwork = serde_json::from_value(val)
+            .expect("Fails to deserialize from json_value::value::Value");
     }
 }

tests/test_json.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "serde")]
+
 #[cfg(test)]
 mod tests {
     use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};