Simplify route manager handle

Author: dlon

talpid-core/src/dns/linux/mod.rs

@@ -8,7 +8,7 @@ use self::{
     systemd_resolved::SystemdResolved,
 };
 use std::{env, fmt, net::IpAddr};
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -37,15 +37,15 @@ pub enum Error {
 }
 
 pub struct DnsMonitor {
-    route_manager: RouteManagerHandle,
+    route_manager: RouteManager,
     handle: tokio::runtime::Handle,
     inner: Option<DnsMonitorHolder>,
 }
 
 impl super::DnsMonitorT for DnsMonitor {
     type Error = Error;
 
-    fn new(handle: tokio::runtime::Handle, route_manager: RouteManagerHandle) -> Result<Self> {
+    fn new(handle: tokio::runtime::Handle, route_manager: RouteManager) -> Result<Self> {
         Ok(DnsMonitor {
             route_manager,
             handle,
@@ -129,7 +129,7 @@ impl DnsMonitorHolder {
     fn set(
         &mut self,
         handle: &tokio::runtime::Handle,
-        route_manager: &RouteManagerHandle,
+        route_manager: &RouteManager,
         interface: &str,
         servers: &[IpAddr],
     ) -> Result<()> {

talpid-core/src/dns/linux/systemd_resolved.rs

@@ -1,7 +1,7 @@
 use crate::linux::{iface_index, IfaceIndexLookupError};
 use std::net::IpAddr;
 use talpid_dbus::systemd_resolved::{AsyncHandle, SystemdResolved as DbusInterface};
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 use talpid_types::ErrorExt;
 
 pub(crate) use talpid_dbus::systemd_resolved::Error as SystemdDbusError;
@@ -36,7 +36,7 @@ impl SystemdResolved {
 
     pub async fn set_dns(
         &mut self,
-        _route_manager: RouteManagerHandle,
+        _route_manager: RouteManager,
         interface_name: &str,
         servers: &[IpAddr],
     ) -> Result<()> {

talpid-core/src/dns/mod.rs

@@ -1,6 +1,6 @@
 use std::net::IpAddr;
 #[cfg(target_os = "linux")]
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 
 #[cfg(target_os = "macos")]
 use {
@@ -38,7 +38,7 @@ impl DnsMonitor {
     /// Returns a new `DnsMonitor` that can set and monitor the system DNS.
     pub fn new(
         #[cfg(target_os = "linux")] handle: tokio::runtime::Handle,
-        #[cfg(target_os = "linux")] route_manager: RouteManagerHandle,
+        #[cfg(target_os = "linux")] route_manager: RouteManager,
         #[cfg(target_os = "macos")] tx: Weak<UnboundedSender<TunnelCommand>>,
     ) -> Result<Self, Error> {
         Ok(DnsMonitor {
@@ -94,7 +94,7 @@ trait DnsMonitorT: Sized {
 
     fn new(
         #[cfg(target_os = "linux")] handle: tokio::runtime::Handle,
-        #[cfg(target_os = "linux")] route_manager: RouteManagerHandle,
+        #[cfg(target_os = "linux")] route_manager: RouteManager,
         #[cfg(target_os = "macos")] tx: Weak<UnboundedSender<TunnelCommand>>,
     ) -> Result<Self, Self::Error>;
 

talpid-core/src/offline/linux.rs

@@ -3,7 +3,7 @@ use std::{
     net::{IpAddr, Ipv4Addr, Ipv6Addr},
     sync::Arc,
 };
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 use talpid_types::{net::Connectivity, ErrorExt};
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -15,7 +15,7 @@ pub enum Error {
 }
 
 pub struct MonitorHandle {
-    route_manager: RouteManagerHandle,
+    route_manager: RouteManager,
     fwmark: Option<u32>,
     _notify_tx: Arc<UnboundedSender<Connectivity>>,
 }
@@ -42,7 +42,7 @@ impl MonitorHandle {
 
 pub async fn spawn_monitor(
     notify_tx: UnboundedSender<Connectivity>,
-    route_manager: RouteManagerHandle,
+    route_manager: RouteManager,
     fwmark: Option<u32>,
 ) -> Result<MonitorHandle> {
     let mut is_offline = public_ip_unreachable(&route_manager, fwmark).await?;
@@ -86,10 +86,7 @@ pub async fn spawn_monitor(
     Ok(monitor_handle)
 }
 
-async fn public_ip_unreachable(
-    handle: &RouteManagerHandle,
-    fwmark: Option<u32>,
-) -> Result<Connectivity> {
+async fn public_ip_unreachable(handle: &RouteManager, fwmark: Option<u32>) -> Result<Connectivity> {
     let route_exists = |destination| async move {
         handle
             .get_destination_route(destination, fwmark)

talpid-core/src/offline/macos.rs

@@ -2,7 +2,7 @@
 //! that the app gets stuck in an offline state, blocking all internet access and preventing the
 //! user from connecting to a relay.
 //!
-//! See [RouteManagerHandle::default_route_listener].
+//! See [RouteManager::default_route_listener].
 //!
 //! This offline monitor synthesizes an offline state between network switches and before coming
 //! online from an offline state. This is done to work around issues with DNS being blocked due
@@ -17,7 +17,7 @@ use std::{
     sync::{Arc, Mutex},
     time::Duration,
 };
-use talpid_routing::{DefaultRouteEvent, RouteManagerHandle};
+use talpid_routing::{DefaultRouteEvent, RouteManager};
 use talpid_types::net::Connectivity;
 
 const SYNTHETIC_OFFLINE_DURATION: Duration = Duration::from_secs(1);
@@ -65,7 +65,7 @@ impl ConnectivityInner {
 
 pub async fn spawn_monitor(
     notify_tx: UnboundedSender<Connectivity>,
-    route_manager_handle: RouteManagerHandle,
+    route_manager_handle: RouteManager,
 ) -> Result<MonitorHandle, Error> {
     let notify_tx = Arc::new(notify_tx);
 

talpid-core/src/offline/mod.rs

@@ -1,7 +1,7 @@
 use futures::channel::mpsc::UnboundedSender;
 use once_cell::sync::Lazy;
 #[cfg(not(target_os = "android"))]
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 #[cfg(target_os = "android")]
 use talpid_types::android::AndroidContext;
 use talpid_types::net::Connectivity;
@@ -45,7 +45,7 @@ impl MonitorHandle {
 #[cfg(not(target_os = "android"))]
 pub async fn spawn_monitor(
     sender: UnboundedSender<Connectivity>,
-    route_manager: RouteManagerHandle,
+    route_manager: RouteManager,
     #[cfg(target_os = "linux")] fwmark: Option<u32>,
 ) -> Result<MonitorHandle, Error> {
     let monitor = if *FORCE_DISABLE_OFFLINE_MONITOR {

talpid-core/src/offline/windows.rs

@@ -6,7 +6,7 @@ use std::{
     sync::{Arc, Weak},
     time::Duration,
 };
-use talpid_routing::{get_best_default_route, CallbackHandle, EventType, RouteManagerHandle};
+use talpid_routing::{get_best_default_route, CallbackHandle, EventType, RouteManager};
 use talpid_types::{net::Connectivity, ErrorExt};
 use talpid_windows::net::AddressFamily;
 
@@ -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_handle: RouteManager,
         mut power_mgmt_rx: PowerManagementListener,
     ) -> Result<Self, Error> {
         let notify_tx = Arc::new(notify_tx);
@@ -107,7 +107,7 @@ 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_handle: RouteManager,
     ) -> Result<CallbackHandle, Error> {
         let change_handle = route_manager_handle
             .add_default_route_change_callback(Box::new(move |event, addr_family| {
@@ -202,7 +202,7 @@ pub type MonitorHandle = BroadcastListener;
 
 pub async fn spawn_monitor(
     sender: UnboundedSender<Connectivity>,
-    route_manager_handle: RouteManagerHandle,
+    route_manager_handle: RouteManager,
 ) -> Result<MonitorHandle, Error> {
     let power_mgmt_rx = crate::window::PowerManagementListener::new();
     BroadcastListener::start(sender, route_manager_handle, power_mgmt_rx).await

talpid-core/src/split_tunnel/windows/mod.rs

@@ -18,7 +18,7 @@ use std::{
     },
     time::Duration,
 };
-use talpid_routing::{get_best_default_route, CallbackHandle, EventType, RouteManagerHandle};
+use talpid_routing::{get_best_default_route, CallbackHandle, EventType, RouteManager};
 use talpid_types::{split_tunnel::ExcludedProcess, tunnel::ErrorStateCause, ErrorExt};
 use talpid_windows::{
     io::Overlapped,
@@ -112,7 +112,7 @@ pub struct SplitTunnel {
     _route_change_callback: Option<CallbackHandle>,
     daemon_tx: Weak<mpsc::UnboundedSender<TunnelCommand>>,
     async_path_update_in_progress: Arc<AtomicBool>,
-    route_manager: RouteManagerHandle,
+    route_manager: RouteManager,
 }
 
 enum Request {
@@ -166,7 +166,7 @@ impl SplitTunnel {
         resource_dir: PathBuf,
         daemon_tx: Weak<mpsc::UnboundedSender<TunnelCommand>>,
         volume_update_rx: mpsc::UnboundedReceiver<()>,
-        route_manager: RouteManagerHandle,
+        route_manager: RouteManager,
     ) -> Result<Self, Error> {
         let excluded_processes = Arc::new(RwLock::new(HashMap::new()));
 

talpid-core/src/tunnel/mod.rs

@@ -3,7 +3,7 @@ use crate::logging;
 use futures::channel::oneshot;
 use std::path;
 #[cfg(not(target_os = "android"))]
-use talpid_routing::RouteManagerHandle;
+use talpid_routing::RouteManager;
 pub use talpid_tunnel::{TunnelArgs, TunnelEvent, TunnelMetadata};
 #[cfg(not(target_os = "android"))]
 use talpid_types::net::openvpn as openvpn_types;
@@ -227,7 +227,7 @@ impl TunnelMonitor {
         resource_dir: &path::Path,
         on_event: L,
         tunnel_close_rx: oneshot::Receiver<()>,
-        route_manager: RouteManagerHandle,
+        route_manager: RouteManager,
     ) -> Result<Self>
     where
         L: (Fn(TunnelEvent) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>)

talpid-core/src/tunnel_state_machine/connecting_state.rs

@@ -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);
         }
@@ -202,7 +202,7 @@ impl ConnectingState {
                 })
             };
 
-        let route_manager_handle = route_manager.handle();
+        let route_manager_handle = 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,

talpid-core/src/tunnel_state_machine/mod.rs

@@ -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 = RouteManager::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")]

talpid-openvpn/src/lib.rs

@@ -249,7 +249,7 @@ impl OpenVpnMonitor<OpenVpnCommand> {
         params: &openvpn::TunnelParameters,
         log_path: Option<PathBuf>,
         resource_dir: &Path,
-        route_manager: talpid_routing::RouteManagerHandle,
+        route_manager: talpid_routing::RouteManager,
     ) -> Result<Self>
     where
         L: (Fn(TunnelEvent) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>)
@@ -817,7 +817,7 @@ mod event_server {
         pub proxy_auth_file_path: Option<super::PathBuf>,
         pub abort_server_tx: triggered::Trigger,
         pub proxy: Option<CustomProxy>,
-        pub route_manager_handle: talpid_routing::RouteManagerHandle,
+        pub route_manager_handle: talpid_routing::RouteManager,
         #[cfg(target_os = "linux")]
         pub ipv6_enabled: bool,
     }

talpid-routing/src/lib.rs

@@ -25,7 +25,7 @@ use netlink_packet_route::rtnl::constants::RT_TABLE_MAIN;
 #[cfg(target_os = "macos")]
 pub use imp::{imp::RouteError, DefaultRouteEvent, PlatformError};
 
-pub use imp::{Error, RouteManager, RouteManagerHandle};
+pub use imp::{Error, RouteManager};
 
 /// A network route with a specific network node, destination and an optional metric.
 #[derive(Debug, Hash, Eq, PartialEq, Clone)]