Init commit

app/src/main/java/io/nekohasekai/sfa/bg/BootReceiver.kt

@@ -0,0 +1,30 @@
+package io.nekohasekai.sfa.bg
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import io.nekohasekai.sfa.database.Settings
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class BootReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        when (intent.action) {
+            Intent.ACTION_BOOT_COMPLETED, Intent.ACTION_MY_PACKAGE_REPLACED -> {
+            }
+
+            else -> return
+        }
+        GlobalScope.launch(Dispatchers.IO) {
+            if (Settings.startedByUser) {
+                withContext(Dispatchers.Main) {
+                    BoxService.start()
+                }
+            }
+        }
+    }
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/BoxService.kt

@@ -0,0 +1,264 @@
+package io.nekohasekai.sfa.bg
+
+import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.IBinder
+import android.os.ParcelFileDescriptor
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.MutableLiveData
+import go.Seq
+import io.nekohasekai.libbox.BoxService
+import io.nekohasekai.libbox.CommandServer
+import io.nekohasekai.libbox.CommandServerHandler
+import io.nekohasekai.libbox.Libbox
+import io.nekohasekai.libbox.PProfServer
+import io.nekohasekai.libbox.PlatformInterface
+import io.nekohasekai.sfa.Application
+import io.nekohasekai.sfa.constant.Action
+import io.nekohasekai.sfa.constant.Alert
+import io.nekohasekai.sfa.constant.Status
+import io.nekohasekai.sfa.database.Profiles
+import io.nekohasekai.sfa.database.Settings
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class BoxService(
+    private val service: Service,
+    private val platformInterface: PlatformInterface
+) : CommandServerHandler {
+
+    companion object {
+
+        private var initializeOnce = false
+        private fun initialize() {
+            if (initializeOnce) return
+            val baseDir = Application.application.getExternalFilesDir(null) ?: return
+            baseDir.mkdirs()
+            val tempDir = Application.application.cacheDir
+            tempDir.mkdirs()
+            Libbox.setup(baseDir.path, tempDir.path, -1, -1)
+            Libbox.redirectStderr(File(baseDir, "stderr.log").path)
+            initializeOnce = true
+            return
+        }
+
+        fun start() {
+            val intent = runBlocking {
+                withContext(Dispatchers.IO) {
+                    Intent(Application.application, Settings.serviceClass())
+                }
+            }
+            ContextCompat.startForegroundService(Application.application, intent)
+        }
+
+        fun stop() {
+            Application.application.sendBroadcast(
+                Intent(Action.SERVICE_CLOSE).setPackage(
+                    Application.application.packageName
+                )
+            )
+        }
+    }
+
+    var fileDescriptor: ParcelFileDescriptor? = null
+
+    private val status = MutableLiveData(Status.Stopped)
+    private val binder = ServiceBinder(status)
+    private val notification = ServiceNotification(service)
+    private var boxService: BoxService? = null
+    private var commandServer: CommandServer? = null
+    private var pprofServer: PProfServer? = null
+    private var receiverRegistered = false
+    private val receiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            when (intent.action) {
+                Action.SERVICE_CLOSE -> {
+                    stopService()
+                }
+            }
+        }
+    }
+
+    private fun startCommandServer() {
+        val commandServer =
+            CommandServer(Application.application.filesDir.absolutePath, this)
+        commandServer.start()
+        this.commandServer = commandServer
+    }
+
+    private suspend fun startService() {
+        initialize()
+        try {
+            val selectedProfileId = Settings.selectedProfile
+            if (selectedProfileId == -1L) {
+                stopAndAlert(Alert.EmptyConfiguration)
+                return
+            }
+
+            val profile = Profiles.get(selectedProfileId)
+            if (profile == null) {
+                stopAndAlert(Alert.EmptyConfiguration)
+                return
+            }
+
+            val content = File(profile.typed.path).readText()
+            if (content.isBlank()) {
+                stopAndAlert(Alert.EmptyConfiguration)
+                return
+            }
+
+            withContext(Dispatchers.Main) {
+                binder.broadcast {
+                    it.onServiceResetLogs(listOf())
+                }
+            }
+
+            DefaultNetworkMonitor.start()
+            Libbox.registerLocalDNSTransport(LocalResolver)
+
+            val newService = try {
+                Libbox.newService(content, platformInterface)
+            } catch (e: Exception) {
+                stopAndAlert(Alert.CreateService, e.message)
+                return
+            }
+
+            newService.start()
+            boxService = newService
+
+            status.postValue(Status.Started)
+        } catch (e: Exception) {
+            stopAndAlert(Alert.StartService, e.message)
+            return
+        }
+    }
+
+    override fun serviceReload() {
+        GlobalScope.launch(Dispatchers.IO) {
+            val pfd = fileDescriptor
+            if (pfd != null) {
+                pfd.close()
+                fileDescriptor = null
+            }
+            boxService?.apply {
+                runCatching {
+                    close()
+                }.onFailure {
+                    writeLog("service: error when closing: $it")
+                }
+                Seq.destroyRef(refnum)
+            }
+            boxService = null
+            startService()
+        }
+    }
+
+    override fun serviceStop() {
+
+    }
+
+    private fun stopService() {
+        if (status.value != Status.Started) return
+        status.value = Status.Stopping
+        if (receiverRegistered) {
+            service.unregisterReceiver(receiver)
+            receiverRegistered = false
+        }
+        notification.close()
+        GlobalScope.launch(Dispatchers.IO) {
+            val pfd = fileDescriptor
+            if (pfd != null) {
+                pfd.close()
+                fileDescriptor = null
+            }
+            boxService?.apply {
+                runCatching {
+                    close()
+                }.onFailure {
+                    writeLog("service: error when closing: $it")
+                }
+                Seq.destroyRef(refnum)
+            }
+            boxService = null
+            Libbox.registerLocalDNSTransport(null)
+            DefaultNetworkMonitor.stop()
+
+            commandServer?.apply {
+                close()
+                Seq.destroyRef(refnum)
+            }
+            commandServer = null
+            Settings.startedByUser = false
+            withContext(Dispatchers.Main) {
+                status.value = Status.Stopped
+                service.stopSelf()
+            }
+        }
+    }
+
+    private suspend fun stopAndAlert(type: Alert, message: String? = null) {
+        Settings.startedByUser = false
+        withContext(Dispatchers.Main) {
+            if (receiverRegistered) {
+                service.unregisterReceiver(receiver)
+                receiverRegistered = false
+            }
+            notification.close()
+            binder.broadcast { callback ->
+                callback.onServiceAlert(type.ordinal, message)
+            }
+            status.value = Status.Stopped
+        }
+    }
+
+    fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (status.value != Status.Stopped) return Service.START_NOT_STICKY
+        status.value = Status.Starting
+
+        if (!receiverRegistered) {
+            service.registerReceiver(receiver, IntentFilter().apply {
+                addAction(Action.SERVICE_CLOSE)
+            })
+            receiverRegistered = true
+        }
+
+        notification.show()
+        GlobalScope.launch(Dispatchers.IO) {
+            Settings.startedByUser = true
+            try {
+                startCommandServer()
+            } catch (e: Exception) {
+                stopAndAlert(Alert.StartCommandServer, e.message)
+                return@launch
+            }
+            startService()
+        }
+        return Service.START_NOT_STICKY
+    }
+
+    fun onBind(intent: Intent): IBinder {
+        return binder
+    }
+
+    fun onDestroy() {
+        binder.close()
+    }
+
+    fun onRevoke() {
+        stopService()
+    }
+
+    fun writeLog(message: String) {
+        binder.broadcast {
+            it.onServiceWriteLog(message)
+        }
+    }
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/DefaultNetworkListener.kt

@@ -0,0 +1,196 @@
+/*******************************************************************************
+ *                                                                             *
+ *  Copyright (C) 2019 by Max Lv <max.c.lv@gmail.com>                          *
+ *  Copyright (C) 2019 by Mygod Studio <contact-shadowsocks-android@mygod.be>  *
+ *                                                                             *
+ *  This program is free software: you can redistribute it and/or modify       *
+ *  it under the terms of the GNU General Public License as published by       *
+ *  the Free Software Foundation, either version 3 of the License, or          *
+ *  (at your option) any later version.                                        *
+ *                                                                             *
+ *  This program is distributed in the hope that it will be useful,            *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ *  GNU General Public License for more details.                               *
+ *                                                                             *
+ *  You should have received a copy of the GNU General Public License          *
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.       *
+ *                                                                             *
+ *******************************************************************************/
+
+package io.nekohasekai.sfa.bg
+
+import android.annotation.TargetApi
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import io.nekohasekai.sfa.Application
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.actor
+import kotlinx.coroutines.runBlocking
+import java.net.UnknownHostException
+
+object DefaultNetworkListener {
+    private sealed class NetworkMessage {
+        class Start(val key: Any, val listener: (Network?) -> Unit) : NetworkMessage()
+        class Get : NetworkMessage() {
+            val response = CompletableDeferred<Network>()
+        }
+
+        class Stop(val key: Any) : NetworkMessage()
+
+        class Put(val network: Network) : NetworkMessage()
+        class Update(val network: Network) : NetworkMessage()
+        class Lost(val network: Network) : NetworkMessage()
+    }
+
+    private val networkActor = GlobalScope.actor<NetworkMessage>(Dispatchers.Unconfined) {
+        val listeners = mutableMapOf<Any, (Network?) -> Unit>()
+        var network: Network? = null
+        val pendingRequests = arrayListOf<NetworkMessage.Get>()
+        for (message in channel) when (message) {
+            is NetworkMessage.Start -> {
+                if (listeners.isEmpty()) register()
+                listeners[message.key] = message.listener
+                if (network != null) message.listener(network)
+            }
+
+            is NetworkMessage.Get -> {
+                check(listeners.isNotEmpty()) { "Getting network without any listeners is not supported" }
+                if (network == null) pendingRequests += message else message.response.complete(
+                    network
+                )
+            }
+
+            is NetworkMessage.Stop -> if (listeners.isNotEmpty() && // was not empty
+                listeners.remove(message.key) != null && listeners.isEmpty()
+            ) {
+                network = null
+                unregister()
+            }
+
+            is NetworkMessage.Put -> {
+                network = message.network
+                pendingRequests.forEach { it.response.complete(message.network) }
+                pendingRequests.clear()
+                listeners.values.forEach { it(network) }
+            }
+
+            is NetworkMessage.Update -> if (network == message.network) listeners.values.forEach {
+                it(
+                    network
+                )
+            }
+
+            is NetworkMessage.Lost -> if (network == message.network) {
+                network = null
+                listeners.values.forEach { it(null) }
+            }
+        }
+    }
+
+    suspend fun start(key: Any, listener: (Network?) -> Unit) = networkActor.send(
+        NetworkMessage.Start(
+            key,
+            listener
+        )
+    )
+
+    suspend fun get() = if (fallback) @TargetApi(23) {
+        Application.connectivity.activeNetwork
+            ?: throw UnknownHostException() // failed to listen, return current if available
+    } else NetworkMessage.Get().run {
+        networkActor.send(this)
+        response.await()
+    }
+
+    suspend fun stop(key: Any) = networkActor.send(NetworkMessage.Stop(key))
+
+    // NB: this runs in ConnectivityThread, and this behavior cannot be changed until API 26
+    private object Callback : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) = runBlocking {
+            networkActor.send(
+                NetworkMessage.Put(
+                    network
+                )
+            )
+        }
+
+        override fun onCapabilitiesChanged(
+            network: Network,
+            networkCapabilities: NetworkCapabilities
+        ) {
+            // it's a good idea to refresh capabilities
+            runBlocking { networkActor.send(NetworkMessage.Update(network)) }
+        }
+
+        override fun onLost(network: Network) = runBlocking {
+            networkActor.send(
+                NetworkMessage.Lost(
+                    network
+                )
+            )
+        }
+    }
+
+    private var fallback = false
+    private val request = NetworkRequest.Builder().apply {
+        addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+        addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+        if (Build.VERSION.SDK_INT == 23) {  // workarounds for OEM bugs
+            removeCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+            removeCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL)
+        }
+    }.build()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    /**
+     * Unfortunately registerDefaultNetworkCallback is going to return VPN interface since Android P DP1:
+     * https://android.googlesource.com/platform/frameworks/base/+/dda156ab0c5d66ad82bdcf76cda07cbc0a9c8a2e
+     *
+     * This makes doing a requestNetwork with REQUEST necessary so that we don't get ALL possible networks that
+     * satisfies default network capabilities but only THE default network. Unfortunately, we need to have
+     * android.permission.CHANGE_NETWORK_STATE to be able to call requestNetwork.
+     *
+     * Source: https://android.googlesource.com/platform/frameworks/base/+/2df4c7d/services/core/java/com/android/server/ConnectivityService.java#887
+     */
+    private fun register() {
+        when (Build.VERSION.SDK_INT) {
+            in 31..Int.MAX_VALUE -> @TargetApi(31) {
+                Application.connectivity.registerBestMatchingNetworkCallback(
+                    request,
+                    Callback,
+                    mainHandler
+                )
+            }
+
+            in 28 until 31 -> @TargetApi(28) {  // we want REQUEST here instead of LISTEN
+                Application.connectivity.requestNetwork(request, Callback, mainHandler)
+            }
+
+            in 26 until 28 -> @TargetApi(26) {
+                Application.connectivity.registerDefaultNetworkCallback(Callback, mainHandler)
+            }
+
+            in 24 until 26 -> @TargetApi(24) {
+                Application.connectivity.registerDefaultNetworkCallback(Callback)
+            }
+
+            else -> try {
+                fallback = false
+                Application.connectivity.requestNetwork(request, Callback)
+            } catch (e: RuntimeException) {
+                fallback =
+                    true     // known bug on API 23: https://stackoverflow.com/a/33509180/2245107
+            }
+        }
+    }
+
+    private fun unregister() = Application.connectivity.unregisterNetworkCallback(Callback)
+}

app/src/main/java/io/nekohasekai/sfa/bg/DefaultNetworkMonitor.kt

@@ -0,0 +1,43 @@
+package io.nekohasekai.sfa.bg
+
+import android.net.Network
+import android.os.Build
+import io.nekohasekai.libbox.InterfaceUpdateListener
+import io.nekohasekai.sfa.Application
+
+object DefaultNetworkMonitor {
+
+    var defaultNetwork: Network? = null
+    private var listener: InterfaceUpdateListener? = null
+
+    suspend fun start() {
+        DefaultNetworkListener.start(this) {
+            defaultNetwork = it
+            checkDefaultInterfaceUpdate(it)
+        }
+        defaultNetwork = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            Application.connectivity.activeNetwork
+        } else {
+            DefaultNetworkListener.get()
+        }
+    }
+
+    suspend fun stop() {
+        DefaultNetworkListener.stop(this)
+    }
+
+    fun setListener(listener: InterfaceUpdateListener?) {
+        this.listener = listener
+        checkDefaultInterfaceUpdate(defaultNetwork)
+    }
+
+    private fun checkDefaultInterfaceUpdate(
+        newNetwork: Network?
+    ) {
+        val listener = listener ?: return
+        val link = Application.connectivity.getLinkProperties(newNetwork ?: return) ?: return
+        listener.updateDefaultInterface(link.interfaceName, -1)
+    }
+
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/LocalResolver.kt

@@ -0,0 +1,134 @@
+package io.nekohasekai.sfa.bg
+
+import android.net.DnsResolver
+import android.os.Build
+import android.os.CancellationSignal
+import android.system.ErrnoException
+import androidx.annotation.RequiresApi
+import io.nekohasekai.libbox.ExchangeContext
+import io.nekohasekai.libbox.LocalDNSTransport
+import io.nekohasekai.sfa.ktx.tryResumeWithException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asExecutor
+import kotlinx.coroutines.runBlocking
+import java.net.InetAddress
+import java.net.UnknownHostException
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+object LocalResolver : LocalDNSTransport {
+
+    private const val RCODE_NXDOMAIN = 3
+
+    override fun raw(): Boolean {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+    }
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    override fun exchange(ctx: ExchangeContext, message: ByteArray) {
+        return runBlocking {
+            suspendCoroutine { continuation ->
+                val signal = CancellationSignal()
+                ctx.onCancel(signal::cancel)
+                val callback = object : DnsResolver.Callback<ByteArray> {
+                    override fun onAnswer(answer: ByteArray, rcode: Int) {
+                        if (rcode == 0) {
+                            ctx.rawSuccess(answer)
+                        } else {
+                            ctx.errorCode(rcode)
+                        }
+                        continuation.resume(Unit)
+                    }
+
+                    override fun onError(error: DnsResolver.DnsException) {
+                        when (val cause = error.cause) {
+                            is ErrnoException -> {
+                                ctx.errnoCode(cause.errno)
+                                continuation.resume(Unit)
+                                return
+                            }
+                        }
+                        continuation.tryResumeWithException(error)
+                    }
+                }
+                DnsResolver.getInstance().rawQuery(
+                    DefaultNetworkMonitor.defaultNetwork,
+                    message,
+                    DnsResolver.FLAG_NO_RETRY,
+                    Dispatchers.IO.asExecutor(),
+                    signal,
+                    callback
+                )
+            }
+        }
+    }
+
+    override fun lookup(ctx: ExchangeContext, network: String, domain: String) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return runBlocking {
+                suspendCoroutine { continuation ->
+                    val signal = CancellationSignal()
+                    ctx.onCancel(signal::cancel)
+                    val callback = object : DnsResolver.Callback<Collection<InetAddress>> {
+                        @Suppress("ThrowableNotThrown")
+                        override fun onAnswer(answer: Collection<InetAddress>, rcode: Int) {
+                            if (rcode == 0) {
+                                ctx.success((answer as Collection<InetAddress?>).mapNotNull { it?.hostAddress }
+                                    .joinToString("\n"))
+                            } else {
+                                ctx.errorCode(rcode)
+                            }
+                            continuation.resume(Unit)
+                        }
+
+                        override fun onError(error: DnsResolver.DnsException) {
+                            when (val cause = error.cause) {
+                                is ErrnoException -> {
+                                    ctx.errnoCode(cause.errno)
+                                    continuation.resume(Unit)
+                                    return
+                                }
+                            }
+                            continuation.tryResumeWithException(error)
+                        }
+                    }
+                    val type = when {
+                        network.endsWith("4") -> DnsResolver.TYPE_A
+                        network.endsWith("6") -> DnsResolver.TYPE_AAAA
+                        else -> null
+                    }
+                    if (type != null) {
+                        DnsResolver.getInstance().query(
+                            DefaultNetworkMonitor.defaultNetwork,
+                            domain,
+                            type,
+                            DnsResolver.FLAG_NO_RETRY,
+                            Dispatchers.IO.asExecutor(),
+                            signal,
+                            callback
+                        )
+                    } else {
+                        DnsResolver.getInstance().query(
+                            DefaultNetworkMonitor.defaultNetwork,
+                            domain,
+                            DnsResolver.FLAG_NO_RETRY,
+                            Dispatchers.IO.asExecutor(),
+                            signal,
+                            callback
+                        )
+                    }
+                }
+            }
+        } else {
+            val underlyingNetwork =
+                DefaultNetworkMonitor.defaultNetwork ?: error("upstream network not found")
+            val answer = try {
+                underlyingNetwork.getAllByName(domain)
+            } catch (e: UnknownHostException) {
+                ctx.errorCode(RCODE_NXDOMAIN)
+                return
+            }
+            ctx.success(answer.mapNotNull { it.hostAddress }.joinToString("\n"))
+        }
+    }
+}

app/src/main/java/io/nekohasekai/sfa/bg/PlatformInterfaceWrapper.kt

@@ -0,0 +1,144 @@
+package io.nekohasekai.sfa.bg
+
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Process
+import androidx.annotation.RequiresApi
+import io.nekohasekai.libbox.InterfaceUpdateListener
+import io.nekohasekai.libbox.NetworkInterfaceIterator
+import io.nekohasekai.libbox.PlatformInterface
+import io.nekohasekai.libbox.StringIterator
+import io.nekohasekai.libbox.TunOptions
+import io.nekohasekai.sfa.Application
+import java.net.Inet6Address
+import java.net.InetSocketAddress
+import java.net.InterfaceAddress
+import java.net.NetworkInterface
+import java.util.Enumeration
+import io.nekohasekai.libbox.NetworkInterface as LibboxNetworkInterface
+
+interface PlatformInterfaceWrapper : PlatformInterface {
+
+    override fun usePlatformAutoDetectInterfaceControl(): Boolean {
+        return true
+    }
+
+    override fun autoDetectInterfaceControl(fd: Int) {
+    }
+
+    override fun openTun(options: TunOptions): Int {
+        error("invalid argument")
+    }
+
+    override fun useProcFS(): Boolean {
+        return Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+    }
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    override fun findConnectionOwner(
+        ipProtocol: Int,
+        sourceAddress: String,
+        sourcePort: Int,
+        destinationAddress: String,
+        destinationPort: Int
+    ): Int {
+        val uid = Application.connectivity.getConnectionOwnerUid(
+            ipProtocol,
+            InetSocketAddress(sourceAddress, sourcePort),
+            InetSocketAddress(destinationAddress, destinationPort)
+        )
+        if (uid == Process.INVALID_UID) error("android: connection owner not found")
+        return uid
+    }
+
+    override fun packageNameByUid(uid: Int): String {
+        val packages = Application.packageManager.getPackagesForUid(uid)
+        if (packages.isNullOrEmpty()) error("android: package not found")
+        return packages[0]
+    }
+
+    @Suppress("DEPRECATION")
+    override fun uidByPackageName(packageName: String): Int {
+        return try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                Application.packageManager.getPackageUid(
+                    packageName, PackageManager.PackageInfoFlags.of(0)
+                )
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                Application.packageManager.getPackageUid(packageName, 0)
+            } else {
+                Application.packageManager.getApplicationInfo(packageName, 0).uid
+            }
+        } catch (e: PackageManager.NameNotFoundException) {
+            error("android: package not found")
+        }
+    }
+
+    override fun usePlatformDefaultInterfaceMonitor(): Boolean {
+        return true
+    }
+
+    override fun startDefaultInterfaceMonitor(listener: InterfaceUpdateListener) {
+        DefaultNetworkMonitor.setListener(listener)
+    }
+
+    override fun closeDefaultInterfaceMonitor(listener: InterfaceUpdateListener) {
+        DefaultNetworkMonitor.setListener(null)
+    }
+
+    override fun usePlatformInterfaceGetter(): Boolean {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
+    }
+
+    override fun getInterfaces(): NetworkInterfaceIterator {
+        return InterfaceArray(NetworkInterface.getNetworkInterfaces())
+    }
+
+    override fun underNetworkExtension(): Boolean {
+        return false
+    }
+
+    private class InterfaceArray(private val iterator: Enumeration<NetworkInterface>) :
+        NetworkInterfaceIterator {
+
+        override fun hasNext(): Boolean {
+            return iterator.hasMoreElements()
+        }
+
+        override fun next(): LibboxNetworkInterface {
+            val element = iterator.nextElement()
+            return LibboxNetworkInterface().apply {
+                name = element.name
+                index = element.index
+                runCatching {
+                    mtu = element.mtu
+                }
+                addresses =
+                    StringArray(
+                        element.interfaceAddresses.mapTo(mutableListOf()) { it.toPrefix() }
+                            .iterator()
+                    )
+            }
+        }
+
+        private fun InterfaceAddress.toPrefix(): String {
+            return if (address is Inet6Address) {
+                "${Inet6Address.getByAddress(address.address).hostAddress}/${networkPrefixLength}"
+            } else {
+                "${address.hostAddress}/${networkPrefixLength}"
+            }
+        }
+    }
+
+    private class StringArray(private val iterator: Iterator<String>) : StringIterator {
+
+        override fun hasNext(): Boolean {
+            return iterator.hasNext()
+        }
+
+        override fun next(): String {
+            return iterator.next()
+        }
+    }
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/ProxyService.kt

@@ -0,0 +1,17 @@
+package io.nekohasekai.sfa.bg
+
+import android.app.Service
+import android.content.Intent
+
+class ProxyService : Service(), PlatformInterfaceWrapper {
+
+    private val service = BoxService(this, this)
+
+    override fun onStartCommand(intent: Intent, flags: Int, startId: Int) =
+        service.onStartCommand(intent, flags, startId)
+
+    override fun onBind(intent: Intent) = service.onBind(intent)
+    override fun onDestroy() = service.onDestroy()
+
+    override fun writeLog(message: String) = service.writeLog(message)
+}

app/src/main/java/io/nekohasekai/sfa/bg/ServiceBinder.kt

@@ -0,0 +1,59 @@
+package io.nekohasekai.sfa.bg
+
+import android.os.RemoteCallbackList
+import androidx.lifecycle.MutableLiveData
+import io.nekohasekai.sfa.aidl.IService
+import io.nekohasekai.sfa.aidl.IServiceCallback
+import io.nekohasekai.sfa.constant.Status
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+class ServiceBinder(private val status: MutableLiveData<Status>) : IService.Stub() {
+    private val callbacks = RemoteCallbackList<IServiceCallback>()
+    private val broadcastLock = Mutex()
+
+    init {
+        status.observeForever {
+            broadcast { callback ->
+                callback.onServiceStatusChanged(it.ordinal)
+            }
+        }
+    }
+
+    fun broadcast(work: (IServiceCallback) -> Unit) {
+        GlobalScope.launch(Dispatchers.Main) {
+            broadcastLock.withLock {
+                val count = callbacks.beginBroadcast()
+                try {
+                    repeat(count) {
+                        try {
+                            work(callbacks.getBroadcastItem(it))
+                        } catch (_: Exception) {
+                        }
+                    }
+                } finally {
+                    callbacks.finishBroadcast()
+                }
+            }
+        }
+    }
+
+    override fun getStatus(): Int {
+        return (status.value ?: Status.Stopped).ordinal
+    }
+
+    override fun registerCallback(callback: IServiceCallback) {
+        callbacks.register(callback)
+    }
+
+    override fun unregisterCallback(callback: IServiceCallback?) {
+        callbacks.unregister(callback)
+    }
+
+    fun close() {
+        callbacks.kill()
+    }
+}

app/src/main/java/io/nekohasekai/sfa/bg/ServiceConnection.kt

@@ -0,0 +1,115 @@
+package io.nekohasekai.sfa.bg
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.os.RemoteException
+import android.util.Log
+import androidx.appcompat.app.AppCompatActivity
+import io.nekohasekai.sfa.aidl.IService
+import io.nekohasekai.sfa.aidl.IServiceCallback
+import io.nekohasekai.sfa.constant.Action
+import io.nekohasekai.sfa.constant.Alert
+import io.nekohasekai.sfa.constant.Status
+import io.nekohasekai.sfa.database.Settings
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+
+class ServiceConnection(
+    private val context: Context,
+    callback: Callback,
+    private val register: Boolean = true,
+) : ServiceConnection {
+
+    companion object {
+        private const val TAG = "ServiceConnection"
+    }
+
+    private val callback = ServiceCallback(callback)
+    private var service: IService? = null
+
+    val status get() = service?.status?.let { Status.values()[it] } ?: Status.Stopped
+
+    fun connect() {
+        val intent = runBlocking {
+            withContext(Dispatchers.IO) {
+                Intent(context, Settings.serviceClass()).setAction(Action.SERVICE)
+            }
+        }
+        context.bindService(intent, this, AppCompatActivity.BIND_AUTO_CREATE)
+        Log.d(TAG, "request connect")
+    }
+
+    fun disconnect() {
+        try {
+            context.unbindService(this)
+        } catch (_: IllegalArgumentException) {
+        }
+        Log.d(TAG, "request disconnect")
+    }
+
+    fun reconnect() {
+        try {
+            context.unbindService(this)
+        } catch (_: IllegalArgumentException) {
+        }
+        val intent = runBlocking {
+            withContext(Dispatchers.IO) {
+                Intent(context, Settings.serviceClass()).setAction(Action.SERVICE)
+            }
+        }
+        context.bindService(intent, this, AppCompatActivity.BIND_AUTO_CREATE)
+        Log.d(TAG, "request reconnect")
+    }
+
+    override fun onServiceConnected(name: ComponentName, binder: IBinder) {
+        val service = IService.Stub.asInterface(binder)
+        this.service = service
+        try {
+            if (register) service.registerCallback(callback)
+            callback.onServiceStatusChanged(service.status)
+        } catch (e: RemoteException) {
+            Log.e(TAG, "initialize service connection", e)
+        }
+        Log.d(TAG, "service connected")
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+        try {
+            service?.unregisterCallback(callback)
+        } catch (e: RemoteException) {
+            Log.e(TAG, "cleanup service connection", e)
+        }
+        Log.d(TAG, "service disconnected")
+    }
+
+    override fun onBindingDied(name: ComponentName?) {
+        reconnect()
+        Log.d(TAG, "service dead")
+    }
+
+    interface Callback {
+        fun onServiceStatusChanged(status: Status)
+        fun onServiceAlert(type: Alert, message: String?) {}
+        fun onServiceWriteLog(message: String?) {}
+        fun onServiceResetLogs(messages: MutableList<String>) {}
+    }
+
+    class ServiceCallback(private val callback: Callback) : IServiceCallback.Stub() {
+        override fun onServiceStatusChanged(status: Int) {
+            callback.onServiceStatusChanged(Status.values()[status])
+        }
+
+        override fun onServiceAlert(type: Int, message: String?) {
+            callback.onServiceAlert(Alert.values()[type], message)
+        }
+
+        override fun onServiceWriteLog(message: String?) = callback.onServiceWriteLog(message)
+
+        override fun onServiceResetLogs(messages: MutableList<String>) =
+            callback.onServiceResetLogs(messages)
+    }
+}

app/src/main/java/io/nekohasekai/sfa/bg/ServiceNotification.kt

@@ -0,0 +1,80 @@
+package io.nekohasekai.sfa.bg
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.ServiceCompat
+import io.nekohasekai.sfa.Application
+import io.nekohasekai.sfa.R
+import io.nekohasekai.sfa.constant.Action
+import io.nekohasekai.sfa.ui.MainActivity
+
+class ServiceNotification(private val service: Service) {
+    companion object {
+        private const val notificationId = 1
+        private const val notificationChannel = "service"
+        private val flags =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
+
+        fun checkPermission(): Boolean {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                return true
+            }
+            if (Application.notification.areNotificationsEnabled()) {
+                return true
+            }
+            return false
+        }
+    }
+
+
+    private val notification by lazy {
+        NotificationCompat.Builder(service, notificationChannel).setWhen(0)
+            .setContentTitle("sing-box")
+            .setContentText("service started").setOnlyAlertOnce(true)
+            .setSmallIcon(R.drawable.ic_launcher_foreground)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setContentIntent(
+                PendingIntent.getActivity(
+                    service,
+                    0,
+                    Intent(
+                        service,
+                        MainActivity::class.java
+                    ).setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT),
+                    flags
+                )
+            )
+            .setPriority(NotificationCompat.PRIORITY_LOW).apply {
+                addAction(
+                    NotificationCompat.Action.Builder(
+                        0, service.getText(R.string.stop), PendingIntent.getBroadcast(
+                            service,
+                            0,
+                            Intent(Action.SERVICE_CLOSE).setPackage(service.packageName),
+                            flags
+                        )
+                    ).build()
+                )
+            }
+    }
+
+    fun show() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Application.notification.createNotificationChannel(
+                NotificationChannel(
+                    notificationChannel, "sing-box service", NotificationManager.IMPORTANCE_LOW
+                )
+            )
+        }
+        service.startForeground(notificationId, notification.build())
+    }
+
+    fun close() {
+        ServiceCompat.stopForeground(service, ServiceCompat.STOP_FOREGROUND_REMOVE)
+    }
+}

app/src/main/java/io/nekohasekai/sfa/bg/TileService.kt

@@ -0,0 +1,49 @@
+package io.nekohasekai.sfa.bg
+
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import androidx.annotation.RequiresApi
+import io.nekohasekai.sfa.constant.Status
+
+@RequiresApi(24)
+class TileService : TileService(), ServiceConnection.Callback {
+
+    private val connection = ServiceConnection(this, this)
+
+    override fun onServiceStatusChanged(status: Status) {
+        qsTile?.apply {
+            state = when (status) {
+                Status.Started -> Tile.STATE_ACTIVE
+                Status.Stopped -> Tile.STATE_INACTIVE
+                else -> Tile.STATE_UNAVAILABLE
+            }
+            updateTile()
+        }
+    }
+
+    override fun onStartListening() {
+        super.onStartListening()
+        connection.connect()
+    }
+
+    override fun onStopListening() {
+        connection.disconnect()
+        super.onStopListening()
+    }
+
+    override fun onClick() {
+        when (connection.status) {
+            Status.Stopped -> {
+                BoxService.start()
+            }
+
+            Status.Started -> {
+                BoxService.stop()
+            }
+
+            else -> {}
+        }
+    }
+
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/UpdateProfileWork.kt

@@ -0,0 +1,92 @@
+package io.nekohasekai.sfa.bg
+
+import android.content.Context
+import android.util.Log
+import androidx.work.BackoffPolicy
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.PeriodicWorkRequest
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import io.nekohasekai.libbox.Libbox
+import io.nekohasekai.sfa.Application
+import io.nekohasekai.sfa.database.Profiles
+import io.nekohasekai.sfa.database.TypedProfile
+import io.nekohasekai.sfa.utils.HTTPClient
+import java.io.File
+import java.util.Date
+import java.util.concurrent.TimeUnit
+
+class UpdateProfileWork {
+
+    companion object {
+        private const val WORK_NAME = "UpdateProfile"
+
+        suspend fun reconfigureUpdater() {
+            runCatching {
+                reconfigureUpdater0()
+            }.onFailure {
+                Log.e("UpdateProfileWork", "reconfigureUpdater", it)
+            }
+        }
+
+        private suspend fun reconfigureUpdater0() {
+            WorkManager.getInstance(Application.application).cancelUniqueWork(WORK_NAME)
+
+            val remoteProfiles = Profiles.list()
+                .filter { it.typed.type == TypedProfile.Type.Remote && it.typed.autoUpdate }
+            if (remoteProfiles.isEmpty()) return
+
+            var minDelay =
+                remoteProfiles.minByOrNull { it.typed.autoUpdateInterval }!!.typed.autoUpdateInterval.toLong()
+            val now = System.currentTimeMillis() / 1000L
+            val minInitDelay =
+                remoteProfiles.minOf { now - (it.typed.lastUpdated.time / 1000L) - (minDelay * 60) }
+            if (minDelay < 15) minDelay = 15
+
+            WorkManager.getInstance(Application.application).enqueueUniquePeriodicWork(
+                WORK_NAME,
+                ExistingPeriodicWorkPolicy.UPDATE,
+                PeriodicWorkRequest.Builder(UpdateTask::class.java, minDelay, TimeUnit.MINUTES)
+                    .apply {
+                        if (minInitDelay > 0) setInitialDelay(minInitDelay, TimeUnit.SECONDS)
+                        setBackoffCriteria(BackoffPolicy.LINEAR, 15, TimeUnit.MINUTES)
+                    }
+                    .build()
+            )
+        }
+
+    }
+
+    class UpdateTask(
+        appContext: Context, params: WorkerParameters
+    ) : CoroutineWorker(appContext, params) {
+        override suspend fun doWork(): Result {
+            val remoteProfiles = Profiles.list()
+                .filter { it.typed.type == TypedProfile.Type.Remote && it.typed.autoUpdate }
+            if (remoteProfiles.isEmpty()) return Result.success()
+            val httpClient = HTTPClient()
+            var success = true
+            for (profile in remoteProfiles) {
+                try {
+                    val content = httpClient.getString(profile.typed.remoteURL)
+                    Libbox.checkConfig(content)
+                    File(profile.typed.path).writeText(content)
+                    profile.typed.lastUpdated = Date()
+                    Profiles.update(profile)
+                } catch (e: Exception) {
+                    Log.e("UpdateProfileWork", "error when updating profile ${profile.name}", e)
+                    success = false
+                }
+            }
+            return if (success) {
+                Result.success()
+            } else {
+                Result.retry()
+            }
+        }
+
+    }
+
+
+}

app/src/main/java/io/nekohasekai/sfa/bg/VPNService.kt

@@ -0,0 +1,119 @@
+package io.nekohasekai.sfa.bg
+
+import android.content.Intent
+import android.net.ProxyInfo
+import android.net.VpnService
+import android.os.Build
+import io.nekohasekai.libbox.TunOptions
+
+class VPNService : VpnService(), PlatformInterfaceWrapper {
+
+    companion object {
+        private const val TAG = "VPNService"
+    }
+
+    private val service = BoxService(this, this)
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int) =
+        service.onStartCommand(intent, flags, startId)
+
+    override fun onBind(intent: Intent) = service.onBind(intent)
+    override fun onDestroy() {
+        service.onDestroy()
+    }
+
+    override fun onRevoke() {
+        service.onRevoke()
+    }
+
+    override fun autoDetectInterfaceControl(fd: Int) {
+        protect(fd)
+    }
+
+    override fun openTun(options: TunOptions): Int {
+        if (prepare(this) != null) error("android: missing vpn permission")
+
+        val builder = Builder()
+            .setSession("sing-box")
+            .setMtu(options.mtu)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            builder.setMetered(false)
+        }
+
+        val inet4Address = options.inet4Address
+        if (inet4Address.hasNext()) {
+            while (inet4Address.hasNext()) {
+                val address = inet4Address.next()
+                builder.addAddress(address.address, address.prefix)
+            }
+        }
+
+        val inet6Address = options.inet6Address
+        if (inet6Address.hasNext()) {
+            while (inet6Address.hasNext()) {
+                val address = inet6Address.next()
+                builder.addAddress(address.address, address.prefix)
+            }
+        }
+
+        if (options.autoRoute) {
+            builder.addDnsServer(options.dnsServerAddress)
+
+            val inet4RouteAddress = options.inet4RouteAddress
+            if (inet4RouteAddress.hasNext()) {
+                while (inet4RouteAddress.hasNext()) {
+                    val address = inet4RouteAddress.next()
+                    builder.addRoute(address.address, address.prefix)
+                }
+            } else {
+                builder.addRoute("0.0.0.0", 0)
+            }
+
+            val inet6RouteAddress = options.inet6RouteAddress
+            if (inet6RouteAddress.hasNext()) {
+                while (inet6RouteAddress.hasNext()) {
+                    val address = inet6RouteAddress.next()
+                    builder.addRoute(address.address, address.prefix)
+                }
+            } else {
+                builder.addRoute("::", 0)
+            }
+
+            val includePackage = options.includePackage
+            if (includePackage.hasNext()) {
+                while (includePackage.hasNext()) {
+                    builder.addAllowedApplication(includePackage.next())
+                }
+            }
+
+            val excludePackage = options.excludePackage
+            if (excludePackage.hasNext()) {
+                while (excludePackage.hasNext()) {
+                    builder.addDisallowedApplication(excludePackage.next())
+                }
+            }
+        }
+
+        if (options.isHTTPProxyEnabled) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                builder.setHttpProxy(
+                    ProxyInfo.buildDirectProxy(
+                        options.httpProxyServer,
+                        options.httpProxyServerPort
+                    )
+                )
+            } else {
+                error("android: tun.platform.http_proxy requires android 10 or higher")
+            }
+        }
+
+        val pfd =
+            builder.establish() ?: error("android: the application is not prepared or is revoked")
+        service.fileDescriptor = pfd
+        return pfd.fd
+    }
+
+    override fun writeLog(message: String) = service.writeLog(message)
+
+}