vpncloud/src/main.rs

235 lines
7.4 KiB
Rust
Raw Normal View History

// VpnCloud - Peer-to-Peer VPN
// Copyright (C) 2015-2016 Dennis Schwerdel
// This software is licensed under GPL-3 or newer (see LICENSE.md)
#![cfg_attr(feature = "bench", feature(test))]
2016-06-26 17:18:38 +00:00
2015-11-19 15:34:20 +00:00
#[macro_use] extern crate log;
2016-06-30 08:05:37 +00:00
#[macro_use] extern crate bitflags;
2015-11-19 15:34:20 +00:00
extern crate time;
extern crate docopt;
extern crate rustc_serialize;
2015-11-25 13:31:05 +00:00
extern crate signal;
2015-11-25 20:55:30 +00:00
extern crate libc;
2015-11-30 21:11:37 +00:00
extern crate aligned_alloc;
extern crate rand;
2016-03-29 08:45:54 +00:00
extern crate fnv;
2016-05-02 06:35:11 +00:00
extern crate net2;
extern crate yaml_rust;
extern crate igd;
extern crate siphasher;
2016-11-23 14:21:22 +00:00
extern crate daemonize;
#[cfg(feature = "bench")] extern crate test;
2015-11-19 15:34:20 +00:00
2016-06-27 13:43:30 +00:00
#[macro_use] pub mod util;
pub mod types;
pub mod crypto;
pub mod udpmessage;
pub mod ethernet;
pub mod ip;
pub mod cloud;
pub mod device;
2016-06-30 08:05:37 +00:00
pub mod poll;
pub mod config;
pub mod configfile;
pub mod port_forwarding;
2015-11-26 21:16:51 +00:00
#[cfg(test)] mod tests;
#[cfg(feature = "bench")] mod benches;
2015-11-19 15:34:20 +00:00
use docopt::Docopt;
2016-11-23 14:21:22 +00:00
use std::sync::Mutex;
2015-11-23 00:40:47 +00:00
use std::str::FromStr;
2015-11-23 18:06:25 +00:00
use std::process::Command;
2016-11-23 14:21:22 +00:00
use std::fs::File;
use std::path::Path;
use std::io::{self, Write};
2015-11-20 17:40:23 +00:00
2016-06-26 17:18:38 +00:00
use device::{Device, Type};
2015-11-23 00:40:47 +00:00
use ethernet::SwitchTable;
use ip::RoutingTable;
use types::{Mode, Range, Table, Protocol, HeaderMagic};
use cloud::GenericCloud;
2015-11-30 16:27:50 +00:00
use crypto::{Crypto, CryptoMethod};
use port_forwarding::PortForwarding;
use util::Duration;
use config::Config;
const VERSION: u8 = 1;
const MAGIC: HeaderMagic = *b"vpn\x01";
2015-11-19 15:34:20 +00:00
static USAGE: &'static str = include_str!("usage.txt");
2016-08-08 14:56:58 +00:00
#[derive(RustcDecodable, Debug, Default)]
pub struct Args {
flag_config: Option<String>,
flag_type: Option<Type>,
flag_mode: Option<Mode>,
flag_shared_key: Option<String>,
flag_crypto: Option<CryptoMethod>,
flag_subnet: Vec<String>,
flag_device: Option<String>,
flag_listen: Option<u16>,
flag_network_id: Option<String>,
flag_magic: Option<String>,
flag_connect: Vec<String>,
flag_peer_timeout: Option<Duration>,
flag_dst_timeout: Option<Duration>,
flag_verbose: bool,
flag_quiet: bool,
flag_ifup: Option<String>,
flag_ifdown: Option<String>,
flag_version: bool,
2016-11-23 14:21:22 +00:00
flag_no_port_forwarding: bool,
flag_daemon: bool,
flag_pid_file: Option<String>,
flag_user: Option<String>,
flag_group: Option<String>,
flag_log_file: Option<String>
}
2015-11-19 15:34:20 +00:00
2016-11-23 14:21:22 +00:00
struct DualLogger {
file: Mutex<Option<File>>
}
impl DualLogger {
pub fn new<P: AsRef<Path>>(path: Option<P>) -> Result<Self, io::Error> {
if let Some(path) = path {
let file = try!(File::create(path));
Ok(DualLogger{file: Mutex::new(Some(file))})
} else {
Ok(DualLogger{file: Mutex::new(None)})
}
}
}
2015-11-19 15:34:20 +00:00
2016-11-23 14:21:22 +00:00
impl log::Log for DualLogger {
2016-06-11 14:08:57 +00:00
#[inline]
2015-11-19 15:34:20 +00:00
fn enabled(&self, _metadata: &log::LogMetadata) -> bool {
true
}
2016-06-11 14:08:57 +00:00
#[inline]
2015-11-19 15:34:20 +00:00
fn log(&self, record: &log::LogRecord) {
if self.enabled(record.metadata()) {
2016-11-23 14:21:22 +00:00
println!("{} - {}", record.level(), record.args());
let mut file = self.file.lock().expect("Lock poisoned");
if let &mut Some(ref mut file) = &mut file as &mut Option<File> {
let time = time::strftime("%F %T", &time::now()).expect("Failed to format timestamp");
writeln!(file, "{} - {} - {}", time, record.level(), record.args()).expect("Failed to write to logfile");
}
2015-11-19 15:34:20 +00:00
}
}
}
2015-11-23 18:06:25 +00:00
fn run_script(script: String, ifname: &str) {
let mut cmd = Command::new("sh");
cmd.arg("-c").arg(&script).env("IFNAME", ifname);
debug!("Running script: {:?}", cmd);
match cmd.status() {
2016-06-11 14:08:57 +00:00
Ok(status) => if status.success() {
()
} else {
error!("Script returned with error: {:?}", status.code())
2015-11-23 18:06:25 +00:00
},
Err(e) => error!("Failed to execute script {:?}: {}", script, e)
}
2015-11-19 15:34:20 +00:00
}
fn run<T: Protocol> (config: Config) {
let device = try_fail!(Device::new(&config.device_name, config.device_type),
"Failed to open virtual {} interface {}: {}", config.device_type, config.device_name);
2015-11-23 00:40:47 +00:00
info!("Opened device {}", device.ifname());
let mut ranges = Vec::with_capacity(config.subnets.len());
for s in &config.subnets {
ranges.push(try_fail!(Range::from_str(s), "Invalid subnet format: {} ({})", s));
2015-11-22 19:02:02 +00:00
}
let dst_timeout = config.dst_timeout;
let peer_timeout = config.peer_timeout;
let (learning, broadcasting, table): (bool, bool, Box<Table>) = match config.mode {
Mode::Normal => match config.device_type {
2015-11-23 00:40:47 +00:00
Type::Tap => (true, true, Box::new(SwitchTable::new(dst_timeout))),
Type::Tun => (false, false, Box::new(RoutingTable::new()))
},
2015-11-23 10:55:37 +00:00
Mode::Router => (false, false, Box::new(RoutingTable::new())),
Mode::Switch => (true, true, Box::new(SwitchTable::new(dst_timeout))),
Mode::Hub => (false, true, Box::new(SwitchTable::new(dst_timeout)))
2015-11-23 00:40:47 +00:00
};
let magic = config.get_magic();
2015-11-29 20:53:08 +00:00
Crypto::init();
let crypto = match config.shared_key {
Some(key) => Crypto::from_shared_key(config.crypto, &key),
2015-11-23 14:40:04 +00:00
None => Crypto::None
};
let port_forwarding = if config.port_forwarding {
PortForwarding::new(config.port)
} else {
None
};
let mut cloud = GenericCloud::<T>::new(magic, device, config.port, table, peer_timeout, learning, broadcasting, ranges, crypto, port_forwarding);
if let Some(script) = config.ifup {
run_script(script, cloud.ifname());
}
for addr in config.peers {
try_fail!(cloud.connect(&addr as &str), "Failed to send message to {}: {}", &addr);
cloud.add_reconnect_peer(addr);
}
2016-11-23 14:21:22 +00:00
if config.daemonize {
info!("Running process as daemon");
let mut daemonize = daemonize::Daemonize::new();
if let Some(user) = config.user {
daemonize = daemonize.user(&user as &str);
}
if let Some(group) = config.group {
daemonize = daemonize.group(&group as &str);
}
if let Some(pid_file) = config.pid_file {
daemonize = daemonize.pid_file(pid_file).chown_pid_file(true);
}
try_fail!(daemonize.start(), "Failed to daemonize: {}");
}
cloud.run();
if let Some(script) = config.ifdown {
run_script(script, cloud.ifname());
}
}
fn main() {
let args: Args = Docopt::new(USAGE).and_then(|d| d.decode()).unwrap_or_else(|e| e.exit());
if args.flag_version {
2015-11-30 22:04:24 +00:00
Crypto::init();
println!("VpnCloud v{}, protocol version {}, libsodium {} (AES256: {})",
env!("CARGO_PKG_VERSION"),
VERSION,
Crypto::sodium_version(),
Crypto::aes256_available()
);
return;
}
log::set_logger(|max_log_level| {
assert!(!args.flag_verbose || !args.flag_quiet);
if args.flag_verbose {
max_log_level.set(log::LogLevelFilter::Debug);
} else if args.flag_quiet {
max_log_level.set(log::LogLevelFilter::Error);
} else {
max_log_level.set(log::LogLevelFilter::Info);
2015-11-23 00:40:47 +00:00
}
2016-11-23 14:21:22 +00:00
Box::new(try_fail!(DualLogger::new(args.flag_log_file.as_ref()), "Failed to open logfile: {}"))
}).unwrap();
let mut config = Config::default();
if let Some(ref file) = args.flag_config {
info!("Reading config file '{}'", file);
let config_file = try_fail!(configfile::parse(file), "Failed to load config file: {:?}");
config.merge_file(config_file)
}
config.merge_args(args);
debug!("Config: {:?}", config);
match config.device_type {
Type::Tap => run::<ethernet::Frame>(config),
Type::Tun => run::<ip::Packet>(config)
}
2015-11-22 19:02:02 +00:00
}