{"record":{"id":"c3a91d00fdcabe00","repo":"shadowsocks/shadowsocks-rust","slug":"local-dns-address-invalid","errorCode":null,"errorMessage":"`local_dns_address` invalid","messagePattern":"`local_dns_address` invalid","errorType":"validation","errorClass":null,"httpStatus":null,"severity":"error","filePath":"crates/shadowsocks-service/src/config.rs","lineNumber":1985,"sourceCode":"                        }\n\n                        #[cfg(feature = \"local-dns\")]\n                        if let Some(local_dns_address) = local.local_dns_address {\n                            match local_dns_address.parse::<IpAddr>() {\n                                Ok(ip) => {\n                                    local_config.local_dns_addr = Some(NameServerAddr::SocketAddr(SocketAddr::new(\n                                        ip,\n                                        local.local_dns_port.unwrap_or(53),\n                                    )));\n                                }\n                                #[cfg(unix)]\n                                Err(..) => {\n                                    local_config.local_dns_addr =\n                                        Some(NameServerAddr::UnixSocketAddr(PathBuf::from(local_dns_address)));\n                                }\n                                #[cfg(not(unix))]\n                                Err(..) => {\n                                    let err = Error::new(ErrorKind::Malformed, \"`local_dns_address` invalid\", None);\n                                    return Err(err);\n                                }\n                            }\n                        }\n\n                        #[cfg(feature = \"local-dns\")]\n                        if let Some(client_cache_size) = local.client_cache_size {\n                            local_config.client_cache_size = Some(client_cache_size);\n                        }\n\n                        #[cfg(feature = \"local-dns\")]\n                        if let Some(remote_dns_address) = local.remote_dns_address {\n                            let remote_dns_port = local.remote_dns_port.unwrap_or(53);\n                            local_config.remote_dns_addr = Some(match remote_dns_address.parse::<IpAddr>() {\n                                Ok(ip) => Address::from(SocketAddr::new(ip, remote_dns_port)),\n                                Err(..) => Address::from((remote_dns_address, remote_dns_port)),\n                            });\n                        }","sourceCodeStart":1967,"sourceCodeEnd":2003,"githubUrl":"https://github.com/shadowsocks/shadowsocks-rust/blob/8eb0f0a65b1d976ab6bed5787327ef86529b0435/crates/shadowsocks-service/src/config.rs#L1967-L2003","documentation":"Raised under the `local-dns` feature (and only on non-Unix platforms) when `local_dns_address` cannot be interpreted as a local DNS bind address. On Unix, a failed socket-address parse is treated as a Unix socket path (`NameServerAddr::UnixSocketAddr`); on non-Unix there is no such fallback, so an unparseable value produces this Malformed error.","triggerScenarios":"On Windows/non-Unix: `local_dns_address` set to something that is not a valid SocketAddr, e.g. a Unix socket path like \"/var/run/dns.sock\", or a malformed address like \"127.0.0.1\" (missing port) or \"localhost:53\" (non-IP host).","commonSituations":"Configs moved from Linux (Unix socket DNS address) to Windows; addresses written as hostnames instead of IP:port; missing port in the address string.","solutions":["On non-Unix, set `local_dns_address` to a valid IP:port, e.g. \"127.0.0.1:6533\" (hostname forms are not accepted).","Replace Unix-socket paths with a TCP UDP-capable address when porting configs from Linux.","Include the port explicitly — \"127.0.0.1\" alone will fail to parse as a SocketAddr."],"exampleFix":"// before\n{ \"local_dns_address\": \"127.0.0.1\" }\n// after\n{ \"local_dns_address\": \"127.0.0.1:6533\" }","handlingStrategy":"validation","validationCode":"fn validate_local_dns_address(entry: &serde_json::Value) -> Result<(), String> {\n    if let Some(a) = entry.get(\"local_dns_address\").and_then(|v| v.as_str()) {\n        if a.starts_with('/') {\n            return Err(\"unix socket paths for local_dns_address only work on unix targets\".into());\n        }\n        if a.parse::<std::net::SocketAddr>().is_err() {\n            return Err(format!(\"local_dns_address '{a}' is not a valid IP:port\"));\n        }\n    }\n    Ok(())\n}","typeGuard":"fn is_valid_socket_addr(s: &str) -> bool {\n    s.parse::<std::net::SocketAddr>().is_ok()\n}","tryCatchPattern":"#[cfg(feature = \"local-dns\")]\nmatch LocalConfig::load_from(config_path) {\n    Ok(cfg) => start(cfg),\n    Err(e) if e.to_string().contains(\"local_dns_address\") => {\n        eprintln!(\"Use IP:port for local_dns_address on this platform: {e}\");\n        std::process::exit(1);\n    }\n    Err(e) => return Err(e.into()),\n}","preventionTips":["On non-Unix targets always use IP:port (e.g. 127.0.0.1:6533), never a socket path.","Include the port explicitly; bare IPs will not parse.","When porting Linux configs to Windows/macOS, replace Unix-socket DNS addresses first."],"tags":["config","dns","platform","validation"],"backgroundTag":"invalid-config-value","analyzedSha":"8eb0f0a65b1d976ab6bed5787327ef86529b0435","analyzedAt":"2026-09-09T12:20:43.168Z","contentChangedAt":"2026-09-09T12:20:43.168Z","schemaVersion":2},"datasetVersion":"2026-09-14T11:17:12.474Z"}