diff options
Diffstat (limited to 'mullvad-cli/src')
| -rw-r--r-- | mullvad-cli/src/cmds/tunnel.rs | 370 |
1 files changed, 277 insertions, 93 deletions
diff --git a/mullvad-cli/src/cmds/tunnel.rs b/mullvad-cli/src/cmds/tunnel.rs index 8d601cd345..329f72f6bd 100644 --- a/mullvad-cli/src/cmds/tunnel.rs +++ b/mullvad-cli/src/cmds/tunnel.rs @@ -1,7 +1,12 @@ -use clap; +use clap::{self, value_t}; use {new_rpc_client, Command, Result}; -use talpid_types::net::{OpenVpnTunnelOptions, TunnelOptions}; +use talpid_types::net::{ + LocalOpenVpnProxySettings, OpenVpnProxyAuth, OpenVpnProxySettings, + OpenVpnProxySettingsValidation, RemoteOpenVpnProxySettings, TunnelOptions, +}; + +use std::net::{IpAddr, SocketAddr}; pub struct Tunnel; @@ -14,134 +19,313 @@ impl Command for Tunnel { clap::SubCommand::with_name(self.name()) .about("Manage tunnel specific options") .setting(clap::AppSettings::SubcommandRequired) - .subcommand( - clap::SubCommand::with_name("openvpn") - .about("Manage options for OpenVPN tunnels") - .setting(clap::AppSettings::SubcommandRequired) - .subcommand( - clap::SubCommand::with_name("set") - .subcommand( - clap::SubCommand::with_name("mssfix").arg( - clap::Arg::with_name("mssfix") - .help( - "Sets the optional mssfix parameter. \ - Set an empty string to clear it.", - ) - .required(true), - ), - ) - .setting(clap::AppSettings::SubcommandRequired), - ) - .subcommand( - clap::SubCommand::with_name("get") - .help("Retrieves the current setting for mssfix"), - ), - ) - .subcommand( - clap::SubCommand::with_name("set") - .subcommand( - clap::SubCommand::with_name("ipv6").arg( - clap::Arg::with_name("enable") - .required(true) - .takes_value(true) - .possible_values(&["on", "off"]), - ), - ) - .setting(clap::AppSettings::SubcommandRequired), - ) - .subcommand( - clap::SubCommand::with_name("get") - .help("Retrieves the current setting for common tunnel options"), - ) + .subcommand(create_openvpn_subcommand()) + .subcommand(create_ipv6_subcommand()) } fn run(&self, matches: &clap::ArgMatches) -> Result<()> { if let Some(openvpn_matches) = matches.subcommand_matches("openvpn") { Self::handle_openvpn_cmd(openvpn_matches) - } else if let Some(set_matches) = matches.subcommand_matches("set") { - Self::set_tunnel_option(set_matches) - } else if let Some(_) = matches.subcommand_matches("get") { - let tunnel_options = Self::get_tunnel_options()?; - Self::print_common_tunnel_options(&tunnel_options); - Ok(()) + } else if let Some(ipv6_matches) = matches.subcommand_matches("ipv6") { + Self::handle_ipv6_cmd(ipv6_matches) } else { - unreachable!("No tunnel command given") + unreachable!("unhandled command"); } } } +fn create_openvpn_subcommand() -> clap::App<'static, 'static> { + clap::SubCommand::with_name("openvpn") + .about("Manage options for OpenVPN tunnels") + .setting(clap::AppSettings::SubcommandRequired) + .subcommand(create_openvpn_mssfix_subcommand()) + .subcommand(create_openvpn_proxy_subcommand()) +} + +fn create_openvpn_mssfix_subcommand() -> clap::App<'static, 'static> { + clap::SubCommand::with_name("mssfix") + .about("Configure the optional mssfix parameter") + .setting(clap::AppSettings::SubcommandRequired) + .subcommand(clap::SubCommand::with_name("get")) + .subcommand(clap::SubCommand::with_name("unset")) + .subcommand( + clap::SubCommand::with_name("set").arg(clap::Arg::with_name("mssfix").required(true)), + ) +} + +fn create_openvpn_proxy_subcommand() -> clap::App<'static, 'static> { + clap::SubCommand::with_name("proxy") + .about("Configure a SOCKS5 proxy") + .setting(clap::AppSettings::SubcommandRequired) + .subcommand(clap::SubCommand::with_name("get")) + .subcommand(clap::SubCommand::with_name("unset")) + .subcommand( + clap::SubCommand::with_name("set") + .setting(clap::AppSettings::SubcommandRequired) + .subcommand( + clap::SubCommand::with_name("local") + .about("Registers a local SOCKS5 proxy") + .arg( + clap::Arg::with_name("local-port") + .help("Specifies the port the local proxy server is listening on") + .required(true) + .index(1), + ) + .arg( + clap::Arg::with_name("remote-ip") + .help("Specifies the IP of the proxy server peer") + .required(true) + .index(2), + ) + .arg( + clap::Arg::with_name("remote-port") + .help("Specifies the port of the proxy server peer") + .required(true) + .index(3), + ), + ) + .subcommand( + clap::SubCommand::with_name("remote") + .about("Registers a remote SOCKS5 proxy") + .arg( + clap::Arg::with_name("remote-ip") + .help("Specifies the IP of the remote proxy server") + .required(true) + .index(1), + ) + .arg( + clap::Arg::with_name("remote-port") + .help("Specifies the port the remote proxy server is listening on") + .required(true) + .index(2), + ) + .arg( + clap::Arg::with_name("username") + .help("Specifies the username for remote authentication") + .index(3), + ) + .arg( + clap::Arg::with_name("password") + .help("Specifies the password for remote authentication") + .index(4), + ), + ), + ) +} + +fn create_ipv6_subcommand() -> clap::App<'static, 'static> { + clap::SubCommand::with_name("ipv6") + .setting(clap::AppSettings::SubcommandRequired) + .subcommand(clap::SubCommand::with_name("get")) + .subcommand( + clap::SubCommand::with_name("set").arg( + clap::Arg::with_name("enable") + .required(true) + .takes_value(true) + .possible_values(&["on", "off"]), + ), + ) +} + impl Tunnel { - fn set_tunnel_option(matches: &clap::ArgMatches) -> Result<()> { - if let Some(ipv6_args) = matches.subcommand_matches("ipv6") { - Self::set_enable_ipv6_option(ipv6_args) + fn handle_openvpn_cmd(matches: &clap::ArgMatches) -> Result<()> { + if let Some(m) = matches.subcommand_matches("mssfix") { + Self::handle_openvpn_mssfix_cmd(m) + } else if let Some(m) = matches.subcommand_matches("proxy") { + Self::handle_openvpn_proxy_cmd(m) } else { - unreachable!("Invalid option passed to 'tunnel set'"); + unreachable!("unhandled command"); } } - fn set_enable_ipv6_option(args: &clap::ArgMatches) -> Result<()> { - let enabled = args.value_of("enable").unwrap() == "on"; + fn handle_openvpn_mssfix_cmd(matches: &clap::ArgMatches) -> Result<()> { + if let Some(_) = matches.subcommand_matches("get") { + Self::process_openvpn_mssfix_get() + } else if let Some(_) = matches.subcommand_matches("unset") { + Self::process_openvpn_mssfix_unset() + } else if let Some(m) = matches.subcommand_matches("set") { + Self::process_openvpn_mssfix_set(m) + } else { + unreachable!("unhandled command"); + } + } - let mut rpc = new_rpc_client()?; - rpc.set_enable_ipv6(enabled)?; - println!("IPv6 {}", if enabled { "on" } else { "off" }); - Ok(()) + fn handle_openvpn_proxy_cmd(matches: &clap::ArgMatches) -> Result<()> { + if let Some(_) = matches.subcommand_matches("get") { + Self::process_openvpn_proxy_get() + } else if let Some(_) = matches.subcommand_matches("unset") { + Self::process_openvpn_proxy_unset() + } else if let Some(m) = matches.subcommand_matches("set") { + Self::process_openvpn_proxy_set(m) + } else { + unreachable!("unhandled command"); + } } - fn handle_openvpn_cmd(matches: &clap::ArgMatches) -> Result<()> { - if let Some(set_matches) = matches.subcommand_matches("set") { - Self::set_openvpn_option(set_matches) - } else if let Some(_) = matches.subcommand_matches("get") { - let tunnel_options = Self::get_tunnel_options()?; - Self::print_openvpn_tunnel_options(tunnel_options.openvpn); - Ok(()) + fn handle_ipv6_cmd(matches: &clap::ArgMatches) -> Result<()> { + if let Some(_) = matches.subcommand_matches("get") { + Self::process_ipv6_get() + } else if let Some(m) = matches.subcommand_matches("set") { + Self::process_ipv6_set(m) } else { - unreachable!("Unrecognized subcommand"); + unreachable!("unhandled command"); } } - fn set_openvpn_option(matches: &clap::ArgMatches) -> Result<()> { - if let Some(mssfix_args) = matches.subcommand_matches("mssfix") { - Self::set_openvpn_mssfix_option(mssfix_args) + fn process_openvpn_mssfix_get() -> Result<()> { + let tunnel_options = Self::get_tunnel_options()?; + println!( + "mssfix: {}", + tunnel_options + .openvpn + .mssfix + .map_or_else(|| "unset".to_string(), |v| v.to_string()) + ); + Ok(()) + } + + fn get_tunnel_options() -> Result<TunnelOptions> { + let mut rpc = new_rpc_client()?; + Ok(rpc.get_settings()?.get_tunnel_options().clone()) + } + + fn process_openvpn_mssfix_unset() -> Result<()> { + let mut rpc = new_rpc_client()?; + rpc.set_openvpn_mssfix(None)?; + println!("mssfix parameter has been unset"); + Ok(()) + } + + fn process_openvpn_mssfix_set(matches: &clap::ArgMatches) -> Result<()> { + let new_value = value_t!(matches.value_of("mssfix"), u16).unwrap_or_else(|e| e.exit()); + let mut rpc = new_rpc_client()?; + rpc.set_openvpn_mssfix(Some(new_value))?; + println!("mssfix parameter has been updated"); + Ok(()) + } + + fn process_openvpn_proxy_get() -> Result<()> { + let tunnel_options = Self::get_tunnel_options()?; + if let Some(proxy) = tunnel_options.openvpn.proxy { + if let OpenVpnProxySettings::Local(local_proxy) = proxy { + Self::print_local_proxy(&local_proxy) + } else if let OpenVpnProxySettings::Remote(remote_proxy) = proxy { + Self::print_remote_proxy(&remote_proxy) + } else { + unreachable!("unhandled proxy type"); + } } else { - unreachable!("Invalid option passed to 'openvpn set'"); + println!("proxy: unset"); } + Ok(()) } - fn set_openvpn_mssfix_option(args: &clap::ArgMatches) -> Result<()> { - let mssfix_str = args.value_of("mssfix").unwrap(); - let mssfix: Option<u16> = if mssfix_str == "" { - None + fn print_local_proxy(proxy: &LocalOpenVpnProxySettings) { + println!("proxy: local"); + println!(" local port: {}", proxy.port); + println!(" peer IP: {}", proxy.peer.ip()); + println!(" peer port: {}", proxy.peer.port()); + } + + fn print_remote_proxy(proxy: &RemoteOpenVpnProxySettings) { + println!("proxy: remote"); + println!(" server IP: {}", proxy.address.ip()); + println!(" server port: {}", proxy.address.port()); + + if let Some(ref auth) = proxy.auth { + println!(" auth username: {}", auth.username); + println!(" auth password: {}", auth.password); } else { - Some(mssfix_str.parse()?) - }; + println!(" auth: none"); + } + } + fn process_openvpn_proxy_unset() -> Result<()> { let mut rpc = new_rpc_client()?; - rpc.set_openvpn_mssfix(mssfix)?; - println!("mssfix parameter updated"); + rpc.set_openvpn_proxy(None)?; + println!("proxy details have been unset"); Ok(()) } - fn get_tunnel_options() -> Result<TunnelOptions> { - let mut rpc = new_rpc_client()?; - Ok(rpc.get_settings()?.get_tunnel_options().clone()) + fn process_openvpn_proxy_set(matches: &clap::ArgMatches) -> Result<()> { + if let Some(args) = matches.subcommand_matches("local") { + let local_port = + value_t!(args.value_of("local-port"), u16).unwrap_or_else(|e| e.exit()); + let remote_ip = + value_t!(args.value_of("remote-ip"), IpAddr).unwrap_or_else(|e| e.exit()); + let remote_port = + value_t!(args.value_of("remote-port"), u16).unwrap_or_else(|e| e.exit()); + + let proxy = LocalOpenVpnProxySettings { + port: local_port, + peer: SocketAddr::new(remote_ip, remote_port), + }; + + let packed_proxy = OpenVpnProxySettings::Local(proxy); + + if let Err(error) = OpenVpnProxySettingsValidation::validate(&packed_proxy) { + panic!(error); + } + + let mut rpc = new_rpc_client()?; + rpc.set_openvpn_proxy(Some(packed_proxy))?; + } else if let Some(args) = matches.subcommand_matches("remote") { + let remote_ip = + value_t!(args.value_of("remote-ip"), IpAddr).unwrap_or_else(|e| e.exit()); + let remote_port = + value_t!(args.value_of("remote-port"), u16).unwrap_or_else(|e| e.exit()); + let username = args.value_of("username"); + let password = args.value_of("password"); + + let auth = match (username, password) { + (Some(username), Some(password)) => Some(OpenVpnProxyAuth { + username: username.to_string(), + password: password.to_string(), + }), + _ => None, + }; + + let proxy = RemoteOpenVpnProxySettings { + address: SocketAddr::new(remote_ip, remote_port), + auth: auth, + }; + + let packed_proxy = OpenVpnProxySettings::Remote(proxy); + + if let Err(error) = OpenVpnProxySettingsValidation::validate(&packed_proxy) { + panic!(error); + } + + let mut rpc = new_rpc_client()?; + rpc.set_openvpn_proxy(Some(packed_proxy))?; + } else { + unreachable!("unhandled proxy type"); + } + + println!("proxy details have been updated"); + println!("note: The OpenVPN tunnel constraints have been updated to use TCP"); + Ok(()) } - fn print_common_tunnel_options(options: &TunnelOptions) { - println!("Common tunnel options"); + fn process_ipv6_get() -> Result<()> { + let tunnel_options = Self::get_tunnel_options()?; println!( - "\tIPv6: {}", - if options.enable_ipv6 { "on" } else { "off" } + "IPv6: {}", + if tunnel_options.enable_ipv6 { + "on" + } else { + "off" + } ); + Ok(()) } - fn print_openvpn_tunnel_options(options: OpenVpnTunnelOptions) { - println!("OpenVPN tunnel options"); - println!( - "\tmssfix: {}", - options - .mssfix - .map_or_else(|| "UNSET".to_string(), |v| v.to_string()) - ); + fn process_ipv6_set(matches: &clap::ArgMatches) -> Result<()> { + let enabled = matches.value_of("enable").unwrap() == "on"; + + let mut rpc = new_rpc_client()?; + rpc.set_enable_ipv6(enabled)?; + println!("IPv6 setting has been updated"); + Ok(()) } } |