Replace old waitForTunnelUp function

Cargo.toml

@@ -5,6 +5,9 @@ license = "GPL-3.0"
 edition = "2021"
 rust-version = "1.80.0"
 
+[patch.crates-io]
+jnix = { git = "https://github.com/mullvad/jnix.git", branch = "i16-from-java" }
+
 [workspace]
 resolver = "2"
 members = [

android/app/src/main/kotlin/net/mullvad/mullvadvpn/compose/component/notificationbanner/NotificationData.kt

@@ -198,6 +198,7 @@ private fun ErrorState.message(): String {
     val cause = this.cause
     return when {
         isBlocking -> cause.errorMessageId()
+        cause is ErrorStateCause.RoutesTimedOut -> "Yo routes is fukkkd"
         else -> stringResource(R.string.failed_to_block_internet)
     }
 }
@@ -223,6 +224,8 @@ private fun ErrorStateCause.errorMessageId(): String =
                 R.string.invalid_dns_servers,
                 addresses.joinToString { address -> address.addressString() },
             )
+
+        ErrorStateCause.RoutesTimedOut -> "Yo routes is fukkked"
     }
 
 private fun AuthFailedError.errorMessageId(): Int =

android/lib/common/src/main/kotlin/net/mullvad/mullvadvpn/lib/common/util/VpnServiceUtils.kt

@@ -2,17 +2,23 @@ package net.mullvad.mullvadvpn.lib.common.util
 
 import android.content.Context
 import android.content.Intent
+import android.net.VpnService
 import android.net.VpnService.prepare
+import android.os.ParcelFileDescriptor
 import arrow.core.Either
-import arrow.core.flatten
+import arrow.core.flatMap
 import arrow.core.left
+import arrow.core.raise.either
+import arrow.core.raise.ensureNotNull
 import arrow.core.right
 import co.touchlab.kermit.Logger
 import net.mullvad.mullvadvpn.lib.common.util.SdkUtils.getInstalledPackagesList
 import net.mullvad.mullvadvpn.lib.model.PrepareError
 import net.mullvad.mullvadvpn.lib.model.Prepared
 
 /**
+ * Safely prepare to establish a VPN connection.
+ *
  * Invoking VpnService.prepare() can result in 3 out comes:
  * 1. IllegalStateException - There is a legacy VPN profile marked as always on
  * 2. Intent
@@ -34,7 +40,7 @@ fun Context.prepareVpnSafe(): Either<PrepareError, Prepared> =
                 else -> throw it
             }
         }
-        .map { intent ->
+        .flatMap { intent ->
             if (intent == null) {
                 Prepared.right()
             } else {
@@ -46,7 +52,6 @@ fun Context.prepareVpnSafe(): Either<PrepareError, Prepared> =
                 }
             }
         }
-        .flatten()
 
 fun Context.getAlwaysOnVpnAppName(): String? {
     return resolveAlwaysOnVpnPackageName()
@@ -59,3 +64,38 @@ fun Context.getAlwaysOnVpnAppName(): String? {
         ?.loadLabel(packageManager)
         ?.toString()
 }
+
+/**
+ * Establish a VPN connection safely.
+ *
+ * This function wraps the [VpnService.Builder.establish] function and catches any exceptions that
+ * may be thrown and type them to a more specific error.
+ *
+ * @return [ParcelFileDescriptor] if successful, [EstablishError] otherwise
+ */
+fun VpnService.Builder.establishSafe(): Either<EstablishError, ParcelFileDescriptor> = either {
+    val vpnInterfaceFd =
+        Either.catch { establish() }
+            .mapLeft {
+                when (it) {
+                    is IllegalStateException -> EstablishError.ParameterNotApplied(it)
+                    is IllegalArgumentException -> EstablishError.ParameterNotAccepted(it)
+                    else -> EstablishError.UnknownError(it)
+                }
+            }
+            .bind()
+
+    ensureNotNull(vpnInterfaceFd) { EstablishError.NullVpnInterface }
+
+    vpnInterfaceFd
+}
+
+sealed interface EstablishError {
+    data class ParameterNotApplied(val exception: IllegalStateException) : EstablishError
+
+    data class ParameterNotAccepted(val exception: IllegalArgumentException) : EstablishError
+
+    data object NullVpnInterface : EstablishError
+
+    data class UnknownError(val error: Throwable) : EstablishError
+}

android/lib/daemon-grpc/src/main/kotlin/net/mullvad/mullvadvpn/lib/daemon/grpc/mapper/ToDomain.kt

@@ -261,6 +261,8 @@ internal fun ManagementInterface.ErrorState.toDomain(
                 ManagementInterface.ErrorState.Cause.OTHER_LEGACY_ALWAYS_ON_VPN ->
                     ErrorStateCause.OtherLegacyAlwaysOnApp
                 ManagementInterface.ErrorState.Cause.INVALID_DNS_SERVERS -> invalidDnsServers!!
+                ManagementInterface.ErrorState.Cause.ROUTES_TIMED_OUT ->
+                    ErrorStateCause.RoutesTimedOut
             },
         isBlocking = !hasBlockingError(),
     )

android/lib/model/src/main/kotlin/net/mullvad/mullvadvpn/lib/model/ErrorStateCause.kt

@@ -21,6 +21,8 @@ sealed class ErrorStateCause {
 
     data object StartTunnelError : ErrorStateCause()
 
+    data object RoutesTimedOut : ErrorStateCause()
+
     data class TunnelParameterError(val error: ParameterGenerationError) : ErrorStateCause()
 
     data object IsOffline : ErrorStateCause()

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

@@ -7,18 +7,20 @@ import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import co.touchlab.kermit.Logger
 import java.net.InetAddress
+import kotlin.collections.ArrayList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.scan
 import kotlinx.coroutines.flow.stateIn
+import net.mullvad.talpid.model.NetworkState as DaemonNetworkState
 import net.mullvad.talpid.util.NetworkEvent
-import net.mullvad.talpid.util.defaultNetworkFlow
+import net.mullvad.talpid.util.NetworkState
+import net.mullvad.talpid.util.defaultNetworkStateFlow
 import net.mullvad.talpid.util.networkFlow
 
 class ConnectivityListener(val connectivityManager: ConnectivityManager) {
@@ -27,33 +29,29 @@ class ConnectivityListener(val connectivityManager: ConnectivityManager) {
     val isConnected
         get() = _isConnected.value
 
-    private lateinit var _currentDnsServers: StateFlow<List<InetAddress>>
+    private lateinit var _currentNetworkState: StateFlow<DaemonNetworkState?>
+
+    val currentDefaultNetworkState: DaemonNetworkState?
+        get() = _currentNetworkState.value
+
     // Used by JNI
-    val currentDnsServers
-        get() = ArrayList(_currentDnsServers.value)
+    val currentDnsServers: ArrayList<InetAddress>
+        get() = _currentNetworkState.value?.dnsServers ?: ArrayList()
 
     fun register(scope: CoroutineScope) {
-        _currentDnsServers =
-            dnsServerChanges().stateIn(scope, SharingStarted.Eagerly, currentDnsServers())
+        _currentNetworkState =
+            connectivityManager
+                .defaultNetworkStateFlow()
+                .map { it?.toDaemonNetworkState() }
+                .onEach { notifyDefaultNetworkChange(it) }
+                .stateIn(scope, SharingStarted.Eagerly, null)
 
         _isConnected =
             hasInternetCapability()
                 .onEach { notifyConnectivityChange(it) }
                 .stateIn(scope, SharingStarted.Eagerly, false)
     }
 
-    private fun dnsServerChanges(): Flow<List<InetAddress>> =
-        connectivityManager
-            .defaultNetworkFlow()
-            .filterIsInstance<NetworkEvent.LinkPropertiesChanged>()
-            .onEach { Logger.d("Link properties changed") }
-            .map { it.linkProperties.dnsServersWithoutFallback() }
-
-    private fun currentDnsServers(): List<InetAddress> =
-        connectivityManager
-            .getLinkProperties(connectivityManager.activeNetwork)
-            ?.dnsServersWithoutFallback() ?: emptyList()
-
     private fun LinkProperties.dnsServersWithoutFallback(): List<InetAddress> =
         dnsServers.filter { it.hostAddress != TalpidVpnService.FALLBACK_DUMMY_DNS_SERVER }
 
@@ -87,5 +85,14 @@ class ConnectivityListener(val connectivityManager: ConnectivityManager) {
             .distinctUntilChanged()
     }
 
+    private fun NetworkState.toDaemonNetworkState(): DaemonNetworkState =
+        DaemonNetworkState(
+            network.networkHandle,
+            linkProperties?.routes,
+            linkProperties?.dnsServersWithoutFallback(),
+        )
+
     private external fun notifyConnectivityChange(isConnected: Boolean)
+
+    private external fun notifyDefaultNetworkChange(networkState: DaemonNetworkState?)
 }