Revert "Switch to local UDP DNS resolver"

.circleci/config.yml

@@ -7,10 +7,11 @@ jobs:
     environment:
       GRADLE_OPTS: -Dorg.gradle.workers.max=1 -Dorg.gradle.daemon=false -Dkotlin.compiler.execution.strategy="in-process"
     steps:
+      - run: rustup toolchain install nightly-2020-12-20
+      - run: rustup override set nightly-2020-12-20
+      - run: rustup target install armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
       - checkout
       - run: git submodule update --init --recursive
-      - run: rustup update
-      - run: cd core/src/main/rust/shadowsocks-rust && rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
       - restore_cache:
           key: jars-{{ checksum "build.gradle.kts" }}
       - run:

README.md

@@ -21,8 +21,9 @@ for Android TV ([beta](https://play.google.com/apps/testing/com.github.shadowsoc
 * Rust with Android targets installed  
 
 ```bash
-  $ cd core/src/main/rust/shadowsocks-rust
-  $ rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
+  $ rustup toolchain install nightly-2020-12-20
+  $ rustup override set nightly-2020-12-20
+  $ rustup target install armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
 ```
 
 ### BUILD

core/src/main/java/com/github/shadowsocks/bg/BaseService.kt

@@ -253,7 +253,7 @@ object BaseService {
                     File(Core.deviceStorage.noBackupFilesDir, "stat_udp"),
                     File(configRoot, CONFIG_FILE_UDP),
                     "-u", false)
-            data.localDns = LocalDnsWorker(this::rawResolver, DataStore.portLocalDns + 1).apply { start() }
+            data.localDns = LocalDnsWorker(this::rawResolver).apply { start() }
         }
 
         fun startRunner() {

core/src/main/java/com/github/shadowsocks/bg/LocalDnsWorker.kt

@@ -1,6 +1,8 @@
 package com.github.shadowsocks.bg
 
-import com.github.shadowsocks.net.ConcurrentUdpSocketListener
+import android.net.LocalSocket
+import com.github.shadowsocks.Core
+import com.github.shadowsocks.net.ConcurrentLocalSocketListener
 import com.github.shadowsocks.net.DnsResolverCompat
 import com.github.shadowsocks.utils.readableMessage
 import kotlinx.coroutines.CancellationException
@@ -10,45 +12,47 @@ import kotlinx.coroutines.launch
 import org.xbill.DNS.Message
 import org.xbill.DNS.Rcode
 import timber.log.Timber
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.io.File
 import java.io.IOException
-import java.net.SocketAddress
-import java.nio.ByteBuffer
-import java.nio.channels.DatagramChannel
 
-class LocalDnsWorker(private val resolver: suspend (ByteArray) -> ByteArray, port: Int) : ConcurrentUdpSocketListener(
-        "LocalDnsThread", port), CoroutineScope {
-
-    override fun handle(channel: DatagramChannel, sender: SocketAddress, query: ByteBuffer) {
+class LocalDnsWorker(private val resolver: suspend (ByteArray) -> ByteArray) : ConcurrentLocalSocketListener(
+        "LocalDnsThread", File(Core.deviceStorage.noBackupFilesDir, "local_dns_path")), CoroutineScope {
+    override fun acceptInternal(socket: LocalSocket) = error("big no no")
+    override fun accept(socket: LocalSocket) {
         launch {
-            query.flip()
-            val data = ByteArray(query.remaining())
-            query.get(data)
-            try {
-                resolver(data)
-            } catch (e: Exception) {
-                when (e) {
-                    is TimeoutCancellationException -> Timber.w("Resolving timed out")
-                    is CancellationException -> {
-                    } // ignore
-                    is IOException -> Timber.d(e)
-                    else -> Timber.w(e)
-                }
-                try {
-                    DnsResolverCompat.prepareDnsResponse(Message(data)).apply {
-                        header.rcode = Rcode.SERVFAIL
-                    }.toWire()
-                } catch (_: IOException) {
-                    byteArrayOf()   // return empty if cannot parse packet
+            socket.use {
+                val input = DataInputStream(socket.inputStream)
+                val query = try {
+                    ByteArray(input.readUnsignedShort()).also { input.read(it) }
+                } catch (e: IOException) {  // connection early close possibly due to resolving timeout
+                    return@use Timber.d(e)
                 }
-            }?.let { r ->
                 try {
-                    val response = ByteBuffer.allocate(1024)
-                    response.clear()
-                    response.put(r)
-                    response.flip()
-                    channel.send(response, sender)
-                } catch (e: IOException) {
-                    Timber.d(e.readableMessage)
+                    resolver(query)
+                } catch (e: Exception) {
+                    when (e) {
+                        is TimeoutCancellationException -> Timber.w("Resolving timed out")
+                        is CancellationException -> { } // ignore
+                        is IOException -> Timber.d(e)
+                        else -> Timber.w(e)
+                    }
+                    try {
+                        DnsResolverCompat.prepareDnsResponse(Message(query)).apply {
+                            header.rcode = Rcode.SERVFAIL
+                        }.toWire()
+                    } catch (_: IOException) {
+                        byteArrayOf()   // return empty if cannot parse packet
+                    }
+                }?.let { response ->
+                    try {
+                        val output = DataOutputStream(socket.outputStream)
+                        output.writeShort(response.size)
+                        output.write(response)
+                    } catch (e: IOException) {
+                        Timber.d(e.readableMessage)
+                    }
                 }
             }
         }

core/src/main/java/com/github/shadowsocks/bg/ProxyInstance.kt

@@ -91,7 +91,7 @@ class ProxyInstance(val profile: Profile, private val route: String = profile.ro
         }.let { dns ->
             cmd += arrayListOf(
                     "--dns-addr", "${DataStore.listenAddress}:${DataStore.portLocalDns}",
-                    "--local-dns-addr", "127.0.0.1:${DataStore.portLocalDns + 1}",
+                    "--local-dns-addr", "local_dns_path",
                     "--remote-dns-addr", "${dns.host ?: "0.0.0.0"}:${if (dns.port < 0) 53 else dns.port}")
         }
 

core/src/main/res/values/arrays.xml

@@ -16,6 +16,7 @@
         <item>AES-128-GCM</item>
         <item>AES-256-GCM</item>
         <item>CHACHA20-IETF-POLY1305</item>
+        <item>XCHACHA20-IETF-POLY1305</item>
     </string-array>
 
     <string-array name="enc_method_value" translatable="false">
@@ -34,6 +35,7 @@
         <item>aes-128-gcm</item>
         <item>aes-256-gcm</item>
         <item>chacha20-ietf-poly1305</item>
+        <item>xchacha20-ietf-poly1305</item>
     </string-array>
 
     <string-array name="bypass_private_route" translatable="false">