Detect available IP versions

Try to detect available IP versions by looking at the available routes
on the host. On Linux, we check if there exists IPv4 and/or IPv6 routes
to some public IP addresses. On macOS and Windows, we check if there
exists default routes for IPv4 and/or IPv6. On Android, we check if
there is any connectivity at all.

The intention is to be able to generate better default constraints for
tunnel endpoints. If we can detect "working" IPv4 and/or IPv6 and
forward this information to a `TunnelParametersGenerator`, we may choose
to connect to a Wireguard relay using IPv6 as part of our
retry-strategy. This has not been possible before.

Author: MarkusPettersson98

mullvad-daemon/src/api.rs

@@ -21,7 +21,9 @@ use mullvad_types::access_method::{
 };
 use std::{net::SocketAddr, path::PathBuf};
 use talpid_core::mpsc::Sender;
-use talpid_types::net::{AllowedClients, AllowedEndpoint, Endpoint, TransportProtocol};
+use talpid_types::net::{
+    AllowedClients, AllowedEndpoint, Connectivity, Endpoint, TransportProtocol,
+};
 
 pub enum Message {
     Get(ResponseTx<ResolvedConnectionMode>),
@@ -527,18 +529,26 @@ pub fn allowed_clients(connection_mode: &ApiConnectionMode) -> AllowedClients {
     }
 }
 
+/// Forwards the received values from `offline_state_rx` to the [`ApiAvailabilityHandle`].
 pub(crate) fn forward_offline_state(
     api_availability: ApiAvailabilityHandle,
-    mut offline_state_rx: mpsc::UnboundedReceiver<bool>,
+    mut offline_state_rx: mpsc::UnboundedReceiver<Connectivity>,
 ) {
     tokio::spawn(async move {
-        let initial_state = offline_state_rx
+        let is_offline = offline_state_rx
             .next()
             .await
-            .expect("missing initial offline state");
-        api_availability.set_offline(initial_state);
-        while let Some(is_offline) = offline_state_rx.next().await {
-            api_availability.set_offline(is_offline);
+            .expect("missing initial offline state")
+            .is_offline();
+        log::info!(
+            "Initial offline state - {state}",
+            state = if is_offline { "offline" } else { "online" },
+        );
+        api_availability.set_offline(is_offline);
+
+        while let Some(state) = offline_state_rx.next().await {
+            log::info!("Detecting changes to offline state - {state:?}");
+            api_availability.set_offline(state.is_offline());
         }
     });
 }

talpid-core/src/offline/android.rs

@@ -4,13 +4,13 @@ use jnix::{
         self,
         objects::{GlobalRef, JObject, JValue},
         signature::{JavaType, Primitive},
-        sys::{jboolean, jlong, JNI_FALSE},
+        sys::{jboolean, jlong, JNI_TRUE},
         JNIEnv, JavaVM,
     },
     JnixEnv,
 };
 use std::sync::{Arc, Weak};
-use talpid_types::{android::AndroidContext, ErrorExt};
+use talpid_types::{android::AndroidContext, net::Connectivity, ErrorExt};
 
 #[derive(err_derive::Error, Debug)]
 #[error(no_from)]
@@ -43,13 +43,13 @@ pub struct MonitorHandle {
     jvm: Arc<JavaVM>,
     class: GlobalRef,
     object: GlobalRef,
-    _sender: Arc<UnboundedSender<bool>>,
+    _sender: Arc<UnboundedSender<Connectivity>>,
 }
 
 impl MonitorHandle {
     pub fn new(
         android_context: AndroidContext,
-        sender: Arc<UnboundedSender<bool>>,
+        sender: Arc<UnboundedSender<Connectivity>>,
     ) -> Result<Self, Error> {
         let env = JnixEnv::from(
             android_context
@@ -101,30 +101,29 @@ impl MonitorHandle {
     }
 
     #[allow(clippy::unused_async)]
-    pub async fn host_is_offline(&self) -> bool {
-        match self.get_is_connected() {
-            Ok(is_connected) => !is_connected,
-            Err(error) => {
+    pub async fn connectivity(&self) -> Connectivity {
+        self.get_is_connected()
+            .map(|connected| Connectivity::Status { connected })
+            .unwrap_or_else(|error| {
                 log::error!(
                     "{}",
                     error.display_chain_with_msg("Failed to check connectivity status")
                 );
-                false
-            }
-        }
+                Connectivity::PresumeOnline
+            })
     }
 
     fn get_is_connected(&self) -> Result<bool, Error> {
-        let result = self.call_method(
+        let is_connected = self.call_method(
             "isConnected",
             "()Z",
             &[],
             JavaType::Primitive(Primitive::Boolean),
         )?;
 
-        match result {
-            JValue::Bool(JNI_FALSE) => Ok(false),
-            JValue::Bool(_) => Ok(true),
+        match is_connected {
+            JValue::Bool(JNI_TRUE) => Ok(true),
+            JValue::Bool(_) => Ok(false),
             value => Err(Error::InvalidMethodResult(
                 "ConnectivityListener",
                 "isConnected",
@@ -133,7 +132,7 @@ impl MonitorHandle {
         }
     }
 
-    fn set_sender(&self, sender: Weak<UnboundedSender<bool>>) -> Result<(), Error> {
+    fn set_sender(&self, sender: Weak<UnboundedSender<Connectivity>>) -> Result<(), Error> {
         let sender_ptr = Box::new(sender);
         let sender_address = Box::into_raw(sender_ptr) as jlong;
 
@@ -182,14 +181,16 @@ impl MonitorHandle {
 pub extern "system" fn Java_net_mullvad_talpid_ConnectivityListener_notifyConnectivityChange(
     _: JNIEnv<'_>,
     _: JObject<'_>,
-    is_connected: jboolean,
+    connected: jboolean,
     sender_address: jlong,
 ) {
+    let connected = JNI_TRUE == connected;
     let sender_ref = Box::leak(unsafe { get_sender_from_address(sender_address) });
-    let is_offline = is_connected == JNI_FALSE;
-
     if let Some(sender) = sender_ref.upgrade() {
-        if sender.unbounded_send(is_offline).is_err() {
+        if sender
+            .unbounded_send(Connectivity::Status { connected })
+            .is_err()
+        {
             log::warn!("Failed to send offline change event");
         }
     }
@@ -206,13 +207,13 @@ pub extern "system" fn Java_net_mullvad_talpid_ConnectivityListener_destroySende
     let _ = unsafe { get_sender_from_address(sender_address) };
 }
 
-unsafe fn get_sender_from_address(address: jlong) -> Box<Weak<UnboundedSender<bool>>> {
-    Box::from_raw(address as *mut Weak<UnboundedSender<bool>>)
+unsafe fn get_sender_from_address(address: jlong) -> Box<Weak<UnboundedSender<Connectivity>>> {
+    Box::from_raw(address as *mut Weak<UnboundedSender<Connectivity>>)
 }
 
 #[allow(clippy::unused_async)]
 pub async fn spawn_monitor(
-    sender: UnboundedSender<bool>,
+    sender: UnboundedSender<Connectivity>,
     android_context: AndroidContext,
 ) -> Result<MonitorHandle, Error> {
     let sender = Arc::new(sender);

talpid-core/src/offline/linux.rs

@@ -4,7 +4,7 @@ use std::{
     sync::Arc,
 };
 use talpid_routing::{self, RouteManagerHandle};
-use talpid_types::ErrorExt;
+use talpid_types::{net::Connectivity, ErrorExt};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -18,30 +18,31 @@ pub enum Error {
 pub struct MonitorHandle {
     route_manager: RouteManagerHandle,
     fwmark: Option<u32>,
-    _notify_tx: Arc<UnboundedSender<bool>>,
+    _notify_tx: Arc<UnboundedSender<Connectivity>>,
 }
 
+/// A non-local IPv4 address.
 const PUBLIC_INTERNET_ADDRESS_V4: IpAddr = IpAddr::V4(Ipv4Addr::new(193, 138, 218, 78));
+/// A non-local IPv6 address.
 const PUBLIC_INTERNET_ADDRESS_V6: IpAddr =
     IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6));
 
 impl MonitorHandle {
-    pub async fn host_is_offline(&self) -> bool {
-        match public_ip_unreachable(&self.route_manager, self.fwmark).await {
-            Ok(is_offline) => is_offline,
-            Err(err) => {
+    pub async fn connectivity(&self) -> Connectivity {
+        public_ip_unreachable(&self.route_manager, self.fwmark)
+            .await
+            .unwrap_or_else(|err| {
                 log::error!(
                     "Failed to verify offline state: {}. Presuming connectivity",
                     err
                 );
-                false
-            }
-        }
+                Connectivity::PresumeOnline
+            })
     }
 }
 
 pub async fn spawn_monitor(
-    notify_tx: UnboundedSender<bool>,
+    notify_tx: UnboundedSender<Connectivity>,
     route_manager: RouteManagerHandle,
     fwmark: Option<u32>,
 ) -> Result<MonitorHandle> {
@@ -71,7 +72,7 @@ pub async fn spawn_monitor(
                                 "{}",
                                 err.display_chain_with_msg("Failed to infer offline state")
                             );
-                            false
+                            Connectivity::PresumeOnline
                         });
                     if new_offline_state != is_offline {
                         is_offline = new_offline_state;
@@ -86,15 +87,20 @@ pub async fn spawn_monitor(
     Ok(monitor_handle)
 }
 
-async fn public_ip_unreachable(handle: &RouteManagerHandle, fwmark: Option<u32>) -> Result<bool> {
-    Ok(handle
-        .get_destination_route(PUBLIC_INTERNET_ADDRESS_V4, fwmark)
-        .await
-        .map_err(Error::RouteManagerError)?
-        .is_none()
-        && handle
-            .get_destination_route(PUBLIC_INTERNET_ADDRESS_V6, fwmark)
+async fn public_ip_unreachable(
+    handle: &RouteManagerHandle,
+    fwmark: Option<u32>,
+) -> Result<Connectivity> {
+    let route_exists = |destination| async move {
+        handle
+            .get_destination_route(destination, fwmark)
             .await
-            .unwrap_or(None)
-            .is_none())
+            .map_err(Error::RouteManagerError)
+            .map(|x| x.is_some())
+    };
+    let connectivity = Connectivity::Status {
+        ipv4: route_exists(PUBLIC_INTERNET_ADDRESS_V4).await?,
+        ipv6: route_exists(PUBLIC_INTERNET_ADDRESS_V6).await?,
+    };
+    Ok(connectivity)
 }