Merge branch 'move-directories-to-shared-state'

4 files changed, 71 insertions, 60 deletions

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 22103282cf..5362d0805c 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -179,8 +179,6 @@ pub struct Daemon {
     tokio_remote: tokio_core::reactor::Remote,
     relay_selector: relays::RelaySelector,
     current_relay: Option<Relay>,
-    log_dir: Option<PathBuf>,
-    resource_dir: PathBuf,
     version: String,
 }
 
@@ -215,12 +213,15 @@ impl Daemon {
             relays::RelaySelector::new(rpc_handle.clone(), &resource_dir, &cache_dir);
 
         let (tx, rx) = mpsc::channel();
-        let tunnel_command_tx =
-            tunnel_state_machine::spawn(cache_dir.clone(), IntoSender::from(tx.clone()))?;
+        let tunnel_command_tx = tunnel_state_machine::spawn(
+            log_dir,
+            resource_dir,
+            cache_dir.clone(),
+            IntoSender::from(tx.clone()),
+        )?;
 
         let target_state = TargetState::Unsecured;
-        let management_interface_result =
-            Self::start_management_interface(tx.clone(), cache_dir.clone())?;
+        let management_interface_result = Self::start_management_interface(tx.clone(), cache_dir)?;
 
         // Attempt to download a fresh relay list
         relay_selector.update();
@@ -243,8 +244,6 @@ impl Daemon {
             tokio_remote,
             relay_selector,
             current_relay: None,
-            log_dir,
-            resource_dir,
             version,
         })
     }
@@ -648,8 +647,6 @@ impl Daemon {
         TunnelParameters {
             endpoint,
             options: self.settings.get_tunnel_options().clone(),
-            log_dir: self.log_dir.clone(),
-            resource_dir: self.resource_dir.clone(),
             username: account_token,
             allow_lan: self.settings.get_allow_lan(),
         }
diff --git a/talpid-core/src/tunnel_state_machine/connected_state.rs b/talpid-core/src/tunnel_state_machine/connected_state.rs
index 224fce3e91..1308e82032 100644
--- a/talpid-core/src/tunnel_state_machine/connected_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connected_state.rs
@@ -2,7 +2,6 @@ use error_chain::ChainedError;
 use futures::sync::{mpsc, oneshot};
 use futures::{Async, Future, Stream};
 
-use talpid_types::net::TunnelEndpoint;
 use talpid_types::tunnel::BlockReason;
 
 use super::{
@@ -16,7 +15,6 @@ use tunnel::{CloseHandle, TunnelEvent, TunnelMetadata};
 pub struct ConnectedStateBootstrap {
     pub metadata: TunnelMetadata,
     pub tunnel_events: mpsc::UnboundedReceiver<TunnelEvent>,
-    pub tunnel_endpoint: TunnelEndpoint,
     pub tunnel_parameters: TunnelParameters,
     pub tunnel_close_event: oneshot::Receiver<()>,
     pub close_handle: CloseHandle,
@@ -26,7 +24,6 @@ pub struct ConnectedStateBootstrap {
 pub struct ConnectedState {
     metadata: TunnelMetadata,
     tunnel_events: mpsc::UnboundedReceiver<TunnelEvent>,
-    tunnel_endpoint: TunnelEndpoint,
     tunnel_parameters: TunnelParameters,
     tunnel_close_event: oneshot::Receiver<()>,
     close_handle: CloseHandle,
@@ -37,7 +34,6 @@ impl ConnectedState {
         ConnectedState {
             metadata: bootstrap.metadata,
             tunnel_events: bootstrap.tunnel_events,
-            tunnel_endpoint: bootstrap.tunnel_endpoint,
             tunnel_parameters: bootstrap.tunnel_parameters,
             tunnel_close_event: bootstrap.tunnel_close_event,
             close_handle: bootstrap.close_handle,
@@ -46,7 +42,7 @@ impl ConnectedState {
 
     fn set_security_policy(&self, shared_values: &mut SharedTunnelStateValues) -> Result<()> {
         let policy = SecurityPolicy::Connected {
-            relay_endpoint: self.tunnel_endpoint.to_endpoint(),
+            relay_endpoint: self.tunnel_parameters.endpoint.to_endpoint(),
             tunnel: self.metadata.clone(),
             allow_lan: self.tunnel_parameters.allow_lan,
         };
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 2d0e8d7795..1dc057a7e5 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -1,5 +1,5 @@
 use std::ffi::OsString;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::thread;
 use std::time::{Duration, Instant};
@@ -46,26 +46,12 @@ error_chain! {
 /// The tunnel has been started, but it is not established/functional.
 pub struct ConnectingState {
     tunnel_events: mpsc::UnboundedReceiver<TunnelEvent>,
-    tunnel_endpoint: TunnelEndpoint,
     tunnel_parameters: TunnelParameters,
     tunnel_close_event: oneshot::Receiver<()>,
     close_handle: CloseHandle,
 }
 
 impl ConnectingState {
-    fn new(parameters: TunnelParameters) -> Result<Self> {
-        let tunnel_endpoint = parameters.endpoint;
-        let (tunnel_events, tunnel_close_event, close_handle) = Self::start_tunnel(&parameters)?;
-
-        Ok(ConnectingState {
-            tunnel_events,
-            tunnel_endpoint,
-            tunnel_parameters: parameters,
-            tunnel_close_event,
-            close_handle,
-        })
-    }
-
     fn set_security_policy(
         shared_values: &mut SharedTunnelStateValues,
         endpoint: TunnelEndpoint,
@@ -82,22 +68,28 @@ impl ConnectingState {
     }
 
     fn start_tunnel(
-        parameters: &TunnelParameters,
-    ) -> Result<(
-        mpsc::UnboundedReceiver<TunnelEvent>,
-        oneshot::Receiver<()>,
-        CloseHandle,
-    )> {
+        parameters: TunnelParameters,
+        log_dir: &Option<PathBuf>,
+        resource_dir: &Path,
+    ) -> Result<Self> {
         let (event_tx, event_rx) = mpsc::unbounded();
-        let monitor = Self::spawn_tunnel_monitor(&parameters, event_tx.wait())?;
+        let monitor =
+            Self::spawn_tunnel_monitor(&parameters, log_dir, resource_dir, event_tx.wait())?;
         let close_handle = monitor.close_handle();
         let tunnel_close_event = Self::spawn_tunnel_monitor_wait_thread(monitor);
 
-        Ok((event_rx, tunnel_close_event, close_handle))
+        Ok(ConnectingState {
+            tunnel_events: event_rx,
+            tunnel_parameters: parameters,
+            tunnel_close_event,
+            close_handle,
+        })
     }
 
     fn spawn_tunnel_monitor(
         parameters: &TunnelParameters,
+        log_dir: &Option<PathBuf>,
+        resource_dir: &Path,
         events: Wait<mpsc::UnboundedSender<TunnelEvent>>,
     ) -> Result<TunnelMonitor> {
         let event_tx = Mutex::new(events);
@@ -111,7 +103,7 @@ impl ConnectingState {
                 warn!("Tunnel state machine stopped before tunnel event was received");
             }
         };
-        let log_file = Self::prepare_tunnel_log_file(&parameters)?;
+        let log_file = Self::prepare_tunnel_log_file(&parameters, log_dir)?;
 
         Ok(TunnelMonitor::new(
             parameters.endpoint,
@@ -119,13 +111,16 @@ impl ConnectingState {
             TUNNEL_INTERFACE_ALIAS.to_owned().map(OsString::from),
             &parameters.username,
             log_file.as_ref().map(PathBuf::as_path),
-            &parameters.resource_dir,
+            resource_dir,
             on_tunnel_event,
         )?)
     }
 
-    fn prepare_tunnel_log_file(parameters: &TunnelParameters) -> Result<Option<PathBuf>> {
-        if let Some(ref log_dir) = parameters.log_dir {
+    fn prepare_tunnel_log_file(
+        parameters: &TunnelParameters,
+        log_dir: &Option<PathBuf>,
+    ) -> Result<Option<PathBuf>> {
+        if let Some(ref log_dir) = log_dir {
             let filename = match parameters.endpoint.tunnel {
                 TunnelEndpointData::OpenVpn(_) => OPENVPN_LOG_FILENAME,
                 TunnelEndpointData::Wireguard(_) => WIREGUARD_LOG_FILENAME,
@@ -170,7 +165,6 @@ impl ConnectingState {
         ConnectedStateBootstrap {
             metadata,
             tunnel_events: self.tunnel_events,
-            tunnel_endpoint: self.tunnel_endpoint,
             tunnel_parameters: self.tunnel_parameters,
             tunnel_close_event: self.tunnel_close_event,
             close_handle: self.close_handle,
@@ -187,7 +181,11 @@ impl ConnectingState {
         match try_handle_event!(self, commands.poll()) {
             Ok(TunnelCommand::AllowLan(allow_lan)) => {
                 self.tunnel_parameters.allow_lan = allow_lan;
-                match Self::set_security_policy(shared_values, self.tunnel_endpoint, allow_lan) {
+                match Self::set_security_policy(
+                    shared_values,
+                    self.tunnel_parameters.endpoint,
+                    allow_lan,
+                ) {
                     Ok(()) => SameState(self),
                     Err(error) => {
                         error!("{}", error.display_chain());
@@ -309,7 +307,11 @@ impl TunnelState for ConnectingState {
             return BlockedState::enter(shared_values, (BlockReason::StartTunnelError, allow_lan));
         }
 
-        match Self::new(parameters) {
+        match Self::start_tunnel(
+            parameters,
+            &shared_values.log_dir,
+            &shared_values.resource_dir,
+        ) {
             Ok(connecting_state) => (
                 TunnelStateWrapper::from(connecting_state),
                 TunnelStateTransition::Connecting,
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index 3338d3c4cc..20d58c05d4 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -43,6 +43,8 @@ error_chain! {
 
 /// Spawn the tunnel state machine thread, returning a channel for sending tunnel commands.
 pub fn spawn<P, T>(
+    log_dir: Option<PathBuf>,
+    resource_dir: PathBuf,
     cache_dir: P,
     state_change_listener: IntoSender<TunnelStateTransition, T>,
 ) -> Result<mpsc::UnboundedSender<TunnelCommand>>
@@ -53,8 +55,14 @@ where
     let (command_tx, command_rx) = mpsc::unbounded();
     let (startup_result_tx, startup_result_rx) = sync_mpsc::channel();
 
-    thread::spawn(
-        move || match create_event_loop(cache_dir, command_rx, state_change_listener) {
+    thread::spawn(move || {
+        match create_event_loop(
+            log_dir,
+            resource_dir,
+            cache_dir,
+            command_rx,
+            state_change_listener,
+        ) {
             Ok((mut reactor, event_loop)) => {
                 startup_result_tx.send(Ok(())).expect(
                     "Tunnel state machine won't be started because the owner thread crashed",
@@ -71,8 +79,8 @@ where
                     .send(Err(startup_error))
                     .expect("Failed to send startup error");
             }
-        },
-    );
+        }
+    });
 
     startup_result_rx
         .recv()
@@ -80,17 +88,18 @@ where
         .map(|_| command_tx)
 }
 
-fn create_event_loop<P, T>(
-    cache_dir: P,
+fn create_event_loop<T>(
+    log_dir: Option<PathBuf>,
+    resource_dir: PathBuf,
+    cache_dir: impl AsRef<Path>,
     commands: mpsc::UnboundedReceiver<TunnelCommand>,
     state_change_listener: IntoSender<TunnelStateTransition, T>,
 ) -> Result<(Core, impl Future<Item = (), Error = Error>)>
 where
-    P: AsRef<Path>,
     T: From<TunnelStateTransition> + Send + 'static,
 {
     let reactor = Core::new().chain_err(|| ErrorKind::ReactorError)?;
-    let state_machine = TunnelStateMachine::new(&cache_dir, commands)?;
+    let state_machine = TunnelStateMachine::new(log_dir, resource_dir, cache_dir, commands)?;
 
     let future = state_machine.for_each(move |state_change_event| {
         state_change_listener
@@ -120,10 +129,6 @@ pub struct TunnelParameters {
     pub endpoint: TunnelEndpoint,
     /// Tunnel connection options.
     pub options: TunnelOptions,
-    /// Directory to store tunnel log file.
-    pub log_dir: Option<PathBuf>,
-    /// Resource directory path.
-    pub resource_dir: PathBuf,
     /// Username to use for setting up the tunnel.
     pub username: String,
     /// Should LAN access be allowed outside the tunnel.
@@ -143,13 +148,19 @@ struct TunnelStateMachine {
 }
 
 impl TunnelStateMachine {
-    fn new<P: AsRef<Path>>(
-        cache_dir: P,
+    fn new(
+        log_dir: Option<PathBuf>,
+        resource_dir: PathBuf,
+        cache_dir: impl AsRef<Path>,
         commands: mpsc::UnboundedReceiver<TunnelCommand>,
     ) -> Result<Self> {
         let security =
             NetworkSecurity::new(cache_dir).chain_err(|| ErrorKind::NetworkSecurityError)?;
-        let mut shared_values = SharedTunnelStateValues { security };
+        let mut shared_values = SharedTunnelStateValues {
+            security,
+            log_dir,
+            resource_dir,
+        };
 
         let (initial_state, _) = DisconnectedState::enter(&mut shared_values, ());
         Ok(TunnelStateMachine {
@@ -210,9 +221,14 @@ impl<T: TunnelState> From<EventConsequence<T>> for TunnelStateMachineAction {
     }
 }
 
+
 /// Values that are common to all tunnel states.
 struct SharedTunnelStateValues {
     security: NetworkSecurity,
+    /// Directory to store tunnel log file.
+    log_dir: Option<PathBuf>,
+    /// Resource directory path.
+    resource_dir: PathBuf,
 }
 
 /// Asynchronous result of an attempt to progress a state.