Skip to content

A rootless Android app that boots Alpine Linux: run containers (Podman/Docker/LXC) and GUI desktop apps.

feat(forward): raise the rule cap to 2048 and add clean-all

ExTv0ae123e49e77
diff --git a/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt b/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt
index ebba0e0..c7612c8 100644
--- a/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt
+++ b/app/src/main/java/com/excp/podroid/data/repository/PortForwardRepository.kt
@@ -72,7 +72,7 @@ data class PortForwardRule(
* a listening socket, a row in the Settings list, and a QMP round trip on every
* boot. One user scripted 1005 of them and made their VM unstartable.
*/
-internal const val MAX_PORT_FORWARD_RULES = 128
+internal const val MAX_PORT_FORWARD_RULES = 2048
/** Outcome of [PortForwardRepository.addRule]. */
enum class AddRuleResult { ADDED, RESERVED, TABLE_FULL }
@@ -169,6 +169,21 @@ class PortForwardRepository @Inject constructor(
}
}
+ /**
+ * Removes every persisted rule and reports how many were removed. All
+ * entries in the DataStore set are user rules by construction (implicit
+ * forwards never persist), so this is a plain wipe of [KEY_PORT_FORWARDS] -
+ * no other DataStore key is touched.
+ */
+ suspend fun clearRules(): Int {
+ var removed = 0
+ context.dataStore.edit { prefs ->
+ removed = prefs[KEY_PORT_FORWARDS]?.size ?: 0
+ prefs[KEY_PORT_FORWARDS] = emptySet()
+ }
+ return removed
+ }
+
suspend fun getRulesSnapshot(): List<PortForwardRule> =
context.dataStore.data
.catch { e -> if (e is IOException) emit(emptyPreferences()) else throw e }
diff --git a/app/src/main/java/com/excp/podroid/engine/avf/AvfEngine.kt b/app/src/main/java/com/excp/podroid/engine/avf/AvfEngine.kt
index 2e7f638..00fa94f 100644
--- a/app/src/main/java/com/excp/podroid/engine/avf/AvfEngine.kt
+++ b/app/src/main/java/com/excp/podroid/engine/avf/AvfEngine.kt
@@ -697,13 +697,21 @@ class AvfEngine @Inject constructor(
runCatching { fw.close() }
return
}
- // Re-check Running before start() so a concurrent cleanup() doesn't
- // orphan us. If state slipped, drop the freshly-mapped forwarder.
- if (_state.value !is VmState.Running) {
- forwarders.remove(vport)
- return
+ // Re-check Running and start() as one atomic step under the same
+ // monitor onVmTerminal holds (@Synchronized -> this). The two
+ // statements alone aren't atomic across threads: a concurrent
+ // cleanup() (only reachable while Running via onVmTerminal) could
+ // otherwise land in the gap between the check and start(), tearing
+ // down AvfForwarderDispatcher just before start() recreates it -
+ // orphaning a freshly-bound ServerSocket/accept thread that no
+ // later cleanup() would know to close.
+ synchronized(this) {
+ if (_state.value !is VmState.Running) {
+ forwarders.remove(vport)
+ return
+ }
+ fw.start()
}
- fw.start()
val ctl = control
if (ctl != null) {
ctl.addForward(vport, rule.protocol, "127.0.0.1", rule.guestPort)
@@ -814,6 +822,7 @@ class AvfEngine @Inject constructor(
// VM doesn't see late vsock connect attempts after onStopped.
forwarders.values.forEach { runCatching { it.close() } }
forwarders.clear()
+ AvfForwarderDispatcher.shutdown()
lastSentRows = -1
lastSentCols = -1
resizeDebounceJob?.cancel()
diff --git a/app/src/main/java/com/excp/podroid/engine/avf/Forwarder.kt b/app/src/main/java/com/excp/podroid/engine/avf/Forwarder.kt
index 5a4c60f..4a0e0b1 100644
--- a/app/src/main/java/com/excp/podroid/engine/avf/Forwarder.kt
+++ b/app/src/main/java/com/excp/podroid/engine/avf/Forwarder.kt
@@ -7,7 +7,72 @@
*/
package com.excp.podroid.engine.avf
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.launch
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
internal interface Forwarder {
fun start()
fun close()
}
+
+/**
+ * Shared dispatcher for every forwarder's blocking accept()/receive()/reaper
+ * loop (VsockPortForwarder's accept loop, VsockUdpForwarder's receive and
+ * reaper loops). `Dispatchers.IO` caps at 64 threads; one rule parks one
+ * thread there for its whole lifetime, so past 64 rules the blocking loops
+ * alone would exhaust the pool and starve every other IO user in the app.
+ * A cached thread pool has no such cap - idle threads are reclaimed, busy
+ * ones aren't capped.
+ *
+ * Per-connection/per-flow pump coroutines are NOT moved here: their
+ * concurrency is bounded by real traffic (MAX_INFLIGHT / MAX_FLOWS) rather
+ * than by rule count, so `Dispatchers.IO` remains the right fit for them.
+ *
+ * Lazily created on first forwarder start, shut down by AvfEngine.cleanup()
+ * alongside the forwarders it backs; the next VM start recreates it on demand.
+ */
+internal object AvfForwarderDispatcher {
+ @Volatile private var executor: ExecutorService? = null
+ @Volatile private var dispatcher: CoroutineDispatcher? = null
+
+ /**
+ * Obtains the shared dispatcher and launches [block] on [scope] with it
+ * as a single atomic step. A forwarder's start() races against a
+ * concurrent AvfEngine.cleanup() (EngineHolder's rule-diff collector can
+ * still be mid-loop calling addPortForward while a VM stop flips state
+ * and runs cleanup() on another thread); reading the dispatcher and
+ * submitting to it under two separate locks would let shutdown() land in
+ * between - grabbing a dispatcher instance right as it's torn down, or
+ * silently spinning up a fresh executor after shutdown() already ran,
+ * which would then never get reaped. Sharing [shutdown]'s lock across
+ * both steps closes that window.
+ */
+ fun launch(
+ scope: CoroutineScope,
+ context: CoroutineContext = EmptyCoroutineContext,
+ block: suspend CoroutineScope.() -> Unit,
+ ): Job = synchronized(this) {
+ val d = dispatcher ?: Executors.newCachedThreadPool { r ->
+ Thread(r, "avf-forwarder-io").apply { isDaemon = true }
+ }.let { newExecutor ->
+ executor = newExecutor
+ newExecutor.asCoroutineDispatcher().also { dispatcher = it }
+ }
+ scope.launch(d + context, block = block)
+ }
+
+ fun shutdown() {
+ synchronized(this) {
+ executor?.shutdownNow()
+ executor = null
+ dispatcher = null
+ }
+ }
+}
diff --git a/app/src/main/java/com/excp/podroid/engine/avf/VsockPortForwarder.kt b/app/src/main/java/com/excp/podroid/engine/avf/VsockPortForwarder.kt
index 8a858b0..69d279b 100644
--- a/app/src/main/java/com/excp/podroid/engine/avf/VsockPortForwarder.kt
+++ b/app/src/main/java/com/excp/podroid/engine/avf/VsockPortForwarder.kt
@@ -79,7 +79,10 @@ class VsockPortForwarder(
val s = ServerSocket(hostPort, /* backlog */ 16, InetAddress.getByName(bindAddress))
server = s
Log.d(TAG, "listening on $bindAddress:$hostPort → vsock:$guestVsockPort")
- acceptJob = scope.launch(Dispatchers.IO) {
+ // The accept loop blocks on ServerSocket.accept() for the forwarder's
+ // whole lifetime, so it runs on the shared AvfForwarderDispatcher
+ // rather than the 64-thread-capped Dispatchers.IO (see its doc).
+ acceptJob = AvfForwarderDispatcher.launch(scope) {
while (!closed) {
val client = try { s.accept() } catch (_: SocketException) { break }
if (!inflight.tryAcquire()) {
diff --git a/app/src/main/java/com/excp/podroid/engine/avf/VsockUdpForwarder.kt b/app/src/main/java/com/excp/podroid/engine/avf/VsockUdpForwarder.kt
index 28f2f6c..bd4392b 100644
--- a/app/src/main/java/com/excp/podroid/engine/avf/VsockUdpForwarder.kt
+++ b/app/src/main/java/com/excp/podroid/engine/avf/VsockUdpForwarder.kt
@@ -82,8 +82,12 @@ class VsockUdpForwarder(
}
socket = s
Log.d(TAG, "listening udp $bindAddress:$hostPort → vsock:$guestVsockPort")
- recvJob = scope.launch(Dispatchers.IO + children) { receiveLoop(s) }
- reaperJob = scope.launch(Dispatchers.IO + children) { reapLoop() }
+ // Both loops block/park for the forwarder's whole lifetime (receive()
+ // and the reaper's delay loop), so they run on the shared
+ // AvfForwarderDispatcher rather than the 64-thread-capped
+ // Dispatchers.IO (see its doc). Per-flow reader jobs stay on IO.
+ recvJob = AvfForwarderDispatcher.launch(scope, children) { receiveLoop(s) }
+ reaperJob = AvfForwarderDispatcher.launch(scope, children) { reapLoop() }
}
private suspend fun receiveLoop(s: DatagramSocket) {
diff --git a/app/src/main/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcher.kt b/app/src/main/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcher.kt
index 180c1c8..764a751 100644
--- a/app/src/main/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcher.kt
+++ b/app/src/main/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcher.kt
@@ -18,6 +18,7 @@ class HostRequestDispatcher(
private val addForward: suspend (PortForwardRule) -> AddRuleResult,
private val removeForward: suspend (PortForwardRule) -> Unit,
private val listForwards: suspend () -> List<PortForwardRule>,
+ private val clearForwards: suspend () -> Int,
private val openUrl: suspend (String) -> String,
private val power: suspend (String) -> String,
private val setHeadless: suspend (String) -> String,
@@ -40,6 +41,7 @@ class HostRequestDispatcher(
"FWD-ADD" -> handleFwdAdd(parts)
"FWD-REMOVE" -> handleFwdRemove(parts)
"FWD-LIST" -> handleFwdList()
+ "FWD-CLEAN" -> handleFwdClean(parts)
"OPEN" -> handleOpen(parts)
"POWER" -> handlePower(parts)
"HEADLESS" -> handleHeadless(parts)
@@ -109,6 +111,13 @@ class HostRequestDispatcher(
return HostProtocol.ok(HostProtocol.enc(table))
}
+ // FWD-CLEAN (no arguments)
+ private suspend fun handleFwdClean(p: List<String>): String {
+ if (p.size != 1) return HostProtocol.err("bad request")
+ val removed = clearForwards()
+ return HostProtocol.ok("removed $removed")
+ }
+
// OPEN <b64url>
private suspend fun handleOpen(p: List<String>): String {
if (p.size != 2) return HostProtocol.err("bad request")
diff --git a/app/src/main/java/com/excp/podroid/service/PodroidService.kt b/app/src/main/java/com/excp/podroid/service/PodroidService.kt
index 60e6b0c..afb04c1 100644
--- a/app/src/main/java/com/excp/podroid/service/PodroidService.kt
+++ b/app/src/main/java/com/excp/podroid/service/PodroidService.kt
@@ -285,6 +285,7 @@ class PodroidService : Service() {
addForward = { portForwardRepository.addRule(it) },
removeForward = { portForwardRepository.removeRule(it) },
listForwards = { portForwardRepository.getRulesSnapshot() },
+ clearForwards = { portForwardRepository.clearRules() },
openUrl = { handleOpenUrl(it) },
power = { handlePowerRequest(it) },
setHeadless = { handleHeadlessRequest(it) },
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
index ca3b48b..64fc599 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsScreen.kt
@@ -18,8 +18,11 @@ import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
@@ -48,7 +51,6 @@ import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
-import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
@@ -287,6 +289,7 @@ fun SettingsScreen(
sshEnabled = ui.sshEnabled,
onAdd = { showAddDialog = true },
onRemove = { viewModel.removePortForward(it) },
+ onClean = { viewModel.clearPortForwards() },
)
// ── STORAGE / SHARING ─────────────────────────────────
@@ -529,10 +532,23 @@ private fun PortForwardSection(
sshEnabled: Boolean,
onAdd: () -> Unit,
onRemove: (PortForwardRule) -> Unit,
+ onClean: () -> Unit,
) {
+ var showCleanConfirm by remember { mutableStateOf(false) }
+
PodroidListRow(
label = stringResource(R.string.port_forwards_count, rules.size),
- rightSlot = { PodroidInlineAction(label = stringResource(R.string.add_btn), onClick = onAdd) },
+ rightSlot = {
+ Row(horizontalArrangement = Arrangement.spacedBy(PodroidTokens.Spacing.SM)) {
+ if (rules.isNotEmpty()) {
+ PodroidInlineAction(
+ label = stringResource(R.string.port_forwards_clean),
+ onClick = { showCleanConfirm = true },
+ )
+ }
+ PodroidInlineAction(label = stringResource(R.string.add_btn), onClick = onAdd)
+ }
+ },
)
// The forwards Podroid sets up itself. They never appear in the rule list
@@ -559,8 +575,10 @@ private fun PortForwardSection(
purpose = stringResource(R.string.port_forward_purpose_audio),
dimmed = false,
)
- rules.forEach { rule ->
- key(rule.hostPort, rule.protocol) {
+ LazyColumn(
+ modifier = Modifier.heightIn(max = 360.dp),
+ ) {
+ items(rules, key = { "${it.protocol}:${it.hostPort}" }) { rule ->
Row(
modifier = Modifier
.fillMaxWidth()
@@ -589,6 +607,27 @@ private fun PortForwardSection(
)
}
}
+
+ if (showCleanConfirm) {
+ AlertDialog(
+ onDismissRequest = { showCleanConfirm = false },
+ title = { Text(stringResource(R.string.port_forwards_clean_confirm_title)) },
+ text = { Text(stringResource(R.string.port_forwards_clean_confirm_body, rules.size)) },
+ confirmButton = {
+ TextButton(onClick = {
+ onClean()
+ showCleanConfirm = false
+ }) {
+ Text(stringResource(R.string.port_forwards_clean_confirm_btn), color = MaterialTheme.colorScheme.error)
+ }
+ },
+ dismissButton = {
+ TextButton(onClick = { showCleanConfirm = false }) {
+ Text(stringResource(R.string.cancel))
+ }
+ },
+ )
+ }
}
/** One of Podroid's own forwards: shown for reference, with no delete action. */
diff --git a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
index ea818d0..388627a 100644
--- a/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
+++ b/app/src/main/java/com/excp/podroid/ui/screens/settings/SettingsViewModel.kt
@@ -312,6 +312,11 @@ class SettingsViewModel @Inject constructor(
viewModelScope.launch { portForwardRepository.removeRule(rule) }
}
+ /** Removes every persisted user rule. Implicit forwards (SSH/VNC/audio) are in-memory and unaffected. */
+ fun clearPortForwards() {
+ viewModelScope.launch { portForwardRepository.clearRules() }
+ }
+
fun resetVm() {
viewModelScope.launch {
withContext(Dispatchers.IO) {
diff --git a/app/src/main/res/values-zh/strings.xml b/app/src/main/res/values-zh/strings.xml
index 569251b..e903401 100644
--- a/app/src/main/res/values-zh/strings.xml
+++ b/app/src/main/res/values-zh/strings.xml
@@ -125,6 +125,10 @@
<string name="port_forward_purpose_vnc">桌面,仅限本机</string>
<string name="port_forward_purpose_audio">桌面音频,仅限本机</string>
<string name="port_forwards_count">端口转发 (%1$d)</string>
+ <string name="port_forwards_clean">全部清除</string>
+ <string name="port_forwards_clean_confirm_title">移除所有端口转发?</string>
+ <string name="port_forwards_clean_confirm_body">这将移除全部 %1$d 条转发规则。Podroid 自身的转发(SSH、显示、音频)不受影响。</string>
+ <string name="port_forwards_clean_confirm_btn">全部移除</string>
<string name="none">无</string>
<string name="active">活动</string>
<string name="off">关闭</string>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 3713ff0..e94e5e7 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -125,6 +125,10 @@
<string name="port_forward_purpose_vnc">Desktop, this phone only</string>
<string name="port_forward_purpose_audio">Desktop audio, this phone only</string>
<string name="port_forwards_count">Port forwards (%1$d)</string>
+ <string name="port_forwards_clean">Clean all</string>
+ <string name="port_forwards_clean_confirm_title">Remove all port forwards?</string>
+ <string name="port_forwards_clean_confirm_body">This removes all %1$d forwarding rules. Podroid\'s own forwards (SSH, display, audio) are not affected.</string>
+ <string name="port_forwards_clean_confirm_btn">Remove all</string>
<string name="none">None</string>
<string name="active">active</string>
<string name="off">Off</string>
diff --git a/app/src/test/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcherTest.kt b/app/src/test/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcherTest.kt
index 9e4ffb9..5f066dc 100644
--- a/app/src/test/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcherTest.kt
+++ b/app/src/test/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcherTest.kt
@@ -48,6 +48,7 @@ private fun dispatcher(
},
removeForward = { r -> rules.removeAll { it.hostPort == r.hostPort && it.protocol == r.protocol } },
listForwards = { rules.toList() },
+ clearForwards = { val n = rules.size; rules.clear(); n },
openUrl = openUrl,
power = power,
setHeadless = setHeadless,
@@ -145,6 +146,21 @@ class HostRequestDispatcherTest {
assertEquals("8080 80 tcp\n9000 90 udp", table)
}
+ @Test fun fwdCleanRemovesAllAndReportsCount() = runBlocking {
+ val rules = mutableListOf(PortForwardRule(8080, 80, "tcp"), PortForwardRule(9000, 90, "udp"))
+ val d = dispatcher(rules = rules)
+ assertEquals("OK removed 2", d.handle("FWD-CLEAN"))
+ assertEquals(emptyList<PortForwardRule>(), rules)
+ }
+
+ @Test fun fwdCleanRejectsExtraTokens() = runBlocking {
+ val rules = mutableListOf(PortForwardRule(8080, 80, "tcp"))
+ val d = dispatcher(rules = rules)
+ assertTrue(d.handle("FWD-CLEAN extra").startsWith("ERR "))
+ // Rejected request must not have cleared anything.
+ assertEquals(listOf(PortForwardRule(8080, 80, "tcp")), rules)
+ }
+
@Test fun pingPongs() = runBlocking {
assertEquals("PONG", dispatcher().handle("PING"))
}
diff --git a/build-rootfs/host-bridge/podroid-hostd.c b/build-rootfs/host-bridge/podroid-hostd.c
index 77a6685..8ad570b 100644
--- a/build-rootfs/host-bridge/podroid-hostd.c
+++ b/build-rootfs/host-bridge/podroid-hostd.c
@@ -298,13 +298,16 @@ static int cli_forward(int argc, char **argv) {
} else if (argc >= 2 && strcmp(argv[1], "list") == 0) {
snprintf(req, sizeof(req), "FWD-LIST");
list_decode = 1;
+ } else if (argc >= 2 && strcmp(argv[1], "clean") == 0) {
+ snprintf(req, sizeof(req), "FWD-CLEAN");
} else {
fprintf(stderr,
"usage:\n"
" podroid-forward <hostPort> <guestPort>\n"
" podroid-forward add <hostPort> <guestPort> [tcp|udp]\n"
" podroid-forward remove <hostPort> [tcp|udp]\n"
- " podroid-forward list\n");
+ " podroid-forward list\n"
+ " podroid-forward clean\n");
return 2;
}
char resp[8192];