use super::{device::Type, types::Mode, util::Duration};
use crate::config::{ConfigFile, ConfigFileBeacon, ConfigFileDevice, ConfigFileStatsd, CryptoConfig};
use std::collections::HashMap;
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
pub enum OldCryptoMethod {
#[serde(rename = "chacha20")]
ChaCha20,
#[serde(rename = "aes256")]
AES256,
#[serde(rename = "aes128")]
AES128,
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
pub struct OldConfigFile {
#[serde(alias = "device-type")]
pub device_type: Option<Type>,
#[serde(alias = "device-name")]
pub device_name: Option<String>,
#[serde(alias = "device-path")]
pub device_path: Option<String>,
pub ifup: Option<String>,
pub ifdown: Option<String>,
pub crypto: Option<OldCryptoMethod>,
#[serde(alias = "shared-key")]
pub shared_key: Option<String>,
pub magic: Option<String>,
pub port: Option<u16>,
pub listen: Option<String>,
pub peers: Option<Vec<String>>,
#[serde(alias = "peer-timeout")]
pub peer_timeout: Option<Duration>,
pub keepalive: Option<Duration>,
#[serde(alias = "beacon-store")]
pub beacon_store: Option<String>,
#[serde(alias = "beacon-load")]
pub beacon_load: Option<String>,
#[serde(alias = "beacon-interval")]
pub beacon_interval: Option<Duration>,
pub mode: Option<Mode>,
#[serde(alias = "dst-timeout")]
pub dst_timeout: Option<Duration>,
pub subnets: Option<Vec<String>>,
#[serde(alias = "port-forwarding")]
pub port_forwarding: Option<bool>,
#[serde(alias = "pid-file")]
pub pid_file: Option<String>,
#[serde(alias = "stats-file")]
pub stats_file: Option<String>,
#[serde(alias = "statsd-server")]
pub statsd_server: Option<String>,
#[serde(alias = "statsd-prefix")]
pub statsd_prefix: Option<String>,
pub user: Option<String>,
pub group: Option<String>,
}
impl OldConfigFile {
#[allow(clippy::or_fun_call)]
pub fn convert(self) -> ConfigFile {
if self.device_type.is_none() {
warn!("The default device type changed from TAP to TUN")
}
if self.ifup.is_some() {
info!("There is a new option --ip that can handle most use cases of --ifup")
}
info!("The converted config enables all available encryption algorithms");
if self.shared_key.is_none() {
warn!("Operation without a password is no longer supported, password set to 'none'");
}
if self.magic.is_some() {
warn!("The magic header functionality is no longer supported")
}
if self.listen.is_some() && self.port.is_some() {
warn!("The port option is no longer available, using listen instead")
}
if self.peer_timeout.is_none() {
info!("The default peer timeout changed from 10 minutes to 5 minutes")
}
warn!("Even with a converted config file version 2 nodes can not communicate with version 1 nodes");
ConfigFile {
auto_claim: None,
beacon: Some(ConfigFileBeacon {
interval: self.beacon_interval,
load: self.beacon_load,
store: self.beacon_store,
password: self.shared_key.clone(),
}),
claims: self.subnets,
crypto: CryptoConfig {
algorithms: vec![],
password: Some(self.shared_key.unwrap_or_else(|| "none".to_string())),
private_key: None,
public_key: None,
trusted_keys: vec![],
},
device: Some(ConfigFileDevice {
fix_rp_filter: None,
name: self.device_name,
path: self.device_path,
type_: self.device_type,
}),
group: self.group,
ifdown: self.ifdown,
ifup: self.ifup,
ip: None,
advertise_addresses: None,
keepalive: self.keepalive,
listen: self.listen.or(self.port.map(|p| format!("{}", p))),
mode: self.mode,
peer_timeout: self.peer_timeout,
peers: self.peers,
pid_file: self.pid_file,
port_forwarding: self.port_forwarding,
stats_file: self.stats_file,
statsd: Some(ConfigFileStatsd { prefix: self.statsd_prefix, server: self.statsd_server }),
switch_timeout: self.dst_timeout,
user: self.user,
hook: None,
hooks: HashMap::new(),
}
}
}