Use setter helper to update `allow_lan`

5 files changed, 48 insertions, 35 deletions

diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index 3ce80db030..1c0407a615 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -110,21 +110,23 @@ impl ConnectedState {
 
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                shared_values.allow_lan = allow_lan;
-
-                match self.set_firewall_policy(shared_values) {
-                    Ok(()) => SameState(self),
-                    Err(error) => {
-                        log::error!(
-                            "{}",
-                            error.display_chain_with_msg(
-                                "Failed to apply firewall policy for connected state"
+                if let Err(error_cause) = shared_values.set_allow_lan(allow_lan) {
+                    self.disconnect(shared_values, AfterDisconnect::Block(error_cause))
+                } else {
+                    match self.set_firewall_policy(shared_values) {
+                        Ok(()) => SameState(self),
+                        Err(error) => {
+                            log::error!(
+                                "{}",
+                                error.display_chain_with_msg(
+                                    "Failed to apply firewall policy for connected state"
+                                )
+                            );
+                            self.disconnect(
+                                shared_values,
+                                AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError),
                             )
-                        );
-                        self.disconnect(
-                            shared_values,
-                            AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError),
-                        )
+                        }
                     }
                 }
             }
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 2aec258503..848b2c7485 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -182,21 +182,24 @@ impl ConnectingState {
 
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                shared_values.allow_lan = allow_lan;
-                match Self::set_firewall_policy(shared_values, &self.tunnel_parameters) {
-                    Ok(()) => SameState(self),
-                    Err(error) => {
-                        error!(
-                            "{}",
-                            error.display_chain_with_msg(
-                                "Failed to apply firewall policy for connecting state"
-                            )
-                        );
+                if let Err(error_cause) = shared_values.set_allow_lan(allow_lan) {
+                    self.disconnect(shared_values, AfterDisconnect::Block(error_cause))
+                } else {
+                    match Self::set_firewall_policy(shared_values, &self.tunnel_parameters) {
+                        Ok(()) => SameState(self),
+                        Err(error) => {
+                            error!(
+                                "{}",
+                                error.display_chain_with_msg(
+                                    "Failed to apply firewall policy for connecting state"
+                                )
+                            );
 
-                        self.disconnect(
-                            shared_values,
-                            AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError),
-                        )
+                            self.disconnect(
+                                shared_values,
+                                AfterDisconnect::Block(ErrorStateCause::SetFirewallPolicyError),
+                            )
+                        }
                     }
                 }
             }
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index f183a7c78c..0eb02252dd 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -59,7 +59,12 @@ impl TunnelState for DisconnectedState {
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 if shared_values.allow_lan != allow_lan {
-                    shared_values.allow_lan = allow_lan;
+                    // The only platform that can fail is Android, but Android doesn't support the
+                    // "block when disconnected" option, so the following call never fails.
+                    shared_values
+                        .set_allow_lan(allow_lan)
+                        .expect("Failed to set allow LAN parameter");
+
                     Self::set_firewall_policy(shared_values);
                 }
                 SameState(self)
diff --git a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
index d18fdeb6ee..c07ecbf8f7 100644
--- a/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnecting_state.rs
@@ -32,7 +32,7 @@ impl DisconnectingState {
         self.after_disconnect = match after_disconnect {
             AfterDisconnect::Nothing => match event {
                 Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                    shared_values.allow_lan = allow_lan;
+                    let _ = shared_values.set_allow_lan(allow_lan);
                     AfterDisconnect::Nothing
                 }
                 Ok(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
@@ -49,7 +49,7 @@ impl DisconnectingState {
             },
             AfterDisconnect::Block(reason) => match event {
                 Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                    shared_values.allow_lan = allow_lan;
+                    let _ = shared_values.set_allow_lan(allow_lan);
                     AfterDisconnect::Block(reason)
                 }
                 Ok(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
@@ -71,7 +71,7 @@ impl DisconnectingState {
             },
             AfterDisconnect::Reconnect(retry_attempt) => match event {
                 Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                    shared_values.allow_lan = allow_lan;
+                    let _ = shared_values.set_allow_lan(allow_lan);
                     AfterDisconnect::Reconnect(retry_attempt)
                 }
                 Ok(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 9d8402997d..b1bf5183b2 100644
--- a/talpid-core/src/tunnel_state_machine/error_state.rs
+++ b/talpid-core/src/tunnel_state_machine/error_state.rs
@@ -81,9 +81,12 @@ impl TunnelState for ErrorState {
 
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
-                shared_values.allow_lan = allow_lan;
-                Self::set_firewall_policy(shared_values);
-                SameState(self)
+                if let Err(error_state_cause) = shared_values.set_allow_lan(allow_lan) {
+                    NewState(Self::enter(shared_values, error_state_cause))
+                } else {
+                    Self::set_firewall_policy(shared_values);
+                    SameState(self)
+                }
             }
             Ok(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
                 shared_values.block_when_disconnected = block_when_disconnected;