Phase 4: PRoot rootfs installer (tar.gz extractor) and launcher

app/src/main/java/io/github/abrarul/modularai/proot/Proot.kt

@@ -0,0 +1,155 @@
+package io.github.abrarul.modularai.proot
+
+import android.content.Context
+import android.system.Os
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import java.util.zip.GZIPInputStream
+
+/**
+ * Since Android 10 an app cannot execute files from its writable storage, so the proot binary and
+ * its loader must ship inside the APK as jniLibs/arm64-v8a/libproot.so and libproot-loader.so
+ * (see app/src/main/jniLibs/README.md). The root filesystem itself is only read/written, so it
+ * lives in filesDir and is downloaded on demand.
+ */
+class Proot(private val ctx: Context) {
+    private val lib = File(ctx.applicationInfo.nativeLibraryDir)
+    private val bin get() = File(lib, "libproot.so")
+    private val loader get() = File(lib, "libproot-loader.so")
+    val rootfs = File(ctx.filesDir, "rootfs/alpine")
+
+    val binaryAvailable get() = bin.exists() && loader.exists()
+    val installed get() = File(rootfs, "bin/sh").exists() || File(rootfs, "bin/busybox").exists()
+
+    suspend fun installAlpine(onLog: (String) -> Unit) = withContext(Dispatchers.IO) {
+        val url = "https://dl-cdn.alpinelinux.org/alpine/v3.20/releases/aarch64/alpine-minirootfs-3.20.3-aarch64.tar.gz"
+        onLog("Downloading $url")
+        rootfs.deleteRecursively(); rootfs.mkdirs()
+        var n = 0
+        URL(url).openStream().use { Tar.extract(it, rootfs) { n++ } }
+        File(rootfs, "etc/resolv.conf").apply { parentFile?.mkdirs(); writeText("nameserver 8.8.8.8\nnameserver 1.1.1.1\n") }
+        onLog("Extracted $n entries into ${rootfs.path}")
+    }
+
+    fun remove() = rootfs.deleteRecursively()
+
+    /** Runs [cmd] with /bin/sh inside the rootfs and streams combined output line by line. */
+    fun exec(cmd: String, onLine: (String) -> Unit): Int {
+        check(binaryAvailable) { "proot binary not bundled in this build (use 'termux ...' instead)" }
+        check(installed) { "Rootfs not installed. Run: proot install" }
+        val tmp = File(ctx.filesDir, "tmp").apply { mkdirs() }
+        val pb = ProcessBuilder(
+            bin.path, "-0", "-r", rootfs.path,
+            "-b", "/dev", "-b", "/proc", "-b", "/sys",
+            "-w", "/root",
+            "/usr/bin/env", "-i", "HOME=/root", "TERM=xterm-256color",
+            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+            "/bin/sh", "-c", cmd
+        ).redirectErrorStream(true)
+        pb.environment()["PROOT_LOADER"] = loader.path
+        pb.environment()["PROOT_TMP_DIR"] = tmp.path
+        val p = pb.start()
+        p.inputStream.bufferedReader().forEachLine(onLine)
+        return p.waitFor()
+    }
+}
+
+/** Minimal ustar/pax/GNU-longname reader for .tar.gz rootfs archives. */
+object Tar {
+    fun extract(gz: InputStream, dest: File, onEntry: () -> Unit = {}) {
+        val inp = GZIPInputStream(gz.buffered(1 shl 16))
+        val h = ByteArray(512)
+        var longName: String? = null
+        var paxPath: String? = null
+        var paxLink: String? = null
+        val root = dest.canonicalPath
+
+        while (readFully(inp, h)) {
+            if (h.all { it == 0.toByte() }) break
+            var name = str(h, 0, 100)
+            val mode = octal(h, 100, 8).toInt()
+            val size = octal(h, 124, 12)
+            val type = h[156].toInt().toChar()
+            var link = str(h, 157, 100)
+            val prefix = str(h, 345, 155)
+            if (prefix.isNotEmpty()) name = "$prefix/$name"
+            val pad = ((size + 511) / 512) * 512 - size
+
+            when (type) {
+                'L' -> { longName = String(readN(inp, size)).trimEnd('\u0000', '\n'); skip(inp, pad); continue }
+                'x' -> {
+                    String(readN(inp, size)).split('\n').forEach { l ->
+                        val kv = l.substringAfter(' ', "")
+                        when {
+                            kv.startsWith("path=") -> paxPath = kv.removePrefix("path=")
+                            kv.startsWith("linkpath=") -> paxLink = kv.removePrefix("linkpath=")
+                        }
+                    }
+                    skip(inp, pad); continue
+                }
+                'g' -> { skip(inp, size + pad); continue }
+            }
+            name = longName ?: paxPath ?: name
+            link = paxLink ?: link
+            longName = null; paxPath = null; paxLink = null
+
+            val out = File(dest, name.trimStart('/')).let { File(it.parentFile?.canonicalFile ?: dest, it.name) }
+            if (!out.path.startsWith(root)) { skip(inp, size + pad); continue } // path traversal guard
+            onEntry()
+
+            when (type) {
+                '5' -> { out.mkdirs(); Os.chmod(out.path, (mode or 448) and 4095) }
+                '2' -> { out.parentFile?.mkdirs(); out.delete(); Os.symlink(link, out.path) }
+                '1' -> {
+                    out.parentFile?.mkdirs()
+                    File(dest, link.trimStart('/')).takeIf { it.exists() }?.copyTo(out, overwrite = true)
+                }
+                '0', '\u0000' -> {
+                    out.parentFile?.mkdirs()
+                    out.outputStream().use { o ->
+                        var left = size
+                        val buf = ByteArray(1 shl 16)
+                        while (left > 0) {
+                            val n = inp.read(buf, 0, minOf(buf.size.toLong(), left).toInt())
+                            if (n < 0) error("Truncated archive")
+                            o.write(buf, 0, n); left -= n
+                        }
+                    }
+                    Os.chmod(out.path, (mode or 384) and 4095)
+                    skip(inp, pad)
+                    continue
+                }
+                else -> { /* device nodes, fifos: skipped */ }
+            }
+            skip(inp, size + pad)
+        }
+    }
+
+    private fun str(b: ByteArray, off: Int, len: Int): String {
+        var e = off; while (e < off + len && b[e] != 0.toByte()) e++
+        return String(b, off, e - off, Charsets.UTF_8)
+    }
+    private fun octal(b: ByteArray, off: Int, len: Int): Long {
+        if (b[off].toInt() and 0x80 != 0) { // base-256 for huge sizes
+            var v = (b[off].toInt() and 0x7f).toLong()
+            for (i in 1 until len) v = (v shl 8) or (b[off + i].toLong() and 0xff)
+            return v
+        }
+        val s = str(b, off, len).trim()
+        return if (s.isEmpty()) 0 else s.toLong(8)
+    }
+    private fun readFully(i: InputStream, b: ByteArray): Boolean {
+        var n = 0
+        while (n < b.size) { val r = i.read(b, n, b.size - n); if (r < 0) return false; n += r }
+        return true
+    }
+    private fun readN(i: InputStream, n: Long): ByteArray = ByteArray(n.toInt()).also { if (n > 0 && !readFully(i, it)) error("Truncated archive") }
+    private fun skip(i: InputStream, n: Long) {
+        var left = n
+        val buf = ByteArray(8192)
+        while (left > 0) { val r = i.read(buf, 0, minOf(buf.size.toLong(), left).toInt()); if (r < 0) return; left -= r }
+    }
+}