crust 0.32.1

Peer-to-peer networking library. Automatically reconnect and manage connections.
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

// Copyright 2018 MaidSafe.net limited.
//
// This SAFE Network Software is licensed to you under the MIT license <LICENSE-MIT
// http://opensource.org/licenses/MIT> or the Modified BSD license <LICENSE-BSD
// https://opensource.org/licenses/BSD-3-Clause>, at your option. This file may not be copied,
// modified, or distributed except according to those terms. Please review the Licences for the
// specific language governing permissions and limitations relating to use of the SAFE Network
// Software.

//! Defines the `MappingContext` type

use super::NatError;
use crossbeam;
use get_if_addrs::{self, IfAddr};
use igd::{self, Gateway};
use nat;
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
use std::time::Duration;

/// Keeps track of information about external mapping servers
#[derive(Debug, Clone)]
pub struct MappingContext {
    our_ifv4s: Vec<(Ipv4Addr, Option<Gateway>)>,
    our_ifv6s: Vec<Ipv6Addr>,
    peer_stuns: Vec<SocketAddr>,
}

impl MappingContext {
    /// Create a new `MappingContext`
    pub fn new() -> Result<MappingContext, NatError> {
        let ifs = get_if_addrs::get_if_addrs()?;
        let (mut ifv4s, mut ifv6s) = (Vec::with_capacity(5), Vec::with_capacity(5));
        for interface in ifs {
            match interface.addr {
                IfAddr::V4(v4_addr) => ifv4s.push((v4_addr.ip, None)),
                IfAddr::V6(v6_addr) => ifv6s.push(v6_addr.ip),
            }
        }

        crossbeam::scope(|scope| {
            let mut guards = Vec::with_capacity(ifv4s.len());
            for ifv4 in &mut ifv4s {
                if !ifv4.0.is_loopback() {
                    guards.push(scope.spawn(move || {
                        ifv4.1 =
                            igd::search_gateway_from_timeout(ifv4.0, Duration::from_secs(1)).ok();
                    }));
                }
            }
        });

        Ok(MappingContext {
            our_ifv4s: ifv4s,
            our_ifv6s: ifv6s,
            peer_stuns: Vec::with_capacity(10),
        })
    }

    /// Inform the context about external "STUN" servers. Note that crust does not actually use
    /// STUN but a custom STUN-like protocol.
    pub fn add_peer_stuns<A: IntoIterator<Item = SocketAddr>>(&mut self, stun_addrs: A) {
        let listeners = stun_addrs
            .into_iter()
            .filter(|elt| nat::ip_addr_is_global(&elt.ip()));
        self.peer_stuns.extend(listeners);
    }

    /// Get v4 interfaces
    pub fn ifv4s(&self) -> &Vec<(Ipv4Addr, Option<Gateway>)> {
        &self.our_ifv4s
    }

    /// Iterate over the known servers
    pub fn peer_stuns(&self) -> &Vec<SocketAddr> {
        &self.peer_stuns
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Run with `cargo test igd -- --ignored` to find if IGD is available for you
    #[test]
    #[ignore]
    fn igd_gateway_available() {
        let mc = unwrap!(MappingContext::new(), "Could not instantiate MC");
        assert!(!mc.our_ifv4s.is_empty());

        let mut loopback_found = false;
        let mut non_loopback_found = false;

        for ifv4 in mc.our_ifv4s {
            if ifv4.0.is_loopback() {
                loopback_found = true;
                assert!(ifv4.1.is_none());
            } else {
                non_loopback_found = true;
                assert!(ifv4.1.is_some());
            }
        }

        assert!(loopback_found);
        assert!(non_loopback_found);
    }
}