// VpnCloud - Peer-to-Peer VPN // Copyright (C) 2015-2020 Dennis Schwerdel // This software is licensed under GPL-3 or newer (see LICENSE.md) use std::{ collections::{HashMap, VecDeque}, io::{self, ErrorKind}, net::{IpAddr, SocketAddr, UdpSocket, Ipv6Addr}, os::unix::io::{AsRawFd, RawFd}, sync::atomic::{AtomicBool, Ordering} }; use super::util::{MockTimeSource, MsgBuffer, Time, TimeSource}; use crate::port_forwarding::PortForwarding; pub fn mapped_addr(addr: SocketAddr) -> SocketAddr { // HOT PATH match addr { SocketAddr::V4(addr4) => SocketAddr::new(IpAddr::V6(addr4.ip().to_ipv6_mapped()), addr4.port()), _ => addr } } pub fn get_ip() -> IpAddr { let s = UdpSocket::bind("[::]:0").unwrap(); s.connect("8.8.8.8:0").unwrap(); s.local_addr().unwrap().ip() } pub trait Socket: AsRawFd + Sized { fn listen(addr: &str) -> Result; fn receive(&mut self, buffer: &mut MsgBuffer) -> Result; fn send(&mut self, data: &[u8], addr: SocketAddr) -> Result; fn address(&self) -> Result; fn create_port_forwarding(&self) -> Option; } fn parse_listen(addr: &str) -> SocketAddr { if let Some(addr) = addr.strip_prefix("*:") { let port = try_fail!(addr.parse::(), "Invalid port: {}"); SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port) } else if addr.contains(':') { try_fail!(addr.parse::(), "Invalid address: {}: {}", addr) } else { let port = try_fail!(addr.parse::(), "Invalid port: {}"); SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port) } } impl Socket for UdpSocket { fn listen(addr: &str) -> Result { let addr = parse_listen(addr); UdpSocket::bind(addr) } fn receive(&mut self, buffer: &mut MsgBuffer) -> Result { buffer.clear(); let (size, addr) = self.recv_from(buffer.buffer())?; buffer.set_length(size); Ok(addr) } fn send(&mut self, data: &[u8], addr: SocketAddr) -> Result { self.send_to(data, addr) } fn address(&self) -> Result { let mut addr = self.local_addr()?; addr.set_ip(get_ip()); Ok(addr) } fn create_port_forwarding(&self) -> Option { PortForwarding::new(self.address().unwrap().port()) } } thread_local! { static MOCK_SOCKET_NAT: AtomicBool = AtomicBool::new(false); } pub struct MockSocket { nat: bool, nat_peers: HashMap, address: SocketAddr, outbound: VecDeque<(SocketAddr, Vec)>, inbound: VecDeque<(SocketAddr, Vec)> } impl MockSocket { pub fn new(address: SocketAddr) -> Self { Self { nat: Self::get_nat(), nat_peers: HashMap::new(), address, outbound: VecDeque::new(), inbound: VecDeque::new() } } pub fn set_nat(nat: bool) { MOCK_SOCKET_NAT.with(|t| t.store(nat, Ordering::SeqCst)) } pub fn get_nat() -> bool { MOCK_SOCKET_NAT.with(|t| t.load(Ordering::SeqCst)) } pub fn put_inbound(&mut self, from: SocketAddr, data: Vec) -> bool { if !self.nat { self.inbound.push_back((from, data)); return true } if let Some(timeout) = self.nat_peers.get(&from) { if *timeout >= MockTimeSource::now() { self.inbound.push_back((from, data)); return true } } warn!("Sender {:?} is filtered out by NAT", from); false } pub fn pop_outbound(&mut self) -> Option<(SocketAddr, Vec)> { self.outbound.pop_front() } } impl AsRawFd for MockSocket { fn as_raw_fd(&self) -> RawFd { unimplemented!() } } impl Socket for MockSocket { fn listen(addr: &str) -> Result { Ok(Self::new(parse_listen(addr))) } fn receive(&mut self, buffer: &mut MsgBuffer) -> Result { if let Some((addr, data)) = self.inbound.pop_front() { buffer.clear(); buffer.set_length(data.len()); buffer.message_mut().copy_from_slice(&data); Ok(addr) } else { Err(io::Error::new(ErrorKind::Other, "nothing in queue")) } } fn send(&mut self, data: &[u8], addr: SocketAddr) -> Result { self.outbound.push_back((addr, data.to_owned())); if self.nat { self.nat_peers.insert(addr, MockTimeSource::now() + 300); } Ok(data.len()) } fn address(&self) -> Result { Ok(self.address) } fn create_port_forwarding(&self) -> Option { None } } #[cfg(feature = "bench")] mod bench { use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket}; use test::Bencher; #[bench] fn udp_send(b: &mut Bencher) { let sock = UdpSocket::bind("127.0.0.1:0").unwrap(); let data = [0; 1400]; let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 1); b.iter(|| sock.send_to(&data, &addr).unwrap()); b.bytes = 1400; } }