Skip to content

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

feat(hostbridge): add request dispatcher with unit tests

ExTv6387adbaed93
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
new file mode 100644
index 0000000..735e670
--- /dev/null
+++ b/app/src/main/java/com/excp/podroid/engine/hostbridge/HostRequestDispatcher.kt
@@ -0,0 +1,77 @@
+/*
+ * Podroid - Rootless Podman for Android
+ * Copyright (C) 2024-2026 Podroid contributors
+ *
+ * Parses one guest request line, executes it, and returns one response line.
+ * Backend-neutral and free of Android framework deps (transport + posting are
+ * injected) so it is fully unit-testable.
+ */
+package com.excp.podroid.engine.hostbridge
+
+import com.excp.podroid.data.repository.PortForwardRule
+
+class HostRequestDispatcher(
+ private val notifications: NotificationPoster,
+ private val addForward: suspend (PortForwardRule) -> Unit,
+ private val removeForward: suspend (PortForwardRule) -> Unit,
+ private val listForwards: suspend () -> List<PortForwardRule>,
+) {
+ private val validProtocols = setOf("tcp", "udp")
+
+ suspend fun handle(line: String): String {
+ val parts = line.trim().split(" ")
+ return try {
+ when (parts[0]) {
+ "NOTIFY" -> handleNotify(parts)
+ "FWD-ADD" -> handleFwdAdd(parts)
+ "FWD-REMOVE" -> handleFwdRemove(parts)
+ "FWD-LIST" -> handleFwdList()
+ "PING" -> "PONG"
+ else -> HostProtocol.err("bad request")
+ }
+ } catch (e: Exception) {
+ HostProtocol.err(e.message ?: e.javaClass.simpleName)
+ }
+ }
+
+ // NOTIFY <prio> <id|-> <b64title|-> <b64body>
+ private fun handleNotify(p: List<String>): String {
+ if (p.size != 5) return HostProtocol.err("bad request")
+ val prio = p[1]
+ if (prio !in HostProtocol.VALID_PRIORITIES) return HostProtocol.err("bad priority")
+ val id = if (p[2] == "-") null else p[2].toIntOrNull() ?: return HostProtocol.err("bad id")
+ val title = if (p[3] == "-") null else HostProtocol.dec(p[3]) ?: return HostProtocol.err("bad title")
+ val body = HostProtocol.dec(p[4]) ?: return HostProtocol.err("bad body")
+ if (!notifications.notificationsPermitted()) return HostProtocol.err("notifications not permitted")
+ val used = notifications.post(title, body, prio, id)
+ return HostProtocol.ok(used.toString())
+ }
+
+ // FWD-ADD <hostPort> <guestPort> <proto>
+ private suspend fun handleFwdAdd(p: List<String>): String {
+ if (p.size != 4) return HostProtocol.err("bad request")
+ val host = p[1].toIntOrNull() ?: return HostProtocol.err("bad host port")
+ val guest = p[2].toIntOrNull() ?: return HostProtocol.err("bad guest port")
+ val proto = p[3]
+ if (host !in 1..65535 || guest !in 1..65535) return HostProtocol.err("port out of range")
+ if (proto !in validProtocols) return HostProtocol.err("bad protocol")
+ addForward(PortForwardRule(host, guest, proto))
+ return HostProtocol.ok()
+ }
+
+ // FWD-REMOVE <hostPort> <proto>
+ private suspend fun handleFwdRemove(p: List<String>): String {
+ if (p.size != 3) return HostProtocol.err("bad request")
+ val host = p[1].toIntOrNull() ?: return HostProtocol.err("bad host port")
+ val proto = p[2]
+ val existing = listForwards().firstOrNull { it.hostPort == host && it.protocol == proto }
+ ?: return HostProtocol.err("no such forward")
+ removeForward(existing)
+ return HostProtocol.ok()
+ }
+
+ private suspend fun handleFwdList(): String {
+ val table = listForwards().joinToString("\n") { "${it.hostPort} ${it.guestPort} ${it.protocol}" }
+ return HostProtocol.ok(HostProtocol.enc(table))
+ }
+}
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 9da606c..2acb729 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
@@ -3,6 +3,9 @@ package com.excp.podroid.engine.hostbridge
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test
+import com.excp.podroid.data.repository.PortForwardRule
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertTrue
class HostProtocolTest {
@Test fun base64RoundTripsUtf8() {
@@ -15,3 +18,106 @@ class HostProtocolTest {
assertNull(HostProtocol.dec("!!!not base64!!!"))
}
}
+
+private class FakePoster(var permitted: Boolean = true) : NotificationPoster {
+ data class Posted(val title: String?, val body: String, val priority: String, val id: Int?)
+ val posts = mutableListOf<Posted>()
+ override fun notificationsPermitted() = permitted
+ override fun post(title: String?, body: String, priority: String, id: Int?): Int {
+ posts.add(Posted(title, body, priority, id))
+ return id ?: 7000
+ }
+}
+
+private fun dispatcher(
+ poster: NotificationPoster = FakePoster(),
+ rules: MutableList<PortForwardRule> = mutableListOf(),
+) = HostRequestDispatcher(
+ notifications = poster,
+ addForward = { r -> rules.removeAll { it.hostPort == r.hostPort && it.protocol == r.protocol }; rules.add(r) },
+ removeForward = { r -> rules.removeAll { it.hostPort == r.hostPort && it.protocol == r.protocol } },
+ listForwards = { rules.toList() },
+)
+
+class HostRequestDispatcherTest2 {
+ @Test fun notifyPostsAndReturnsId() = runBlocking {
+ val poster = FakePoster()
+ val d = dispatcher(poster)
+ val resp = d.handle("NOTIFY high 42 ${HostProtocol.enc("Podroid")} ${HostProtocol.enc("done")}")
+ assertEquals("OK 42", resp)
+ assertEquals(1, poster.posts.size)
+ assertEquals("Podroid", poster.posts[0].title)
+ assertEquals("done", poster.posts[0].body)
+ assertEquals(HostProtocol.PRIO_HIGH, poster.posts[0].priority)
+ assertEquals(42, poster.posts[0].id)
+ }
+
+ @Test fun notifyWithNoTitleAndNoId() = runBlocking {
+ val poster = FakePoster()
+ val d = dispatcher(poster)
+ val resp = d.handle("NOTIFY normal - - ${HostProtocol.enc("hi")}")
+ assertEquals("OK 7000", resp)
+ assertEquals(null, poster.posts[0].title)
+ assertEquals(null, poster.posts[0].id)
+ }
+
+ @Test fun notifyDeniedWhenNotPermitted() = runBlocking {
+ val d = dispatcher(FakePoster(permitted = false))
+ val resp = d.handle("NOTIFY normal - - ${HostProtocol.enc("hi")}")
+ assertTrue(resp.startsWith("ERR "))
+ assertEquals("notifications not permitted", HostProtocol.dec(resp.removePrefix("ERR ")))
+ }
+
+ @Test fun notifyRejectsBadPriority() = runBlocking {
+ val d = dispatcher()
+ assertTrue(d.handle("NOTIFY urgent - - ${HostProtocol.enc("hi")}").startsWith("ERR "))
+ }
+
+ @Test fun fwdAddStoresRule() = runBlocking {
+ val rules = mutableListOf<PortForwardRule>()
+ val d = dispatcher(rules = rules)
+ assertEquals("OK", d.handle("FWD-ADD 8080 80 tcp"))
+ assertEquals(listOf(PortForwardRule(8080, 80, "tcp")), rules)
+ }
+
+ @Test fun fwdAddSugarDefaultsTcp() = runBlocking {
+ val rules = mutableListOf<PortForwardRule>()
+ assertEquals("OK", dispatcher(rules = rules).handle("FWD-ADD 8080 80 tcp"))
+ assertEquals("tcp", rules.single().protocol)
+ }
+
+ @Test fun fwdAddRejectsBadPort() = runBlocking {
+ assertTrue(dispatcher().handle("FWD-ADD 0 80 tcp").startsWith("ERR "))
+ assertTrue(dispatcher().handle("FWD-ADD 70000 80 tcp").startsWith("ERR "))
+ assertTrue(dispatcher().handle("FWD-ADD 8080 80 sctp").startsWith("ERR "))
+ }
+
+ @Test fun fwdRemoveByHostPortAndProto() = runBlocking {
+ val rules = mutableListOf(PortForwardRule(8080, 80, "tcp"), PortForwardRule(9000, 90, "udp"))
+ val d = dispatcher(rules = rules)
+ assertEquals("OK", d.handle("FWD-REMOVE 8080 tcp"))
+ assertEquals(listOf(PortForwardRule(9000, 90, "udp")), rules)
+ }
+
+ @Test fun fwdRemoveUnknownIsError() = runBlocking {
+ val d = dispatcher(rules = mutableListOf())
+ assertTrue(d.handle("FWD-REMOVE 8080 tcp").startsWith("ERR "))
+ }
+
+ @Test fun fwdListReturnsBase64Table() = runBlocking {
+ val rules = mutableListOf(PortForwardRule(8080, 80, "tcp"), PortForwardRule(9000, 90, "udp"))
+ val resp = dispatcher(rules = rules).handle("FWD-LIST")
+ assertTrue(resp.startsWith("OK "))
+ val table = HostProtocol.dec(resp.removePrefix("OK "))
+ assertEquals("8080 80 tcp\n9000 90 udp", table)
+ }
+
+ @Test fun pingPongs() = runBlocking {
+ assertEquals("PONG", dispatcher().handle("PING"))
+ }
+
+ @Test fun unknownIsBadRequest() = runBlocking {
+ assertTrue(dispatcher().handle("FROBNICATE x").startsWith("ERR "))
+ assertTrue(dispatcher().handle("").startsWith("ERR "))
+ }
+}