tunneler-core 0.13.1

Provides the Core functionality for the Tunneler software
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

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

/// The Details about a single Connection
#[derive(Debug, PartialEq)]
pub struct Details {
    ip: IpAddr,
}

#[derive(Debug)]
pub enum DeserializeDetailsError {
    DeserializeError(Box<dyn std::fmt::Debug>),
}

impl Details {
    pub(crate) fn new(ip: IpAddr) -> Self {
        Self { ip }
    }

    pub(crate) fn serialize(&self) -> Vec<u8> {
        let mut result = Vec::new();

        result.extend(self.ip.serialize());

        result
    }

    pub(crate) fn deserialize(data: &mut Vec<u8>) -> Result<Details, DeserializeDetailsError> {
        let ip = match IpAddr::deserialize(data) {
            Ok(i) => i,
            Err(e) => return Err(DeserializeDetailsError::DeserializeError(Box::new(e))),
        };

        Ok(Details { ip })
    }

    /// The IP address of the User
    pub fn ip(&self) -> &IpAddr {
        &self.ip
    }
}

trait SerializeDetails: Sized {
    type DeserializeError: std::fmt::Debug;

    fn serialize(&self) -> Vec<u8>;
    fn deserialize(buffer: &mut Vec<u8>) -> Result<Self, Self::DeserializeError>;
}

#[derive(Debug)]
enum DeserializeIPError {
    UnknownID,
    Incomplete,
}
impl SerializeDetails for IpAddr {
    type DeserializeError = DeserializeIPError;

    fn serialize(&self) -> Vec<u8> {
        match self {
            IpAddr::V4(ip4) => {
                let octets = ip4.octets();

                let mut result = vec![0; 5];
                result[0] = 4;
                result[1..5].copy_from_slice(&octets);

                result
            }
            IpAddr::V6(ip6) => {
                let octets = ip6.octets();

                let mut result = vec![0; 17];
                result[0] = 6;
                result[1..17].copy_from_slice(&octets);

                result
            }
        }
    }
    fn deserialize(buffer: &mut Vec<u8>) -> Result<Self, Self::DeserializeError> {
        match buffer.get(0) {
            Some(4) => {
                if buffer.len() < 5 {
                    return Err(DeserializeIPError::Incomplete);
                }

                let mut result = [0; 4];
                result.copy_from_slice(&buffer[1..5]);
                buffer.drain(0..5);
                Ok(IpAddr::V4(Ipv4Addr::from(result)))
            }
            Some(6) => {
                if buffer.len() < 17 {
                    return Err(DeserializeIPError::Incomplete);
                }

                let mut result = [0; 16];
                result.copy_from_slice(&buffer[1..17]);
                buffer.drain(0..17);
                Ok(IpAddr::V6(Ipv6Addr::from(result)))
            }
            _ => Err(DeserializeIPError::UnknownID),
        }
    }
}

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

    #[test]
    fn serialize_v4() {
        let ip = IpAddr::V4(Ipv4Addr::from([1, 2, 3, 4]));
        let expected = vec![4, 1, 2, 3, 4];
        assert_eq!(expected, ip.serialize());
    }
    #[test]
    fn deserialize_v4() {
        let mut data = vec![4, 1, 2, 3, 4];
        let expected = IpAddr::V4(Ipv4Addr::from([1, 2, 3, 4]));

        let result = IpAddr::deserialize(&mut data);
        assert_eq!(true, result.is_ok());
        assert_eq!(expected, result.unwrap());
        assert_eq!(0, data.len());
    }

    #[test]
    fn serialize_v6() {
        let ip = IpAddr::V6(Ipv6Addr::from([
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
        ]));
        let expected = vec![6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
        assert_eq!(expected, ip.serialize());
    }
    #[test]
    fn deserialize_v6() {
        let mut data = vec![6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
        let expected = IpAddr::V6(Ipv6Addr::from([
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
        ]));

        let result = IpAddr::deserialize(&mut data);
        assert_eq!(true, result.is_ok());
        assert_eq!(expected, result.unwrap());
        assert_eq!(0, data.len());
    }
}