quincy-server 1.0.0-beta.8

QUIC-based VPN - Server binaries
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

use dashmap::DashSet;
use ipnet::{IpAddrRange, IpNet, Ipv4AddrRange, Ipv6AddrRange};
use std::net::IpAddr;

/// Represents a pool of addresses from which addresses can be requested and released.
pub struct AddressPool {
    network: IpNet,
    used_addresses: DashSet<IpAddr>,
}

impl AddressPool {
    /// Creates a new instance of an `AddressPool`.
    ///
    /// ### Arguments
    /// - `network` - the network address and mask
    pub fn new(network: IpNet) -> Self {
        let pool = Self {
            network,
            used_addresses: DashSet::new(),
        };

        pool.reset();

        pool
    }

    /// Returns the next available address if such an address exists.
    pub fn next_available_address(&self) -> Option<IpNet> {
        let mut range = match self.network {
            IpNet::V4(network) => {
                IpAddrRange::V4(Ipv4AddrRange::new(network.network(), network.broadcast()))
            }
            IpNet::V6(network) => {
                IpAddrRange::V6(Ipv6AddrRange::new(network.network(), network.broadcast()))
            }
        };

        range
            .find(|address| !self.used_addresses.contains(address))
            .map(|address| {
                self.used_addresses.insert(address);
                IpNet::with_netmask(address, self.network.netmask())
                    .expect("Netmask will always be valid")
            })
    }

    /// Releases the specified address so it can be used in further requests.
    ///
    /// ### Arguments
    /// - `address` - the address to release
    pub fn release_address(&self, address: &IpAddr) {
        self.used_addresses.remove(address);
    }

    /// Resets the address pool by releasing all addresses.
    pub fn reset(&self) {
        self.used_addresses.clear();
        self.used_addresses.insert(self.network.network());
        self.used_addresses.insert(self.network.addr());
        self.used_addresses.insert(self.network.broadcast());
    }
}

#[cfg(test)]
mod tests {
    use crate::server::address_pool::AddressPool;
    use ipnet::{IpNet, Ipv4Net};
    use std::net::{IpAddr, Ipv4Addr};

    #[test]
    fn test_address_pool() {
        let pool = AddressPool::new(IpNet::V4(
            Ipv4Net::with_netmask(
                Ipv4Addr::new(10, 0, 0, 1),
                Ipv4Addr::new(255, 255, 255, 252),
            )
            .unwrap(),
        ));

        assert_eq!(
            pool.next_available_address().unwrap(),
            IpNet::V4(
                Ipv4Net::with_netmask(
                    Ipv4Addr::new(10, 0, 0, 2),
                    Ipv4Addr::new(255, 255, 255, 252),
                )
                .unwrap()
            )
        );

        assert_eq!(pool.next_available_address(), None);
        pool.release_address(&IpAddr::V4(Ipv4Addr::new(10, 0, 0, 2)));

        assert_eq!(
            pool.next_available_address().unwrap(),
            IpNet::V4(
                Ipv4Net::with_netmask(
                    Ipv4Addr::new(10, 0, 0, 2),
                    Ipv4Addr::new(255, 255, 255, 252),
                )
                .unwrap()
            )
        );
    }
}