2016-02-05 15:58:32 +00:00
|
|
|
// VpnCloud - Peer-to-Peer VPN
|
|
|
|
// Copyright (C) 2015-2016 Dennis Schwerdel
|
|
|
|
// This software is licensed under GPL-3 or newer (see LICENSE.md)
|
|
|
|
|
2016-05-02 07:05:34 +00:00
|
|
|
use std::net::{SocketAddr, ToSocketAddrs};
|
|
|
|
use std::collections::{HashMap, HashSet};
|
2015-11-19 15:34:20 +00:00
|
|
|
use std::net::UdpSocket;
|
2016-02-08 19:37:06 +00:00
|
|
|
use std::io::Result as IoResult;
|
2015-11-23 00:04:30 +00:00
|
|
|
use std::fmt;
|
2015-11-20 08:11:54 +00:00
|
|
|
use std::os::unix::io::AsRawFd;
|
2015-11-21 17:09:13 +00:00
|
|
|
use std::marker::PhantomData;
|
2016-03-29 08:45:54 +00:00
|
|
|
use std::hash::BuildHasherDefault;
|
2015-11-19 15:34:20 +00:00
|
|
|
|
2016-03-29 08:45:54 +00:00
|
|
|
use fnv::FnvHasher;
|
2015-11-20 08:11:54 +00:00
|
|
|
use epoll;
|
2015-11-25 13:31:05 +00:00
|
|
|
use nix::sys::signal::{SIGTERM, SIGQUIT, SIGINT};
|
|
|
|
use signal::trap::Trap;
|
2015-11-25 20:55:30 +00:00
|
|
|
use time::SteadyTime;
|
2015-12-04 10:25:14 +00:00
|
|
|
use rand::{random, sample, thread_rng};
|
2016-05-02 06:35:11 +00:00
|
|
|
use net2::UdpBuilder;
|
2015-11-19 15:34:20 +00:00
|
|
|
|
2015-12-03 08:38:14 +00:00
|
|
|
use super::types::{Table, Protocol, Range, Error, NetworkId, NodeId};
|
2015-11-23 00:40:47 +00:00
|
|
|
use super::device::Device;
|
2015-11-22 16:28:04 +00:00
|
|
|
use super::udpmessage::{encode, decode, Options, Message};
|
2015-11-24 19:55:14 +00:00
|
|
|
use super::crypto::Crypto;
|
2015-12-04 10:25:14 +00:00
|
|
|
use super::util::{now, Time, Duration};
|
2015-11-19 15:34:20 +00:00
|
|
|
|
2016-03-29 08:45:54 +00:00
|
|
|
type Hash = BuildHasherDefault<FnvHasher>;
|
|
|
|
|
2015-11-19 15:34:20 +00:00
|
|
|
struct PeerList {
|
|
|
|
timeout: Duration,
|
2016-05-02 07:05:34 +00:00
|
|
|
peers: HashMap<SocketAddr, (Time, NodeId, Vec<SocketAddr>), Hash>,
|
|
|
|
nodes: HashMap<NodeId, SocketAddr, Hash>,
|
|
|
|
addresses: HashSet<SocketAddr, Hash>
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl PeerList {
|
|
|
|
fn new(timeout: Duration) -> PeerList {
|
2016-05-02 07:05:34 +00:00
|
|
|
PeerList{
|
|
|
|
peers: HashMap::default(),
|
|
|
|
timeout: timeout,
|
|
|
|
nodes: HashMap::default(),
|
|
|
|
addresses: HashSet::default()
|
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2015-11-20 11:09:07 +00:00
|
|
|
fn timeout(&mut self) -> Vec<SocketAddr> {
|
2015-11-25 20:55:30 +00:00
|
|
|
let now = now();
|
2015-11-19 15:34:20 +00:00
|
|
|
let mut del: Vec<SocketAddr> = Vec::new();
|
2016-05-02 07:05:34 +00:00
|
|
|
for (&addr, &(timeout, _nodeid, ref _alt_addrs)) in &self.peers {
|
2015-11-19 15:34:20 +00:00
|
|
|
if timeout < now {
|
|
|
|
del.push(addr);
|
|
|
|
}
|
|
|
|
}
|
2015-11-20 11:09:07 +00:00
|
|
|
for addr in &del {
|
2016-02-02 21:03:56 +00:00
|
|
|
debug!("Forgot peer: {}", addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
if let Some((_timeout, nodeid, alt_addrs)) = self.peers.remove(addr) {
|
|
|
|
self.nodes.remove(&nodeid);
|
|
|
|
self.addresses.remove(addr);
|
|
|
|
for addr in &alt_addrs {
|
|
|
|
self.addresses.remove(addr);
|
|
|
|
}
|
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
2015-11-20 11:09:07 +00:00
|
|
|
del
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2015-11-20 12:34:54 +00:00
|
|
|
#[inline(always)]
|
2016-05-11 08:54:00 +00:00
|
|
|
fn contains_addr(&self, addr: &SocketAddr) -> bool {
|
2016-05-02 07:05:34 +00:00
|
|
|
self.addresses.contains(addr)
|
|
|
|
}
|
|
|
|
|
2016-05-24 08:32:03 +00:00
|
|
|
#[inline]
|
|
|
|
fn is_connected<Addr: ToSocketAddrs+fmt::Display>(&self, addr: Addr) -> Result<bool, Error> {
|
|
|
|
let mut addrs = try!(addr.to_socket_addrs().map_err(|_| Error::SocketError("Error looking up name")));
|
|
|
|
while let Some(a) = addrs.next() {
|
|
|
|
if self.contains_addr(&a) {
|
|
|
|
return Ok(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(false)
|
|
|
|
}
|
|
|
|
|
2016-05-02 07:05:34 +00:00
|
|
|
#[inline(always)]
|
2016-05-11 08:54:00 +00:00
|
|
|
fn contains_node(&self, node_id: &NodeId) -> bool {
|
2016-05-02 07:05:34 +00:00
|
|
|
self.nodes.contains_key(node_id)
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2016-05-02 07:05:34 +00:00
|
|
|
|
2015-11-20 12:34:54 +00:00
|
|
|
#[inline]
|
2016-05-02 07:05:34 +00:00
|
|
|
fn add(&mut self, node_id: NodeId, addr: SocketAddr) {
|
|
|
|
if self.nodes.insert(node_id, addr).is_none() {
|
2016-02-02 21:03:56 +00:00
|
|
|
info!("New peer: {}", addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
self.peers.insert(addr, (now()+self.timeout as Time, node_id, vec![]));
|
2016-05-25 11:30:18 +00:00
|
|
|
self.addresses.insert(addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn add_alt_addr(&mut self, node_id: NodeId, addr: SocketAddr) {
|
|
|
|
if let Some(main_addr) = self.nodes.get(&node_id) {
|
|
|
|
if let Some(&mut (_timeout, _node_id, ref mut alt_addrs)) = self.peers.get_mut(main_addr) {
|
|
|
|
alt_addrs.push(addr);
|
2016-05-25 11:30:18 +00:00
|
|
|
self.addresses.insert(addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
} else {
|
|
|
|
error!("Main address for node is not connected");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
error!("Node not connected");
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-20 12:34:54 +00:00
|
|
|
#[inline]
|
2015-11-19 15:34:20 +00:00
|
|
|
fn as_vec(&self) -> Vec<SocketAddr> {
|
2016-05-02 07:05:34 +00:00
|
|
|
self.addresses.iter().map(|addr| *addr).collect()
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2015-11-20 12:34:54 +00:00
|
|
|
#[inline(always)]
|
|
|
|
fn len(&self) -> usize {
|
|
|
|
self.peers.len()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2015-12-04 10:25:14 +00:00
|
|
|
fn subset(&self, size: usize) -> Vec<SocketAddr> {
|
|
|
|
sample(&mut thread_rng(), self.as_vec(), size)
|
2015-11-20 12:34:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2015-11-19 15:34:20 +00:00
|
|
|
fn remove(&mut self, addr: &SocketAddr) {
|
2016-05-02 07:05:34 +00:00
|
|
|
if let Some((_timeout, node_id, alt_addrs)) = self.peers.remove(&addr) {
|
2016-02-02 21:03:56 +00:00
|
|
|
info!("Removed peer: {}", addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
self.nodes.remove(&node_id);
|
|
|
|
self.addresses.remove(addr);
|
|
|
|
for addr in alt_addrs {
|
|
|
|
self.addresses.remove(&addr);
|
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-24 08:32:03 +00:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct ReconnectEntry {
|
|
|
|
address: String,
|
|
|
|
tries: u16,
|
|
|
|
timeout: u16,
|
|
|
|
next: Time
|
|
|
|
}
|
2015-11-22 16:28:04 +00:00
|
|
|
|
2015-11-23 00:40:47 +00:00
|
|
|
pub struct GenericCloud<P: Protocol> {
|
2015-12-03 08:38:14 +00:00
|
|
|
node_id: NodeId,
|
2015-11-20 08:11:54 +00:00
|
|
|
peers: PeerList,
|
2015-11-22 23:49:58 +00:00
|
|
|
addresses: Vec<Range>,
|
2015-11-22 21:00:34 +00:00
|
|
|
learning: bool,
|
2015-11-22 21:45:04 +00:00
|
|
|
broadcast: bool,
|
2016-05-24 08:32:03 +00:00
|
|
|
reconnect_peers: Vec<ReconnectEntry>,
|
2015-12-03 08:38:14 +00:00
|
|
|
blacklist_peers: Vec<SocketAddr>,
|
2015-11-23 00:40:47 +00:00
|
|
|
table: Box<Table>,
|
2016-05-02 06:35:11 +00:00
|
|
|
socket4: UdpSocket,
|
|
|
|
socket6: UdpSocket,
|
2015-11-23 00:40:47 +00:00
|
|
|
device: Device,
|
2015-11-23 14:40:04 +00:00
|
|
|
options: Options,
|
|
|
|
crypto: Crypto,
|
2015-11-25 20:55:30 +00:00
|
|
|
next_peerlist: Time,
|
2015-11-19 19:51:53 +00:00
|
|
|
update_freq: Duration,
|
2015-11-20 09:59:01 +00:00
|
|
|
buffer_out: [u8; 64*1024],
|
2015-11-25 20:55:30 +00:00
|
|
|
next_housekeep: Time,
|
2015-11-23 00:40:47 +00:00
|
|
|
_dummy_p: PhantomData<P>,
|
2015-11-19 16:11:59 +00:00
|
|
|
}
|
|
|
|
|
2015-11-23 00:40:47 +00:00
|
|
|
impl<P: Protocol> GenericCloud<P> {
|
2016-05-02 06:35:11 +00:00
|
|
|
pub fn new(device: Device, listen: u16, network_id: Option<NetworkId>, table: Box<Table>,
|
2015-11-23 14:40:04 +00:00
|
|
|
peer_timeout: Duration, learning: bool, broadcast: bool, addresses: Vec<Range>,
|
|
|
|
crypto: Crypto) -> Self {
|
2016-05-02 06:35:11 +00:00
|
|
|
let socket4 = match UdpBuilder::new_v4().expect("Failed to obtain ipv4 socket builder")
|
|
|
|
.reuse_address(true).expect("Failed to set so_reuseaddr").bind(("0.0.0.0", listen)) {
|
2015-11-19 15:34:20 +00:00
|
|
|
Ok(socket) => socket,
|
2016-05-02 06:35:11 +00:00
|
|
|
Err(err) => fail!("Failed to open ipv4 address 0.0.0.0:{}: {}", listen, err)
|
|
|
|
};
|
|
|
|
let socket6 = match UdpBuilder::new_v6().expect("Failed to obtain ipv6 socket builder")
|
|
|
|
.only_v6(true).expect("Failed to set only_v6")
|
|
|
|
.reuse_address(true).expect("Failed to set so_reuseaddr").bind(("::", listen)) {
|
|
|
|
Ok(socket) => socket,
|
|
|
|
Err(err) => fail!("Failed to open ipv6 address ::{}: {}", listen, err)
|
2015-11-19 15:34:20 +00:00
|
|
|
};
|
2015-11-23 14:40:04 +00:00
|
|
|
let mut options = Options::default();
|
|
|
|
options.network_id = network_id;
|
2015-11-22 16:28:04 +00:00
|
|
|
GenericCloud{
|
2015-12-03 08:38:14 +00:00
|
|
|
node_id: random(),
|
2015-11-20 08:11:54 +00:00
|
|
|
peers: PeerList::new(peer_timeout),
|
2015-11-22 21:00:34 +00:00
|
|
|
addresses: addresses,
|
|
|
|
learning: learning,
|
2015-11-22 21:45:04 +00:00
|
|
|
broadcast: broadcast,
|
2015-11-20 11:09:07 +00:00
|
|
|
reconnect_peers: Vec::new(),
|
2015-12-03 08:38:14 +00:00
|
|
|
blacklist_peers: Vec::new(),
|
2015-11-22 15:48:01 +00:00
|
|
|
table: table,
|
2016-05-02 06:35:11 +00:00
|
|
|
socket4: socket4,
|
|
|
|
socket6: socket6,
|
2015-11-22 15:48:01 +00:00
|
|
|
device: device,
|
2015-11-23 14:40:04 +00:00
|
|
|
options: options,
|
|
|
|
crypto: crypto,
|
2015-11-25 20:55:30 +00:00
|
|
|
next_peerlist: now(),
|
2015-11-19 19:51:53 +00:00
|
|
|
update_freq: peer_timeout/2,
|
2015-11-20 09:59:01 +00:00
|
|
|
buffer_out: [0; 64*1024],
|
2015-11-25 20:55:30 +00:00
|
|
|
next_housekeep: now(),
|
2015-11-23 00:40:47 +00:00
|
|
|
_dummy_p: PhantomData,
|
2015-11-20 08:11:54 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2015-12-22 21:45:52 +00:00
|
|
|
#[inline]
|
2015-11-23 18:06:25 +00:00
|
|
|
pub fn ifname(&self) -> &str {
|
|
|
|
self.device.ifname()
|
|
|
|
}
|
|
|
|
|
2015-12-22 21:45:52 +00:00
|
|
|
#[inline]
|
|
|
|
fn broadcast_msg(&mut self, msg: &mut Message) -> Result<(), Error> {
|
|
|
|
debug!("Broadcasting {:?}", msg);
|
|
|
|
let msg_data = encode(&mut self.options, msg, &mut self.buffer_out, &mut self.crypto);
|
|
|
|
for addr in &self.peers.as_vec() {
|
2016-05-02 06:35:11 +00:00
|
|
|
let socket = match addr {
|
|
|
|
&SocketAddr::V4(_) => &self.socket4,
|
|
|
|
&SocketAddr::V6(_) => &self.socket6
|
|
|
|
};
|
|
|
|
try!(match socket.send_to(msg_data, addr) {
|
2015-12-22 21:45:52 +00:00
|
|
|
Ok(written) if written == msg_data.len() => Ok(()),
|
|
|
|
Ok(_) => Err(Error::SocketError("Sent out truncated packet")),
|
|
|
|
Err(e) => {
|
|
|
|
error!("Failed to send via network {:?}", e);
|
|
|
|
Err(Error::SocketError("IOError when sending"))
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn send_msg(&mut self, addr: SocketAddr, msg: &mut Message) -> Result<(), Error> {
|
2015-11-19 15:34:20 +00:00
|
|
|
debug!("Sending {:?} to {}", msg, addr);
|
2015-12-13 21:03:06 +00:00
|
|
|
let msg_data = encode(&mut self.options, msg, &mut self.buffer_out, &mut self.crypto);
|
2016-05-02 06:35:11 +00:00
|
|
|
let socket = match &addr {
|
|
|
|
&SocketAddr::V4(_) => &self.socket4,
|
|
|
|
&SocketAddr::V6(_) => &self.socket6
|
|
|
|
};
|
|
|
|
match socket.send_to(msg_data, addr) {
|
2015-12-13 21:03:06 +00:00
|
|
|
Ok(written) if written == msg_data.len() => Ok(()),
|
2015-11-19 15:34:20 +00:00
|
|
|
Ok(_) => Err(Error::SocketError("Sent out truncated packet")),
|
|
|
|
Err(e) => {
|
|
|
|
error!("Failed to send via network {:?}", e);
|
|
|
|
Err(Error::SocketError("IOError when sending"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-08 19:37:06 +00:00
|
|
|
#[allow(dead_code)]
|
2016-05-02 06:35:11 +00:00
|
|
|
pub fn address(&self) -> IoResult<(SocketAddr, SocketAddr)> {
|
|
|
|
Ok((try!(self.socket4.local_addr()), try!(self.socket6.local_addr())))
|
2016-02-08 19:37:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(dead_code)]
|
|
|
|
pub fn peer_count(&self) -> usize {
|
|
|
|
self.peers.len()
|
|
|
|
}
|
|
|
|
|
2016-05-11 08:54:00 +00:00
|
|
|
pub fn add_reconnect_peer(&mut self, add: String) {
|
2016-05-24 08:32:03 +00:00
|
|
|
self.reconnect_peers.push(ReconnectEntry {
|
|
|
|
address: add,
|
|
|
|
tries: 0,
|
|
|
|
timeout: 1,
|
|
|
|
next: now()
|
|
|
|
})
|
2016-05-11 08:54:00 +00:00
|
|
|
}
|
|
|
|
|
2016-05-24 08:32:03 +00:00
|
|
|
fn is_blacklisted<Addr: ToSocketAddrs+fmt::Display>(&self, addr: Addr) -> Result<bool, Error> {
|
|
|
|
let mut addrs = try!(addr.to_socket_addrs().map_err(|_| Error::SocketError("Error looking up name")));
|
|
|
|
while let Some(a) = addrs.next() {
|
|
|
|
if self.blacklist_peers.contains(&a) {
|
|
|
|
return Ok(true);
|
2015-11-20 11:09:07 +00:00
|
|
|
}
|
|
|
|
}
|
2016-05-24 08:32:03 +00:00
|
|
|
Ok(false)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn connect<Addr: ToSocketAddrs+fmt::Display+Clone>(&mut self, addr: Addr) -> Result<(), Error> {
|
|
|
|
if try!(self.peers.is_connected(addr.clone())) || try!(self.is_blacklisted(addr.clone())) {
|
|
|
|
return Ok(())
|
|
|
|
}
|
2015-11-23 10:55:37 +00:00
|
|
|
debug!("Connecting to {}", addr);
|
2015-12-22 21:44:25 +00:00
|
|
|
let subnets = self.addresses.clone();
|
2015-12-03 08:38:14 +00:00
|
|
|
let node_id = self.node_id.clone();
|
2015-12-22 21:44:25 +00:00
|
|
|
let mut msg = Message::Init(0, node_id, subnets);
|
2016-05-25 11:30:18 +00:00
|
|
|
if let Ok(addrs) = addr.to_socket_addrs() {
|
|
|
|
let mut addrs = addrs.collect::<Vec<_>>();
|
|
|
|
addrs.dedup();
|
|
|
|
for a in addrs {
|
2015-12-22 21:44:25 +00:00
|
|
|
//Ignore error this time
|
|
|
|
self.send_msg(a, &mut msg).ok();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(())
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
|
2015-11-20 08:11:54 +00:00
|
|
|
fn housekeep(&mut self) -> Result<(), Error> {
|
|
|
|
self.peers.timeout();
|
2015-11-21 17:09:13 +00:00
|
|
|
self.table.housekeep();
|
2016-05-24 08:32:03 +00:00
|
|
|
let now = now();
|
|
|
|
if self.next_peerlist <= now {
|
2015-11-19 15:34:20 +00:00
|
|
|
debug!("Send peer list to all peers");
|
2015-11-20 12:34:54 +00:00
|
|
|
let mut peer_num = self.peers.len();
|
|
|
|
if peer_num > 10 {
|
|
|
|
peer_num = (peer_num as f32).sqrt().ceil() as usize;
|
|
|
|
if peer_num < 10 {
|
|
|
|
peer_num = 10;
|
|
|
|
}
|
2016-02-04 21:40:26 +00:00
|
|
|
if peer_num > 255 {
|
|
|
|
peer_num = 255
|
|
|
|
}
|
2015-11-20 12:34:54 +00:00
|
|
|
}
|
2015-12-04 10:25:14 +00:00
|
|
|
let peers = self.peers.subset(peer_num);
|
2015-12-13 21:03:06 +00:00
|
|
|
let mut msg = Message::Peers(peers);
|
2015-12-22 21:45:52 +00:00
|
|
|
try!(self.broadcast_msg(&mut msg));
|
2016-05-24 08:32:03 +00:00
|
|
|
self.next_peerlist = now + self.update_freq as Time;
|
|
|
|
}
|
|
|
|
for entry in self.reconnect_peers.clone() {
|
|
|
|
if entry.next > now {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
try!(self.connect(&entry.address as &str));
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
2016-05-24 08:32:03 +00:00
|
|
|
for entry in &mut self.reconnect_peers {
|
|
|
|
if try!(self.peers.is_connected(&entry.address as &str)) {
|
|
|
|
entry.tries = 0;
|
|
|
|
entry.timeout = 1;
|
|
|
|
entry.next = now + 1;
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if entry.next > now {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
entry.tries += 1;
|
|
|
|
if entry.tries > 10 {
|
|
|
|
entry.tries = 0;
|
|
|
|
entry.timeout *= 2;
|
|
|
|
}
|
|
|
|
if entry.timeout > 3600 {
|
|
|
|
entry.timeout = 3600;
|
|
|
|
}
|
|
|
|
entry.next = now + entry.timeout as Time;
|
2015-11-20 11:09:07 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2016-02-08 19:37:06 +00:00
|
|
|
pub fn handle_interface_data(&mut self, payload: &mut [u8], start: usize, end: usize) -> Result<(), Error> {
|
2015-12-22 21:47:41 +00:00
|
|
|
let (src, dst) = try!(P::parse(&payload[start..end]));
|
|
|
|
debug!("Read data from interface: src: {}, dst: {}, {} bytes", src, dst, end-start);
|
2015-11-22 17:05:15 +00:00
|
|
|
match self.table.lookup(&dst) {
|
2015-11-19 15:34:20 +00:00
|
|
|
Some(addr) => {
|
2015-11-26 21:16:51 +00:00
|
|
|
debug!("Found destination for {} => {}", dst, addr);
|
2016-05-02 07:05:34 +00:00
|
|
|
if self.peers.contains_addr(&addr) {
|
2015-12-13 21:03:06 +00:00
|
|
|
try!(self.send_msg(addr, &mut Message::Data(payload, start, end)))
|
2015-11-22 21:00:34 +00:00
|
|
|
} else {
|
2015-11-26 21:16:51 +00:00
|
|
|
warn!("Destination for {} not found in peers: {}", dst, addr);
|
2016-03-29 11:54:28 +00:00
|
|
|
self.table.remove(&dst);
|
2015-11-22 21:00:34 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
},
|
|
|
|
None => {
|
2015-11-22 21:45:04 +00:00
|
|
|
if !self.broadcast {
|
2015-11-26 21:16:51 +00:00
|
|
|
debug!("No destination for {} found, dropping", dst);
|
2015-11-22 21:45:04 +00:00
|
|
|
return Ok(());
|
|
|
|
}
|
2015-11-26 21:16:51 +00:00
|
|
|
debug!("No destination for {} found, broadcasting", dst);
|
2015-12-13 21:03:06 +00:00
|
|
|
let mut msg = Message::Data(payload, start, end);
|
2015-12-22 21:45:52 +00:00
|
|
|
try!(self.broadcast_msg(&mut msg));
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2016-02-08 19:37:06 +00:00
|
|
|
pub fn handle_net_message(&mut self, peer: SocketAddr, options: Options, msg: Message) -> Result<(), Error> {
|
2015-12-02 13:16:13 +00:00
|
|
|
if self.options.network_id != options.network_id {
|
|
|
|
info!("Ignoring message from {} with wrong token {:?}", peer, options.network_id);
|
|
|
|
return Err(Error::WrongNetwork(options.network_id));
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
2015-11-25 20:05:11 +00:00
|
|
|
debug!("Received {:?} from {}", msg, peer);
|
2015-11-19 15:34:20 +00:00
|
|
|
match msg {
|
2015-12-13 21:03:06 +00:00
|
|
|
Message::Data(payload, start, end) => {
|
|
|
|
let (src, _dst) = try!(P::parse(&payload[start..end]));
|
|
|
|
debug!("Writing data to device: {} bytes", end-start);
|
|
|
|
match self.device.write(&payload[start..end]) {
|
2015-11-19 15:34:20 +00:00
|
|
|
Ok(()) => (),
|
|
|
|
Err(e) => {
|
2015-11-26 21:16:51 +00:00
|
|
|
error!("Failed to send via device: {}", e);
|
2015-11-22 21:00:34 +00:00
|
|
|
return Err(Error::TunTapDevError("Failed to write to device"));
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
2015-11-25 20:05:11 +00:00
|
|
|
// not adding peer to increase performance
|
2015-11-22 21:00:34 +00:00
|
|
|
if self.learning {
|
2015-11-22 23:49:58 +00:00
|
|
|
//learn single address
|
|
|
|
self.table.learn(src, None, peer);
|
2015-11-22 21:00:34 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
},
|
2015-11-20 17:09:51 +00:00
|
|
|
Message::Peers(peers) => {
|
2015-11-19 15:34:20 +00:00
|
|
|
for p in &peers {
|
2016-05-02 07:05:34 +00:00
|
|
|
if ! self.peers.contains_addr(p) && ! self.blacklist_peers.contains(p) {
|
2016-05-11 08:54:00 +00:00
|
|
|
try!(self.connect(p));
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
2015-12-03 08:38:14 +00:00
|
|
|
Message::Init(stage, node_id, ranges) => {
|
|
|
|
if node_id == self.node_id {
|
|
|
|
self.blacklist_peers.push(peer);
|
|
|
|
return Ok(())
|
|
|
|
}
|
2016-05-02 07:05:34 +00:00
|
|
|
if self.peers.contains_node(&node_id) {
|
|
|
|
self.peers.add_alt_addr(node_id, peer);
|
|
|
|
} else {
|
|
|
|
self.peers.add(node_id, peer);
|
|
|
|
for range in ranges {
|
|
|
|
self.table.learn(range.base, Some(range.prefix_len), peer.clone());
|
|
|
|
}
|
2015-11-22 21:00:34 +00:00
|
|
|
}
|
2015-11-26 09:52:58 +00:00
|
|
|
if stage == 0 {
|
2015-12-03 08:38:14 +00:00
|
|
|
let peers = self.peers.as_vec();
|
|
|
|
let own_addrs = self.addresses.clone();
|
|
|
|
let own_node_id = self.node_id.clone();
|
2015-12-13 21:03:06 +00:00
|
|
|
try!(self.send_msg(peer, &mut Message::Init(stage+1, own_node_id, own_addrs)));
|
|
|
|
try!(self.send_msg(peer, &mut Message::Peers(peers)));
|
2015-11-26 09:52:58 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
},
|
2015-11-20 17:09:51 +00:00
|
|
|
Message::Close => {
|
2015-11-20 09:59:01 +00:00
|
|
|
self.peers.remove(&peer);
|
2016-03-29 11:54:28 +00:00
|
|
|
self.table.remove_all(&peer);
|
2015-11-20 09:59:01 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2015-11-20 08:11:54 +00:00
|
|
|
pub fn run(&mut self) {
|
2015-11-25 20:55:30 +00:00
|
|
|
let dummy_time = SteadyTime::now();
|
2015-11-25 13:31:05 +00:00
|
|
|
let trap = Trap::trap(&[SIGINT, SIGTERM, SIGQUIT]);
|
2015-11-25 11:29:12 +00:00
|
|
|
let epoll_handle = try_fail!(epoll::create1(0), "Failed to create epoll handle: {}");
|
2016-05-02 06:35:11 +00:00
|
|
|
let socket4_fd = self.socket4.as_raw_fd();
|
|
|
|
let socket6_fd = self.socket6.as_raw_fd();
|
2015-11-22 15:48:01 +00:00
|
|
|
let device_fd = self.device.as_raw_fd();
|
2016-05-02 06:35:11 +00:00
|
|
|
let mut socket4_event = epoll::EpollEvent{events: epoll::util::event_type::EPOLLIN, data: 0};
|
|
|
|
let mut socket6_event = epoll::EpollEvent{events: epoll::util::event_type::EPOLLIN, data: 1};
|
|
|
|
let mut device_event = epoll::EpollEvent{events: epoll::util::event_type::EPOLLIN, data: 2};
|
|
|
|
try_fail!(epoll::ctl(epoll_handle, epoll::util::ctl_op::ADD, socket4_fd, &mut socket4_event), "Failed to add ipv4 socket to epoll handle: {}");
|
|
|
|
try_fail!(epoll::ctl(epoll_handle, epoll::util::ctl_op::ADD, socket6_fd, &mut socket6_event), "Failed to add ipv6 socket to epoll handle: {}");
|
2015-11-25 11:29:12 +00:00
|
|
|
try_fail!(epoll::ctl(epoll_handle, epoll::util::ctl_op::ADD, device_fd, &mut device_event), "Failed to add device to epoll handle: {}");
|
2015-11-20 08:11:54 +00:00
|
|
|
let mut events = [epoll::EpollEvent{events: 0, data: 0}; 2];
|
|
|
|
let mut buffer = [0; 64*1024];
|
2015-11-19 15:34:20 +00:00
|
|
|
loop {
|
2016-03-29 11:54:28 +00:00
|
|
|
let count = try_fail!(epoll::wait(epoll_handle, &mut events, 1000), "Epoll wait failed: {}") as usize;
|
2015-11-20 09:59:01 +00:00
|
|
|
// Process events
|
2015-11-20 08:11:54 +00:00
|
|
|
for i in 0..count {
|
2016-03-29 11:54:28 +00:00
|
|
|
match &events[i].data {
|
2015-11-25 11:29:12 +00:00
|
|
|
&0 => {
|
2016-05-02 06:35:11 +00:00
|
|
|
let (size, src) = try_fail!(self.socket4.recv_from(&mut buffer), "Failed to read from ipv4 network socket: {}");
|
2015-11-25 11:29:12 +00:00
|
|
|
match decode(&mut buffer[..size], &mut self.crypto).and_then(|(options, msg)| self.handle_net_message(src, options, msg)) {
|
|
|
|
Ok(_) => (),
|
2015-11-30 22:04:24 +00:00
|
|
|
Err(e) => error!("Error: {}, from: {}", e, src)
|
2015-11-25 11:29:12 +00:00
|
|
|
}
|
2015-11-20 08:11:54 +00:00
|
|
|
},
|
2015-11-25 11:29:12 +00:00
|
|
|
&1 => {
|
2016-05-02 06:35:11 +00:00
|
|
|
let (size, src) = try_fail!(self.socket6.recv_from(&mut buffer), "Failed to read from ipv6 network socket: {}");
|
|
|
|
match decode(&mut buffer[..size], &mut self.crypto).and_then(|(options, msg)| self.handle_net_message(src, options, msg)) {
|
|
|
|
Ok(_) => (),
|
|
|
|
Err(e) => error!("Error: {}, from: {}", e, src)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
&2 => {
|
2015-12-13 21:03:06 +00:00
|
|
|
let start = 64;
|
|
|
|
let size = try_fail!(self.device.read(&mut buffer[start..]), "Failed to read from tap device: {}");
|
|
|
|
match self.handle_interface_data(&mut buffer, start, start+size) {
|
2015-11-22 15:48:01 +00:00
|
|
|
Ok(_) => (),
|
2015-11-26 21:16:51 +00:00
|
|
|
Err(e) => error!("Error: {}", e)
|
2015-11-25 11:29:12 +00:00
|
|
|
}
|
2015-11-20 08:11:54 +00:00
|
|
|
},
|
|
|
|
_ => unreachable!()
|
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|
2015-11-25 20:55:30 +00:00
|
|
|
if self.next_housekeep < now() {
|
|
|
|
// Check for signals
|
|
|
|
if trap.wait(dummy_time).is_some() {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Do the housekeeping
|
2015-11-20 09:59:01 +00:00
|
|
|
match self.housekeep() {
|
|
|
|
Ok(_) => (),
|
2015-11-26 21:16:51 +00:00
|
|
|
Err(e) => error!("Error: {}", e)
|
2015-11-20 09:59:01 +00:00
|
|
|
}
|
2015-11-25 20:55:30 +00:00
|
|
|
self.next_housekeep = now() + 1
|
2015-11-20 09:59:01 +00:00
|
|
|
}
|
2015-11-19 19:51:53 +00:00
|
|
|
}
|
2015-11-25 13:31:05 +00:00
|
|
|
info!("Shutting down...");
|
2015-12-22 21:45:52 +00:00
|
|
|
self.broadcast_msg(&mut Message::Close).ok();
|
2015-11-19 19:51:53 +00:00
|
|
|
}
|
2015-11-19 15:34:20 +00:00
|
|
|
}
|