Renaming remaining mentions of "security" to "firewall"

5 files changed, 21 insertions, 21 deletions

diff --git a/talpid-core/src/tunnel_state_machine/blocked_state.rs b/talpid-core/src/tunnel_state_machine/blocked_state.rs
index 3d63e543a2..4fd992dd4d 100644
--- a/talpid-core/src/tunnel_state_machine/blocked_state.rs
+++ b/talpid-core/src/tunnel_state_machine/blocked_state.rs
@@ -14,13 +14,13 @@ pub struct BlockedState {
 }
 
 impl BlockedState {
-    fn set_security_policy(shared_values: &mut SharedTunnelStateValues) -> Option<BlockReason> {
+    fn set_firewall_policy(shared_values: &mut SharedTunnelStateValues) -> Option<BlockReason> {
         let policy = FirewallPolicy::Blocked {
             allow_lan: shared_values.allow_lan,
         };
 
         match shared_values
-            .security
+            .firewall
             .apply_policy(policy)
             .chain_err(|| "Failed to apply firewall policy for blocked state")
         {
@@ -40,7 +40,7 @@ impl TunnelState for BlockedState {
         shared_values: &mut SharedTunnelStateValues,
         block_reason: Self::Bootstrap,
     ) -> (TunnelStateWrapper, TunnelStateTransition) {
-        let block_reason = Self::set_security_policy(shared_values).unwrap_or_else(|| block_reason);
+        let block_reason = Self::set_firewall_policy(shared_values).unwrap_or_else(|| block_reason);
 
         (
             TunnelStateWrapper::from(BlockedState {
@@ -60,7 +60,7 @@ impl TunnelState for BlockedState {
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 shared_values.allow_lan = allow_lan;
-                Self::set_security_policy(shared_values);
+                Self::set_firewall_policy(shared_values);
                 SameState(self)
             }
             Ok(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index 73751076e9..1a979476e7 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -46,7 +46,7 @@ impl ConnectedState {
         }
     }
 
-    fn set_security_policy(&self, shared_values: &mut SharedTunnelStateValues) -> Result<()> {
+    fn set_firewall_policy(&self, shared_values: &mut SharedTunnelStateValues) -> Result<()> {
         // If a proxy is specified we need to pass it on as the peer endpoint.
         let peer_endpoint = self.get_endpoint_from_params();
 
@@ -56,7 +56,7 @@ impl ConnectedState {
             allow_lan: shared_values.allow_lan,
         };
         shared_values
-            .security
+            .firewall
             .apply_policy(policy)
             .chain_err(|| "Failed to apply firewall policy for connected state")
     }
@@ -111,7 +111,7 @@ impl ConnectedState {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 shared_values.allow_lan = allow_lan;
 
-                match self.set_security_policy(shared_values) {
+                match self.set_firewall_policy(shared_values) {
                     Ok(()) => SameState(self),
                     Err(error) => {
                         log::error!("{}", error.display_chain());
@@ -195,7 +195,7 @@ impl TunnelState for ConnectedState {
         let connected_state = ConnectedState::from(bootstrap);
         let tunnel_endpoint = connected_state.tunnel_parameters.get_tunnel_endpoint();
 
-        if let Err(error) = connected_state.set_security_policy(shared_values) {
+        if let Err(error) = connected_state.set_firewall_policy(shared_values) {
             log::error!("{}", error.display_chain());
             DisconnectingState::enter(
                 shared_values,
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 5c34a240ee..0896fd18cf 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -60,7 +60,7 @@ pub struct ConnectingState {
 }
 
 impl ConnectingState {
-    fn set_security_policy(
+    fn set_firewall_policy(
         shared_values: &mut SharedTunnelStateValues,
         proxy: &Option<openvpn::ProxySettings>,
         endpoint: Endpoint,
@@ -76,7 +76,7 @@ impl ConnectingState {
             allow_lan: shared_values.allow_lan,
         };
         shared_values
-            .security
+            .firewall
             .apply_policy(policy)
             .chain_err(|| "Failed to apply firewall policy for connecting state")
     }
@@ -217,7 +217,7 @@ impl ConnectingState {
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 shared_values.allow_lan = allow_lan;
-                match Self::set_security_policy(
+                match Self::set_firewall_policy(
                     shared_values,
                     &get_openvpn_proxy_settings(&self.tunnel_parameters),
                     self.tunnel_parameters.get_tunnel_endpoint().endpoint,
@@ -369,7 +369,7 @@ impl TunnelState for ConnectingState {
             None => BlockedState::enter(shared_values, BlockReason::NoMatchingRelay),
             Some(tunnel_parameters) => {
                 let endpoint = tunnel_parameters.get_tunnel_endpoint().endpoint;
-                if let Err(error) = Self::set_security_policy(
+                if let Err(error) = Self::set_firewall_policy(
                     shared_values,
                     &get_openvpn_proxy_settings(&tunnel_parameters),
                     endpoint,
diff --git a/talpid-core/src/tunnel_state_machine/disconnected_state.rs b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
index 9bda32f1b2..299d00d303 100644
--- a/talpid-core/src/tunnel_state_machine/disconnected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/disconnected_state.rs
@@ -10,18 +10,18 @@ use futures::{sync::mpsc, Stream};
 pub struct DisconnectedState;
 
 impl DisconnectedState {
-    fn set_security_policy(shared_values: &mut SharedTunnelStateValues) {
+    fn set_firewall_policy(shared_values: &mut SharedTunnelStateValues) {
         let result = if shared_values.block_when_disconnected {
             let policy = FirewallPolicy::Blocked {
                 allow_lan: shared_values.allow_lan,
             };
             shared_values
-                .security
+                .firewall
                 .apply_policy(policy)
                 .chain_err(|| "Failed to apply blocking firewall policy for disconnected state")
         } else {
             shared_values
-                .security
+                .firewall
                 .reset_policy()
                 .chain_err(|| "Failed to reset firewall policy")
         };
@@ -38,7 +38,7 @@ impl TunnelState for DisconnectedState {
         shared_values: &mut SharedTunnelStateValues,
         _: Self::Bootstrap,
     ) -> (TunnelStateWrapper, TunnelStateTransition) {
-        Self::set_security_policy(shared_values);
+        Self::set_firewall_policy(shared_values);
         (
             TunnelStateWrapper::from(DisconnectedState),
             TunnelStateTransition::Disconnected,
@@ -56,14 +56,14 @@ impl TunnelState for DisconnectedState {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 if shared_values.allow_lan != allow_lan {
                     shared_values.allow_lan = allow_lan;
-                    Self::set_security_policy(shared_values);
+                    Self::set_firewall_policy(shared_values);
                 }
                 SameState(self)
             }
             Ok(TunnelCommand::BlockWhenDisconnected(block_when_disconnected)) => {
                 if shared_values.block_when_disconnected != block_when_disconnected {
                     shared_values.block_when_disconnected = block_when_disconnected;
-                    Self::set_security_policy(shared_values);
+                    Self::set_firewall_policy(shared_values);
                 }
                 SameState(self)
             }
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index 19d0cc707f..4e85e9a0be 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -181,10 +181,10 @@ impl TunnelStateMachine {
         cache_dir: impl AsRef<Path>,
         commands: mpsc::UnboundedReceiver<TunnelCommand>,
     ) -> Result<Self> {
-        let security = Firewall::new().chain_err(|| ErrorKind::FirewallError)?;
+        let firewall = Firewall::new().chain_err(|| ErrorKind::FirewallError)?;
         let dns_monitor = DnsMonitor::new(cache_dir).chain_err(|| ErrorKind::DnsMonitorError)?;
         let mut shared_values = SharedTunnelStateValues {
-            security,
+            firewall,
             dns_monitor,
             allow_lan,
             block_when_disconnected,
@@ -262,7 +262,7 @@ pub trait TunnelParametersGenerator: Send + 'static {
 
 /// Values that are common to all tunnel states.
 struct SharedTunnelStateValues {
-    security: Firewall,
+    firewall: Firewall,
     dns_monitor: DnsMonitor,
     /// Should LAN access be allowed outside the tunnel.
     allow_lan: bool,