cdns_rs/sync/

query.rs

/*-
 * cdns-rs - a simple sync/async DNS query library
 * 
 * Copyright (C) 2020  Aleksandr Morozov
 * 
 * Copyright 2025 Aleksandr Morozov
 * 
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence").
 * 
 * You may not use this work except in compliance with the Licence.
 * 
 * You may obtain a copy of the Licence at:
 * 
 *    https://joinup.ec.europa.eu/software/page/eupl
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * Licence for the specific language governing permissions and limitations
 * under the Licence.
 */

use std::collections::{BTreeSet, HashMap};
use std::convert::TryFrom;
use std::io::ErrorKind;
use std::net::{IpAddr, SocketAddr, TcpStream, ToSocketAddrs, UdpSocket};
use std::vec;
use std::sync::Arc;
use std::time::Duration;
use std::time::Instant;

use crate::cfg_resolv_parser::{ConfigEntryTls, ResolveConfEntry, ResolveConfig, ResolveConfigFamily};
use crate::{error::*, write_error};
use crate::query::{QDnsQuery, QDnsQueryResult, QuerySetup};
use crate::sync::network::NetworkTap;
use crate::internal_error;
use crate::query_private::QDnsReq;
use crate::common::*;

use super::caches::CACHE;
use super::network::{SocketTap, TcpHttpsConnection, TcpTlsConnection};

/// A struct which implements the [ToSocketAddrs] to resolve A and AAAA
/// directly to functions which argumnets are implementing [ToSocketAddrs]
/// Available only for the `sync` version. Tokio has ToSocketAddrs `sealed`.
#[derive(Clone, Debug)]
pub enum QDnsSockerAddr
{
    Ip(SocketAddr),
    Host(String, u16)
}

impl ToSocketAddrs for QDnsSockerAddr
{
    type Iter = vec::IntoIter<SocketAddr>;

    fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> 
    {
        match self
        {
            QDnsSockerAddr::Ip(socket_addr) => 
                return Ok(vec![socket_addr.clone()].into_iter()),
            QDnsSockerAddr::Host(host, port) => 
            {
                let qdns = 
                    QDns::make_a_aaaa_request(None, host.as_str(), QuerySetup::default())
                        .map_err(|e|
                            std::io::Error::new(ErrorKind::NotFound, CDnsSuperError::from(e))
                        )?;

                let res = 
                    qdns
                        .query()
                        .collect_ok()
                        .into_iter()
                        .map(|resp|
                            resp
                                .get_responses()
                                .iter()
                                .map(|r| 
                                    r.get_rdata().get_ip().map(|f| SocketAddr::new(f, *port))
                                )
                                .collect::<Vec<Option<SocketAddr>>>()
                        )
                        .flatten()
                        .filter(|p| p.is_some())
                        .map(|v| v.unwrap())
                        .collect::<Vec<SocketAddr>>();

                return Ok( res.into_iter() );
            }
        }
    }
}


impl QDnsSockerAddr
{
    /// Creates instance for A and AAAA records resolution from configured
    /// in `/etc/resolv.conf` DNS servers. The instance performs the DNS resolve
    /// when passed to functions which arguments implements [ToSocketAddrs]. 
    /// 
    /// # Arguments 
    /// 
    /// * `host` - `domain`:`port` i.e example.com:443. The `ip``port` is also
    ///     possible and no DNS resolution will be performed.
    pub 
    fn resolve<D>(host: D) -> std::io::Result<Self> 
    where D: AsRef<str>
    {
        if let Ok(addr) = host.as_ref().parse::<SocketAddr>() 
        {
            return Ok(Self::Ip(addr));
        }
        else
        {
            let ref_host = host.as_ref();

            let (domain, port) = 
                match ref_host.split_once(":")
                {
                    Some((h, portno)) => 
                    {
                        let port: u16 = 
                            portno
                                .parse()
                                .map_err(|e| 
                                    std::io::Error::new(ErrorKind::InvalidData, format!("{}", e))
                                )?;

                        (h, port)
                    },
                    None => 
                        return Err(std::io::Error::new(ErrorKind::InvalidData, "missing prot number"))
                };
            
            return Ok(Self::Host(domain.to_string(), port));
        }
    }

    /// Same as `resolve` but port is provided separatly.
    ///     
    /// # Arguments 
    /// 
    /// * `host` - `domain` name i.e example.com. The `ip`` is also
    ///     possible and no DNS resolution will be performed.
    /// 
    /// * `port` - a port number to be added to the result.
    pub 
    fn resolve_port<D>(host: D, port: u16) -> std::io::Result<Self> 
    where D: AsRef<str>
    {
        if let Ok(addr) = host.as_ref().parse::<IpAddr>() 
        {
            return Ok(Self::Ip(SocketAddr::new(addr, port)));
        }
        else
        {   
            return Ok(Self::Host(host.as_ref().to_string(), port));
        }
    }
}

/// A main instance which contains all common logic.
#[derive(Clone, Debug)]
pub struct QDns
{
    /// An instance of the parser /etc/resolv.conf or custom config
    resolvers: Arc<ResolveConfig>,
    /// A pre-ordered list of the requests, if more than one
    ordered_req_list: Vec<QDnsReq>,
    /// Override options
    opts: QuerySetup,
}

impl QDns
{
    /// Initializes new empty storage for requests.
    /// 
    /// # Arguments
    /// 
    /// * `resolvers` - an [Arc] [ResolveConfig] which contains configuration i.e nameservers
    /// 
    /// * `opts` - [QuerySetup] additional options or overrides. Use default() for default
    ///     values.
    /// 
    /// # Returns
    /// 
    /// Never panics. Returns Self.
    pub 
    fn make_empty(resolvers: Option<Arc<ResolveConfig>>, opts: QuerySetup) -> CDnsResult<Self>
    {
        return Ok(
            Self
            {
                resolvers: resolvers.unwrap_or(CACHE.clone_resolve_list()?),
                ordered_req_list: Vec::new(),
                opts: opts,
            }
        );
    }

    /// Adds new request to previously created empty storage for request with [QDns::make_empty].
    /// 
    /// # Arguemnts
    /// 
    /// * `qtype` - a [QType] type of the request
    /// 
    /// * `req_name` - a [Into] [QDnsName] which is target. i.e 'localhost' or 'domain.tld'
    /// 
    /// # Returns
    /// 
    /// * [CDnsResult] - Ok with nothing in inner type
    /// 
    /// * [CDnsResult] - Err with error description
    pub 
    fn add_request(&mut self, qtype: QType, req_name: impl Into<QDnsName>)
    {
        let qr = QDnsReq::new_into(req_name, qtype);

        self.ordered_req_list.push(qr);

        return;
    }

    /// This is helper which makes for you an A, AAAA query. The order of A and AAAA and
    /// which from both are allowed is defined in the [ResolveConfig].
    /// 
    /// Use this function directly. Do not use [QDns::make_empty]
    /// 
    /// # Arguments
    /// 
    /// * `resolvers` - an [Option] value [Arc] [ResolveConfig] which can be used to 
    ///     override the system's `resolv.conf`
    /// 
    /// * `req_name` - a [Into] [QDnsName] which is target i.e 'localhost' or 'domain.tld'
    /// 
    /// * `opts` - [QuerySetup] additional options or overrides. Use default() for default
    ///     values.
    /// 
    /// # Returns
    /// 
    /// A [CDnsResult] is returned;
    /// 
    /// * [Result::Ok] - with Self as inner type
    /// 
    /// * [Result::Err] - with error description
    pub 
    fn make_a_aaaa_request(resolvers_opt: Option<Arc<ResolveConfig>>, req_name: impl Into<QDnsName>, 
        opts: QuerySetup) -> CDnsResult<Self>
    {
        let resolvers =  resolvers_opt.unwrap_or(CACHE.clone_resolve_list()?);

        // store the A and AAAA depending on order
        let reqs: Vec<QDnsReq> = 
            match resolvers.family
            {
                ResolveConfigFamily::INET4_INET6 => 
                {
                    let req_n: QDnsName = req_name.into();

                    vec![
                        QDnsReq::new(req_n.clone(), QType::A),
                        QDnsReq::new(req_n, QType::AAAA),
                    ]
                },
                ResolveConfigFamily::INET6_INET4 => 
                {
                    let req_n: QDnsName = req_name.into();

                    vec![
                        QDnsReq::new(req_n.clone(), QType::AAAA),
                        QDnsReq::new(req_n, QType::A),
                    ]
                },
                ResolveConfigFamily::INET6 => 
                {
                    vec![
                        QDnsReq::new(req_name.into(), QType::AAAA),
                    ]
                },
                ResolveConfigFamily::INET4 => 
                {
                    vec![
                        QDnsReq::new(req_name.into(), QType::A),
                    ]
                }
                _ =>
                {
                    // set default
                    let req_n: QDnsName = req_name.into();

                    vec![
                        QDnsReq::new(req_n.clone(), QType::A),
                        QDnsReq::new(req_n, QType::AAAA),
                    ]
                }
            };

        
        
        return Ok(
            Self
            {
                resolvers: resolvers,
                ordered_req_list: reqs,
                opts: opts,
            }
        );
    }

    /// Resolves the created query/ies.
    /// 
    /// # Returns
    /// 
    /// * [CDnsResult] with [QDnsQueryResult] which may contain results
    /// 
    /// * [CDnsResult] with error
    /// 
    /// Should not panic. MT-safe.
    pub 
    fn query(mut self) -> QDnsQueryResult
    {
        // check if we need to measure time
        let now = 
            if self.opts.measure_time == true
            {
                Some(Instant::now())
            }
            else
            {
                None
            };

        // determine where to look firstly i.e file -> bind, bind -> file
        // or bind only, or file only
        if self.resolvers.lookup.is_file_first()
        {
            let mut query_res = 
                match self.lookup_file(now.as_ref())
                {
                    Ok(file) => 
                    {
                        if file.is_empty() == false
                        {
                            // remove records which was resolved
                            self.ordered_req_list.retain(|req| 
                                {
                                    return !file.contains_dnsreq(req);
                                }
                            );
                        }

                        file
                    },
                    Err(e) => 
                    {
                        write_error!(e);

                        QDnsQueryResult::default()
                    }
                };


            // if something left unresolved, try ask internet
            if self.ordered_req_list.is_empty() == false && self.resolvers.lookup.is_bind() == true
            {
                let res = self.process_request(now.as_ref());
                
                query_res.extend(res);
            }

            return query_res;
        }
        else
        {
            let mut dns_res = self.process_request(now.as_ref());
            if dns_res.is_empty() == false
            {
                // remove records which was resolved
                self.ordered_req_list.retain(|req| 
                    {
                        return !dns_res.contains_dnsreq(req);
                    }
                );
            }



            if self.ordered_req_list.is_empty() == false && self.resolvers.lookup.is_file() == true
            {
                match self.lookup_file(now.as_ref())
                {
                    Ok(res) => 
                    {
                        dns_res.extend(res);
                    },
                    Err(e) =>
                    {
                        write_error!(e);
                    }
                }
            }

            return dns_res;
        }
    }

    /// Returns timeout
    fn get_timeout(&self) -> Duration
    {
        if let Some(timeout) = self.opts.timeout
        {
            return Duration::from_secs(timeout as u64);
        }
        else
        {
            return Duration::from_secs(self.resolvers.timeout as u64);
        }
    }

    /// Searches in /etc/hosts
    fn lookup_file(&mut self, now: Option<&Instant>) -> CDnsResult<QDnsQueryResult>
    {
        let mut dnsquries: QDnsQueryResult = QDnsQueryResult::default();

        // check if the it is overriden
        if self.opts.ign_hosts == false
        {
            let hlist = CACHE.clone_host_list()?;

            for req in self.ordered_req_list.iter()
            {
                match *req.get_type()
                {
                    QType::A | QType::AAAA => 
                    {
                        let req_name = String::from(req.get_req_name());

                        let Some(host_name_ent) = hlist.search_by_fqdn(req.get_type(), req_name.as_str())
                            else { continue };
                        
                        let Some(drp) = DnsResponsePayload::new_local(*req.get_type(), host_name_ent)
                            else { continue };
                        
                        // store to list
                        dnsquries.push(req.clone(), Ok(QDnsQuery::from_local(drp, now)));
                    },
                    QType::PTR => 
                    {
                        let Ok(ip) = IpAddr::try_from(req.get_req_name())
                            else { continue };

                        let Some(host_name_ent) = hlist.search_by_ip(&ip)
                            else { continue };

                        let Some(drp) = DnsResponsePayload::new_local(*req.get_type(), host_name_ent)
                            else { continue };    

                        dnsquries.push(req.clone(), Ok(QDnsQuery::from_local(drp, now))); 
                    },
                    _ => 
                        continue,
                }
            }

            
        }

        return Ok(dnsquries);
    }

    /// Creates socket based on config and flag. If `force_tcp` is set then Tcp tap will
    /// be created.
    #[inline]
    fn create_socket(&self, force_tcp: bool, resolver: Arc<ResolveConfEntry>) -> CDnsResult<Box<dyn SocketTap>>
    {
        let is_tls = resolver.get_tls_type();

        if is_tls == ConfigEntryTls::Tls
        {
            return NetworkTap::<TcpTlsConnection>::new(resolver, self.get_timeout());
        }
        else if is_tls == ConfigEntryTls::Https
        {
            return NetworkTap::<TcpHttpsConnection>::new(resolver, self.get_timeout());
        }
        else if self.resolvers.option_flags.is_force_tcp() == true || force_tcp == true
        {
            return NetworkTap::<TcpStream>::new(resolver, self.get_timeout());
        }
        else
        {
            return NetworkTap::<UdpSocket>::new(resolver, self.get_timeout());
        }
    }

    /// Quering nameservers
    fn process_request(&mut self, now: Option<&Instant>) -> QDnsQueryResult
    {
        let mut responses: QDnsQueryResult = QDnsQueryResult::with_capacity(self.ordered_req_list.len());

        if self.resolvers.option_flags.is_no_parallel() == true
        {
            for req in self.ordered_req_list.iter()
            {
                let mut last_resp: Option<CDnsResult<QDnsQuery>> = None;

                for resolver in self.resolvers.get_resolvers_iter()
                {
                    match self.query_exec_seq(now, resolver.clone(), req, None)
                    {
                        Ok(resp) =>
                        {
                            if resp.should_check_next_ns() == true
                            {
                                last_resp = Some(Ok(resp));

                                continue;
                            }
                            else
                            {
                                responses.push(req.clone(), Ok(resp));

                                let _ = last_resp.take();

                                break;
                            }
                        },
                        Err(e) =>
                        {
                            if last_resp.is_none() == true
                            {
                                last_resp = Some(Err(e));
                            }                      

                            continue;
                        }
                    }
                } // for

                responses.push(req.clone(), last_resp.take().unwrap());
            }// for
        }
        else
        {
           // let mut responses: QDnsQueryResult = QDnsQueryResult::with_capacity(self.ordered_req_list.len());

            for resolver in self.resolvers.get_resolvers_iter()
            {
                if self.ordered_req_list.is_empty() == true
                {
                    break;
                }

                match self.query_exec_pipelined(now, resolver.clone(), None)
                {
                    Ok(resp) =>
                    {
                        for (qdns_res, qdns_que) in resp
                        {
                            if let Ok(ref resp) = qdns_que
                            {
                                if resp.should_check_next_ns() == false
                                    {
                                        self
                                            .ordered_req_list
                                            .retain(
                                                |req_item|
                                                req_item != &qdns_res
                                            );
                                    }
                            }
                            
                            responses.push(qdns_res, qdns_que);
                        }
                    },
                    Err(e) =>
                    {
                        write_error!(e);

                        continue;
                    }
                }
            }
        }

        return responses;
    }


    fn query_exec_pipelined(
        &self, 
        now: Option<&Instant>, 
        resolver: Arc<ResolveConfEntry>,
        requery: Option<HashMap<DnsRequestHeader, QDnsReq>>,
    ) -> CDnsResult<QDnsQueryResult>
    {
        let force_tcp = self.resolvers.option_flags.is_force_tcp() || requery.is_some();

        let mut query_headers: HashMap<DnsRequestHeader, QDnsReq> = 
            if let Some(requer) = requery
            {
                let pkts_ids = requer.iter().map(|q| q.0.get_id()).collect::<BTreeSet<u16>>();

                // regenerate que ID and collect
                requer
                    .into_iter()
                    .map(
                        |(mut qrr, qdr)| 
                        { 
                            loop
                            {
                                qrr.regenerate_id(); 

                                if pkts_ids.contains(&qrr.get_id()) == false
                                {
                                    break;
                                }
                            }
                            (qrr, qdr)
                        })
                    .collect::<HashMap<DnsRequestHeader, QDnsReq>>()
            }
            else    
            {
                let mut pkts_ids: BTreeSet<u16> = BTreeSet::new();

                // create que
                self
                    .ordered_req_list
                    .iter()
                    .map(
                        |query| 
                        {
                            
                            let mut drh_res = DnsRequestHeader::try_from(query);
                            
                            loop
                            {
                                if let Ok(ref mut drh) = drh_res
                                {
                                    if pkts_ids.contains(&drh.get_id()) == true
                                    {
                                        drh.regenerate_id();

                                        continue;
                                    }
                                    else
                                    {
                                        pkts_ids.insert(drh.get_id());
                                        break;
                                    }
                                }
                                else
                                {
                                    break;
                                }
                            }

                            drh_res.map(|dh| (dh, query.clone()))
                        }
                    )
                    .collect::<CDnsResult<HashMap<DnsRequestHeader, QDnsReq>>>()?
            };

        // create socket and store
        let mut tap = self.create_socket(force_tcp, resolver.clone())?;

        tap.connect(true, CDdnsGlobals::get_tcp_conn_timeout())?;

        // send everything
        for qh in query_headers.iter()
        {
            let pkt = qh.0.to_bytes(tap.should_append_len())?;

            tap.send(pkt.as_slice())?;
        }

        let mut resp: QDnsQueryResult = QDnsQueryResult::with_capacity(self.ordered_req_list.len());
        let mut requery: HashMap<DnsRequestHeader, QDnsReq> = HashMap::new();
        // poll socket
        
        loop
        {
            if query_headers.len() == 0
            {
                break;
            }
            
            /*let mut poll_tap = [PollFd::new(tap.get_fd().unwrap(), PollFlags::from(PollFlags::POLLIN))];
            
            let poll_res = 
                nix::poll::poll(&mut poll_tap, self.resolvers.timeout * 1000 as u16)
                    .map_err(|e| internal_error_map!(CDnsErrorType::IoError, "{}", e))?;

            if poll_res == 0
            {
                internal_error!(CDnsErrorType::IoError, "Timeout");
            }

            let Some(revents) = poll_tap[0].revents()
                else
                {
                    internal_error!(CDnsErrorType::IoError, "Crate NIX returned None due to unknown data returned by kernel!\
                        Try update nix crate! Probably it is outdated!");
                };

            if revents.intersects(PollFlags::POLLERR | PollFlags::POLLHUP | PollFlags::POLLNVAL ) == true
            {
                write_error!(internal_error_map!(CDnsErrorType::IoError, "socket poll error {:?}", revents));
                break;
            }
            else if revents.intersects(PollFlags::POLLIN) == true
            {*/
                if tap.poll_read()? == false
                {
                    // timeout
                    break;
                }

                let ans = tap.recv()?;//self.read_response(tap.as_mut())?;

                let Some((query_header, qdnsreq)) = query_headers.remove_entry(&ans.req_header)
                    else
                    {
                        internal_error!(CDnsErrorType::IoError, "can not find response with request: {}", ans.req_header);
                    };

                ans.verify(&query_header)?;

                // verified
                let qdns_resp = QDnsQuery::from_response(tap.get_remote_addr(), ans, now);

                if let Ok(ref qdns) = qdns_resp
                {
                    if qdns.get_status().should_try_tcp() == true && force_tcp == false
                    {
                        requery.insert(query_header, qdnsreq);
                    }
                    else
                    {
                        resp.push(qdnsreq, qdns_resp);
                    }
                }
                else
                {
                    resp.push(qdnsreq, qdns_resp);
                }
           // }
        }

        if requery.is_empty() == false
        {
            let res = self.query_exec_pipelined(now, resolver, Some(requery))?;

            resp.extend(res);
        }
        
        return Ok(resp);   
    }

    /// Runs sequentually
    fn query_exec_seq(
        &self, 
        now: Option<&Instant>, 
        resolver: Arc<ResolveConfEntry>,
        query: &QDnsReq,
        requery: Option<DnsRequestHeader>,
    ) -> CDnsResult<QDnsQuery>
    {
        let force_tcp = self.resolvers.option_flags.is_force_tcp() || requery.is_some();

        // create socket and store
        let mut tap = self.create_socket(force_tcp, resolver.clone())?;

        let query_header = 
            // form the list of reqests binded to taps
            if let Some(mut requery) = requery
            {
                requery.regenerate_id();

                requery
            }
            else
            {
                let drh_req = DnsRequestHeader::try_from(query)?;
                
                drh_req
            };

        let res = 
            {
                // open connection, with timeout because working in non parallel mode
                tap.connect(false, CDdnsGlobals::get_tcp_conn_timeout())?;

                // convert to byte packet (the error returned is global error i.e OOM)
                let pkt = query_header.to_bytes(tap.should_append_len())?;

                // send to DNS server, if error happens, then stop processing this server
                tap.send(pkt.as_slice())?;

                let ans = tap.recv()?; //self.read_response(tap.as_mut())?;

                ans.verify(&query_header)?;

                // verified
                let resp = QDnsQuery::from_response(tap.get_remote_addr(), ans, now)?;

                Ok(resp)
            };

        if (res.is_ok() == true && res.as_ref().unwrap().status.should_try_tcp() == false) || 
            (res.is_err() == true && force_tcp == true)
        {
            return res;
        }
        

        return 
            self.query_exec_seq(now, resolver.clone(), query, Some(query_header));
    }

    /*
    // Reads response from tap
    fn read_response(&self, socktap: &mut (dyn SocketTap)) -> CDnsResult<DnsRequestAnswer>
    {
        if socktap.should_append_len() == false && socktap.is_encrypted() == false
        {
            let mut rcvbuf = vec![0_u8; 1457];

            // receive message
            let n = socktap.recv(rcvbuf.as_mut_slice())?;

            // parsing response to structure
            return DnsRequestAnswer::parse(&rcvbuf, n); //DnsRequestAnswer::try_from(rcvbuf.as_slice(), n, socktap.is_tcp())?;
        }
        else if socktap.should_append_len() == false && socktap.is_encrypted() == true
        {
            let mut rcvbuf = vec![0_u8; 1457];
        }
        else
        {
            let mut pkg_pen: [u8; 2] = [0, 0];
            let n = socktap.recv(&mut pkg_pen)?;

            if n == 0
            {
                internal_error!(CDnsErrorType::IoError, "tcp received zero len message!");
            }
            else if n != 2
            {
                internal_error!(CDnsErrorType::IoError, "tcp expected 2 bytes to be read!");
            }

            let ln = u16::from_be_bytes(pkg_pen);

            let mut rcvbuf = vec![0_u8; ln as usize];

            // receive message
            let mut n = socktap.recv(rcvbuf.as_mut_slice())?;

            if n == 0
            {
                internal_error!(CDnsErrorType::IoError, "tcp received zero len message!");
            }
            else if n == 1
            {
                n = socktap.recv(&mut rcvbuf[1..])?;

                if n == 0
                {
                    internal_error!(CDnsErrorType::IoError, "tcp received zero len message again!");
                }

                n += 1;
            }

            return DnsRequestAnswer::parse(&rcvbuf, n); 
        }
    }*/
}

#[cfg(test)]

mod tests
{
    use std::net::IpAddr;

    use crate::{common::{byte2hexchar, ip2pkt, RecordPTR, RecordReader}, sync::{query::QDns, QDnsName}, QDnsQueryRec, QType, QuerySetup};

    #[test]
    fn test_ip2pkt()
    {
        use std::time::Instant;
        use std::net::{IpAddr, Ipv4Addr};
        
        let test = IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8));

        let now = Instant::now();

        let res = ip2pkt(&test);

        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);

        assert_eq!(res.is_ok(), true, "err: {}", res.err().unwrap());

        let res = res.unwrap();
        let ctrl = b"\x01\x38\x01\x38\x01\x38\x01\x38\x07\x69\x6e\x2d\x61\x64\x64\x72\x04\x61\x72\x70\x61\x00";

        assert_eq!(res.as_slice(), ctrl);
    }


    #[test]
    fn test_byte2hexchar()
    {
        assert_eq!(byte2hexchar(1), 0x31);
        assert_eq!(byte2hexchar(9), 0x39);
        assert_eq!(byte2hexchar(10), 'a' as u8);
        assert_eq!(byte2hexchar(15), 'f' as u8);
    }

    #[test]
    fn reverse_lookup_test()
    {
        use std::time::Instant;
        
        let ipp: IpAddr = "8.8.8.8".parse().unwrap();
        //let test = QDnsName::try_from(&ipp).unwrap();

        let mut query_setup = QuerySetup::default();
        query_setup.set_measure_time(true);

        let now = Instant::now();

        let mut dns_req = 
            QDns::make_empty(None, query_setup).unwrap();

        dns_req.add_request(QType::PTR, ipp);
        let res = dns_req.query();

        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);

        println!("{}", res);

        assert_eq!(res.is_empty(), false);

        let recs = res.collect_ok();
        let rec = &recs[0];
        //assert_eq!(rec.server.as_str(), "/etc/hosts");
        assert_eq!(rec.status, QDnsQueryRec::Ok);

        assert_eq!(rec.resp.len(), 1);
        assert_eq!(rec.resp[0].rdata, RecordPTR::wrap(RecordPTR{ fqdn: "dns.google".to_string() }));
    }

    #[test]
    fn reverse_lookup_hosts_test()
    {
        use std::time::Instant;

        let ipp: IpAddr = "127.0.0.1".parse().unwrap();
        //let test = QDnsName::try_from(&ipp).unwrap();
        
        let now = Instant::now();

        let mut query_setup = QuerySetup::default();
        query_setup.set_measure_time(true);

        let mut dns_req = 
            QDns::make_empty(None, query_setup).unwrap();

        dns_req.add_request(QType::PTR, ipp);

        let res = dns_req.query();
        
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);

        println!("{}", res);

        assert_eq!(res.is_empty(), false);

        let recs = res.collect_ok();
        let rec = &recs[0];

        assert_eq!(rec.server.as_str(), "/etc/hosts");
        assert_eq!(rec.status, QDnsQueryRec::Ok);

        assert_eq!(rec.resp.len(), 1);
        assert_eq!(rec.resp[0].rdata, RecordPTR::wrap(RecordPTR{ fqdn: "localhost".to_string() }));
    }


    #[test]
    fn reverse_lookup_a()
    {
        use std::time::Instant;

       // let test = QDnsName::try_from("dns.google").unwrap();

        let mut query_setup = QuerySetup::default();
        query_setup.set_measure_time(true);


        let res = 
            QDns::make_a_aaaa_request(None, "dns.google", query_setup).unwrap();
        
        
        let now = Instant::now();
        let res = res.query();
        

        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);

    /*  assert_eq!(res.is_ok(), true, "{}", res.err().unwrap());
        
        let res = res.unwrap();*/
        println!("{}", res);
    }


    #[test]
    fn truncation_test_1()
    {
        use std::time::Instant;

        //let test = QDnsName::try_from("truncate-zyxw11.go.dnscheck.tools").unwrap();

        let mut query_setup = QuerySetup::default();
        query_setup.set_measure_time(true);


        let mut res = 
            QDns::make_empty(None, query_setup).unwrap();

        res.add_request(QType::TXT, "truncate-zyxw11.go.dnscheck.tools");
        
        
        let now = Instant::now();
        let res = res.query();
        

        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);

    /*  assert_eq!(res.is_ok(), true, "{}", res.err().unwrap());
        
        let res = res.unwrap();*/
        println!("{}", res);
    }

    #[test]
    fn truncation_test_2()
    {
        use std::time::Instant;

       // let test = QDnsName::try_from("dnscheck.tools").unwrap();
      //  let test2 = QDnsName::try_from("localhost").unwrap();
      //  let test3 = QDnsName::try_from("unknownnonexistentdomain.com").unwrap();
      //  let test4 = QDnsName::try_from("example.com").unwrap();

        let mut query_setup = QuerySetup::default();
        query_setup.set_measure_time(true);


        let mut res = 
            QDns::make_empty(None, query_setup).unwrap();

        res.add_request(QType::A, "dnscheck.tools");
        res.add_request(QType::A, "localhost");
        res.add_request(QType::A, "unknownnonexistentdomain.com");
        res.add_request(QType::TXT, "example.com");
        
        
        let now = Instant::now();
        let res = res.query();
        

        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);


        let (ans, errs) = res.collect_split();

        println!("ANSWERS");
        for a in ans
        {
            println!("-----\n{} \n{}", a.0, a.1.unwrap());
        }

        println!("ERRORS");
        for b in errs
        {
            println!("-----\n{} \n{}", b.0, b.1.err().unwrap());
        }
    }
}