netu 0.2.0

Networking utilities.
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

use std::{
    net::Ipv4Addr,
    ops::{Deref, DerefMut}, sync::{Arc, Mutex, Condvar},
    time::Duration,
    error::Error,
};

pub const LEASE: Duration = Duration::from_secs(10 * 60);

/// A wrapper for `TcpListener` that will stop the forwarding on drop.
/// Implements `Deref` and `DerefMut` to the inner `TcpListener`.
pub struct Forwarded<T> {
    pub(crate) inner: T,
    pub(crate) external: Ipv4Addr,
    pub(crate) state: Arc<(Mutex<State>, Condvar)>
}

#[derive(PartialEq, Eq, Clone, Copy)]
pub(crate) enum State {
    Running,
    Error,
    Terminate,
}

impl<T> Forwarded<T> {
    /// External ip address
    pub fn external(&self) -> Ipv4Addr {
        self.external.clone()
    }
    /// Is forwarding still active
    pub fn is_forwarded(&self) -> bool {
        *self.state.0.lock().unwrap() == State::Running
    }
}

impl<T> Drop for Forwarded<T> {
    fn drop(&mut self) {
        let (lock, cv) = &*self.state;
        let mut guard = lock.lock().unwrap();
        *guard = State::Terminate;
        drop(guard);
        cv.notify_one();
    }
}

impl<T> Deref for Forwarded<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<T> DerefMut for Forwarded<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

#[derive(Debug)]
pub enum ForwardingError {
    DiscoveryFailed,
    CannotFetchExternalIp,
    NonIpv4
}

impl std::fmt::Display for ForwardingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Error for ForwardingError {}