inherface 0.3.0

Retrieve a system's Network Interfaces on Linux
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
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Network Interface abstraction from commonly used fields for nodes from the
//! linked list provided by system functions like `getifaddrs` and
//! `GetAdaptersAddresses`.
#[cfg(feature = "mac")]
use mac_address::MacAddress;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::fmt::{Debug, Display};
use std::net::{Ipv4Addr, Ipv6Addr};

/// A system's network interface
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub struct NetworkInterface {
    /// Interface's name
    pub name: String,
    /// The position of this interface in the list of interfaces
    pub index: u32,
    /// Collection of interface's Ipv4 addresses
    #[cfg(feature = "ipv4")]
    pub v4_addr: Vec<V4IfAddr>,
    /// Collection of interface's Ipv6 addresses
    #[cfg(feature = "ipv6")]
    pub v6_addr: Vec<V6IfAddr>,
    /// MAC Address
    #[cfg(feature = "mac")]
    pub mac_addr: Option<MacAddress>,
}

/// IPV4 Interface from the AFINET network interface family
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub struct V4IfAddr {
    /// The IP address for this network interface
    pub ip: Ipv4Addr,
    /// The broadcast address for this interface
    pub broadcast: Option<Ipv4Addr>,
    /// The netmask for this interface
    pub netmask: Option<Ipv4Addr>,
}

/// IPV6 Interface from the AFINET6 network interface family
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub struct V6IfAddr {
    /// The IP address for this network interface
    pub ip: Ipv6Addr,
    /// The broadcast address for this interface
    pub broadcast: Option<Ipv6Addr>,
    /// The netmask for this interface
    pub netmask: Option<Ipv6Addr>,
}

impl NetworkInterface {
    /// Create a NetworkInterface with default, empty values
    /// for everything except name and index.
    pub fn new(name: String, index: u32) -> Self {
        NetworkInterface {
            name,
            index,
            #[cfg(feature = "ipv4")]
            v4_addr: Vec::new(),
            #[cfg(feature = "ipv6")]
            v6_addr: Vec::new(),
            #[cfg(feature = "mac")]
            mac_addr: None,
        }
    }

    /// Add ipv4 addresses to NetworkInterface.v4_addr
    #[cfg(feature = "ipv4")]
    pub fn add_v4(&mut self, ip: Ipv4Addr, broadcast: Option<Ipv4Addr>, netmask: Option<Ipv4Addr>) {
        let v4 = V4IfAddr {
            ip,
            broadcast,
            netmask,
        };

        self.v4_addr.push(v4);
    }

    /// Add ipv6 addresses to NetworkInterface.v6_addr
    #[cfg(feature = "ipv6")]
    pub fn add_v6(&mut self, ip: Ipv6Addr, broadcast: Option<Ipv6Addr>, netmask: Option<Ipv6Addr>) {
        let v6 = V6IfAddr {
            ip,
            broadcast,
            netmask,
        };

        self.v6_addr.push(v6);
    }
}

impl Display for NetworkInterface {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{}. {}", self.index, self.name)?;

        if let Some(mac) = self.mac_addr {
            write!(f, "    link: {mac}\n")?;
        };

        for v4_addr in self.v4_addr.iter() {
            write!(f, "{}", v4_addr)?
        }

        for v6_addr in self.v6_addr.iter() {
            write!(f, "{}", v6_addr)?
        }

        Ok(())
    }
}

/// This implementation of Display is meant to be used in conjunction with `NetworkInterface`.
impl Display for V4IfAddr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "    ipv4: {}\n", self.ip)?;

        if let Some(netmask) = self.netmask {
            write!(f, "        netmask: {netmask}\n")?;
        };

        if let Some(broadcast) = self.broadcast {
            write!(f, "        broadcast: {broadcast}\n")?;
        };

        Ok(())
    }
}

/// This implementation of Display is meant to be used in conjunction with `NetworkInterface`.
impl Display for V6IfAddr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "    ipv6: {}\n", self.ip)?;

        if let Some(netmask) = self.netmask {
            write!(f, "        netmask: {netmask}\n")?;
        };

        if let Some(broadcast) = self.broadcast {
            write!(f, "        broadcast: {broadcast}\n")?;
        };

        Ok(())
    }
}