chore: Merge resolver service into client service

src/service/client/dns.rs

@@ -0,0 +1,111 @@
+use std::{net::SocketAddr, sync::Arc, time::Duration};
+
+use conduwuit::{Result, Server, err};
+use futures::FutureExt;
+use hickory_resolver::{
+	TokioResolver, config::ConnectionConfig, lookup_ip::LookupIp,
+	net::runtime::TokioRuntimeProvider,
+};
+use reqwest::dns::{Addrs, Name, Resolve, Resolving};
+
+pub struct Resolver {
+	pub(crate) resolver: Arc<TokioResolver>,
+	server: Arc<Server>,
+}
+
+type ResolvingResult = Result<Addrs, Box<dyn std::error::Error + Send + Sync>>;
+
+impl Resolver {
+	#[allow(clippy::as_conversions, clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+	pub(super) fn build(server: &Arc<Server>) -> Result<Arc<Self>> {
+		let config = &server.config;
+		let (sys_conf, mut opts) = hickory_resolver::system_conf::read_system_conf()
+			.map_err(|e| err!(error!("Failed to configure DNS resolver from system: {e}")))?;
+
+		let mut conf = hickory_resolver::config::ResolverConfig::default();
+
+		if let Some(domain) = sys_conf.domain() {
+			conf.set_domain(domain.clone());
+		}
+
+		for sys_conf in sys_conf.search() {
+			conf.add_search(sys_conf.clone());
+		}
+
+		for sys_conf in sys_conf.name_servers() {
+			let mut ns = sys_conf.clone();
+
+			if config.query_over_tcp_only {
+				ns.connections = vec![ConnectionConfig::tcp()];
+			}
+
+			ns.trust_negative_responses = !config.query_all_nameservers;
+
+			conf.add_name_server(ns);
+		}
+
+		opts.cache_size = u64::from(config.dns_cache_entries);
+		opts.preserve_intermediates = true;
+		opts.negative_min_ttl = Some(Duration::from_secs(config.dns_min_ttl_nxdomain));
+		opts.negative_max_ttl = Some(Duration::from_hours(720));
+		opts.positive_min_ttl = Some(Duration::from_secs(config.dns_min_ttl));
+		opts.positive_max_ttl = Some(Duration::from_hours(168));
+		opts.timeout = Duration::from_secs(config.dns_timeout);
+		opts.attempts = config.dns_attempts as usize;
+		opts.try_tcp_on_error = config.dns_tcp_fallback;
+		opts.num_concurrent_reqs = 1;
+		opts.edns0 = true;
+		opts.case_randomization = true;
+		opts.ip_strategy = match config.ip_lookup_strategy {
+			| 1 => hickory_resolver::config::LookupIpStrategy::Ipv4Only,
+			| 2 => hickory_resolver::config::LookupIpStrategy::Ipv6Only,
+			| 3 => hickory_resolver::config::LookupIpStrategy::Ipv4AndIpv6,
+			| 4 => hickory_resolver::config::LookupIpStrategy::Ipv6thenIpv4,
+			| _ => hickory_resolver::config::LookupIpStrategy::Ipv4thenIpv6,
+		};
+
+		let runtime_provider = TokioRuntimeProvider::new();
+		let mut builder = TokioResolver::builder_with_config(conf, runtime_provider);
+		*builder.options_mut() = opts;
+		let resolver = Arc::new(builder.build().expect("failed to build resolver :("));
+
+		Ok(Arc::new(Self {
+			resolver: resolver.clone(),
+			server: server.clone(),
+		}))
+	}
+
+	/// Clear the in-memory hickory-dns caches
+	#[inline]
+	pub fn clear_cache(&self) { self.resolver.clear_cache(); }
+}
+
+impl Resolve for Resolver {
+	fn resolve(&self, name: Name) -> Resolving {
+		resolve_to_reqwest(self.server.clone(), self.resolver.clone(), name).boxed()
+	}
+}
+
+async fn resolve_to_reqwest(
+	server: Arc<Server>,
+	resolver: Arc<TokioResolver>,
+	name: Name,
+) -> ResolvingResult {
+	use std::{io, io::ErrorKind::Interrupted};
+
+	let handle_shutdown = || Box::new(io::Error::new(Interrupted, "Server shutting down"));
+	let handle_results = |results: LookupIp| {
+		Box::new(
+			results
+				.iter()
+				.collect::<Vec<_>>()
+				.into_iter()
+				.map(|ip| SocketAddr::new(ip, 0)),
+		)
+	};
+
+	tokio::select! {
+		results = resolver.lookup_ip(name.as_str()) => Ok(handle_results(results?)),
+		() = server.until_shutdown() => Err(handle_shutdown()),
+	}
+}

src/service/client/mod.rs

@@ -1,13 +1,20 @@
+mod dns;
+
 use std::{sync::Arc, time::Duration};
 
+use async_trait::async_trait;
 use conduwuit::{Config, Result, err, trace};
 use either::Either;
 use ipaddress::IPAddress;
 use reqwest::redirect;
+use resolvematrix::server::{MatrixResolver, MatrixResolverBuilder};
 
-use crate::{resolver, service};
+use crate::{client::dns::Resolver, service};
 
 pub struct Service {
+	pub resolver: MatrixResolver,
+	pub dns: Arc<Resolver>,
+
 	pub default: reqwest::Client,
 	pub url_preview: reqwest::Client,
 	pub extern_media: reqwest::Client,
@@ -20,10 +27,24 @@ pub struct Service {
 	pub cidr_range_denylist: Vec<IPAddress>,
 }
 
+#[async_trait]
 impl crate::Service for Service {
 	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
 		let config = &args.server.config;
-		let resolver = args.require::<resolver::Service>("resolver");
+		let dns = Resolver::build(args.server)?;
+		let resolver = MatrixResolverBuilder::new()
+			.dangerous_tls_accept_invalid_certs(args.server.config.allow_invalid_tls_certificates_yes_i_know_what_the_fuck_i_am_doing_with_this_and_i_know_this_is_insecure)
+			.http_client(
+				base(&args.server.config)?
+					.connect_timeout(Duration::from_secs(args.server.config.well_known_conn_timeout))
+					.read_timeout(Duration::from_secs(args.server.config.well_known_timeout))
+					.timeout(Duration::from_secs(args.server.config.well_known_timeout))
+					.pool_max_idle_per_host(0)
+					.redirect(redirect::Policy::limited(4))
+					.build()?
+			)
+			.dns_resolver(dns.resolver.clone())
+			.build()?;
 
 		let url_preview_bind_addr = config
 			.url_preview_bound_interface
@@ -41,28 +62,29 @@ impl crate::Service for Service {
 			.unwrap_or_else(|| conduwuit::user_agent_media().to_owned());
 
 		Ok(Arc::new(Self {
-			default: base(config)?
-				.dns_resolver(resolver.dns.resolver.clone())
-				.build()?,
+			resolver,
+			dns: dns.clone(),
+
+			default: base(config)?.dns_resolver(dns.clone()).build()?,
 
 			url_preview: base(config)
 				.and_then(|builder| {
 					builder_interface(builder, url_preview_bind_iface.as_deref())
 				})?
 				.local_address(url_preview_bind_addr)
-				.dns_resolver(resolver.dns.resolver.clone())
+				.dns_resolver(dns.clone())
 				.timeout(Duration::from_secs(config.url_preview_timeout))
 				.redirect(redirect::Policy::limited(3))
 				.user_agent(url_preview_user_agent)
 				.build()?,
 
 			extern_media: base(config)?
-				.dns_resolver(resolver.dns.resolver.clone())
+				.dns_resolver(dns.clone())
 				.redirect(redirect::Policy::limited(3))
 				.build()?,
 
 			federation: base(config)?
-				.dns_resolver(resolver.dns.resolver.hooked.clone())
+				.dns_resolver(dns.clone())
 				.connect_timeout(Duration::from_secs(config.federation_conn_timeout))
 				.read_timeout(Duration::from_secs(config.federation_timeout))
 				.timeout(Duration::from_secs(
@@ -76,7 +98,7 @@ impl crate::Service for Service {
 				.build()?,
 
 			federation_slow: base(config)?
-				.dns_resolver(resolver.dns.resolver.hooked.clone())
+				.dns_resolver(dns.clone())
 				.connect_timeout(Duration::from_secs(config.federation_conn_timeout))
 				.read_timeout(Duration::from_secs(config.federation_timeout.saturating_mul(6)))
 				.timeout(Duration::from_secs(
@@ -90,7 +112,7 @@ impl crate::Service for Service {
 				.build()?,
 
 			sender: base(config)?
-				.dns_resolver(resolver.dns.resolver.hooked.clone())
+				.dns_resolver(dns.clone())
 				.connect_timeout(Duration::from_secs(config.federation_conn_timeout))
 				.read_timeout(Duration::from_secs(config.sender_timeout))
 				.timeout(Duration::from_secs(config.sender_timeout))
@@ -100,7 +122,7 @@ impl crate::Service for Service {
 				.build()?,
 
 			appservice: base(config)?
-				.dns_resolver(resolver.dns.resolver.clone())
+				.dns_resolver(dns.clone())
 				.connect_timeout(Duration::from_secs(5))
 				.read_timeout(Duration::from_secs(config.appservice_timeout))
 				.timeout(Duration::from_secs(config.appservice_timeout))
@@ -110,7 +132,7 @@ impl crate::Service for Service {
 				.build()?,
 
 			pusher: base(config)?
-				.dns_resolver(resolver.dns.resolver.clone())
+				.dns_resolver(dns.clone())
 				.connect_timeout(Duration::from_secs(config.pusher_conn_timeout))
 				.timeout(Duration::from_secs(config.pusher_timeout))
 				.pool_max_idle_per_host(1)
@@ -128,6 +150,11 @@ impl crate::Service for Service {
 		}))
 	}
 
+	async fn clear_cache(&self) {
+		self.resolver.clear_cache();
+		self.dns.resolver.clear_cache();
+	}
+
 	fn name(&self) -> &str { service::make_name(std::module_path!()) }
 }