Add setup readiness checks

Add a pre-connect setup readiness action that checks required profile fields, resolver input, local port availability, LAN proxy safety rules, and advisory server address lookup before the user starts a connection.

Expose resolver test parallelism presets for 32, 64, 100, and 128 worker budgets while keeping custom expert values available.

Add model tests for setup validation, SOCKS credential normalization, resolver parallelism presets, and multi-domain normalization.

Author: AmirrezaFarnamTaheri

app/src/main/java/shop/whitedns/client/MainActivity.kt

@@ -123,6 +123,7 @@ class MainActivity : ComponentActivity() {
                             ConnectionStatus.CONNECTED -> viewModel.disconnect()
                         }
                     },
+                    onTestProfileClick = viewModel::testCurrentProfileReadiness,
                     onScanFileSelected = viewModel::beginScanFromFile,
                     onScanDefaultListSelected = viewModel::beginScanFromDefaultResolvers,
                     onScanStartClick = viewModel::startPreparedScan,

app/src/main/java/shop/whitedns/client/model/WhiteDnsModels.kt

@@ -224,6 +224,30 @@ data class ResolverTextValidation(
         get() = normalizedResolvers.isNotEmpty() && invalidEntries.isEmpty()
 }
 
+object WhiteDnsValidationSeverity {
+    const val Fatal = "fatal"
+    const val Warning = "warning"
+}
+
+data class WhiteDnsValidationIssue(
+    val severity: String,
+    val field: String,
+    val message: String,
+)
+
+data class WhiteDnsSettingsValidation(
+    val issues: List<WhiteDnsValidationIssue>,
+) {
+    val fatalIssues: List<WhiteDnsValidationIssue>
+        get() = issues.filter { it.severity == WhiteDnsValidationSeverity.Fatal }
+
+    val warnings: List<WhiteDnsValidationIssue>
+        get() = issues.filter { it.severity == WhiteDnsValidationSeverity.Warning }
+
+    val canConnect: Boolean
+        get() = fatalIssues.isEmpty()
+}
+
 data class WhiteDnsSettings(
     val selectedConnectionProfileId: String = ConnectionProfile.DefaultId,
     val connectionProfiles: List<ConnectionProfile> = listOf(ConnectionProfile.defaultProfile()),
@@ -513,6 +537,7 @@ data class WhiteDnsUiState(
     val connectionStats: ConnectionStats = ConnectionStats(),
     val resolverRuntimeState: ResolverRuntimeState = ResolverRuntimeState(),
     val connectionProgress: ConnectionProgressState = ConnectionProgressState(),
+    val profileReadiness: ConnectionVerificationState = ConnectionVerificationState(),
     val connectionVerification: ConnectionVerificationState = ConnectionVerificationState(),
     val autoTuneTrialResults: List<AutoTuneTrialResult> = emptyList(),
     val scanState: WhiteDnsScanState = WhiteDnsScanState(),
@@ -534,12 +559,21 @@ object WhiteDnsOptions {
     const val SplitTunnelModeOff = "off"
     const val SplitTunnelModeInclude = "include"
     const val SplitTunnelModeExclude = "exclude"
+    const val ResolverTestParallelismCustom = "custom"
 
     val connectionModes = listOf(
         Choice("proxy", "Proxy Mode"),
         Choice("vpn", "Full VPN"),
     )
 
+    val resolverTestParallelismPresets = listOf(
+        Choice("32", "32 - Light"),
+        Choice("64", "64 - Balanced"),
+        Choice("100", "100 - Current"),
+        Choice("128", "128 - Deep"),
+        Choice(ResolverTestParallelismCustom, "Custom"),
+    )
+
     val themeModes = listOf(
         Choice(WhiteDnsThemeMode.System, "Auto"),
         Choice(WhiteDnsThemeMode.Light, "Light"),
@@ -603,6 +637,14 @@ object WhiteDnsOptions {
     fun splitTunnelModeLabel(mode: String): String {
         return splitTunnelModes.firstOrNull { it.value == mode }?.label ?: "All Apps"
     }
+
+    fun resolverTestParallelismPreset(value: String): String {
+        val trimmed = value.trim()
+        return resolverTestParallelismPresets
+            .firstOrNull { choice -> choice.value == trimmed }
+            ?.value
+            ?: ResolverTestParallelismCustom
+    }
 }
 
 fun WhiteDnsSettings.normalizedConnectionProfiles(): List<ConnectionProfile> {
@@ -1458,8 +1500,10 @@ private enum class ResolverTextEntryType {
 }
 
 private const val DefaultResolverPort = 53
+private const val MaxRecommendedResolvers = 256
 
 private val ResolverIpv6Chars = Regex("^[0-9A-Fa-f:.]+$")
+private val ServerDomainLabelRegex = Regex("^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$")
 
 private fun normalizeSplitTunnelMode(raw: String): String {
     return when (raw) {
@@ -1487,6 +1531,24 @@ private fun normalizeThemeMode(raw: String): String {
     }
 }
 
+fun normalizeServerDomainText(raw: String): String {
+    return normalizeServerDomains(raw).joinToString(separator = "\n")
+}
+
+fun normalizeServerDomains(raw: String): List<String> {
+    return raw
+        .replace("[", " ")
+        .replace("]", " ")
+        .replace("\"", " ")
+        .replace("'", " ")
+        .split(Regex("[,;\\s]+"))
+        .asSequence()
+        .map { it.trim().trimEnd('.') }
+        .filter(String::isNotEmpty)
+        .distinct()
+        .toList()
+}
+
 private fun normalizePackageNames(raw: List<String>): List<String> {
     return raw
         .asSequence()
@@ -1497,6 +1559,142 @@ private fun normalizePackageNames(raw: List<String>): List<String> {
         .toList()
 }
 
+fun validateConnectionSettings(settings: WhiteDnsSettings): WhiteDnsSettingsValidation {
+    val normalizedSettings = settings.syncSelectedConnectionProfileFields()
+    val runtimeSettings = normalizedSettings.runtimeConnectionSettings()
+    val resolvedSettings = runtimeSettings.resolve()
+    val connectionProfile = normalizedSettings.selectedConnectionProfile()
+    val resolverValidation = validateResolverText(runtimeSettings.resolverText)
+    val issues = mutableListOf<WhiteDnsValidationIssue>()
+
+    fun fatal(field: String, message: String) {
+        issues += WhiteDnsValidationIssue(WhiteDnsValidationSeverity.Fatal, field, message)
+    }
+
+    fun warning(field: String, message: String) {
+        issues += WhiteDnsValidationIssue(WhiteDnsValidationSeverity.Warning, field, message)
+    }
+
+    val serverDomains = normalizeServerDomains(connectionProfile.customServerDomain)
+    if (serverDomains.isEmpty() || connectionProfile.customServerEncryptionKey.isBlank()) {
+        fatal("server", "Custom StormDNS domain and encryption key are required")
+    } else if (serverDomains.any { !isValidServerDomain(it) }) {
+        fatal("server", "One or more custom StormDNS domains are not valid")
+    }
+
+    if (resolverValidation.normalizedResolvers.isEmpty()) {
+        fatal("resolvers", "Resolvers are required to connect")
+    }
+    if (resolverValidation.invalidEntries.isNotEmpty()) {
+        fatal("resolvers", "Resolver list contains invalid entries")
+    }
+    if (resolverValidation.normalizedResolvers.size > MaxRecommendedResolvers) {
+        warning("resolvers", "Large resolver lists can slow startup and increase battery use")
+    }
+
+    validatePortText(runtimeSettings.listenPort, "listenPort", "SOCKS listen port") { field, message ->
+        fatal(field, message)
+    }
+    if (runtimeSettings.httpProxyEnabled) {
+        validatePortText(runtimeSettings.httpProxyPort, "httpProxyPort", "HTTP proxy port") { field, message ->
+            fatal(field, message)
+        }
+        if (resolvedSettings.httpProxyPort == resolvedSettings.listenPort) {
+            fatal("httpProxyPort", "HTTP proxy port must differ from the SOCKS listen port")
+        }
+    }
+    if (runtimeSettings.localDnsEnabled) {
+        validatePortText(runtimeSettings.localDnsPort, "localDnsPort", "Local DNS port") { field, message ->
+            fatal(field, message)
+        }
+    }
+    if (runtimeSettings.localDnsEnabled && resolvedSettings.localDnsPort == resolvedSettings.listenPort) {
+        fatal("localDnsPort", "Local DNS port must differ from the SOCKS listen port")
+    }
+    if (runtimeSettings.localDnsEnabled && runtimeSettings.httpProxyEnabled &&
+        resolvedSettings.localDnsPort == resolvedSettings.httpProxyPort
+    ) {
+        fatal("localDnsPort", "Local DNS port must differ from the HTTP proxy port")
+    }
+
+    if (
+        resolvedSettings.connectionMode == "proxy" &&
+        isLanReachableListenIp(resolvedSettings.listenIp) &&
+        !hasCompleteSocksCredentials(
+            enabled = resolvedSettings.socks5Authentication,
+            username = resolvedSettings.socksUsername,
+            password = resolvedSettings.socksPassword,
+        )
+    ) {
+        fatal("socks5Authentication", "LAN-reachable proxy requires a SOCKS5 username and password")
+    }
+
+    if (resolvedSettings.rxTxWorkers > 32 || resolvedSettings.tunnelProcessWorkers > 32) {
+        warning("workers", "High worker counts can increase CPU and battery use")
+    }
+    if (resolvedSettings.mtuTestParallelismResolvers > 128) {
+        warning("resolverTestParallelism", "Very high resolver test parallelism can increase upload, CPU, and battery use")
+    }
+    if (resolvedSettings.txChannelSize > 8192 || resolvedSettings.rxChannelSize > 8192) {
+        warning("queues", "Large queues can increase memory use")
+    }
+    if (resolvedSettings.maxUploadMtu < resolvedSettings.minUploadMtu ||
+        resolvedSettings.maxDownloadMtu < resolvedSettings.minDownloadMtu
+    ) {
+        fatal("mtu", "Maximum MTU values must be greater than or equal to minimum MTU values")
+    }
+    if (resolvedSettings.localHandshakeTimeoutSeconds < 1.0 ||
+        resolvedSettings.socksUdpAssociateReadTimeoutSeconds < 1.0 ||
+        resolvedSettings.tunnelPacketTimeoutSeconds < 1.0
+    ) {
+        warning("timeouts", "Very short runtime timeouts can cause unstable connections")
+    }
+
+    return WhiteDnsSettingsValidation(issues)
+}
+
+private fun validatePortText(
+    raw: String,
+    field: String,
+    label: String,
+    fatal: (String, String) -> Unit,
+) {
+    val port = raw.trim().toIntOrNull()
+    if (port == null || port !in 1..65535) {
+        fatal(field, "$label must be between 1 and 65535")
+    }
+}
+
+private fun isValidServerDomain(raw: String): Boolean {
+    val domain = raw.trim().trimEnd('.')
+    if (domain.isBlank() || domain.length > 253 || domain.any(Char::isWhitespace)) {
+        return false
+    }
+    if (domain.startsWith("[") && domain.endsWith("]")) {
+        return domain.length > 2
+    }
+    return domain.split('.').all { label ->
+        label.isNotBlank() && ServerDomainLabelRegex.matches(label)
+    }
+}
+
+private fun isLanReachableListenIp(raw: String): Boolean {
+    val value = raw.trim()
+    return value.isNotBlank() &&
+        value != "127.0.0.1" &&
+        value != "localhost" &&
+        value != "::1" &&
+        value != "[::1]"
+}
+
+private fun hasCompleteSocksCredentials(
+    enabled: Boolean,
+    username: String,
+    password: String,
+): Boolean {
+    return enabled && username.isNotBlank() && password.isNotBlank()
+}
+
 fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
     fun boundedInt(raw: String, defaultValue: Int, minValue: Int, maxValue: Int): Int {
         return raw.trim().toIntOrNull()?.coerceIn(minValue, maxValue) ?: defaultValue
@@ -1541,6 +1739,11 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
         .coerceAtLeast(resolvedMinUploadMtu)
     val resolvedMaxDownloadMtu = boundedInt(maxDownloadMtu, defaultValue = 3000, minValue = 1, maxValue = 65535)
         .coerceAtLeast(resolvedMinDownloadMtu)
+    val resolvedSocksUsername = socksUsername.take(255)
+    val resolvedSocksPassword = socksPassword.take(255)
+    val resolvedSocks5Authentication = socks5Authentication &&
+        resolvedSocksUsername.isNotBlank() &&
+        resolvedSocksPassword.isNotBlank()
 
     return ResolvedWhiteDnsSettings(
         connectionMode = when (connectionMode) {
@@ -1553,9 +1756,9 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
         listenPort = boundedInt(listenPort, defaultValue = 10886, minValue = 1, maxValue = 65535),
         httpProxyEnabled = httpProxyEnabled,
         httpProxyPort = boundedInt(httpProxyPort, defaultValue = 10887, minValue = 1, maxValue = 65535),
-        socks5Authentication = socks5Authentication,
-        socksUsername = socksUsername.take(255),
-        socksPassword = socksPassword.take(255),
+        socks5Authentication = resolvedSocks5Authentication,
+        socksUsername = resolvedSocksUsername,
+        socksPassword = resolvedSocksPassword,
         balancingStrategy = listOf(1, 2, 3, 4).firstOrNull { it == balancingStrategy } ?: 3,
         uploadDuplication = boundedInt(uploadDuplication, defaultValue = 3, minValue = 1, maxValue = 30),
         downloadDuplication = boundedInt(downloadDuplication, defaultValue = 7, minValue = 1, maxValue = 30),