From 00d9bd21e713ceec0eb973629d9862fde16d4718 Mon Sep 17 00:00:00 2001 From: ZaychenkoAA Date: Fri, 14 Aug 2026 11:13:38 +0700 Subject: [PATCH] =?UTF-8?q?=D1=84=D0=B8=D0=BA=D1=81=20=D0=BF=D0=BE=D0=B4?= =?UTF-8?q?=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D1=8F=20=D0=BA=20?= =?UTF-8?q?=D0=B2=D0=BF=D0=BD=20=D0=B2=20=D1=80=D0=B5=D0=B6=D0=B8=D0=BC?= =?UTF-8?q?=D0=B5=20=D0=91=D0=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../tobevpn/app/vpn/NetworkResumePolicy.kt | 2 +- .../com/tobevpn/app/vpn/ToBeVpnService.kt | 28 ++++-- .../app/vpn/UnderlyingNetworkPolicy.kt | 18 ++-- .../tobevpn/app/vpn/VpnConnectionManager.kt | 89 +++++++++++-------- .../vpn/NetworkAvailabilityDeadlineTest.kt | 12 +-- .../app/vpn/NetworkResumePolicyTest.kt | 17 +++- .../app/vpn/UnderlyingNetworkPolicyTest.kt | 42 +++++++-- 7 files changed, 137 insertions(+), 71 deletions(-) diff --git a/app/src/main/java/com/tobevpn/app/vpn/NetworkResumePolicy.kt b/app/src/main/java/com/tobevpn/app/vpn/NetworkResumePolicy.kt index 9755324..1886d65 100644 --- a/app/src/main/java/com/tobevpn/app/vpn/NetworkResumePolicy.kt +++ b/app/src/main/java/com/tobevpn/app/vpn/NetworkResumePolicy.kt @@ -12,5 +12,5 @@ internal object NetworkResumePolicy { expectedRequest == currentRequest && hasNetworkTimeoutError && sameServer && - availability == UnderlyingNetworkAvailability.VALIDATED + UnderlyingNetworkPolicy.canAttemptTunnelProbe(availability) } diff --git a/app/src/main/java/com/tobevpn/app/vpn/ToBeVpnService.kt b/app/src/main/java/com/tobevpn/app/vpn/ToBeVpnService.kt index 171949b..35c4136 100644 --- a/app/src/main/java/com/tobevpn/app/vpn/ToBeVpnService.kt +++ b/app/src/main/java/com/tobevpn/app/vpn/ToBeVpnService.kt @@ -550,7 +550,6 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { val cm = getSystemService(ConnectivityManager::class.java) ?: return val request = NetworkRequest.Builder() .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) - .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN) .build() @@ -650,7 +649,8 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { PhysicalNetworkSelector.ChangeType.UNAVAILABLE -> { SafeDiagnostics.warn( TAG, - "Validated physical network unavailable: " + + "No validated physical network selected; " + + "tunnel liveness checks remain enabled: " + "previous=${lastUnderlyingNetworkSummary ?: "UNKNOWN"}", ) cancelNetworkHandover() @@ -692,7 +692,11 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { networkBaselineReady = true val selected = physicalNetworkSelector.selectedOrNull() if (selected == null) { - SafeDiagnostics.warn(TAG, "Physical-network baseline has no validated network") + SafeDiagnostics.trace( + TAG, + "Physical-network baseline has no validated network; " + + "tunnel liveness checks remain enabled", + ) scheduleUnderlyingNetworkTimeout(cm, "BASELINE_EMPTY") } else { val summary = cm.getNetworkCapabilities(selected)?.let(::networkSummary) @@ -756,10 +760,15 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { if (cleanedUp || activeConnectionGeneration < 0) return val generation = activeConnectionGeneration val startedAtMs = SystemClock.elapsedRealtime() + val initialAvailability = underlyingNetworkAvailability(cm) + val initialTimeoutMs = + UnderlyingNetworkPolicy.teardownTimeoutMs(initialAvailability) + if (initialTimeoutMs == null) { + cancelUnderlyingNetworkTimeout() + return + } synchronized(networkJobLock) { if (underlyingNetworkTimeoutJob?.isCompleted == false) return - val initialAvailability = underlyingNetworkAvailability(cm) - val initialTimeoutMs = UnderlyingNetworkPolicy.timeoutMs(initialAvailability) SafeDiagnostics.trace( TAG, "Underlying-network timeout scheduled: generation=$generation " + @@ -769,14 +778,15 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { val job = serviceScope.launch(start = CoroutineStart.LAZY) { while (!cleanedUp && generation == activeConnectionGeneration) { val availability = underlyingNetworkAvailability(cm) - if (availability == UnderlyingNetworkAvailability.VALIDATED) { + val timeoutMs = UnderlyingNetworkPolicy.teardownTimeoutMs(availability) + if (timeoutMs == null) { SafeDiagnostics.trace( TAG, - "Underlying-network timeout cancelled by final validation", + "Underlying-network timeout cancelled after physical network returned: " + + "availability=${availability.name}", ) return@launch } - val timeoutMs = UnderlyingNetworkPolicy.timeoutMs(availability) val nowMs = SystemClock.elapsedRealtime() val deadline = NetworkAvailabilityDeadline( startedAtMs = startedAtMs, @@ -785,7 +795,7 @@ class ToBeVpnService : VpnService(), CoreCallbackHandler { if (deadline.isExpired(nowMs)) { SafeDiagnostics.warn( TAG, - "Validated physical network unavailable: generation=$generation " + + "Physical network unavailable: generation=$generation " + "source=$source availability=${availability.name} " + "timeout_ms=$timeoutMs", ) diff --git a/app/src/main/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicy.kt b/app/src/main/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicy.kt index 10a8659..59a6f5a 100644 --- a/app/src/main/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicy.kt +++ b/app/src/main/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicy.kt @@ -2,8 +2,9 @@ package com.tobevpn.app.vpn /** * Distinguishes a complete loss of physical connectivity from Android's - * temporary internet-validation state. A TUN must not be kept indefinitely, - * but captive-portal checks and Wi-Fi revalidation need more than 15 seconds. + * general-internet validation state. An unvalidated carrier network can still + * carry a working VPN tunnel (for example on an operator allowlist), so only + * complete physical-network loss receives a teardown deadline. */ internal enum class UnderlyingNetworkAvailability { VALIDATED, @@ -13,11 +14,12 @@ internal enum class UnderlyingNetworkAvailability { internal object UnderlyingNetworkPolicy { const val NO_NETWORK_TIMEOUT_MS = 15_000L - const val UNVALIDATED_NETWORK_TIMEOUT_MS = 45_000L - fun timeoutMs(availability: UnderlyingNetworkAvailability): Long = when (availability) { - UnderlyingNetworkAvailability.VALIDATED -> 0L - UnderlyingNetworkAvailability.UNVALIDATED -> UNVALIDATED_NETWORK_TIMEOUT_MS - UnderlyingNetworkAvailability.UNAVAILABLE -> NO_NETWORK_TIMEOUT_MS - } + fun canAttemptTunnelProbe(availability: UnderlyingNetworkAvailability): Boolean = + availability != UnderlyingNetworkAvailability.UNAVAILABLE + + fun teardownTimeoutMs(availability: UnderlyingNetworkAvailability): Long? = + NO_NETWORK_TIMEOUT_MS.takeIf { + availability == UnderlyingNetworkAvailability.UNAVAILABLE + } } diff --git a/app/src/main/java/com/tobevpn/app/vpn/VpnConnectionManager.kt b/app/src/main/java/com/tobevpn/app/vpn/VpnConnectionManager.kt index 4a08a86..7a84ea3 100644 --- a/app/src/main/java/com/tobevpn/app/vpn/VpnConnectionManager.kt +++ b/app/src/main/java/com/tobevpn/app/vpn/VpnConnectionManager.kt @@ -1064,9 +1064,10 @@ class VpnConnectionManager @Inject constructor( } /** - * A physical network did not become validated within the service grace - * period. Tear down the TUN instead of leaving Android routing traffic into - * a dead VPN until the process or phone is restarted. + * The physical network disappeared for the full service grace period. + * Tear down the TUN instead of leaving Android routing traffic into a dead + * VPN until the process or phone is restarted. Merely missing Android's + * general-internet validation is not treated as physical-network loss. */ fun handleUnderlyingNetworkUnavailable(generation: Int) { cancelPendingRecovery("UNDERLYING_NETWORK_UNAVAILABLE") @@ -1085,7 +1086,7 @@ class VpnConnectionManager @Inject constructor( val resumeRequest = requestedOperation.get() SafeDiagnostics.warn( TAG, - "VPN stopped after validated physical network timeout: generation=$generation", + "VPN stopped after physical network loss timeout: generation=$generation", ) val waitingServiceKept = stopForUnderlyingNetworkTimeout(generation) ?: return@launch @@ -1182,13 +1183,12 @@ class VpnConnectionManager @Inject constructor( val cm = context.getSystemService(ConnectivityManager::class.java) ?: return false val networkRequest = NetworkRequest.Builder() .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) - .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN) .build() lateinit var callback: ConnectivityManager.NetworkCallback callback = object : ConnectivityManager.NetworkCallback() { override fun onAvailable(network: Network) { - resumeAfterValidatedNetwork( + resumeAfterAvailableNetwork( callback = callback, cm = cm, server = server, @@ -1201,18 +1201,13 @@ class VpnConnectionManager @Inject constructor( network: Network, networkCapabilities: NetworkCapabilities, ) { - if (networkCapabilities.hasCapability( - NetworkCapabilities.NET_CAPABILITY_VALIDATED, - ) - ) { - resumeAfterValidatedNetwork( - callback = callback, - cm = cm, - server = server, - request = request, - waitingServiceGeneration = waitingServiceGeneration, - ) - } + resumeAfterAvailableNetwork( + callback = callback, + cm = cm, + server = server, + request = request, + waitingServiceGeneration = waitingServiceGeneration, + ) } } val timeoutJob = scope.launch(start = CoroutineStart.LAZY) { @@ -1233,10 +1228,10 @@ class VpnConnectionManager @Inject constructor( timeoutJob.start() SafeDiagnostics.info( TAG, - "VPN waiting for validated physical network before same-server resume: " + + "VPN waiting for physical network before same-server resume: " + "timeout_ms=$NETWORK_RESUME_WAIT_TIMEOUT_MS", ) - resumeAfterValidatedNetwork( + resumeAfterAvailableNetwork( callback = callback, cm = cm, server = server, @@ -1264,7 +1259,7 @@ class VpnConnectionManager @Inject constructor( } } - private fun resumeAfterValidatedNetwork( + private fun resumeAfterAvailableNetwork( callback: ConnectivityManager.NetworkCallback, cm: ConnectivityManager, server: Server, @@ -1272,7 +1267,7 @@ class VpnConnectionManager @Inject constructor( waitingServiceGeneration: Int, ) { val availability = underlyingNetworkAvailability() - if (availability != UnderlyingNetworkAvailability.VALIDATED) return + if (!UnderlyingNetworkPolicy.canAttemptTunnelProbe(availability)) return val (accepted, timeoutJob) = synchronized(networkResumeLock) { if (networkResumeCallback !== callback) { false to null @@ -1319,7 +1314,8 @@ class VpnConnectionManager @Inject constructor( } SafeDiagnostics.info( TAG, - "Validated physical network returned; resuming the same VPN server: " + + "Physical network returned; resuming the same VPN server: " + + "availability=${availability.name} " + diagnosticServerDescriptor(server), ) startVpnInternal( @@ -1370,7 +1366,7 @@ class VpnConnectionManager @Inject constructor( runCatching { cm.unregisterNetworkCallback(callback) } SafeDiagnostics.warn( TAG, - "Validated physical network wait expired: " + + "Physical network wait expired: " + "timeout_ms=$NETWORK_RESUME_WAIT_TIMEOUT_MS", ) finishNetworkResumeWait( @@ -1967,22 +1963,24 @@ class VpnConnectionManager @Inject constructor( _connectionState.value is ConnectionState.Connecting ) { val availability = underlyingNetworkAvailability() - if (availability != UnderlyingNetworkAvailability.VALIDATED) { + val networkLossTimeoutMs = + UnderlyingNetworkPolicy.teardownTimeoutMs(availability) + if (networkLossTimeoutMs != null) { val now = SystemClock.elapsedRealtime() val unavailableSince = networkUnavailableStartedAtMs ?: now.also { networkUnavailableStartedAtMs = it } - val timeoutMs = UnderlyingNetworkPolicy.timeoutMs(availability) val networkDeadline = NetworkAvailabilityDeadline( startedAtMs = unavailableSince, - timeoutMs = timeoutMs, + timeoutMs = networkLossTimeoutMs, ) if (networkDeadline.isExpired(now)) { SafeDiagnostics.warn( TAG, - "Startup tunnel validation aborted: no validated physical network " + + "Startup tunnel validation aborted: no physical network " + "generation=$generation " + - "availability=${availability.name} timeout_ms=$timeoutMs", + "availability=${availability.name} " + + "timeout_ms=$networkLossTimeoutMs", ) // This coroutine is the active healthCheckJob and // performStop() cancels that job. Delegate the stop to @@ -1993,8 +1991,9 @@ class VpnConnectionManager @Inject constructor( } SafeDiagnostics.trace( TAG, - "Startup tunnel validation waiting for validated underlying internet: " + - "availability=${availability.name} timeout_ms=$timeoutMs", + "Startup tunnel validation waiting for physical network: " + + "availability=${availability.name} " + + "timeout_ms=$networkLossTimeoutMs", ) delay( networkDeadline.nextCheckDelayMs( @@ -2005,6 +2004,12 @@ class VpnConnectionManager @Inject constructor( continue } networkUnavailableStartedAtMs = null + if (availability == UnderlyingNetworkAvailability.UNVALIDATED) { + SafeDiagnostics.trace( + TAG, + "Startup tunnel validation probing through unvalidated physical network", + ) + } val probeStartedAt = SystemClock.elapsedRealtime() val probe = withTimeoutOrNull(TUNNEL_STARTUP_VALIDATION_TIMEOUT_MS) { @@ -2123,7 +2128,9 @@ class VpnConnectionManager @Inject constructor( var networkUnavailableStartedAtMs: Long? = null while (gen == latestConnectionGeneration.get() && _connectionState.value is ConnectionState.Connected) { val availability = underlyingNetworkAvailability() - if (availability != UnderlyingNetworkAvailability.VALIDATED) { + val networkLossTimeoutMs = + UnderlyingNetworkPolicy.teardownTimeoutMs(availability) + if (networkLossTimeoutMs != null) { val now = SystemClock.elapsedRealtime() val unavailableSince = networkUnavailableStartedAtMs ?: now.also { networkUnavailableStartedAtMs = it @@ -2133,17 +2140,16 @@ class VpnConnectionManager @Inject constructor( "generation=$gen availability=${availability.name}", ) } - val timeoutMs = UnderlyingNetworkPolicy.timeoutMs(availability) val deadline = NetworkAvailabilityDeadline( startedAtMs = unavailableSince, - timeoutMs = timeoutMs, + timeoutMs = networkLossTimeoutMs, ) if (deadline.isExpired(now)) { SafeDiagnostics.warn( TAG, - "Tunnel watchdog stopped VPN without validated physical network: " + + "Tunnel watchdog stopped VPN without a physical network: " + "generation=$gen availability=${availability.name} " + - "timeout_ms=$timeoutMs", + "timeout_ms=$networkLossTimeoutMs", ) // The service callback normally reaches the same // deadline first. This independent guard covers a rare @@ -2154,8 +2160,9 @@ class VpnConnectionManager @Inject constructor( } SafeDiagnostics.trace( TAG, - "Tunnel health cycle skipped: availability=${availability.name} " + - "timeout_ms=$timeoutMs", + "Tunnel health cycle skipped without physical network: " + + "availability=${availability.name} " + + "timeout_ms=$networkLossTimeoutMs", ) delay( deadline.nextCheckDelayMs( @@ -2166,6 +2173,12 @@ class VpnConnectionManager @Inject constructor( continue } networkUnavailableStartedAtMs = null + if (availability == UnderlyingNetworkAvailability.UNVALIDATED) { + SafeDiagnostics.trace( + TAG, + "Tunnel health probe proceeding through unvalidated physical network", + ) + } // Freeze liveness evidence before the watchdog sends anything. // Otherwise the failed probe's own uplink (or handshake bytes) diff --git a/app/src/test/java/com/tobevpn/app/vpn/NetworkAvailabilityDeadlineTest.kt b/app/src/test/java/com/tobevpn/app/vpn/NetworkAvailabilityDeadlineTest.kt index 0b2aad5..39f01cf 100644 --- a/app/src/test/java/com/tobevpn/app/vpn/NetworkAvailabilityDeadlineTest.kt +++ b/app/src/test/java/com/tobevpn/app/vpn/NetworkAvailabilityDeadlineTest.kt @@ -17,16 +17,18 @@ class NetworkAvailabilityDeadlineTest { } @Test - fun `unvalidated physical network uses forty five second boundary`() { + fun `physical network loss uses policy deadline`() { val deadline = NetworkAvailabilityDeadline( startedAtMs = 1_000L, - timeoutMs = UnderlyingNetworkPolicy.timeoutMs( - UnderlyingNetworkAvailability.UNVALIDATED, + timeoutMs = requireNotNull( + UnderlyingNetworkPolicy.teardownTimeoutMs( + UnderlyingNetworkAvailability.UNAVAILABLE, + ), ), ) - assertFalse(deadline.isExpired(45_999L)) - assertTrue(deadline.isExpired(46_000L)) + assertFalse(deadline.isExpired(15_999L)) + assertTrue(deadline.isExpired(16_000L)) } @Test diff --git a/app/src/test/java/com/tobevpn/app/vpn/NetworkResumePolicyTest.kt b/app/src/test/java/com/tobevpn/app/vpn/NetworkResumePolicyTest.kt index 85d154d..b1794b4 100644 --- a/app/src/test/java/com/tobevpn/app/vpn/NetworkResumePolicyTest.kt +++ b/app/src/test/java/com/tobevpn/app/vpn/NetworkResumePolicyTest.kt @@ -43,8 +43,8 @@ class NetworkResumePolicyTest { } @Test - fun `unvalidated network cannot restart vpn`() { - assertFalse( + fun `unvalidated carrier network can restart vpn for tunnel validation`() { + assertTrue( NetworkResumePolicy.shouldResume( expectedRequest = 7, currentRequest = 7, @@ -54,4 +54,17 @@ class NetworkResumePolicyTest { ), ) } + + @Test + fun `missing physical network cannot restart vpn`() { + assertFalse( + NetworkResumePolicy.shouldResume( + expectedRequest = 7, + currentRequest = 7, + hasNetworkTimeoutError = true, + sameServer = true, + availability = UnderlyingNetworkAvailability.UNAVAILABLE, + ), + ) + } } diff --git a/app/src/test/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicyTest.kt b/app/src/test/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicyTest.kt index 8c2fbe9..5327b88 100644 --- a/app/src/test/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicyTest.kt +++ b/app/src/test/java/com/tobevpn/app/vpn/UnderlyingNetworkPolicyTest.kt @@ -1,31 +1,57 @@ package com.tobevpn.app.vpn import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue import org.junit.Test class UnderlyingNetworkPolicyTest { @Test fun `complete physical network loss keeps the existing fifteen second deadline`() { + val timeoutMs = requireNotNull( + UnderlyingNetworkPolicy.teardownTimeoutMs( + UnderlyingNetworkAvailability.UNAVAILABLE, + ), + ) + assertEquals( 15_000L, - UnderlyingNetworkPolicy.timeoutMs(UnderlyingNetworkAvailability.UNAVAILABLE), + timeoutMs, + ) + assertFalse( + UnderlyingNetworkPolicy.canAttemptTunnelProbe( + UnderlyingNetworkAvailability.UNAVAILABLE, + ), ) } @Test - fun `internet network awaiting validation gets a longer deadline`() { - assertEquals( - 45_000L, - UnderlyingNetworkPolicy.timeoutMs(UnderlyingNetworkAvailability.UNVALIDATED), + fun `unvalidated carrier network can prove tunnel liveness without teardown deadline`() { + assertNull( + UnderlyingNetworkPolicy.teardownTimeoutMs( + UnderlyingNetworkAvailability.UNVALIDATED, + ), + ) + assertTrue( + UnderlyingNetworkPolicy.canAttemptTunnelProbe( + UnderlyingNetworkAvailability.UNVALIDATED, + ), ) } @Test fun `validated network needs no teardown deadline`() { - assertEquals( - 0L, - UnderlyingNetworkPolicy.timeoutMs(UnderlyingNetworkAvailability.VALIDATED), + assertNull( + UnderlyingNetworkPolicy.teardownTimeoutMs( + UnderlyingNetworkAvailability.VALIDATED, + ), + ) + assertTrue( + UnderlyingNetworkPolicy.canAttemptTunnelProbe( + UnderlyingNetworkAvailability.VALIDATED, + ), ) } }