mirror of https://github.com/dswd/vpncloud.git
145 lines
3.7 KiB
Rust
145 lines
3.7 KiB
Rust
// VpnCloud - Peer-to-Peer VPN
|
|
// Copyright (C) 2015-2020 Dennis Schwerdel
|
|
// This software is licensed under GPL-3 or newer (see LICENSE.md)
|
|
|
|
#[macro_use]
|
|
mod helper;
|
|
mod nat;
|
|
mod payload;
|
|
mod peers;
|
|
|
|
use std::{
|
|
io::Write,
|
|
net::{IpAddr, Ipv6Addr, SocketAddr},
|
|
sync::{
|
|
atomic::{AtomicUsize, Ordering},
|
|
Once
|
|
}
|
|
};
|
|
|
|
pub use super::{
|
|
cloud::GenericCloud,
|
|
config::Config,
|
|
crypto::Crypto,
|
|
device::MockDevice,
|
|
ethernet::{self, SwitchTable},
|
|
ip::{self, RoutingTable},
|
|
net::MockSocket,
|
|
types::{Protocol, Range, Table},
|
|
udpmessage::Message,
|
|
util::MockTimeSource
|
|
};
|
|
|
|
|
|
static INIT_LOGGER: Once = Once::new();
|
|
|
|
pub fn init_debug_logger() {
|
|
INIT_LOGGER.call_once(|| {
|
|
log::set_boxed_logger(Box::new(DebugLogger)).unwrap();
|
|
log::set_max_level(log::LevelFilter::Debug);
|
|
})
|
|
}
|
|
|
|
struct DebugLogger;
|
|
|
|
impl log::Log for DebugLogger {
|
|
#[inline]
|
|
fn enabled(&self, _metadata: &log::Metadata) -> bool {
|
|
true
|
|
}
|
|
|
|
#[inline]
|
|
fn log(&self, record: &log::Record) {
|
|
if self.enabled(record.metadata()) {
|
|
eprintln!("{} - {}", record.level(), record.args());
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn flush(&self) {
|
|
std::io::stderr().flush().expect("Failed to flush")
|
|
}
|
|
}
|
|
|
|
|
|
type TestNode<P, T> = GenericCloud<MockDevice, P, T, MockSocket, MockTimeSource>;
|
|
|
|
type TapTestNode = TestNode<ethernet::Frame, SwitchTable<MockTimeSource>>;
|
|
#[allow(dead_code)]
|
|
type TunTestNode = TestNode<ip::Packet, RoutingTable>;
|
|
|
|
|
|
thread_local! {
|
|
static NEXT_PORT: AtomicUsize = AtomicUsize::new(1);
|
|
}
|
|
|
|
fn next_sock_addr() -> SocketAddr {
|
|
SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), NEXT_PORT.with(|p| p.fetch_add(1, Ordering::Relaxed)) as u16)
|
|
}
|
|
|
|
fn create_tap_node(nat: bool) -> TapTestNode {
|
|
create_tap_node_with_config(nat, Config::default())
|
|
}
|
|
|
|
fn create_tap_node_with_config(nat: bool, mut config: Config) -> TapTestNode {
|
|
MockSocket::set_nat(nat);
|
|
config.listen = next_sock_addr();
|
|
TestNode::new(&config, MockDevice::new(), SwitchTable::new(1800, 10), true, true, vec![], Crypto::None, None, None)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn create_tun_node(nat: bool, addresses: Vec<Range>) -> TunTestNode {
|
|
MockSocket::set_nat(nat);
|
|
TestNode::new(
|
|
&Config { listen: next_sock_addr(), ..Config::default() },
|
|
MockDevice::new(),
|
|
RoutingTable::new(),
|
|
false,
|
|
false,
|
|
addresses,
|
|
Crypto::None,
|
|
None,
|
|
None
|
|
)
|
|
}
|
|
|
|
|
|
fn msg_get<P: Protocol, T: Table>(node: &mut TestNode<P, T>) -> (SocketAddr, Vec<u8>) {
|
|
let msg = node.socket().pop_outbound();
|
|
assert!(msg.is_some());
|
|
msg.unwrap()
|
|
}
|
|
|
|
fn msg_put<P: Protocol, T: Table>(node: &mut TestNode<P, T>, from: SocketAddr, msg: Vec<u8>) {
|
|
if node.socket().put_inbound(from, msg) {
|
|
node.trigger_socket_event();
|
|
}
|
|
}
|
|
|
|
fn simulate<P: Protocol, T: Table>(nodes: &mut [(&mut TestNode<P, T>, SocketAddr)]) {
|
|
for (ref mut node, ref _from_addr) in nodes.iter_mut() {
|
|
while node.device().has_inbound() {
|
|
node.trigger_device_event();
|
|
}
|
|
}
|
|
let mut clean = false;
|
|
while !clean {
|
|
clean = true;
|
|
let mut msgs = Vec::new();
|
|
for (ref mut node, ref from_addr) in nodes.iter_mut() {
|
|
while let Some((to_addr, msg)) = node.socket().pop_outbound() {
|
|
msgs.push((msg, *from_addr, to_addr));
|
|
}
|
|
}
|
|
clean &= msgs.is_empty();
|
|
for (msg, from_addr, to_addr) in msgs {
|
|
for (ref mut node, ref addr) in nodes.iter_mut() {
|
|
if *addr == to_addr {
|
|
msg_put(node, from_addr, msg);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|