Simplify route manager handle

4 files changed, 21 insertions, 45 deletions

diff --git a/talpid-core/src/offline/macos.rs b/talpid-core/src/offline/macos.rs
index 2813dc4211..daafecb052 100644
--- a/talpid-core/src/offline/macos.rs
+++ b/talpid-core/src/offline/macos.rs
@@ -65,14 +65,14 @@ impl ConnectivityInner {
 
 pub async fn spawn_monitor(
     notify_tx: UnboundedSender<Connectivity>,
-    route_manager_handle: RouteManagerHandle,
+    route_manager: RouteManagerHandle,
 ) -> Result<MonitorHandle, Error> {
     let notify_tx = Arc::new(notify_tx);
 
     // note: begin observing before initializing the state
-    let route_listener = route_manager_handle.default_route_listener().await?;
+    let route_listener = route_manager.default_route_listener().await?;
 
-    let (ipv4, ipv6) = match route_manager_handle.get_default_routes().await {
+    let (ipv4, ipv6) = match route_manager.get_default_routes().await {
         Ok((v4_route, v6_route)) => (v4_route.is_some(), v6_route.is_some()),
         Err(error) => {
             log::warn!("Failed to initialize offline monitor: {error}");
diff --git a/talpid-core/src/offline/windows.rs b/talpid-core/src/offline/windows.rs
index f47fe8dd4d..5e09763cd0 100644
--- a/talpid-core/src/offline/windows.rs
+++ b/talpid-core/src/offline/windows.rs
@@ -29,7 +29,7 @@ unsafe impl Send for BroadcastListener {}
 impl BroadcastListener {
     pub async fn start(
         notify_tx: UnboundedSender<Connectivity>,
-        route_manager_handle: RouteManagerHandle,
+        route_manager: RouteManagerHandle,
         mut power_mgmt_rx: PowerManagementListener,
     ) -> Result<Self, Error> {
         let notify_tx = Arc::new(notify_tx);
@@ -67,8 +67,7 @@ impl BroadcastListener {
         });
 
         let callback_handle =
-            Self::setup_network_connectivity_listener(system_state.clone(), route_manager_handle)
-                .await?;
+            Self::setup_network_connectivity_listener(system_state.clone(), route_manager).await?;
 
         Ok(BroadcastListener {
             system_state,
@@ -107,9 +106,9 @@ impl BroadcastListener {
     /// until after `WinNet_DeactivateConnectivityMonitor` has been called.
     async fn setup_network_connectivity_listener(
         system_state: Arc<Mutex<SystemState>>,
-        route_manager_handle: RouteManagerHandle,
+        route_manager: RouteManagerHandle,
     ) -> Result<CallbackHandle, Error> {
-        let change_handle = route_manager_handle
+        let change_handle = route_manager
             .add_default_route_change_callback(Box::new(move |event, addr_family| {
                 Self::connectivity_callback(event, addr_family, &system_state)
             }))
@@ -202,10 +201,10 @@ pub type MonitorHandle = BroadcastListener;
 
 pub async fn spawn_monitor(
     sender: UnboundedSender<Connectivity>,
-    route_manager_handle: RouteManagerHandle,
+    route_manager: RouteManagerHandle,
 ) -> Result<MonitorHandle, Error> {
     let power_mgmt_rx = crate::window::PowerManagementListener::new();
-    BroadcastListener::start(sender, route_manager_handle, power_mgmt_rx).await
+    BroadcastListener::start(sender, route_manager, power_mgmt_rx).await
 }
 
 fn apply_system_state_change(state: Arc<Mutex<SystemState>>, change: StateChange) {
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 927de207bf..71a88e64fb 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -18,7 +18,7 @@ use std::{
     thread,
     time::{Duration, Instant},
 };
-use talpid_routing::RouteManager;
+use talpid_routing::RouteManagerHandle;
 use talpid_tunnel::{tun_provider::TunProvider, TunnelArgs, TunnelEvent, TunnelMetadata};
 use talpid_types::{
     net::{AllowedClients, AllowedEndpoint, AllowedTunnelTraffic, TunnelParameters},
@@ -60,9 +60,9 @@ impl ConnectingState {
         if shared_values.connectivity.is_offline() {
             // FIXME: Temporary: Nudge route manager to update the default interface
             #[cfg(target_os = "macos")]
-            if let Ok(handle) = shared_values.route_manager.handle() {
+            {
                 log::debug!("Poking route manager to update default routes");
-                let _ = handle.refresh_routes();
+                let _ = shared_values.route_manager.refresh_routes();
             }
             return ErrorState::enter(shared_values, ErrorStateCause::IsOffline);
         }
@@ -189,7 +189,7 @@ impl ConnectingState {
         log_dir: &Option<PathBuf>,
         resource_dir: &Path,
         tun_provider: Arc<Mutex<TunProvider>>,
-        route_manager: &RouteManager,
+        route_manager: &RouteManagerHandle,
         retry_attempt: u32,
     ) -> Self {
         let (event_tx, event_rx) = mpsc::unbounded();
@@ -202,7 +202,7 @@ impl ConnectingState {
                 })
             };
 
-        let route_manager_handle = route_manager.handle();
+        let route_manager = route_manager.clone();
         let log_dir = log_dir.clone();
         let resource_dir = resource_dir.to_path_buf();
 
@@ -214,25 +214,6 @@ impl ConnectingState {
         tokio::task::spawn_blocking(move || {
             let start = Instant::now();
 
-            let route_manager_handle = match route_manager_handle {
-                Ok(handle) => handle,
-                Err(error) => {
-                    if tunnel_close_event_tx
-                        .send(Some(ErrorStateCause::StartTunnelError))
-                        .is_err()
-                    {
-                        log::warn!(
-                            "Tunnel state machine stopped before receiving tunnel closed event"
-                        );
-                    }
-                    log::error!(
-                        "{}",
-                        error.display_chain_with_msg("Failed to obtain route monitor handle")
-                    );
-                    return;
-                }
-            };
-
             let args = TunnelArgs {
                 runtime,
                 resource_dir: &resource_dir,
@@ -240,7 +221,7 @@ impl ConnectingState {
                 tunnel_close_rx,
                 tun_provider,
                 retry_attempt,
-                route_manager: route_manager_handle,
+                route_manager,
             };
 
             let block_reason = match TunnelMonitor::start(&mut tunnel_parameters, &log_dir, args) {
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index 75f6cc1ced..bee32bb31d 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -21,7 +21,7 @@ use crate::{
 };
 #[cfg(windows)]
 use std::ffi::OsString;
-use talpid_routing::RouteManager;
+use talpid_routing::RouteManagerHandle;
 use talpid_tunnel::{tun_provider::TunProvider, TunnelEvent};
 
 use futures::{
@@ -269,7 +269,7 @@ impl TunnelStateMachine {
         #[cfg(target_os = "macos")]
         let filtering_resolver = crate::resolver::start_resolver().await?;
 
-        let route_manager = RouteManager::new(
+        let route_manager = RouteManagerHandle::spawn(
             #[cfg(target_os = "linux")]
             args.linux_ids.fwmark,
             #[cfg(target_os = "linux")]
@@ -284,9 +284,7 @@ impl TunnelStateMachine {
             args.resource_dir.clone(),
             args.command_tx.clone(),
             volume_update_rx,
-            route_manager
-                .handle()
-                .map_err(Error::InitRouteManagerError)?,
+            route_manager.clone(),
         )
         .map_err(Error::InitSplitTunneling)?;
 
@@ -308,9 +306,7 @@ impl TunnelStateMachine {
             #[cfg(target_os = "linux")]
             runtime.clone(),
             #[cfg(target_os = "linux")]
-            route_manager
-                .handle()
-                .map_err(Error::InitRouteManagerError)?,
+            route_manager.clone(),
             #[cfg(target_os = "macos")]
             args.command_tx.clone(),
         )
@@ -331,7 +327,7 @@ impl TunnelStateMachine {
         let offline_monitor = offline::spawn_monitor(
             offline_tx,
             #[cfg(not(target_os = "android"))]
-            route_manager.handle()?,
+            route_manager.clone(),
             #[cfg(target_os = "linux")]
             Some(args.linux_ids.fwmark),
             #[cfg(target_os = "android")]
@@ -436,7 +432,7 @@ struct SharedTunnelStateValues {
     runtime: tokio::runtime::Handle,
     firewall: Firewall,
     dns_monitor: DnsMonitor,
-    route_manager: RouteManager,
+    route_manager: RouteManagerHandle,
     _offline_monitor: offline::MonitorHandle,
     /// Should LAN access be allowed outside the tunnel.
     allow_lan: bool,