Merge branch 'next-level-kill-switch'

2 files changed, 49 insertions, 0 deletions

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index f420afdff2..b5ef9dd21e 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -220,6 +220,7 @@ impl Daemon {
         let tunnel_parameters_generator = MullvadTunnelParametersGenerator { tx: tx.clone() };
         let tunnel_command_tx = tunnel_state_machine::spawn(
             settings.get_allow_lan(),
+            settings.get_block_when_disconnected(),
             tunnel_parameters_generator,
             log_dir,
             resource_dir,
@@ -423,6 +424,9 @@ impl Daemon {
             SetAccount(tx, account_token) => self.on_set_account(tx, account_token),
             UpdateRelaySettings(tx, update) => self.on_update_relay_settings(tx, update),
             SetAllowLan(tx, allow_lan) => self.on_set_allow_lan(tx, allow_lan),
+            SetBlockWhenDisconnected(tx, block_when_disconnected) => {
+                self.on_set_block_when_disconnected(tx, block_when_disconnected)
+            }
             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),
@@ -601,6 +605,29 @@ impl Daemon {
         }
     }
 
+    fn on_set_block_when_disconnected(
+        &mut self,
+        tx: oneshot::Sender<()>,
+        block_when_disconnected: bool,
+    ) {
+        let save_result = self
+            .settings
+            .set_block_when_disconnected(block_when_disconnected);
+        match save_result.chain_err(|| "Unable to save settings") {
+            Ok(settings_changed) => {
+                Self::oneshot_send(tx, (), "set_block_when_disconnected response");
+                if settings_changed {
+                    self.management_interface_broadcaster
+                        .notify_settings(&self.settings);
+                    self.send_tunnel_command(TunnelCommand::BlockWhenDisconnected(
+                        block_when_disconnected,
+                    ));
+                }
+            }
+            Err(e) => error!("{}", e.display_chain()),
+        }
+    }
+
     fn on_set_auto_connect(&mut self, tx: oneshot::Sender<()>, auto_connect: bool) {
         let save_result = self.settings.set_auto_connect(auto_connect);
         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 d306e4c33f..f9eb8ffa63 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -65,6 +65,10 @@ build_rpc_trait! {
         #[rpc(meta, name = "set_allow_lan")]
         fn set_allow_lan(&self, Self::Metadata, bool) -> BoxFuture<(), Error>;
 
+        /// Set if the client should allow network communication when in the disconnected state.
+        #[rpc(meta, name = "set_block_when_disconnected")]
+        fn set_block_when_disconnected(&self, Self::Metadata, bool) -> BoxFuture<(), Error>;
+
         /// Set if the daemon should automatically establish a tunnel on start or not.
         #[rpc(meta, name = "set_auto_connect")]
         fn set_auto_connect(&self, Self::Metadata, bool) -> BoxFuture<(), Error>;
@@ -176,6 +180,8 @@ pub enum ManagementCommand {
     UpdateRelaySettings(OneshotSender<()>, RelaySettingsUpdate),
     /// Set the allow LAN setting.
     SetAllowLan(OneshotSender<()>, bool),
+    /// Set the block_when_disconnected setting.
+    SetBlockWhenDisconnected(OneshotSender<()>, bool),
     /// Set the auto-connect setting.
     SetAutoConnect(OneshotSender<()>, bool),
     /// Set the mssfix argument for OpenVPN
@@ -455,6 +461,22 @@ impl<T: From<ManagementCommand> + 'static + Send> ManagementInterfaceApi
         Box::new(future)
     }
 
+    fn set_block_when_disconnected(
+        &self,
+        _: Self::Metadata,
+        block_when_disconnected: bool,
+    ) -> BoxFuture<(), Error> {
+        log::debug!("set_block_when_disconnected({})", block_when_disconnected);
+        let (tx, rx) = sync::oneshot::channel();
+        let future = self
+            .send_command_to_daemon(ManagementCommand::SetBlockWhenDisconnected(
+                tx,
+                block_when_disconnected,
+            ))
+            .and_then(|_| rx.map_err(|_| Error::internal_error()));
+        Box::new(future)
+    }
+
     fn set_auto_connect(&self, _: Self::Metadata, auto_connect: bool) -> BoxFuture<(), Error> {
         log::debug!("set_auto_connect({})", auto_connect);
         let (tx, rx) = sync::oneshot::channel();