nmrs 3.5.5

A Rust library for NetworkManager over D-Bus
Documentation 
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Typed IP addresses and routes decoded from saved connection profiles.

use std::{
    fmt::{self, Display},
    net::{AddrParseError, Ipv4Addr, Ipv6Addr},
    num::ParseIntError,
    str::FromStr,
};

use thiserror::Error;

/// An IP address with its prefix length, such as `192.0.2.10/24`.
///
/// `A` is [`Ipv4Addr`] or [`Ipv6Addr`], so an `IpAddress<Ipv4Addr>` can never
/// carry an IPv6 address. The `address/prefix` form parses with [`FromStr`]:
///
/// ```rust
/// use std::net::Ipv4Addr;
/// use nmrs::models::IpAddress;
///
/// let addr: IpAddress<Ipv4Addr> = "192.0.2.10/24".parse().unwrap();
/// assert_eq!(addr.address, Ipv4Addr::new(192, 0, 2, 10));
/// assert_eq!(addr.prefix, 24);
/// assert_eq!(addr.to_string(), "192.0.2.10/24");
/// ```
#[non_exhaustive]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct IpAddress<A> {
    /// The address itself.
    pub address: A,
    /// Prefix length in bits: `0..=32` for IPv4, `0..=128` for IPv6.
    pub prefix: u8,
}

impl<A> IpAddress<A> {
    /// Creates an address with the given prefix length.
    pub fn new(address: A, prefix: u8) -> Self {
        Self { address, prefix }
    }
}

impl<A> Display for IpAddress<A>
where
    A: Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}/{}", self.address, self.prefix)
    }
}

impl<A> fmt::Debug for IpAddress<A>
where
    A: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}/{}", self.address, self.prefix)
    }
}

impl FromStr for IpAddress<Ipv4Addr> {
    type Err = IpAddressParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (address, prefix) = s.rsplit_once('/').ok_or(IpAddressParseError::Split)?;
        let address = address.parse()?;
        let prefix = prefix.parse()?;
        Ok(Self { address, prefix })
    }
}

impl FromStr for IpAddress<Ipv6Addr> {
    type Err = IpAddressParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (address, prefix) = s.rsplit_once('/').ok_or(IpAddressParseError::Split)?;
        let address = address.parse()?;
        let prefix = prefix.parse()?;
        Ok(Self { address, prefix })
    }
}

impl From<IpAddress<Ipv4Addr>> for Ipv4Addr {
    fn from(value: IpAddress<Ipv4Addr>) -> Self {
        value.address
    }
}

impl From<IpAddress<Ipv6Addr>> for Ipv6Addr {
    fn from(value: IpAddress<Ipv6Addr>) -> Self {
        value.address
    }
}

/// A static route from a profile's `route-data`.
///
/// `dest` is the destination network with its prefix length. `next_hop` is
/// `None` for routes reachable directly on the link, and `metric` is `None`
/// when the profile leaves the metric to NetworkManager.
#[non_exhaustive]
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct IpRoute<A> {
    /// Destination network and prefix length.
    pub dest: IpAddress<A>,
    /// Next-hop gateway, if the route has one.
    pub next_hop: Option<A>,
    /// Route metric, if the profile sets one explicitly.
    pub metric: Option<u32>,
}

impl<A> IpRoute<A> {
    /// Creates a route to `dest` with no next hop and no explicit metric.
    pub fn new(dest: IpAddress<A>) -> Self {
        Self {
            dest,
            next_hop: None,
            metric: None,
        }
    }
}

/// Why a string could not be parsed as an [`IpAddress`].
#[non_exhaustive]
#[derive(Debug, Clone, Error)]
pub enum IpAddressParseError {
    /// The part before the `/` is not an address of the requested family.
    #[error("address parsing failed: {0}")]
    Addr(#[from] AddrParseError),
    /// The part after the `/` is not a prefix length.
    #[error("prefix parsing failed: {0}")]
    Prefix(#[from] ParseIntError),
    /// The string has no `/` separating address and prefix.
    #[error("could not split into address and prefix")]
    Split,
}