Merge branch 'adblocking-dns'

7 files changed, 57 insertions, 66 deletions

diff --git a/talpid-core/src/tunnel/tun_provider/android/mod.rs b/talpid-core/src/tunnel/tun_provider/android/mod.rs
index 575f05f4c2..3febda73d4 100644
--- a/talpid-core/src/tunnel/tun_provider/android/mod.rs
+++ b/talpid-core/src/tunnel/tun_provider/android/mod.rs
@@ -110,7 +110,7 @@ impl AndroidTunProvider {
         self.allowed_endpoint = endpoint;
     }
 
-    pub fn set_custom_dns_servers(&mut self, servers: Option<Vec<IpAddr>>) -> Result<(), Error> {
+    pub fn set_dns_servers(&mut self, servers: Option<Vec<IpAddr>>) -> Result<(), Error> {
         if self.custom_dns_servers != servers {
             self.custom_dns_servers = servers;
             self.recreate_tun_if_open()?;
diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index dd2102127e..ea8ce8e992 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -80,7 +80,7 @@ impl ConnectedState {
     #[allow(unused_variables)]
     fn get_dns_servers(&self, shared_values: &SharedTunnelStateValues) -> Vec<IpAddr> {
         #[cfg(not(target_os = "android"))]
-        if let Some(ref servers) = shared_values.custom_dns {
+        if let Some(ref servers) = shared_values.dns_servers {
             servers.clone()
         } else {
             let mut dns_ips = vec![];
@@ -197,41 +197,34 @@ impl ConnectedState {
                 }
                 SameState(self.into())
             }
-            Some(TunnelCommand::CustomDns(servers)) => {
-                match shared_values.set_custom_dns(servers) {
-                    Ok(true) => {
-                        if let Err(error) = self.set_firewall_policy(shared_values) {
-                            return self.disconnect(
-                                shared_values,
-                                AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError(
-                                    error,
-                                )),
-                            );
-                        }
+            Some(TunnelCommand::Dns(servers)) => match shared_values.set_dns_servers(servers) {
+                Ok(true) => {
+                    if let Err(error) = self.set_firewall_policy(shared_values) {
+                        return self.disconnect(
+                            shared_values,
+                            AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError(error)),
+                        );
+                    }
 
-                        match self.set_dns(shared_values) {
-                            #[cfg(target_os = "android")]
-                            Ok(()) => self.disconnect(shared_values, AfterDisconnect::Reconnect(0)),
-                            #[cfg(not(target_os = "android"))]
-                            Ok(()) => SameState(self.into()),
-                            Err(error) => {
-                                log::error!(
-                                    "{}",
-                                    error.display_chain_with_msg("Failed to set DNS")
-                                );
-                                self.disconnect(
-                                    shared_values,
-                                    AfterDisconnect::Block(ErrorStateCause::SetDnsError),
-                                )
-                            }
+                    match self.set_dns(shared_values) {
+                        #[cfg(target_os = "android")]
+                        Ok(()) => self.disconnect(shared_values, AfterDisconnect::Reconnect(0)),
+                        #[cfg(not(target_os = "android"))]
+                        Ok(()) => SameState(self.into()),
+                        Err(error) => {
+                            log::error!("{}", error.display_chain_with_msg("Failed to set DNS"));
+                            self.disconnect(
+                                shared_values,
+                                AfterDisconnect::Block(ErrorStateCause::SetDnsError),
+                            )
                         }
                     }
-                    Ok(false) => SameState(self.into()),
-                    Err(error_cause) => {
-                        self.disconnect(shared_values, AfterDisconnect::Block(error_cause))
-                    }
                 }
-            }
+                Ok(false) => SameState(self.into()),
+                Err(error_cause) => {
+                    self.disconnect(shared_values, AfterDisconnect::Block(error_cause))
+                }
+            },
             Some(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
                 shared_values.block_when_disconnected = block_when_disconnected;
                 SameState(self.into())
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 29c3bb0a90..553cf9377d 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -267,14 +267,12 @@ impl ConnectingState {
                 }
                 SameState(self.into())
             }
-            Some(TunnelCommand::CustomDns(servers)) => {
-                match shared_values.set_custom_dns(servers) {
-                    #[cfg(target_os = "android")]
-                    Ok(true) => self.disconnect(shared_values, AfterDisconnect::Reconnect(0)),
-                    Ok(_) => SameState(self.into()),
-                    Err(cause) => self.disconnect(shared_values, AfterDisconnect::Block(cause)),
-                }
-            }
+            Some(TunnelCommand::Dns(servers)) => match shared_values.set_dns_servers(servers) {
+                #[cfg(target_os = "android")]
+                Ok(true) => self.disconnect(shared_values, AfterDisconnect::Reconnect(0)),
+                Ok(_) => SameState(self.into()),
+                Err(cause) => self.disconnect(shared_values, AfterDisconnect::Block(cause)),
+            },
             Some(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
                 shared_values.block_when_disconnected = block_when_disconnected;
                 SameState(self.into())
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index 7a02a9e550..8d2c9bc0fa 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -87,10 +87,10 @@ impl TunnelState for DisconnectedState {
                 }
                 SameState(self.into())
             }
-            Some(TunnelCommand::CustomDns(servers)) => {
+            Some(TunnelCommand::Dns(servers)) => {
                 // Same situation as allow LAN above.
                 shared_values
-                    .set_custom_dns(servers)
+                    .set_dns_servers(servers)
                     .expect("Failed to reconnect after changing custom DNS servers");
 
                 SameState(self.into())
diff --git a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
index 7ddbdcf5da..7d308d5971 100644
--- a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
@@ -39,8 +39,8 @@ impl DisconnectingState {
                     }
                     AfterDisconnect::Nothing
                 }
-                Some(TunnelCommand::CustomDns(servers)) => {
-                    let _ = shared_values.set_custom_dns(servers);
+                Some(TunnelCommand::Dns(servers)) => {
+                    let _ = shared_values.set_dns_servers(servers);
                     AfterDisconnect::Nothing
                 }
                 Some(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
@@ -72,8 +72,8 @@ impl DisconnectingState {
                     }
                     AfterDisconnect::Block(reason)
                 }
-                Some(TunnelCommand::CustomDns(servers)) => {
-                    let _ = shared_values.set_custom_dns(servers);
+                Some(TunnelCommand::Dns(servers)) => {
+                    let _ = shared_values.set_dns_servers(servers);
                     AfterDisconnect::Block(reason)
                 }
                 Some(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
@@ -110,8 +110,8 @@ impl DisconnectingState {
                     }
                     AfterDisconnect::Reconnect(retry_attempt)
                 }
-                Some(TunnelCommand::CustomDns(servers)) => {
-                    let _ = shared_values.set_custom_dns(servers);
+                Some(TunnelCommand::Dns(servers)) => {
+                    let _ = shared_values.set_dns_servers(servers);
                     AfterDisconnect::Reconnect(retry_attempt)
                 }
                 Some(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
diff --git a/talpid-core/src/tunnel_state_machine/error_state.rs b/talpid-core/src/tunnel_state_machine/error_state.rs
index 6674cca13e..5e647c8201 100644
--- a/talpid-core/src/tunnel_state_machine/error_state.rs
+++ b/talpid-core/src/tunnel_state_machine/error_state.rs
@@ -123,8 +123,8 @@ impl TunnelState for ErrorState {
                 }
                 SameState(self.into())
             }
-            Some(TunnelCommand::CustomDns(servers)) => {
-                if let Err(error_state_cause) = shared_values.set_custom_dns(servers) {
+            Some(TunnelCommand::Dns(servers)) => {
+                if let Err(error_state_cause) = shared_values.set_dns_servers(servers) {
                     NewState(Self::enter(shared_values, error_state_cause))
                 } else {
                     SameState(self.into())
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index 509a1a0e43..1f26f2fa04 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -76,7 +76,7 @@ pub enum Error {
 pub async fn spawn(
     allow_lan: bool,
     block_when_disconnected: bool,
-    custom_dns: Option<Vec<IpAddr>>,
+    dns_servers: Option<Vec<IpAddr>>,
     allowed_endpoint: Endpoint,
     tunnel_parameters_generator: impl TunnelParametersGenerator,
     log_dir: Option<PathBuf>,
@@ -106,7 +106,7 @@ pub async fn spawn(
         #[cfg(target_os = "android")]
         allowed_endpoint.address.ip(),
         #[cfg(target_os = "android")]
-        custom_dns.clone(),
+        dns_servers.clone(),
     );
 
     let runtime = tokio::runtime::Handle::current();
@@ -118,7 +118,7 @@ pub async fn spawn(
             allow_lan,
             block_when_disconnected,
             is_offline,
-            custom_dns,
+            dns_servers,
             allowed_endpoint,
             tunnel_parameters_generator,
             tun_provider,
@@ -161,8 +161,8 @@ pub enum TunnelCommand {
     /// Endpoint that should never be blocked.
     /// If an error occurs, the sender is dropped.
     AllowEndpoint(Endpoint, oneshot::Sender<()>),
-    /// Set custom DNS servers to use.
-    CustomDns(Option<Vec<IpAddr>>),
+    /// Set DNS servers to use.
+    Dns(Option<Vec<IpAddr>>),
     /// Enable or disable the block_when_disconnected feature.
     BlockWhenDisconnected(bool),
     /// Notify the state machine of the connectivity of the device.
@@ -204,7 +204,7 @@ impl TunnelStateMachine {
         allow_lan: bool,
         block_when_disconnected: bool,
         is_offline: bool,
-        custom_dns: Option<Vec<IpAddr>>,
+        dns_servers: Option<Vec<IpAddr>>,
         allowed_endpoint: Endpoint,
         tunnel_parameters_generator: impl TunnelParametersGenerator,
         tun_provider: TunProvider,
@@ -232,7 +232,7 @@ impl TunnelStateMachine {
             allow_lan,
             block_when_disconnected,
             is_offline,
-            custom_dns,
+            dns_servers,
             allowed_endpoint,
             tunnel_parameters_generator: Box::new(tunnel_parameters_generator),
             tun_provider,
@@ -304,8 +304,8 @@ struct SharedTunnelStateValues {
     block_when_disconnected: bool,
     /// True when the computer is known to be offline.
     is_offline: bool,
-    /// Custom DNS servers to use.
-    custom_dns: Option<Vec<IpAddr>>,
+    /// DNS servers to use (overriding default).
+    dns_servers: Option<Vec<IpAddr>>,
     /// Endpoint that should not be blocked by the firewall.
     allowed_endpoint: Endpoint,
     /// The generator of new `TunnelParameter`s
@@ -359,20 +359,20 @@ impl SharedTunnelStateValues {
         }
     }
 
-    pub fn set_custom_dns(
+    pub fn set_dns_servers(
         &mut self,
-        custom_dns: Option<Vec<IpAddr>>,
+        dns_servers: Option<Vec<IpAddr>>,
     ) -> Result<bool, ErrorStateCause> {
-        if self.custom_dns != custom_dns {
-            self.custom_dns = custom_dns.clone();
+        if self.dns_servers != dns_servers {
+            self.dns_servers = dns_servers.clone();
 
             #[cfg(target_os = "android")]
             {
-                if let Err(error) = self.tun_provider.set_custom_dns_servers(custom_dns) {
+                if let Err(error) = self.tun_provider.set_dns_servers(dns_servers) {
                     log::error!(
                         "{}",
                         error.display_chain_with_msg(
-                            "Failed to restart tunnel after changing custom DNS servers",
+                            "Failed to restart tunnel after changing DNS servers",
                         )
                     );
                     return Err(ErrorStateCause::StartTunnelError);