Iptools

This is a port of package iptools from Python with a lot of optimizations.

Key Features

1. 100% safe Rust with #![forbid(unsafe_code)]
2. Minimum dependencies
3. Optimized for speed, with better performance than the ipnet and ipnetwork crates and the standard library implementation (Benched on AArch64 and x86_64)
4. WebAssembly support (see WASM.md)
5. no_std support with optional serde serialization for IpRange/IpVer

Which crate should I choose?

Recommendation: choose iptools when you need string-based APIs, reserved-block detection, WebAssembly builds, or when execution speed is a priority. Reach for ipnet if you need subnet aggregation, address arithmetic traits, or tighter integration with IpAddr. Use ipnetwork when you only require lightweight CIDR parsing/iteration and prefer its smaller, std-only API surface.

Getting Started

Add the following dependency to your Cargo manifest:

[dependencies]
iptools = "0.4.0"

no_std support

To use iptools in a no_std environment, disable the default features:

[dependencies]
iptools = { version = "0.4.0", default-features = false }

Example of usage

use iptools::iprange::{IpRange, IPv4};

let first_range = match IpRange::<IPv4>::new("127.0.0.1/16", "") {
    Ok(range) => range,
    Err(err) => {
        eprintln!("Error: {}", err);
        return;
    }
};
let second_range = match IpRange::<IPv4>::new("127.0.0.1", "127.0.0.255") {
    Ok(range) => range,
    Err(err) => {
        eprintln!("Error: {}", err);
        return;
    }
};

// Print range bounds (tuple: start, end)
println!("{:?} {:?}", first_range.get_range(), second_range.get_range());

// Use the IpRange as an iterator. Clone the range to iterate without consuming the original
let mut iter = first_range.clone();
println!("Next IPs: {:?} {:?}", iter.next(), iter.next()); // Option<String>

// Print current length (total addresses in the range)
println!("Initial length: {}", first_range.len());

// Remaining addresses to iterate from a cloned iterator
let mut iter2 = first_range.clone();
println!("Remaining before iteration: {}", iter2.remaining());
iter2.next();
println!("Remaining after consuming one IP: {}", iter2.remaining());

// Check whether an IP or CIDR is contained in the range
match first_range.contains("127.0.0.3") {
    Ok(contains) => println!("Contains 127.0.0.3? {}", contains),
    Err(err) => eprintln!("Error: {}", err),
}

// Iterate over addresses (string iterator)
for ip in first_range.clone().take(3) {
	println!("IP: {}", ip);
}

IPv6 validation differences

The Rust port follows the canonical compression rules from RFC 4291 §2.2. That means non-conforming strings such as :::1 are rejected even though Python iptools crate accepted them. You can see the difference locally:

python3 -c "from iptools import ipv6; print(ipv6.validate_ip(':::1'))"

Supported Rust Versions

Rust 1.78.0+

License

This project is licensed under the MIT license.