Fixes

Author: Pururun

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/ConnectivityListener.kt

@@ -66,7 +66,7 @@ class ConnectivityListener(
         _isConnected =
             connectivityManager
                 .hasInternetConnectivity(resolver)
-                .onEach { notifyConnectivityChange(it.ipv4, it.ipv6) }
+                .onEach { notifyConnectivityChange(it.hasIpV4(), it.hasIpV6()) }
                 .stateIn(
                     scope + Dispatchers.IO,
                     SharingStarted.Eagerly,

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/model/Connectivity.kt

@@ -1,8 +1,44 @@
 package net.mullvad.talpid.model
 
+import android.net.LinkAddress
+import java.net.Inet4Address
+import java.net.Inet6Address
+
 sealed class Connectivity {
-    data class Status(val ipv4: Boolean, val ipv6: Boolean) : Connectivity()
+    data class Online(val ipAvailability: IpAvailability) : Connectivity()
+
+    data object Offline : Connectivity()
 
     // Required by jni
     data object PresumeOnline : Connectivity()
+
+    fun hasIpV4() =
+        when (this) {
+            is Online ->
+                ipAvailability == IpAvailability.Ipv4 || ipAvailability == IpAvailability.All
+            else -> false
+        }
+
+    fun hasIpV6() =
+        when (this) {
+            is Online ->
+                ipAvailability == IpAvailability.Ipv6 || ipAvailability == IpAvailability.All
+            else -> false
+        }
+
+    companion object {
+        fun fromIpAvailability(ipv4: Boolean, ipv6: Boolean) =
+            when {
+                ipv4 && ipv6 -> Online(IpAvailability.All)
+                ipv4 -> Online(IpAvailability.Ipv4)
+                ipv6 -> Online(IpAvailability.Ipv6)
+                else -> Offline
+            }
+
+        fun fromLinkAddresses(linkAddresses: List<LinkAddress>): Connectivity {
+            val ipv4 = linkAddresses.any { it.address is Inet4Address }
+            val ipv6 = linkAddresses.any { it.address is Inet6Address }
+            return fromIpAvailability(ipv4, ipv6)
+        }
+    }
 }

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/model/IpAvailability.kt

@@ -0,0 +1,7 @@
+package net.mullvad.talpid.model
+
+enum class IpAvailability {
+    Ipv4,
+    Ipv6,
+    All,
+}

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/util/ConnectivityManagerUtil.kt

@@ -6,8 +6,6 @@ import android.net.LinkProperties
 import android.net.Network
 import android.net.NetworkCapabilities
 import co.touchlab.kermit.Logger
-import java.net.Inet4Address
-import java.net.Inet6Address
 import kotlin.time.Duration.Companion.milliseconds
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.channels.awaitClose
@@ -137,7 +135,7 @@ internal fun ConnectivityManager.activeRawNetworkState(): RawNetworkState? =
 @OptIn(FlowPreview::class)
 fun ConnectivityManager.hasInternetConnectivity(
     resolver: UnderlyingConnectivityStatusResolver
-): Flow<Connectivity.Status> =
+): Flow<Connectivity> =
     this.defaultRawNetworkStateFlow()
         .debounce(CONNECTIVITY_DEBOUNCE)
         .map { resolveConnectivityStatus(it, resolver) }
@@ -146,7 +144,7 @@ fun ConnectivityManager.hasInternetConnectivity(
 internal fun resolveConnectivityStatus(
     currentRawNetworkState: RawNetworkState?,
     resolver: UnderlyingConnectivityStatusResolver,
-): Connectivity.Status =
+): Connectivity =
     if (currentRawNetworkState.isVpn()) {
         // If the default network is a VPN we need to use a socket to check
         // the underlying network
@@ -158,10 +156,7 @@ internal fun resolveConnectivityStatus(
     }
 
 private fun RawNetworkState?.toConnectivityStatus() =
-    Connectivity.Status(
-        ipv4 = this?.linkProperties?.linkAddresses?.any { it.address is Inet4Address } == true,
-        ipv6 = this?.linkProperties?.linkAddresses?.any { it.address is Inet6Address } == true,
-    )
+    Connectivity.fromLinkAddresses(this?.linkProperties?.linkAddresses ?: emptyList())
 
 private fun RawNetworkState?.isVpn(): Boolean =
     this?.networkCapabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN) == false

android/lib/talpid/src/main/kotlin/net/mullvad/talpid/util/UnderlyingConnectivityStatusResolver.kt

@@ -14,8 +14,8 @@ import net.mullvad.talpid.model.Connectivity
 class UnderlyingConnectivityStatusResolver(
     private val protect: (socket: DatagramSocket) -> Boolean
 ) {
-    fun currentStatus(): Connectivity.Status =
-        Connectivity.Status(ipv4 = hasIPv4(), ipv6 = hasIPv6())
+    fun currentStatus(): Connectivity =
+        Connectivity.fromIpAvailability(ipv4 = hasIPv4(), ipv6 = hasIPv6())
 
     private fun hasIPv4(): Boolean =
         hasIpVersion(Inet4Address.getByName(PUBLIC_IPV4_ADDRESS), protect)

mullvad-jni/src/classes.rs

@@ -18,6 +18,8 @@ pub const CLASSES: &[&str] = &[
     "net/mullvad/talpid/ConnectivityListener",
     "net/mullvad/talpid/TalpidVpnService",
     "net/mullvad/mullvadvpn/lib/endpoint/ApiEndpointOverride",
-    "net/mullvad/talpid/model/Connectivity$Status",
+    "net/mullvad/talpid/model/Connectivity$Online",
+    "net/mullvad/talpid/model/Connectivity$Offline",
     "net/mullvad/talpid/model/Connectivity$PresumeOnline",
+    "net/mullvad/talpid/model/IpAvailability",
 ];

talpid-core/src/connectivity_listener.rs

@@ -180,10 +180,7 @@ pub extern "system" fn Java_net_mullvad_talpid_ConnectivityListener_notifyConnec
     let is_ipv6 = JNI_TRUE == is_ipv6;
 
     if tx
-        .unbounded_send(Connectivity::Status {
-            ipv4: is_ipv4,
-            ipv6: is_ipv6,
-        })
+        .unbounded_send(Connectivity::new(is_ipv4, is_ipv6))
         .is_err()
     {
         log::warn!("Failed to send offline change event");

talpid-core/src/offline/macos.rs

@@ -52,10 +52,7 @@ struct ConnectivityInner {
 
 impl ConnectivityInner {
     fn into_connectivity(self) -> Connectivity {
-        Connectivity::Status {
-            ipv4: self.ipv4,
-            ipv6: self.ipv6,
-        }
+        Connectivity::new(self.ipv4, self.ipv6)
     }
 
     fn is_online(&self) -> bool {

talpid-core/src/tunnel_state_machine/connecting_state.rs

@@ -9,7 +9,9 @@ use futures::{FutureExt, StreamExt};
 use talpid_routing::RouteManagerHandle;
 use talpid_tunnel::tun_provider::TunProvider;
 use talpid_tunnel::{EventHook, TunnelArgs, TunnelEvent, TunnelMetadata};
-use talpid_types::net::{AllowedClients, AllowedEndpoint, AllowedTunnelTraffic, TunnelParameters};
+use talpid_types::net::{
+    AllowedClients, AllowedEndpoint, AllowedTunnelTraffic, Connectivity, TunnelParameters,
+};
 use talpid_types::tunnel::{ErrorStateCause, FirewallPolicyError};
 use talpid_types::ErrorExt;
 
@@ -73,7 +75,7 @@ impl ConnectingState {
                 });
         }
 
-        if shared_values.connectivity.is_offline() {
+        if shared_values.connectivity == Connectivity::Offline {
             // FIXME: Temporary: Nudge route manager to update the default interface
             #[cfg(target_os = "macos")]
             {

talpid-types/src/lib.rs

@@ -1,6 +1,7 @@
 #[cfg(target_os = "android")]
 pub mod android;
 pub mod net;
+pub use net::IpAvailability;
 pub mod tunnel;
 
 #[cfg(target_os = "linux")]

talpid-types/src/net/mod.rs

@@ -570,12 +570,10 @@ pub fn all_of_the_internet() -> Vec<ipnetwork::IpNetwork> {
 #[cfg_attr(target_os = "android", derive(FromJava))]
 #[cfg_attr(target_os = "android", jnix(package = "net.mullvad.talpid.model"))]
 pub enum Connectivity {
-    Status {
-        /// Whether IPv4 connectivity seems to be available on the host.
-        ipv4: bool,
-        /// Whether IPv6 connectivity seems to be available on the host.
-        ipv6: bool,
+    Online {
+        ip_availability: IpAvailability,
     },
+    Offline,
     /// On/offline status could not be verified, but we have no particular
     /// reason to believe that the host is offline.
     PresumeOnline,
@@ -590,29 +588,64 @@ impl Connectivity {
     /// If no IP4 nor IPv6 routes exist, we have no way of reaching the internet
     /// so we consider ourselves offline.
     pub fn is_offline(&self) -> bool {
-        matches!(
-            self,
-            Connectivity::Status {
-                ipv4: false,
-                ipv6: false
-            }
-        )
+        matches!(self, Connectivity::Offline)
     }
 
     /// Whether IPv4 connectivity seems to be available on the host.
     ///
     /// If IPv4 status is unknown, `true` is returned.
     pub fn has_ipv4(&self) -> bool {
-        matches!(
-            self,
-            Connectivity::Status { ipv4: true, .. } | Connectivity::PresumeOnline
-        )
+        match self {
+            Connectivity::Offline => false,
+            Connectivity::PresumeOnline => true,
+            Connectivity::Online { ip_availability } => ip_availability.has_ipv4(),
+        }
     }
 
     /// Whether IPv6 connectivity seems to be available on the host.
     ///
     /// If IPv6 status is unknown, `false` is returned.
     pub fn has_ipv6(&self) -> bool {
-        matches!(self, Connectivity::Status { ipv6: true, .. })
+        match self {
+            Connectivity::Offline | Connectivity::PresumeOnline => false,
+            Connectivity::Online { ip_availability } => ip_availability.has_ipv6(),
+        }
+    }
+
+    pub fn new(ipv4: bool, ipv6: bool) -> Connectivity {
+        if ipv4 && ipv6 {
+            Connectivity::Online {
+                ip_availability: IpAvailability::All,
+            }
+        } else if ipv4 {
+            Connectivity::Online {
+                ip_availability: IpAvailability::Ipv4,
+            }
+        } else if ipv6 {
+            Connectivity::Online {
+                ip_availability: IpAvailability::Ipv6,
+            }
+        } else {
+            Connectivity::Offline
+        }
+    }
+}
+
+#[cfg_attr(target_os = "android", derive(FromJava))]
+#[cfg_attr(target_os = "android", jnix(package = "net.mullvad.talpid.model"))]
+#[derive(Clone, Debug, PartialEq, Eq, Copy)]
+pub enum IpAvailability {
+    Ipv4,
+    Ipv6,
+    All,
+}
+
+impl IpAvailability {
+    pub fn has_ipv4(&self) -> bool {
+        self.clone() == IpAvailability::Ipv4 || self.clone() == IpAvailability::All
+    }
+
+    pub fn has_ipv6(&self) -> bool {
+        self.clone() == IpAvailability::Ipv6 || self.clone() == IpAvailability::All
     }
 }