1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! IPv4 and IPv6 network structs.
//!
//! ## Optional features
//!
//! When using this crate, you can choose to compile with these features:
//!
//! * `serde` – for serialization and deserialization by [Serde framework](https://serde.rs).
//! * `diesel` – support for [PostgreSQL CIDR type] with [Diesel ORM](https://diesel.rs).
//! * `postgres` – support for [PostgreSQL CIDR type] with [postgres crate](https://github.com/sfackler/rust-postgres).
//!
//! ## Examples
//!
//! ```rust
//! use std::net::Ipv4Addr;
//! use ip_network::Ipv4Network;
//!
//! let ip_network = Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
//! assert_eq!(Ipv4Addr::new(192, 168, 1, 0), ip_network.network_address());
//! assert_eq!(24, ip_network.netmask());
//! assert_eq!(254, ip_network.hosts().len());
//! assert_eq!("192.168.1.0/24", ip_network.to_string());
//! # Ok::<(), ip_network::IpNetworkError>(())
//! ```
//!
//! [PostgreSQL CIDR type]: https://www.postgresql.org/docs/current/datatype-net-types.html#DATATYPE-CIDR

#[cfg(feature = "diesel")]
#[macro_use]
extern crate diesel;

#[cfg(feature = "diesel")]
/// Support for Diesel PostgreSQL CIDR type.
pub mod diesel_support;
mod helpers;
mod ip_network;
mod ipv4_network;
mod ipv6_network;
/// `Ipv4RangeIterator`, `Ipv4NetworkIterator`, and `Ipv6NetworkIterator`.
pub mod iterator;
#[cfg(any(feature = "diesel", feature = "postgres"))]
mod postgres_common;
#[cfg(feature = "postgres")]
mod postgres_support;
#[cfg(feature = "serde")]
mod serde_support;

use std::error::Error;
use std::fmt;

pub use self::ip_network::IpNetwork;
pub use self::ipv4_network::Ipv4Network;
pub use self::ipv6_network::{Ipv6MulticastScope, Ipv6Network};

/// Errors when creating new IPv4 or IPv6 networks.
#[derive(Debug, PartialEq)]
pub enum IpNetworkError {
    /// Network mask is bigger than possible for given IP version (32 for IPv4, 128 for IPv6).
    NetmaskError(u8),
    /// Host bits are set in given network IP address.
    HostBitsSet,
}

impl Error for IpNetworkError {}

impl fmt::Display for IpNetworkError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let description = match *self {
            IpNetworkError::NetmaskError(_) => "invalid netmask",
            IpNetworkError::HostBitsSet => "IP network address has host bits set",
        };
        write!(fmt, "{}", description)
    }
}

/// Errors from IPv4 or IPv6 network parsing.
#[derive(Debug, PartialEq)]
pub enum IpNetworkParseError {
    /// Network mask is not valid integer between 0 and 255.
    InvalidNetmaskFormat,
    /// Network address has invalid format (not X/Y).
    InvalidFormatError,
    /// Invalid IP address syntax (IPv4 or IPv6).
    AddrParseError,
    /// Error when creating new IPv4 or IPv6 networks.
    IpNetworkError(IpNetworkError),
}

impl Error for IpNetworkParseError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match *self {
            IpNetworkParseError::IpNetworkError(ref ip_network_error) => Some(ip_network_error),
            _ => None,
        }
    }
}

impl fmt::Display for IpNetworkParseError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            IpNetworkParseError::InvalidNetmaskFormat => write!(fmt, "invalid netmask format"),
            IpNetworkParseError::InvalidFormatError => write!(fmt, "invalid format"),
            IpNetworkParseError::AddrParseError => write!(fmt, "invalid IP address syntax"),
            IpNetworkParseError::IpNetworkError(ref ip_network_error) => {
                write!(fmt, "{}", ip_network_error)
            }
        }
    }
}