fix: don't emit user_id-only DNS rules for non-domain routes

Author: starifly

app/src/main/java/io/nekohasekai/sagernet/fmt/ConfigBuilder.kt

@@ -731,8 +731,31 @@ fun buildConfig(
                         return DNSRule_DefaultOptions().apply {
                             if (uidList.isNotEmpty()) user_id = uidList
                             domainList?.let { makeSingBoxRule(it) }
-                            
-                            val nonIpRulesets = mutableListOf<String>()
+                        }
+                    }
+
+                    val hasDomainCriteria = !domainList.isNullOrEmpty()
+                    val hasIpCriteria =
+                        rule.ip.isNotBlank() || rulesetTags.any { it.second }
+                    val hasDomainRuleset = rulesetTags.any { !it.second }
+                    val isAppOnlyDns =
+                        uidList.isNotEmpty() &&
+                            !hasDomainCriteria &&
+                            !hasIpCriteria &&
+                            !hasDomainRuleset &&
+                            rule.port.isBlank() &&
+                            rule.sourcePort.isBlank() &&
+                            rule.network.isBlank() &&
+                            rule.source.isBlank() &&
+                            rule.protocol.isBlank()
+                    val shouldAddDnsRule = hasDomainCriteria || isAppOnlyDns
+
+                    when (rule.outbound) {
+                        -1L -> {
+                            if (shouldAddDnsRule) {
+                                userDNSRuleList += makeDnsRuleObj().apply { server = "dns-direct" }
+                            }
+
                             if (rule_set != null && rulesetTags.isNotEmpty()) {
                                 for (tag in rule_set) {
                                     val tagInfo = rulesetTags.find { it.first == tag }
@@ -752,21 +775,59 @@ fun buildConfig(
                             userDNSRuleList += makeDnsRuleObj().apply { server = "dns-direct" }
                         }
 
-                        -2L -> {
-                            userDNSRuleList += makeDnsRuleObj().apply {
-                                server = "dns-block"
-                                disable_cache = true
+                        0L -> {
+                            if (shouldAddDnsRule) {
+                                if (useFakeDns) userDNSRuleList += makeDnsRuleObj().apply {
+                                    server = "dns-fake"
+                                    inbound = listOf("tun-in")
+                                    query_type = listOf("A", "AAAA")
+                                } else {
+                                    userDNSRuleList += makeDnsRuleObj().apply {
+                                        server = "dns-remote"
+                                    }
+                                }
+                            }
+
+                            if (rule_set != null && rulesetTags.isNotEmpty()) {
+                                for (tag in rule_set) {
+                                    val tagInfo = rulesetTags.find { it.first == tag }
+                                    if (tag.startsWith("ruleset-") && tagInfo != null && !tagInfo.second) {
+                                        if (useFakeDns) {
+                                            userDNSRuleList += DNSRule_DefaultOptions().apply {
+                                                rule_set = mutableListOf(tag)
+                                                server = "dns-fake"
+                                                inbound = listOf("tun-in")
+                                                query_type = listOf("A", "AAAA")
+                                            }
+                                        } else {
+                                            userDNSRuleList += DNSRule_DefaultOptions().apply {
+                                                rule_set = mutableListOf(tag)
+                                                server = "dns-remote"
+                                            }
+                                        }
+                                    }
+                                }
                             }
                         }
 
-                        else -> {
-                            if (useFakeDns) userDNSRuleList += makeDnsRuleObj().apply {
-                                server = "dns-fake"
-                                inbound = listOf("tun-in")
-                                query_type = listOf("A", "AAAA")
-                            } else {
+                        -2L -> {
+                            if (shouldAddDnsRule) {
                                 userDNSRuleList += makeDnsRuleObj().apply {
-                                    server = "dns-remote"
+                                    server = "dns-block"
+                                    disable_cache = true
+                                }
+                            }
+
+                            if (rule_set != null && rulesetTags.isNotEmpty()) {
+                                for (tag in rule_set) {
+                                    val tagInfo = rulesetTags.find { it.first == tag }
+                                    if (tag.startsWith("ruleset-") && tagInfo != null && !tagInfo.second) {
+                                        userDNSRuleList += DNSRule_DefaultOptions().apply {
+                                            rule_set = mutableListOf(tag)
+                                            server = "dns-block"
+                                            disable_cache = true
+                                        }
+                                    }
                                 }
                             }
                         }