Proper dns configuration!

src/config/dns.rs

@@ -6,13 +6,18 @@ use std::collections::HashMap;
 use std::net::SocketAddr;
 
 #[derive(Deserialize, Clone)]
+#[serde(default)]
 pub struct DnsConfig {
 	pub allow_forward_lookup: bool,
 	pub allow_reverse_lookup: bool,
 	pub hidden_suffixes: Vec<String>,
-	#[serde(default="default_dns_resolver_name")]
-	pub default_resolver: String,
+	pub search: Vec<String>,
 	pub resolver: HashMap<String,DnsResolverConfig>,
+
+	pub enable_system_resolver: bool,
+	pub system_resolver_name: String,
+	pub system_resolver_weight: i32,
+	pub system_resolver_id: String,
 }
 
 #[derive(Deserialize, Serialize, Clone)]
@@ -25,10 +30,6 @@ pub enum DnsProtocol {
 	Quic,
 }
 
-pub fn default_dns_resolver_name() -> String {
-	"default".to_string()
-}
-
 #[derive(Deserialize, Serialize, Clone)]
 pub struct DnsResolverConfig {
 	pub display_name: String,
@@ -63,8 +64,13 @@ impl Default for DnsConfig {
 			allow_forward_lookup: true,
 			allow_reverse_lookup: false,
 			hidden_suffixes: Vec::new(),
-			default_resolver: "default".to_string(),
 			resolver: Default::default(),
+			search: Vec::new(),
+
+			enable_system_resolver: true,
+			system_resolver_name: "System".to_string(),
+			system_resolver_weight: 1000,
+			system_resolver_id: "system".to_string(),
 		}
 	}
 }

src/main.rs

@@ -103,6 +103,7 @@ struct ServiceSharedState {
 #[derive(Clone)]
 struct DerivedConfiguration {
 	dns_resolver_selectables: Vec<Selectable>,
+	default_resolver: String,
 }
 
 #[derive(Parser)]
@@ -228,61 +229,30 @@ async fn main() {
 	location_db.reload_database().ok();
 	
 	// Initalize DNS resolver with os defaults
-	println!("Initalizing dns resolver ...");
+	println!("Initalizing dns resolvers ...");
 
 	let mut dns_resolver_selectables = Vec::<Selectable>::new();
-
-	println!("Initalizing System resolver ...");
-	let res = TokioAsyncResolver::tokio_from_system_conf();
-	//let res = TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());
-	let dns_resolver = match res {
-		Ok(resolver) => resolver,
-		Err(e) => {
-			println!("Error while setting up dns resolver: {e}");
-			::std::process::exit(1);
-		}
-	};
-
-	dns_resolver_selectables.push(Selectable {
-		id: "default".to_string(),
-		name: "System".to_string(),
-		weight: 1000,
-	});
-
-	//FIXME: Not release ready,must be configurable and have better error handling.
-	println!("Initalizing Quad9 resolver ...");
-	let quad9_resolver = TokioAsyncResolver::tokio(
-		trust_dns_resolver::config::ResolverConfig::quad9_tls(),
-		Default::default()
-	).unwrap();
-	dns_resolver_selectables.push(Selectable {
-		id: "quad9".to_string(),
-		name: "Quad9".to_string(),
-		weight: 500
-	});
-	println!("Initalizing Google resolver ...");
-	let google_resolver = TokioAsyncResolver::tokio(
-		trust_dns_resolver::config::ResolverConfig::google(),
-		Default::default()
-	).unwrap();
-	dns_resolver_selectables.push(Selectable {
-		id: "google".to_string(),
-		name: "Google".to_string(),
-		weight: 10,
-	});
-	println!("Initalizing Cloudflare resolver ...");
-	let cloudflare_resolver = TokioAsyncResolver::tokio(
-		trust_dns_resolver::config::ResolverConfig::cloudflare_tls(),
-		Default::default()
-	).unwrap();
-	dns_resolver_selectables.push(Selectable {
-		id: "cloudflare".to_string(),
-		name: "Cloudflare".to_string(),
-		weight: 20,
-	});
-
 	let mut dns_resolver_map: HashMap<String,TokioAsyncResolver> = HashMap::new();
 
+	if config.dns.enable_system_resolver {
+		println!("Initalizing System resolver ...");
+		let res = TokioAsyncResolver::tokio_from_system_conf();
+		let resolver = match res {
+			Ok(resolver) => resolver,
+			Err(e) => {
+				println!("Error while setting up dns resolver: {e}");
+				::std::process::exit(1);
+			}
+		};
+
+		dns_resolver_map.insert(config.dns.system_resolver_id.clone(), resolver);
+		dns_resolver_selectables.push(Selectable {
+			id: config.dns.system_resolver_id.clone(),
+			name: config.dns.system_resolver_name.clone(),
+			weight: config.dns.system_resolver_weight,
+		});
+	}
+
 	for (key, resolver_config) in &config.dns.resolver {
 		println!("Initalizing {} resolver ...", key);
 		let resolver = TokioAsyncResolver::tokio(
@@ -297,11 +267,6 @@ async fn main() {
 		});
 	}
 	
-	dns_resolver_map.insert("default".to_string(), dns_resolver);
-	dns_resolver_map.insert("quad9".to_string(), quad9_resolver);
-	dns_resolver_map.insert("google".to_string(), google_resolver);
-	dns_resolver_map.insert("cloudflare".to_string(), cloudflare_resolver);
-
 	let listen_on = config.server.listen_on;
 	let ip_header = config.server.ip_header.clone();
 
@@ -317,8 +282,12 @@ async fn main() {
 	});
 
 	dns_resolver_selectables.sort_by(|a,b| b.weight.cmp(&a.weight));
+	let default_resolver = dns_resolver_selectables.get(0)
+		.map(|s| s.id.clone() )
+		.unwrap_or("none".to_string());
 	let derived_config = DerivedConfiguration {
 		dns_resolver_selectables: dns_resolver_selectables,
+		default_resolver: default_resolver,
 	};
 
 	let signal_usr1_handlers_state = shared_state.clone();
@@ -386,7 +355,7 @@ async fn settings_query_middleware<B>(
 	next: Next<B>
 ) -> Response {
 	let mut format = query.format;
-	let mut dns_resolver_id = config.dns.default_resolver;
+	let mut dns_resolver_id = derived_config.default_resolver;
 
 	if let Some(resolver_id) = query.dns {
 		dns_resolver_id = resolver_id;