Change SetOpenVpnProxy to SetBridgeSettings

2 files changed, 45 insertions, 51 deletions

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 6c53642c71..1d5851d94f 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -621,7 +621,9 @@ where
             }
             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),
+            SetBridgeSettings(tx, bridge_settings) => {
+                self.on_set_bridge_settings(tx, bridge_settings)
+            }
             SetBridgeState(tx, bridge_state) => self.on_set_bridge_state(tx, bridge_state),
             SetEnableIpv6(tx, enable_ipv6) => self.on_set_enable_ipv6(tx, enable_ipv6),
             SetWireguardMtu(tx, mtu) => self.on_set_wireguard_mtu(tx, mtu),
@@ -878,33 +880,26 @@ where
         }
     }
 
-    fn on_set_openvpn_proxy(
+    fn on_set_bridge_settings(
         &mut self,
         tx: oneshot::Sender<::std::result::Result<(), settings::Error>>,
-        proxy: Option<openvpn::ProxySettings>,
+        new_settings: BridgeSettings,
     ) {
-        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 {
+        match self.settings.set_bridge_settings(new_settings) {
+            Ok(settings_changes) => {
+                if settings_changes {
                     self.event_listener.notify_settings(self.settings.clone());
-                    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");
+                };
+                Self::oneshot_send(tx, Ok(()), "set_bridge_settings");
             }
-            (Err(error), Err(_)) => {
-                error!("{}", error.display_chain());
-                Self::oneshot_send(tx, Err(error), "set_openvpn_proxy response");
+
+            Err(e) => {
+                log::error!(
+                    "{}",
+                    e.display_chain_with_msg("Failed to set new bridge settings")
+                );
+                Self::oneshot_send(tx, Err(e), "set_bridge_settings");
             }
         }
     }
@@ -914,18 +909,29 @@ where
         tx: oneshot::Sender<::std::result::Result<(), settings::Error>>,
         bridge_state: BridgeState,
     ) {
-        let result = match self.settings.set_bridge_state(bridge_state) {
+        let result = match self.settings.set_bridge_state(bridge_state.clone()) {
             Ok(settings_changed) => {
                 if settings_changed {
-                    self.management_interface_broadcaster
-                        .notify_settings(self.settings.clone());
-                    info!("Initiating tunnel restart because bridge state changed");
+                    if bridge_state == BridgeState::On {
+                        if let Err(e) = self.apply_proxy_constraints() {
+                            log::error!(
+                                "{}",
+                                e.display_chain_with_msg("Failed to apply proxy constraints")
+                            );
+                        }
+                    }
+
+                    self.event_listener.notify_settings(self.settings.clone());
+                    log::info!("Initiating tunnel restart because bridge state changed");
                     self.reconnect_tunnel();
                 }
                 Ok(())
-            },
+            }
             Err(error) => {
-                error!("{}", error.display_chain_with_msg("Failed"));
+                log::error!(
+                    "{}",
+                    error.display_chain_with_msg("Failed to set new bridge state")
+                );
                 Err(error)
             }
         };
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 7e212e479f..7c195d74e2 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -15,7 +15,7 @@ use mullvad_rpc;
 use mullvad_types::{
     account::{AccountData, AccountToken},
     location::GeoIpLocation,
-    relay_constraints::{BridgeState, RelaySettingsUpdate},
+    relay_constraints::{BridgeSettings, BridgeState, RelaySettingsUpdate},
     relay_list::RelayList,
     settings::{self, Settings},
     states::TargetState,
@@ -27,11 +27,7 @@ use std::{
 };
 use talpid_core::mpsc::IntoSender;
 use talpid_ipc;
-use talpid_types::{
-    net::{openvpn, wireguard},
-    tunnel::TunnelStateTransition,
-    ErrorExt,
-};
+use talpid_types::{net::wireguard, tunnel::TunnelStateTransition, ErrorExt};
 use uuid;
 
 /// FIXME(linus): This is here just because the futures crate has deprecated it and jsonrpc_core
@@ -115,8 +111,8 @@ build_rpc_trait! {
         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<openvpn::ProxySettings>) -> BoxFuture<(), Error>;
+        #[rpc(meta, name = "set_bridge_settings")]
+        fn set_bridge_settings(&self, Self::Metadata, BridgeSettings) -> BoxFuture<(), Error>;
 
         /// Sets bridge state
         #[rpc(meta, name = "set_bridge_state")]
@@ -206,15 +202,9 @@ pub enum ManagementCommand {
     /// Set the mssfix argument for OpenVPN
     SetOpenVpnMssfix(OneshotSender<()>, Option<u16>),
     /// Set proxy details for OpenVPN
-    SetOpenVpnProxy(
-        OneshotSender<Result<(), settings::Error>>,
-        Option<openvpn::ProxySettings>,
-    ),
+    SetBridgeSettings(OneshotSender<Result<(), settings::Error>>, BridgeSettings),
     /// Set proxy state
-    SetBridgeState(
-        OneshotSender<Result<(), settings::Error>>,
-        BridgeState,
-    ),
+    SetBridgeState(OneshotSender<Result<(), settings::Error>>, BridgeState),
     /// Set if IPv6 should be enabled in the tunnel
     SetEnableIpv6(OneshotSender<()>, bool),
     /// Set MTU for wireguard tunnels
@@ -555,15 +545,15 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
         Box::new(future)
     }
 
-    fn set_openvpn_proxy(
+    fn set_bridge_settings(
         &self,
         _: Self::Metadata,
-        proxy: Option<openvpn::ProxySettings>,
+        bridge_settings: BridgeSettings,
     ) -> BoxFuture<(), Error> {
-        log::debug!("set_openvpn_proxy({:?})", proxy);
+        log::debug!("set_bridge_settings({:?})", bridge_settings);
         let (tx, rx) = sync::oneshot::channel();
         let future = self
-            .send_command_to_daemon(ManagementCommand::SetOpenVpnProxy(tx, proxy))
+            .send_command_to_daemon(ManagementCommand::SetBridgeSettings(tx, bridge_settings))
             .and_then(|_| rx.map_err(|_| Error::internal_error()))
             .and_then(|settings_result| {
                 settings_result.map_err(|error| match error {
@@ -587,9 +577,7 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
         let future = self
             .send_command_to_daemon(ManagementCommand::SetBridgeState(tx, bridge_state))
             .and_then(|_| rx.map_err(|_| Error::internal_error()))
-            .and_then(|settings_result| {
-                settings_result.map_err(|_| Error::internal_error())
-            });
+            .and_then(|settings_result| settings_result.map_err(|_| Error::internal_error()));
 
         Box::new(future)
     }