Merge pull request #477 from Luap99/rework

rework parts of coredns code

6 files changed, 166 insertions, 188 deletions

diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 7ac691a..1be84a6 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -24,6 +24,9 @@ pub struct DNSBackend {
     pub network_dns_server: HashMap<String, Vec<IpAddr>>,
     // Map of network name to bool (network is/is not internal)
     pub network_is_internal: HashMap<String, bool>,
+
+    // search_domain used by aardvark-dns
+    pub search_domain: String,
 }
 
 pub enum DNSResult {
@@ -48,7 +51,14 @@ impl DNSBackend {
         ctr_dns_server: HashMap<IpAddr, Option<Vec<IpAddr>>>,
         network_dns_server: HashMap<String, Vec<IpAddr>>,
         network_is_internal: HashMap<String, bool>,
+        mut search_domain: String,
     ) -> DNSBackend {
+        // dns request always end with dot so append one for easier compare later
+        if let Some(c) = search_domain.chars().rev().nth(0) {
+            if c != '.' {
+                search_domain.push('.')
+            }
+        }
         DNSBackend {
             ip_mappings: containers,
             name_mappings: networks,
@@ -56,6 +66,7 @@ impl DNSBackend {
             ctr_dns_server,
             network_dns_server,
             network_is_internal,
+            search_domain,
         }
     }
 
@@ -68,6 +79,14 @@ impl DNSBackend {
     pub fn lookup(&self, requester: &IpAddr, entry: &str) -> DNSResult {
         // Normalize lookup entry to lowercase.
         let mut name = entry.to_lowercase();
+
+        // Trim off configured search domain if needed as keys do not contain it.
+        // There doesn't seem to be a nicer way to do that:
+        // https://users.rust-lang.org/t/can-strip-suffix-mutate-a-string-value/86852
+        if name.ends_with(&self.search_domain) {
+            name.truncate(name.len() - self.search_domain.len())
+        }
+
         let nets = match self.ip_mappings.get(requester) {
             Some(n) => n,
             None => return DNSResult::NoSuchIP,
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 0348c33..88a097a 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -21,6 +21,7 @@ pub mod constants;
 #[allow(clippy::type_complexity)]
 pub fn parse_configs(
     dir: &str,
+    filter_search_domain: &str,
 ) -> Result<
     (
         DNSBackend,
@@ -209,6 +210,7 @@ pub fn parse_configs(
             ctr_dns_server,
             network_dns_server,
             network_is_internal,
+            filter_search_domain.to_owned(),
         ),
         listen_ips_4,
         listen_ips_6,
diff --git a/src/dns/coredns.rs b/src/dns/coredns.rs
index 674403e..6062a58 100644
--- a/src/dns/coredns.rs
+++ b/src/dns/coredns.rs
@@ -1,6 +1,7 @@
 use crate::backend::DNSBackend;
 use crate::backend::DNSResult;
 use arc_swap::ArcSwap;
+use arc_swap::Guard;
 use futures_util::StreamExt;
 use futures_util::TryStreamExt;
 use hickory_client::{client::AsyncClient, proto::xfer::SerialMessage, rr::rdata, rr::Name};
@@ -19,6 +20,7 @@ use std::env;
 use std::fs::File;
 use std::io::Read;
 use std::net::{IpAddr, SocketAddr};
+use std::sync::Arc;
 use tokio::net::UdpSocket;
 
 // Containers can be recreated with different ips quickly so
@@ -33,7 +35,6 @@ pub struct CoreDns {
     address: IpAddr,                       // server address
     port: u32,                             // server port
     backend: &'static ArcSwap<DNSBackend>, // server's data store
-    filter_search_domain: String,          // filter_search_domain
     rx: flume::Receiver<()>,               // kill switch receiver
     resolv_conf: resolv_conf::Config,      // host's parsed /etc/resolv.conf
 }
@@ -46,10 +47,7 @@ impl CoreDns {
         address: IpAddr,
         port: u32,
         network_name: String,
-        forward_addr: IpAddr,
-        forward_port: u16,
         backend: &'static ArcSwap<DNSBackend>,
-        filter_search_domain: String,
         rx: flume::Receiver<()>,
     ) -> anyhow::Result<Self> {
         // this does not have to be unique, if we fail getting server name later
@@ -67,11 +65,6 @@ impl CoreDns {
             name = n;
         }
 
-        debug!(
-            "Will Forward dns requests to udp://{:?}:{}",
-            forward_addr, forward_port,
-        );
-
         let mut resolv_conf: resolv_conf::Config = resolv_conf::Config::new();
         let mut buf = Vec::with_capacity(4096);
         if let Ok(mut f) = File::open("/etc/resolv.conf") {
@@ -88,7 +81,6 @@ impl CoreDns {
             address,
             port,
             backend,
-            filter_search_domain,
             rx,
             resolv_conf,
         })
@@ -130,13 +122,15 @@ impl CoreDns {
                             let src_address = msg.addr();
                             let mut dns_resolver = self.resolv_conf.clone();
                             let sender = sender_original.clone().with_remote_addr(src_address);
-                            let (name, record_type, mut req) = match parse_dns_msg(msg) {
+                            let (request_name, record_type, mut req) = match parse_dns_msg(msg) {
                                 Some((name, record_type, req)) => (name, record_type, req),
                                 _ => {
                                     error!("None received while parsing dns message, this is not expected server will ignore this message");
                                     continue;
                                 }
                             };
+                            let request_name_string = request_name.to_string();
+
                             let mut resolved_ip_list: Vec<IpAddr> = Vec::new();
                             let mut nameservers_scoped: Vec<ScopedIp> = Vec::new();
                             // Add resolvers configured for container
@@ -163,7 +157,7 @@ impl CoreDns {
                             trace!("server name: {:?}", self.name.to_ascii());
                             debug!("request source address: {:?}", src_address);
                             trace!("requested record type: {:?}", record_type);
-                            debug!("checking if backend has entry for: {:?}", name);
+                            debug!("checking if backend has entry for: {:?}", &request_name_string);
                             trace!(
                                 "server backend.name_mappings: {:?}",
                                 backend.name_mappings
@@ -173,126 +167,37 @@ impl CoreDns {
 
                             // if record type is PTR try resolving early and return if record found
                             if record_type == RecordType::PTR {
-                                let mut ptr_lookup_ip: String;
-                                // Are we IPv4 or IPv6?
-                                if name.contains(".in-addr.arpa.") {
-                                    // IPv4
-                                    ptr_lookup_ip = name.trim_end_matches(".in-addr.arpa.").split('.').rev().collect::<Vec<&str>>().join(".");
-                                } else if name.contains(".ip6.arpa.") {
-                                    // IPv6
-                                    ptr_lookup_ip = name.trim_end_matches(".ip6.arpa.").split('.').rev().collect::<String>();
-                                    // We removed all periods; now we need to insert a : every 4 characters.
-                                    // split_off() reduces the original string to 4 characters and returns the remainder.
-                                    // So append the 4-character and continue going until we run out of characters.
-                                    let mut split: Vec<String> = Vec::new();
-                                    while ptr_lookup_ip.len() > 4 {
-                                        let tmp = ptr_lookup_ip.split_off(4);
-                                        split.push(ptr_lookup_ip);
-                                        ptr_lookup_ip = tmp;
-                                    }
-                                    // Length should be equal to 4 here, but just use > 0 for safety.
-                                    if !ptr_lookup_ip.is_empty() {
-                                        split.push(ptr_lookup_ip);
-                                    }
-                                    ptr_lookup_ip = split.join(":");
-                                } else {
-                                    // Not a valid address, so force parse() to fail
-                                    // TODO: this is ugly and I don't like it
-                                    ptr_lookup_ip = String::from("not an ip");
+                                if let Some(msg) = reply_ptr(&request_name_string, &backend, src_address, &req) {
+                                    reply(sender, src_address, &msg);
+                                    continue;
                                 }
-
-                                trace!("Performing reverse lookup for ip: {:?}", ptr_lookup_ip.to_owned());
-                                // We should probably log malformed queries, but for now if-let should be fine.
-                                if let Ok(lookup_ip) = ptr_lookup_ip.parse() {
-                                    if let Some(reverse_lookup) = backend.reverse_lookup(&src_address.ip(), &lookup_ip) {
-                                        let mut req_clone = req.clone();
-                                        for entry in reverse_lookup {
-                                            if let Ok(answer) = Name::from_ascii(format!("{}.", entry)) {
-                                                req_clone.add_answer(
-                                                    Record::new()
-                                                        .set_name(Name::from_str_relaxed(&name).unwrap_or_default())
-                                                        .set_ttl(CONTAINER_TTL)
-                                                        .set_rr_type(RecordType::PTR)
-                                                        .set_dns_class(DNSClass::IN)
-                                                        .set_data(Some(RData::PTR(rdata::PTR(answer))))
-                                                        .clone(),
-                                                );
-                                            }
-                                        }
-                                        reply(sender.clone(), src_address, &req_clone);
-                                    }
-                                };
                             }
 
                             // attempt intra network resolution
-                            match backend.lookup(&src_address.ip(), name.as_str()) {
+                            match backend.lookup(&src_address.ip(), &request_name_string) {
                                 // If we go success from backend lookup
                                 DNSResult::Success(_ip_vec) => {
                                     debug!("Found backend lookup");
                                     resolved_ip_list = _ip_vec;
+
                                 }
                                 // For everything else assume the src_address was not in ip_mappings
                                 _ => {
-                                    debug!(
-                                "No backend lookup found, try resolving in current resolvers entry"
-                            );
+                                    debug!("No backend lookup found, try resolving in current resolvers entry");
                                     if let Some(container_mappings) = backend.name_mappings.get(&self.network_name) {
-                                        for (key, value) in container_mappings {
-
-                                            // if query contains search domain, strip it out.
-                                            // Why? This is a workaround so aardvark works well
-                                            // with setup which was created for dnsname/dnsmasq
-
-                                            let mut request_name = name.as_str().to_owned();
-                                            let mut filter_domain_ndots_complete = self.filter_search_domain.to_owned();
-                                            filter_domain_ndots_complete.push('.');
-
-                                            if request_name.ends_with(&self.filter_search_domain) {
-                                                request_name = match request_name.strip_suffix(&self.filter_search_domain) {
-                                                    Some(value) => value.to_string(),
-                                                     _ => {
-                                                        error!("Unable to parse string suffix, ignore parsing this request");
-                                                        continue;
-                                                    }
-                                                };
-                                                request_name.push('.');
-                                            }
-                                            if request_name.ends_with(&filter_domain_ndots_complete) {
-                                                request_name = match request_name.strip_suffix(&filter_domain_ndots_complete) {
-                                                    Some(value) => value.to_string(),
-                                                     _ => {
-                                                        error!("Unable to parse string suffix, ignore parsing this request");
-                                                        continue;
-                                                    }
-                                                };
-                                                request_name.push('.');
-                                            }
-
-                                            // convert key to fully qualified domain name
-                                            let mut key_fqdn = key.to_owned();
-                                            key_fqdn.push('.');
-                                            if key_fqdn == request_name {
-                                                resolved_ip_list = value.to_vec();
-                                            }
+                                        if let Some(ips) = container_mappings.get(&request_name_string) {
+                                            resolved_ip_list.clone_from(ips);
                                         }
                                     }
                                 }
                             }
-                            let record_name: Name = match Name::from_str_relaxed(name.as_str()) {
-                                Ok(name) => name,
-                                Err(e) => {
-                                    // log and continue server
-                                    error!("Error while parsing record name: {:?}", e);
-                                    continue;
-                                }
-                            };
                             if !resolved_ip_list.is_empty() {
                                 if record_type == RecordType::A {
                                     for record_addr in resolved_ip_list {
                                         if let IpAddr::V4(ipv4) = record_addr {
                                             req.add_answer(
                                                 Record::new()
-                                                    .set_name(record_name.clone())
+                                                    .set_name(request_name.clone())
                                                     .set_ttl(CONTAINER_TTL)
                                                     .set_rr_type(RecordType::A)
                                                     .set_dns_class(DNSClass::IN)
@@ -306,7 +211,7 @@ impl CoreDns {
                                         if let IpAddr::V6(ipv6) = record_addr {
                                             req.add_answer(
                                                 Record::new()
-                                                    .set_name(record_name.clone())
+                                                    .set_name(request_name.clone())
                                                     .set_ttl(CONTAINER_TTL)
                                                     .set_rr_type(RecordType::AAAA)
                                                     .set_dns_class(DNSClass::IN)
@@ -318,10 +223,9 @@ impl CoreDns {
                                 }
                                 reply(sender, src_address, &req);
                             } else {
-                                debug!("Not found, forwarding dns request for {:?}", name);
-                                let request_name = name.as_str().to_owned();
-                                let filter_search_domain_ndots = self.filter_search_domain.clone() + ".";
-                                if no_proxy || backend.ctr_is_internal(&src_address.ip()) || request_name.ends_with(&self.filter_search_domain) || request_name.ends_with(&filter_search_domain_ndots) || request_name.matches('.').count() == 1  {
+                                debug!("Not found, forwarding dns request for {:?}", &request_name_string);
+                                if no_proxy || backend.ctr_is_internal(&src_address.ip()) ||
+                                    request_name_string.ends_with(&backend.search_domain) || request_name_string.matches('.').count() == 1  {
                                     let mut nx_message = req.clone();
                                     nx_message.set_response_code(ResponseCode::NXDomain);
                                     reply(sender.clone(), src_address, &nx_message);
@@ -383,10 +287,10 @@ fn reply(mut sender: BufDnsStreamHandle, socket_addr: SocketAddr, msg: &Message)
     Some(())
 }
 
-fn parse_dns_msg(body: SerialMessage) -> Option<(String, RecordType, Message)> {
+fn parse_dns_msg(body: SerialMessage) -> Option<(Name, RecordType, Message)> {
     match Message::from_vec(body.bytes()) {
         Ok(msg) => {
-            let mut name: String = "".to_string();
+            let mut name = Name::default();
             let mut record_type: RecordType = RecordType::A;
 
             let parsed_msg = format!(
@@ -395,7 +299,7 @@ fn parse_dns_msg(body: SerialMessage) -> Option<(String, RecordType, Message)> {
                 msg.queries()
                     .first()
                     .map(|q| {
-                        name = q.name().to_string();
+                        name = q.name().clone();
                         record_type = q.query_type();
 
                         format!("{} {} {}", q.name(), q.query_type(), q.query_class(),)
@@ -445,3 +349,60 @@ async fn forward_dns_req(cl: AsyncClient, message: Message) -> Option<Message> {
         }
     }
 }
+
+fn reply_ptr(
+    name: &str,
+    backend: &Guard<Arc<DNSBackend>>,
+    src_address: SocketAddr,
+    req: &Message,
+) -> Option<Message> {
+    let ptr_lookup_ip: String;
+    // Are we IPv4 or IPv6?
+
+    match name.strip_suffix(".in-addr.arpa.") {
+        Some(n) => ptr_lookup_ip = n.split('.').rev().collect::<Vec<&str>>().join("."),
+        None => {
+            // not ipv4
+            match name.strip_suffix(".ip6.arpa.") {
+                Some(n) => {
+                    // ipv6 string is 39 chars max
+                    let mut tmp_ip = String::with_capacity(40);
+                    for (i, c) in n.split('.').rev().enumerate() {
+                        tmp_ip.push_str(c);
+                        // insert colon after 4 hex chars but not at the end
+                        if i % 4 == 3 && i < 31 {
+                            tmp_ip.push(':');
+                        }
+                    }
+                    ptr_lookup_ip = tmp_ip;
+                }
+                // neither ipv4 or ipv6, something we do not understand
+                None => return None,
+            }
+        }
+    }
+
+    trace!("Performing reverse lookup for ip: {}", &ptr_lookup_ip);
+
+    // We should probably log malformed queries, but for now if-let should be fine.
+    if let Ok(lookup_ip) = ptr_lookup_ip.parse() {
+        if let Some(reverse_lookup) = backend.reverse_lookup(&src_address.ip(), &lookup_ip) {
+            let mut req_clone = req.clone();
+            for entry in reverse_lookup {
+                if let Ok(answer) = Name::from_ascii(format!("{}.", entry)) {
+                    req_clone.add_answer(
+                        Record::new()
+                            .set_name(Name::from_str_relaxed(name).unwrap_or_default())
+                            .set_ttl(CONTAINER_TTL)
+                            .set_rr_type(RecordType::PTR)
+                            .set_dns_class(DNSClass::IN)
+                            .set_data(Some(RData::PTR(rdata::PTR(answer))))
+                            .clone(),
+                    );
+                }
+            }
+            return Some(req_clone);
+        }
+    };
+    None
+}
diff --git a/src/server/serve.rs b/src/server/serve.rs
index c95c081..90160a9 100644
--- a/src/server/serve.rs
+++ b/src/server/serve.rs
@@ -63,7 +63,8 @@ pub fn serve(
 ) -> Result<(), std::io::Error> {
     let mut signals = Signals::new([SIGHUP])?;
 
-    let (backend, mut listen_ip_v4, mut listen_ip_v6) = parse_configs(config_path)?;
+    let (backend, mut listen_ip_v4, mut listen_ip_v6) =
+        parse_configs(config_path, filter_search_domain)?;
 
     // We store the `DNSBackend` in an `ArcSwap` so we can replace it when the configuration is
     // reloaded.
@@ -95,21 +96,9 @@ pub fn serve(
             process::exit(0);
         }
 
-        stop_and_start_threads(
-            port,
-            filter_search_domain,
-            backend,
-            listen_ip_v4,
-            &mut handles_v4,
-        );
+        stop_and_start_threads(port, backend, listen_ip_v4, &mut handles_v4);
 
-        stop_and_start_threads(
-            port,
-            filter_search_domain,
-            backend,
-            listen_ip_v6,
-            &mut handles_v6,
-        );
+        stop_and_start_threads(port, backend, listen_ip_v6, &mut handles_v6);
 
         // Block until we receive a SIGHUP.
         loop {
@@ -118,15 +107,16 @@ pub fn serve(
             }
         }
 
-        let (new_backend, new_listen_ip_v4, new_listen_ip_v6) = parse_configs(config_path)?;
+        let (new_backend, new_listen_ip_v4, new_listen_ip_v6) =
+            parse_configs(config_path, filter_search_domain)?;
         backend.store(Arc::new(new_backend));
         listen_ip_v4 = new_listen_ip_v4;
         listen_ip_v6 = new_listen_ip_v6;
     }
 }
 
-fn parse_configs(config_path: &str) -> Result<Config, std::io::Error> {
-    config::parse_configs(config_path).map_err(|e| {
+fn parse_configs(config_path: &str, filter_search_domain: &str) -> Result<Config, std::io::Error> {
+    config::parse_configs(config_path, filter_search_domain).map_err(|e| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!("unable to parse config: {}", e),
@@ -140,7 +130,6 @@ fn parse_configs(config_path: &str) -> Result<Config, std::io::Error> {
 /// corresponding to listen IPs that were added.
 fn stop_and_start_threads<Ip>(
     port: u32,
-    filter_search_domain: &str,
     backend: &'static ArcSwap<DNSBackend>,
     listen_ips: HashMap<String, Vec<Ip>>,
     thread_handles: &mut ThreadHandleMap<Ip>,
@@ -173,16 +162,8 @@ fn stop_and_start_threads<Ip>(
     for (network_name, ip) in to_start {
         let (shutdown_tx, shutdown_rx) = flume::bounded(0);
         let network_name_ = network_name.clone();
-        let filter_search_domain = filter_search_domain.to_owned();
         let handle = thread::spawn(move || {
-            if let Err(e) = start_dns_server(
-                network_name_,
-                ip.into(),
-                backend,
-                port,
-                filter_search_domain,
-                shutdown_rx,
-            ) {
+            if let Err(e) = start_dns_server(network_name_, ip.into(), backend, port, shutdown_rx) {
                 error!("Unable to start server: {}", e);
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
@@ -227,22 +208,9 @@ async fn start_dns_server(
     addr: IpAddr,
     backend: &'static ArcSwap<DNSBackend>,
     port: u32,
-    filter_search_domain: String,
     rx: flume::Receiver<()>,
 ) -> Result<(), std::io::Error> {
-    let forward: IpAddr = IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1));
-    match CoreDns::new(
-        addr,
-        port,
-        name,
-        forward,
-        53_u16,
-        backend,
-        filter_search_domain,
-        rx,
-    )
-    .await
-    {
+    match CoreDns::new(addr, port, name, backend, rx).await {
         Ok(mut server) => match server.run().await {
             Ok(_) => Ok(()),
             Err(e) => Err(std::io::Error::new(
diff --git a/src/test/test.rs b/src/test/test.rs
index da5083f..b1de20d 100644
--- a/src/test/test.rs
+++ b/src/test/test.rs
@@ -5,37 +5,49 @@
 // following tests will not test server and event loop since
 // event-loop and server can be tested via integration tests
 mod tests {
+    use std::collections::HashMap;
     use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
-    use aardvark_dns::backend::DNSResult;
+    use aardvark_dns::backend::{DNSBackend, DNSResult};
     use aardvark_dns::config;
     use std::str::FromStr;
+
+    fn parse_configs(
+        dir: &str,
+    ) -> Result<
+        (
+            DNSBackend,
+            HashMap<String, Vec<Ipv4Addr>>,
+            HashMap<String, Vec<Ipv6Addr>>,
+        ),
+        std::io::Error,
+    > {
+        config::parse_configs(dir, "")
+    }
+
     /* -------------------------------------------- */
     // --------- Test aardvark-dns config ---------
     /* -------------------------------------------- */
     #[test]
     // Test loading of config file from directory
     fn test_loading_config_file() {
-        match config::parse_configs("src/test/config/podman") {
-            Ok(_) => {}
-            Err(e) => panic!("{}", e),
-        }
+        parse_configs("src/test/config/podman").unwrap();
     }
     #[test]
     // Test loading of config file from directory with custom DNS for containers
     fn test_loading_config_file_with_dns_servers() {
-        config::parse_configs("src/test/config/podman_custom_dns_servers").unwrap();
+        parse_configs("src/test/config/podman_custom_dns_servers").unwrap();
     }
     #[test]
     // Test loading of config file from directory with custom DNS for containers
     // and custom DNS servers at network level as well.
     fn test_loading_config_file_with_network_scoped_dns_servers() {
-        config::parse_configs("src/test/config/network_scoped_custom_dns").unwrap();
+        parse_configs("src/test/config/network_scoped_custom_dns").unwrap();
     }
     #[test]
     // Parse config files from stub data
     fn test_parsing_config_files() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((_, listen_ip_v4, _)) => {
                 listen_ip_v4.contains_key("podman");
                 assert_eq!(listen_ip_v4["podman"].len(), 1);
@@ -47,7 +59,7 @@ mod tests {
     #[test]
     // Parse bad config files must fail
     fn test_parsing_bad_config_files() {
-        match config::parse_configs("src/test/config/podman_bad_config") {
+        match parse_configs("src/test/config/podman_bad_config") {
             Ok((_, _, _)) => panic!("parsing bad config must fail"),
             Err(_) => {}
         }
@@ -59,7 +71,7 @@ mod tests {
     // Backend must populate ctr_dns_servers via custom
     // DNS servers for container from the aardvark config
     fn test_backend_custom_dns_server() {
-        match config::parse_configs("src/test/config/podman_custom_dns_servers") {
+        match parse_configs("src/test/config/podman_custom_dns_servers") {
             Ok((backend, _, _)) => {
                 // Should contain custom DNS server 8.8.8.8
                 let mut dns_server = backend
@@ -94,7 +106,7 @@ mod tests {
     // DNS servers for container from container entry and
     // network dns servers as well.
     fn test_backend_network_scoped_custom_dns_server() {
-        match config::parse_configs("src/test/config/network_scoped_custom_dns") {
+        match parse_configs("src/test/config/network_scoped_custom_dns") {
             Ok((backend, _, _)) => {
                 let expected_dnsservers = vec![
                     IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
@@ -127,7 +139,7 @@ mod tests {
     // Request address must be v4.
     // Same container --> (resolve) Same container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_same_container_request_from_v4_on_v4_entries() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend.lookup(&"10.88.0.2".parse().unwrap(), "condescendingnash") {
                     DNSResult::Success(ip_vec) => {
@@ -148,7 +160,7 @@ mod tests {
     // Same container --> (resolve) Same container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_same_container_request_from_v4_on_v4_entries_case_insensitive(
     ) {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend.lookup(&"10.88.0.2".parse().unwrap(), "helloworld") {
                     DNSResult::Success(ip_vec) => {
@@ -169,7 +181,7 @@ mod tests {
     // Same container --> (resolve) Same container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_same_container_request_from_v4_on_v4_entries_case_insensitive_uppercase(
     ) {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend.lookup(&"10.88.0.2".parse().unwrap(), "HELLOWORLD") {
                     DNSResult::Success(ip_vec) => {
@@ -186,7 +198,7 @@ mod tests {
     // Check lookup query from backend and simulate
     // nx_domain on bad lookup queries.
     fn test_lookup_queries_from_backend_simulate_nx_domain() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend.lookup(&"10.88.0.2".parse().unwrap(), "somebadquery") {
                     DNSResult::NXDomain => {}
@@ -203,7 +215,7 @@ mod tests {
     // Request address must be v4.
     // Same container --> (resolve) different container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_different_container_request_from_v4() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend.lookup(&"10.88.0.2".parse().unwrap(), "trustingzhukovsky") {
                     DNSResult::Success(ip_vec) => {
@@ -223,7 +235,7 @@ mod tests {
     // Request address must be v4.
     // Same container --> (resolve) different container name by alias --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_different_container_request_from_v4_by_alias() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => match backend.lookup(&"10.88.0.2".parse().unwrap(), "ctr1") {
                 DNSResult::Success(ip_vec) => {
                     // verfiy length for issues like: https://github.com/containers/aardvark-dns/issues/120
@@ -243,7 +255,7 @@ mod tests {
     // Same container --> (resolve) Same container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_same_container_request_from_v4_on_v6_and_v4_entries(
     ) {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -268,7 +280,7 @@ mod tests {
     // Same container --> (resolve) Same container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_same_container_request_from_v6_on_v6_and_v4_entries(
     ) {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -293,7 +305,7 @@ mod tests {
     // Same container --> (resolve) different container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_different_container_request_from_v6_on_v6_and_v4_entries(
     ) {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -318,7 +330,7 @@ mod tests {
     // Same container --> (resolve) different container name --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_different_container_request_from_v4_on_v6_and_v4_entries(
     ) {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -343,7 +355,7 @@ mod tests {
     // Same container --> (resolve) different container by id --> (on) Same Network
     fn test_lookup_queries_from_backend_simulate_different_container_request_by_id_from_v4_on_v6_and_v4_entries(
     ) {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -369,7 +381,7 @@ mod tests {
     // aardvark must return container name and alias
     // Same container --> (resolve) Same ip  --> (on) Same Network
     fn test_reverse_lookup_queries_from_backend_by_ip_v4() {
-        match config::parse_configs("src/test/config/podman") {
+        match parse_configs("src/test/config/podman") {
             Ok((backend, _, _)) => {
                 match backend
                     .reverse_lookup(&"10.88.0.4".parse().unwrap(), &"10.88.0.4".parse().unwrap())
@@ -396,7 +408,7 @@ mod tests {
     // aardvark must return container name and alias
     // Same container --> (resolve) Same ip  --> (on) Same Network
     fn test_reverse_lookup_queries_from_backend_by_ip_v6() {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, _, _)) => {
                 match backend.reverse_lookup(
                     &"fdfd:733b:dc3:220b::2".parse().unwrap(),
@@ -420,7 +432,7 @@ mod tests {
     #[test]
     // Check ip_mappings generated by backend
     fn test_generated_ip_mappings_in_backend() {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -445,7 +457,7 @@ mod tests {
     #[test]
     // Check name_mappings generated by backend
     fn test_generated_name_mappings_in_backend() {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -499,7 +511,7 @@ mod tests {
     #[test]
     // Check reverse_mappings generated by backend
     fn test_generated_reverse_mappings_in_backend() {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 listen_ip_v6.contains_key("podman_v6_entries");
                 listen_ip_v4.contains_key("podman_v6_entries");
@@ -520,7 +532,7 @@ mod tests {
     #[test]
     // Parse a config which contains multiple ipv4 and ipv6 addresses ona single line
     fn test_parse_multiple_ipv4_ipv6_addresses() {
-        match config::parse_configs("src/test/config/podman_v6_entries") {
+        match parse_configs("src/test/config/podman_v6_entries") {
             Ok((backend, listen_ip_v4, listen_ip_v6)) => {
                 assert_eq!(
                     listen_ip_v4["podman_v6_entries_proper"],
diff --git a/test/300-three-networks.bats b/test/300-three-networks.bats
index 9039122..ea53a50 100644
--- a/test/300-three-networks.bats
+++ b/test/300-three-networks.bats
@@ -60,9 +60,25 @@ load helpers
 	# abtwo should be able to resolve A1, B1, and AB2 on both gws
 	dig "$ab2_pid" "aone" "$a_gw"
 	assert "$a1_ip"
+	dig "$ab2_pid" "aone" "$b_gw"
+	assert "$a1_ip"
+
+	dig "$ab2_pid" "bone" "$a_gw"
+	assert "$b1_ip"
 	dig "$ab2_pid" "bone" "$b_gw"
 	assert "$b1_ip"
 
+	# now the same again with search domain set
+	dig "$ab2_pid" "aone.dns.podman" "$a_gw"
+	assert "$a1_ip"
+	dig "$ab2_pid" "aone.dns.podman" "$b_gw"
+	assert "$a1_ip"
+
+	dig "$ab2_pid" "bone.dns.podman" "$a_gw"
+	assert "$b1_ip"
+	dig "$ab2_pid" "bone.dns.podman" "$b_gw"
+	assert "$b1_ip"
+
 	# check ab2 from itself, first from the a side
 	dig "$ab2_pid" "abtwo" "$a_gw"
 	assert "${#lines[@]}" = 2