Merge branch 'openvpn-proxy'

2 files changed, 95 insertions, 4 deletions

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 13ae19e7a7..058466b04e 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -53,8 +53,12 @@ use mullvad_rpc::{AccountsProxy, AppVersionProxy, HttpHandle};
 use mullvad_types::{
     account::{AccountData, AccountToken},
     location::GeoIpLocation,
-    relay_constraints::{RelaySettings, RelaySettingsUpdate},
+    relay_constraints::{
+        Constraint, OpenVpnConstraints, RelayConstraintsUpdate, RelaySettings, RelaySettingsUpdate,
+        TunnelConstraints,
+    },
     relay_list::{Relay, RelayList},
+    settings,
     settings::Settings,
     states::TargetState,
     version::{AppVersion, AppVersionInfo},
@@ -64,7 +68,10 @@ use talpid_core::{
     mpsc::IntoSender,
     tunnel_state_machine::{self, TunnelCommand, TunnelParameters, TunnelParametersGenerator},
 };
-use talpid_types::tunnel::{BlockReason, TunnelStateTransition};
+use talpid_types::{
+    net::{OpenVpnProxySettings, TransportProtocol},
+    tunnel::{BlockReason, TunnelStateTransition},
+};
 
 
 error_chain!{
@@ -369,7 +376,7 @@ impl Daemon {
                     tunnel_parameters_tx
                         .send(TunnelParameters {
                             endpoint,
-                            options: self.settings.get_tunnel_options(),
+                            options: self.settings.get_tunnel_options().clone(),
                             username: account_token,
                         })
                         .map_err(|_| Error::from("Tunnel parameters receiver stopped listening"))
@@ -417,6 +424,7 @@ impl Daemon {
             SetAllowLan(tx, allow_lan) => self.on_set_allow_lan(tx, allow_lan),
             SetAutoConnect(tx, auto_connect) => self.on_set_auto_connect(tx, auto_connect),
             SetOpenVpnMssfix(tx, mssfix_arg) => self.on_set_openvpn_mssfix(tx, mssfix_arg),
+            SetOpenVpnProxy(tx, proxy) => self.on_set_openvpn_proxy(tx, proxy),
             SetEnableIpv6(tx, enable_ipv6) => self.on_set_enable_ipv6(tx, enable_ipv6),
             GetSettings(tx) => self.on_get_settings(tx),
             GetVersionInfo(tx) => self.on_get_version_info(tx),
@@ -619,6 +627,57 @@ impl Daemon {
         }
     }
 
+    fn on_set_openvpn_proxy(
+        &mut self,
+        tx: oneshot::Sender<::std::result::Result<(), settings::Error>>,
+        proxy: Option<OpenVpnProxySettings>,
+    ) {
+        let constraints_result = match proxy {
+            Some(_) => self.apply_proxy_constraints(),
+            _ => Ok(false),
+        };
+        let proxy_result = self.settings.set_openvpn_proxy(proxy);
+
+        match (proxy_result, constraints_result) {
+            (Ok(proxy_changed), Ok(constraints_changed)) => {
+                Self::oneshot_send(tx, Ok(()), "set_openvpn_proxy response");
+                if proxy_changed || constraints_changed {
+                    self.management_interface_broadcaster
+                        .notify_settings(&self.settings);
+                    info!("Initiating tunnel restart because the OpenVPN proxy setting changed");
+                    self.reconnect_tunnel();
+                }
+            }
+            (Ok(_), Err(error)) | (Err(error), Ok(_)) => {
+                error!("{}", error.display_chain());
+                Self::oneshot_send(tx, Err(error), "set_openvpn_proxy response");
+            }
+            (Err(error), Err(_)) => {
+                error!("{}", error.display_chain());
+                Self::oneshot_send(tx, Err(error), "set_openvpn_proxy response");
+            }
+        }
+    }
+
+    // Set the OpenVPN tunnel to use TCP.
+    fn apply_proxy_constraints(&mut self) -> settings::Result<bool> {
+        let openvpn_constraints = OpenVpnConstraints {
+            port: Constraint::Any,
+            protocol: Constraint::Only(TransportProtocol::Tcp),
+        };
+
+        let tunnel_constraints = TunnelConstraints::OpenVpn(openvpn_constraints);
+
+        let constraints_update = RelayConstraintsUpdate {
+            location: None,
+            tunnel: Some(Constraint::Only(tunnel_constraints)),
+        };
+
+        let settings_update = RelaySettingsUpdate::Normal(constraints_update);
+
+        self.settings.update_relay_settings(settings_update)
+    }
+
     fn on_set_enable_ipv6(&mut self, tx: oneshot::Sender<()>, enable_ipv6: bool) {
         let save_result = self.settings.set_enable_ipv6(enable_ipv6);
         match save_result.chain_err(|| "Unable to save settings") {
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 07fd603e2a..3e204245ae 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -11,6 +11,7 @@ use mullvad_types::account::{AccountData, AccountToken};
 use mullvad_types::location::GeoIpLocation;
 use mullvad_types::relay_constraints::RelaySettingsUpdate;
 use mullvad_types::relay_list::RelayList;
+use mullvad_types::settings;
 use mullvad_types::settings::Settings;
 use mullvad_types::states::TargetState;
 use mullvad_types::version;
@@ -24,7 +25,7 @@ use std::sync::{Arc, Mutex, RwLock};
 
 use talpid_core::mpsc::IntoSender;
 use talpid_ipc;
-use talpid_types::tunnel::TunnelStateTransition;
+use talpid_types::{net::OpenVpnProxySettings, tunnel::TunnelStateTransition};
 use uuid;
 
 use account_history::{AccountHistory, Error as AccountHistoryError};
@@ -101,6 +102,10 @@ build_rpc_trait! {
         #[rpc(meta, name = "set_openvpn_mssfix")]
         fn set_openvpn_mssfix(&self, Self::Metadata, Option<u16>) -> BoxFuture<(), Error>;
 
+        /// Sets proxy details for OpenVPN
+        #[rpc(meta, name = "set_openvpn_proxy")]
+        fn set_openvpn_proxy(&self, Self::Metadata, Option<OpenVpnProxySettings>) -> BoxFuture<(), Error>;
+
         /// Set if IPv6 is enabled in the tunnel
         #[rpc(meta, name = "set_enable_ipv6")]
         fn set_enable_ipv6(&self, Self::Metadata, bool) -> BoxFuture<(), Error>;
@@ -170,6 +175,11 @@ pub enum ManagementCommand {
     SetAutoConnect(OneshotSender<()>, bool),
     /// Set the mssfix argument for OpenVPN
     SetOpenVpnMssfix(OneshotSender<()>, Option<u16>),
+    /// Set proxy details for OpenVPN
+    SetOpenVpnProxy(
+        OneshotSender<Result<(), settings::Error>>,
+        Option<OpenVpnProxySettings>,
+    ),
     /// Set if IPv6 should be enabled in the tunnel
     SetEnableIpv6(OneshotSender<()>, bool),
     /// Get the daemon settings
@@ -537,6 +547,28 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
         Box::new(future)
     }
 
+    fn set_openvpn_proxy(
+        &self,
+        _: Self::Metadata,
+        proxy: Option<OpenVpnProxySettings>,
+    ) -> BoxFuture<(), Error> {
+        log::debug!("set_openvpn_proxy({:?})", proxy);
+        let (tx, rx) = sync::oneshot::channel();
+        let future = self
+            .send_command_to_daemon(ManagementCommand::SetOpenVpnProxy(tx, proxy))
+            .and_then(|_| rx.map_err(|_| Error::internal_error()))
+            .and_then(|settings_result| {
+                settings_result.map_err(|err| match err.kind() {
+                    settings::ErrorKind::InvalidProxyData(msg) => {
+                        Error::invalid_params(msg.to_owned())
+                    }
+                    _ => Error::internal_error(),
+                })
+            });
+
+        Box::new(future)
+    }
+
     fn set_enable_ipv6(&self, _: Self::Metadata, enable_ipv6: bool) -> BoxFuture<(), Error> {
         log::debug!("set_enable_ipv6({})", enable_ipv6);
         let (tx, rx) = sync::oneshot::channel();