Use to_owned on string slices, and other small cleanups

mullvad-encrypted-dns-proxy/examples/forwarder.rs

@@ -10,10 +10,10 @@ use tokio::net::TcpListener;
 async fn main() {
     env_logger::init();
 
-    let bind_addr = args().nth(1).unwrap_or("127.0.0.1:0".to_string());
+    let bind_addr = args().nth(1).unwrap_or("127.0.0.1:0".to_owned());
 
     let configs =
-        config_resolver::resolve_configs(config_resolver::default_resolvers(), "frakta.eu")
+        config_resolver::resolve_configs(&config_resolver::default_resolvers(), "frakta.eu")
             .await
             .expect("Failed to resolve configs");
 

mullvad-encrypted-dns-proxy/src/config_resolver.rs

@@ -6,6 +6,9 @@ use hickory_resolver::{config::*, error::ResolveError, TokioAsyncResolver};
 use rustls::ClientConfig;
 use std::{net::IpAddr, sync::Arc};
 
+/// The port to connect to the DoH resolvers over.
+const RESOLVER_PORT: u16 = 443;
+
 pub struct Nameserver {
     pub name: String,
     pub addr: Vec<IpAddr>,
@@ -30,15 +33,15 @@ impl std::error::Error for ResolutionError {
 pub fn default_resolvers() -> Vec<Nameserver> {
     vec![
         Nameserver {
-            name: "one.one.one.one".to_string(),
+            name: "one.one.one.one".to_owned(),
             addr: vec!["1.1.1.1".parse().unwrap(), "1.0.0.1".parse().unwrap()],
         },
         Nameserver {
-            name: "dns.google".to_string(),
+            name: "dns.google".to_owned(),
             addr: vec!["8.8.8.8".parse().unwrap(), "8.8.4.4".parse().unwrap()],
         },
         Nameserver {
-            name: "dns.quad9.net".to_string(),
+            name: "dns.quad9.net".to_owned(),
             addr: vec![
                 "9.9.9.9".parse().unwrap(),
                 "149.112.112.112".parse().unwrap(),
@@ -50,14 +53,18 @@ pub fn default_resolvers() -> Vec<Nameserver> {
 /// Look up the `domain` towards the given `resolvers`, and try to deserialize all the returned
 /// AAAA records into [`ProxyConfig`](config::ProxyConfig)s.
 pub async fn resolve_configs(
-    resolvers: Vec<Nameserver>,
+    resolvers: &[Nameserver],
     domain: &str,
 ) -> Result<Vec<config::ProxyConfig>, ResolutionError> {
     let mut resolver_config = ResolverConfig::new();
-    for resolver in resolvers.into_iter() {
-        let ns_config_group =
-            NameServerConfigGroup::from_ips_https(&resolver.addr, 443, resolver.name, false)
-                .into_inner();
+    for resolver in resolvers.iter() {
+        let ns_config_group = NameServerConfigGroup::from_ips_https(
+            &resolver.addr,
+            RESOLVER_PORT,
+            resolver.name.clone(),
+            false,
+        )
+        .into_inner();
         for ns_config in ns_config_group {
             resolver_config.add_name_server(ns_config);
         }
@@ -120,10 +127,10 @@ fn client_config_tls12() -> ClientConfig {
 async fn test_resolution() {
     let nameservers = vec![Nameserver {
         addr: vec!["1.1.1.1".parse().unwrap()],
-        name: "one.one.one.one".to_string(),
+        name: "one.one.one.one".to_owned(),
     }];
 
-    let _ = resolve_configs(nameservers, "frakta.eu").await.unwrap();
+    let _ = resolve_configs(&nameservers, "frakta.eu").await.unwrap();
 }
 
 #[cfg(test)]