cdns_rs/

common.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.
 */

 /*
                                1  1  1  1  1  1
  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                    | ID |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                    | QDCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                    | ANCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                    | NSCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
                    | ARCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

                                1  1  1  1  1  1
  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                                               |
/                       QNAME                   /
/                                               /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                       QTYPE                   |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|                       QCLASS                  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

*/

/// This file contains the common structures and constants of DNS protocol and 
/// other parts of the code. Also it contains a parser from/to network packet.

use std::{cmp::Ordering, fmt::{self}, io::{Cursor, Read, Write}, net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}, path::Path, sync::{Arc, LazyLock, OnceLock}, time::Duration};
use std::borrow::Borrow;
use std::hash::{Hash, Hasher};

use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};

use crate::{cfg_host_parser::HostnameEntry, error::*, internal_error_map, query_private::QDnsReq};
use crate::internal_error;

/// A location on the disk where resolv.conf is located
pub const RESOLV_CFG_PATH: &'static str = "/etc/resolv.conf";

/// A hosts file location on disk
pub const HOST_CFG_PATH: &'static str = "/etc/hosts";

pub static RESOLV_CFG_PATH_P: LazyLock<&'static Path> = LazyLock::new(|| {Path::new(RESOLV_CFG_PATH)});
pub static HOST_CFG_PATH_P: LazyLock<&'static Path> = LazyLock::new(|| {Path::new(HOST_CFG_PATH)});

pub static GLOBALS: OnceLock<CDdnsGlobals> = OnceLock::new();

/// A nsswitch location
pub const NSSWITCH_CFG_PATH: &'static str = "/etc/nsswitch.conf";

const IN_ADDR_ARPA: &[u8] = b"\x07in-addr\x04arpa\x00";
const IN_ADDR6_ARPA: &[u8] = b"\x03ip6\x04arpa\x00";

pub const DEF_USERAGENT: &'static str = concat!("CDNS-RS/", env!("CARGO_PKG_VERSION"));
pub const DEF_TLS_PORT: u16 = 853;
pub const DEF_HTTPS_PORT: u16 = 443;

/// Default BIND for IPv4
pub const IPV4_BIND_ALL: IpAddr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
/// Default BIND for IPv6
pub const IPV6_BIND_ALL: IpAddr = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));

#[derive(Debug)]
pub struct CDdnsGlobals
{
     pub tcp_timeout: Option<Duration>,
}

impl CDdnsGlobals
{
    /// Many threads may call `init_once` concurrently with different initializing functions, 
    /// but it is guaranteed that only one function will be executed.
    pub 
    fn init_once(globals: CDdnsGlobals)
    {
        GLOBALS.get_or_init(|| globals);

        return;
    }

    pub 
    fn get_tcp_conn_timeout() -> Option<Duration>
    {
        return GLOBALS.get().map_or(None, |f| f.tcp_timeout);
    }
}

#[inline]
pub 
fn bind_all(ip_addr: IpAddr) -> SocketAddr
{
    match ip_addr
    {
        IpAddr::V4(_) => 
            SocketAddr::from((IPV4_BIND_ALL, 0)),
        IpAddr::V6(_) => 
            SocketAddr::from((IPV6_BIND_ALL, 0)),
    }
}

pub 
fn pkt2string_exact(pkt: &mut Cursor<&[u8]>, rdlen: u16) -> CDnsResult<String>
{
    let mut new_string = vec![0_u8; rdlen as usize];

    
    pkt.read_exact(&mut new_string).map_err(map_read_err)?;


    return 
        String::from_utf8(new_string)
            .map_err(|e| 
                internal_error_map!(CDnsErrorType::InternalError, "UTF-8 decode error, {}", e)
            );
}

pub 
fn pkt2vec(pkt: &mut Cursor<&[u8]>, rdlen: Option<u16>) -> CDnsResult<Vec<u8>>
{
    if let Some(rdl) = rdlen
    {
        let mut new_buf = vec![0_u8; rdl as usize];

        
        pkt.read_exact(&mut new_buf).map_err(map_read_err)?;


        return Ok(new_buf);
    }
    else
    {
        let mut new_buf = Vec::new();

        pkt.read_to_end(&mut new_buf).map_err(map_read_err)?;

        return Ok(new_buf);
    }
}

/// Verifies the sequence of labels coding and copies data from pkt to
/// buffer.
/// 
/// # Arguments
/// 
/// * `pkt` - a reference to the [Cursor]
/// 
/// # Returns 
/// 
/// * [CDnsResult] with data copied to new [Vec][u8]
pub 
fn pkt2name(pkt: &mut Cursor<&[u8]>) -> CDnsResult<Vec<u8>>
{
    let qname_s = pkt.position() as usize;

    loop
    {
        let cnt = pkt.read_u8().map_err(map_read_err)?;

        if cnt == 0
        {
            break;
        }
        else
        {
            for _ in 0..cnt
            {
                let c = pkt.read_u8().map_err(map_read_err)?;
                if c == 0
                {
                    internal_error!(
                        CDnsErrorType::DnsResponse, 
                        "incorrectly encoded QNAME in response, found '0' at offset: '{}'",
                        pkt.position()
                    );
                }
            }
        }
    }

    // temporary store the position of the cursor
    let cur_pos = pkt.position() as usize;

    if (cur_pos - qname_s) <= 1
    {
        internal_error!(
            CDnsErrorType::DnsResponse, 
            "read name is too short"
        );
    }

    /*pkt.set_position(qname_s);
    
    // creating buffer for QNAME
    let mut req: Vec<u8> = vec![0_u8; (cur_pos - qname_s) as usize];
    pkt.read_exact(&mut req).map_err(map_read_err)?;

    // restore position
    pkt.set_position(cur_pos);*/
    

    return Ok(pkt.get_ref()[qname_s..cur_pos].to_vec());
}


/// This function converts a QNAME (encoded domains) to the String FQDN.
pub 
fn name2str(pkt: &mut Cursor<&[u8]>, mut opt_rdlen: Option<u16>) -> CDnsResult<String>
{
    let cur_in_pos = pkt.position();
    //let mut p_comp: u8 = 0;
    let mut comp: u8;
    let mut output: Vec<String> = Vec::with_capacity(6);

    loop
    {
        if let Some(rdlen) = opt_rdlen
        {
            if pkt.position() - cur_in_pos >= rdlen as u64
            {
                return Ok(output.join("."));
            }
        }

        // reading word from pkt to detect the type of message
       // p_comp = comp;
        comp = pkt.read_u8().map_err(map_read_err)?;

        /*if p_comp > 0 && comp > 0
        {
            output.push('.');
        }*/

        let msb = comp & 0xC0;

        if msb == 0xC0
        {
            if opt_rdlen.is_none() == true
            {
                opt_rdlen = Some(2);
            }

            let offset1: u16 = ((comp & !0xC0) as u16) << 8;// | pkt.read_u8().map_err(map_read_err)? as u16;
            let offset2: u16 = pkt.read_u8().map_err(map_read_err)? as u16;

            let offset = offset1 | offset2;

            //println!("debug: 1: {} 2: {} offset: {}", offset1, offset2, offset);

            // C0 0...
            if offset as usize >= pkt.get_ref().len()
            {
                internal_error!(
                    CDnsErrorType::DnsResponse, 
                    "incoreclty formated packet: offset: '{}' > len: '{}'", 
                    offset, pkt.get_ref().len()
                );
            }

            // save current cursor position
            let cur_pos = pkt.position();
            pkt.set_position(offset as u64);

            // converting the name to FQDN
            output.push(name2str(pkt, None)?);
            //output.push_str(cache.get(&offset).ok_or_else(|| internal_error_map!(CDnsErrorType::InternalError, "cache mismatch"))?);

            // restoring cursor positon
            pkt.set_position(cur_pos);
        }
        else if msb == 0x00 
        {
            if comp == 0
            {
                if let Some(rdlen) = opt_rdlen
                {
                    let dif = pkt.position() - cur_in_pos;

                    if rdlen as u64 != dif
                    {
                        internal_error!(CDnsErrorType::DnsResponse, "incorrect rdlen: '{}', exp: '{}'", rdlen, dif);
                    }
                }

                return Ok(output.join("."));
            }
            else
            {
                let mut tmp: Vec<u8> = Vec::with_capacity(comp as usize);

                for _ in 0..comp
                {
                    let c = pkt.read_u8().map_err(map_read_err)?;
                    if c == 0
                    {
                        internal_error!(CDnsErrorType::DnsResponse, "protocol violation, incorrectly encoded QNAME in response");
                    }

                    tmp.push(c);
                }

                output
                    .push(
                        String::from_utf8(tmp)
                            .map_err(|e| 
                                internal_error_map!(CDnsErrorType::InternalError, "UTF-8 decode error, {}", e)
                            )?
                    );
            }
        }
        else
        {
            internal_error!(CDnsErrorType::DnsResponse, "incorrect compression: {:x}", msb);
        }

    } // loop
}


/// Converts a part of the octec of IP to printable hex i.e valid range is from
/// 0 up to 15 will be converted to 0x30..0x39 and 'a'..'f'.
/// 
/// # Arguments
/// 
/// * `b` - a part of the octec
/// 
/// # Returns
/// 
/// * u8 an ASCII representation
/// 
/// # Throws
/// 
/// Panic when input b >= 16
pub 
fn byte2hexchar(b: u8) -> u8
{
    match b
    {
        0..=9 => return '0' as u8 + b,
        10..=15 => return 'a' as u8 + (b - 10),
        _ => panic!("out of hex range!")
    }
}

/// Converts [IpAddr] to sequence of bytes coded specially for the payload
/// of package.
/// 
/// # Arguments
/// 
/// * `ip` - the argument with IP address
/// 
/// # Returns
/// 
/// * [CDnsResult] with vector of coded data
pub 
fn ip2pkt(ip: &IpAddr) -> CDnsResult<Vec<u8>>
{    
    match *ip
    {
        IpAddr::V4(ref ipv4) =>
            return ipv4_pkt(ipv4),
        IpAddr::V6(ref ipv6) =>
            return ipv6_pkt(ipv6)
    };
}

const MAX_NAME_LEN: usize = 63;

pub 
fn ipv4_pkt(ip: &Ipv4Addr) -> CDnsResult<Vec<u8>>
{    

    // pre allocate space
    let mut out: Vec<u8> = Vec::with_capacity(16 + IN_ADDR_ARPA.len());
    
    let mut octets = ip.octets();
    octets.reverse();

    for oct in octets
    {
        let str_oct = oct.to_string();

        if str_oct.len() > 3
        {
            internal_error!(
                CDnsErrorType::InternalError, 
                "domain component too long, len: '{}' oct: '{}'", 
                str_oct.len(), str_oct
            );
        }

        let ln: u8 = str_oct.len() as u8;

        out.push(ln);
        out.extend(str_oct.as_bytes());
    }

    out.extend(IN_ADDR_ARPA);

    return Ok(out);
}

pub 
fn ipv6_pkt(ip: &Ipv6Addr) -> CDnsResult<Vec<u8>>
{    
    // pre allocate space
    let mut out: Vec<u8> = Vec::with_capacity(32 + IN_ADDR6_ARPA.len());
    
    let mut octets = ip.octets();
    octets.reverse();

    for oct in octets
    {
        let h_oct = byte2hexchar((oct & 0xF0) >> 4);
        //format!("{:x}", (oct & 0xF0) >> 4);
        let l_oct = byte2hexchar(oct & 0x0F);
        //format!("{:x}", oct & 0x0F);

        //let ln: u8 = str_oct.len() as u8;

        out.push(1);
        out.push(l_oct);
        //out.extend(l_oct.as_bytes());
        out.push(1);
        out.push(h_oct);
    }

    out.extend(IN_ADDR6_ARPA);

    return Ok(out);
}

pub 
fn name2pkt(name: &str) -> CDnsResult<Vec<u8>>
{    
    // pre allocate space
    let mut out: Vec<u8> = Vec::with_capacity(name.len() + 2);
    
    for n in name.split(".")
    {
        if n.len() >= MAX_NAME_LEN
        {
            internal_error!(CDnsErrorType::InternalError, "name too long: '{}' in: '{}'", n.len(), name);
        }

        out.push((n.len() & 0xFF) as u8);
        out.extend(n.as_bytes());
    }

    out.push(0);

    return Ok(out);
}


/// A two octet code which specifies the type of the query.
/// TYPE fields are used in resource records.  Note that these types are a
/// subset of QTYPEs.
/// QTYPE fields appear in the question part of a query.  QTYPES are a
/// superset of TYPEs, hence all TYPEs are valid QTYPEs.
#[repr(u16)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum QType
{
    /// 1 a host address
    A = 1,
    /// 2 an authoritative name server
    NS = 2,
    /// 3 a mail destination (Obsolete - use MX)
    MD = 3,
    /// 4 a mail forwarder (Obsolete - use MX)
    MF = 4,
    /// 5 the canonical name for an alias
    CNAME = 5,
    /// 6 marks the start of a zone of authority
    SOA = 6,
    /// 7 a mailbox domain name (EXPERIMENTAL)
    MB = 7,
    /// 8 a mail group member (EXPERIMENTAL)
    MG = 8,
    /// 9 a mail rename domain name (EXPERIMENTAL)
    MR = 9,
    /// 10 a null RR (EXPERIMENTAL)
    NULL = 10,
    /// 11 a well known service description
    WKS = 11,
    /// 12 a domain name pointer
    PTR = 12,
    /// 13 host information
    HINFO = 13,
    /// 14 mailbox or mail list information
    MINFO = 14,
    /// 15 mail exchange
    MX = 15,
    /// 16 text strings
    TXT = 16,
    /// 18 AFS database record 
    AFSDB = 18,
    /// 25 Key record
    KEY = 25,
    /// 28 IPv6 address record
    AAAA = 28,
    /// 33 Service record
    SRV = 33,
    /// 37 Certificate records
    CERT = 37,
    /// 43 Delegation signer
    DS = 43,
    /// 46 DNSSEC signature
    RRSIG = 46,
    /// 47 Next Secure record
    NSEC = 47,
    /// DNS Key record
    DNSKEY = 48,
    /// 50 Next Secure record version 3
    NSEC3 = 50,
    /// 51 NSEC3 parameters
    NSEC3PARAM = 51,
    /// 59 Child DS 
    CDS = 59,
    /// 60 Child copy of DNSKEY record, for transfer to parent
    CDNSKEY = 60,
    /// OpenPGP public key record 
    OPENPGPKEY = 61,
    // ---- QTYPE ----
    /// 252 A request for a transfer of an entire zone
    AXFR = 252,
    /// 253 A request for mailbox-related records (MB, MG or MR)
    MAILB = 253,
    /// 254 A request for mail agent RRs (Obsolete - see MX)
    MAILA = 254,
    /// 256 Uniform Resource Identifier RFC 7553
    URI = 256,
    /// 257 Certification Authority Authorization 
    CAA = 257,
    /// *
    ALL = 255,
    /// 32769 DNSSEC Lookaside Validation record
    DLV = 32769,
}

impl Default for QType
{
    fn default() -> Self 
    {
        return Self::A;    
    }
}


impl Into<u16> for QType
{
    fn into(self) -> u16 
    {
        return self as u16;
    }
}

impl fmt::Display for QType
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
    {
        match *self
        {
            Self::A          => write!(f, "A"),
            Self::NS         => write!(f, "NS"),
            Self::MD         => write!(f, "MD"),
            Self::MF         => write!(f, "MF"),
            Self::CNAME      => write!(f, "CNAME"),
            Self::SOA        => write!(f, "SOA"),
            Self::MB         => write!(f, "MB"),
            Self::MG         => write!(f, "MG"),
            Self::MR         => write!(f, "MR"),
            Self::NULL       => write!(f, "NULL"),
            Self::WKS        => write!(f, "WKS"),
            Self::PTR        => write!(f, "PTR"),
            Self::HINFO      => write!(f, "HINFO"),
            Self::MINFO      => write!(f, "MINFO"),
            Self::MX         => write!(f, "MX"),
            Self::TXT        => write!(f, "TXT"),
            Self::AFSDB      => write!(f, "AFSDB"),
            Self::KEY        => write!(f, "KEY"),
            Self::AAAA       => write!(f, "AAAA"),
            Self::SRV        => write!(f, "SRV"),
            Self::CERT       => write!(f, "CERT"),
            Self::DS         => write!(f, "DS"),
            Self::RRSIG      => write!(f, "RRSIG"),
            Self::NSEC       => write!(f, "NSEC"),
            Self::DNSKEY     => write!(f, "DNSKEY"),
            Self::NSEC3      => write!(f, "NSEC"),
            Self::NSEC3PARAM => write!(f, "NSEC3PARAM"),
            Self::CDS        => write!(f, "CDS"),
            Self::CDNSKEY    => write!(f, "CDNSKEY"),
            Self::OPENPGPKEY => write!(f, "OPENPGPKEY"),
            Self::AXFR       => write!(f, "AXFR"),
            Self::MAILB      => write!(f, "MAILB"),
            Self::MAILA      => write!(f, "MAILA"),
            Self::CAA        => write!(f, "CAA"),
            Self::ALL        => write!(f, "ALL"),
            Self::DLV        => write!(f, "DLV"),
            Self::URI        => write!(f, "URI"),
        }
    }
}


impl QType
{
    pub 
    fn ipaddr_match(&self, ip: &IpAddr) -> bool
    {
        match *self
        {
            Self::A => return ip.is_ipv4(),
            Self::AAAA => return ip.is_ipv6(),
            _ => false,
        }
    }

    pub 
    fn u16_to_qtype(value: u16) -> CDnsResult<QType>
    {
        match value
        {
            x if x == Self::AXFR as u16    => return Ok(Self::AXFR),
            x if x == Self::MAILB as u16   => return Ok(Self::MAILB),
            x if x == Self::MAILA as u16   => return Ok(Self::MAILA),
            x if x == Self::ALL as u16     => return Ok(Self::ALL),
            x if x == Self::DLV as u16     => return Ok(Self::DLV),
            _ => return Self::u16_to_type(value),
        }
    }

    pub 
    fn u16_to_type(value: u16) -> CDnsResult<QType>
    {

        match value
        {
            x if x == Self::A as u16            => return Ok(Self::A),
            x if x == Self::NS as u16           => return Ok(Self::NS),
            x if x == Self::MD as u16           => return Ok(Self::MD),
            x if x == Self::MF as u16           => return Ok(Self::MF),
            x if x == Self::CNAME as u16        => return Ok(Self::CNAME),
            x if x == Self::SOA as u16          => return Ok(Self::SOA),
            x if x == Self::MB as u16           => return Ok(Self::MB),
            x if x == Self::MG as u16           => return Ok(Self::MG),
            x if x == Self::MR as u16           => return Ok(Self::MR),
            x if x == Self::NULL as u16         => return Ok(Self::NULL),
            x if x == Self::WKS as u16          => return Ok(Self::WKS),
            x if x == Self::PTR as u16          => return Ok(Self::PTR),
            x if x == Self::HINFO as u16        => return Ok(Self::HINFO),
            x if x == Self::MINFO as u16        => return Ok(Self::MINFO),
            x if x == Self::MX as u16           => return Ok(Self::MX),
            x if x == Self::TXT as u16          => return Ok(Self::TXT),
            x if x == Self::AFSDB as u16        => return Ok(Self::AFSDB),
            x if x == Self::KEY as u16          => return Ok(Self::KEY),
            x if x == Self::AAAA as u16         => return Ok(Self::AAAA),
            x if x == Self::CERT as u16         => return Ok(Self::CERT),
            x if x == Self::DS as u16           => return Ok(Self::DS),
            x if x == Self::RRSIG as u16        => return Ok(Self::RRSIG),
            x if x == Self::NSEC as u16         => return Ok(Self::NSEC),
            x if x == Self::DNSKEY as u16       => return Ok(Self::DNSKEY),
            x if x == Self::NSEC3 as u16        => return Ok(Self::NSEC3),
            x if x == Self::NSEC3PARAM as u16   => return Ok(Self::NSEC3PARAM),
            x if x == Self::CDS as u16          => return Ok(Self::CDS),
            x if x == Self::CDNSKEY as u16      => return Ok(Self::CDNSKEY),
            x if x == Self::OPENPGPKEY as u16   => return Ok(Self::OPENPGPKEY),
            _ => internal_error!(CDnsErrorType::DnsResponse, "unknown request record type: '{}'", value),
        }
    }
}


/// A two octet code that specifies the class of the query.
/// 
/// 
#[repr(u16)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum QClass
{
    /// the Internet 1
    IN = 1,
    /// the CSNET class (Obsolete) 2
    CS = 2,
    /// the CHAOS class 3
    CH = 3,
    /// Hesiod [Dyer 87] 4
    HS = 4,
    
    //  --- QClass
    /// any class 255
    ALL = 255,
}

impl fmt::Display for QClass
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match *self
        {
            Self::IN  => write!(f, "IN"),
            Self::CS  => write!(f, "CS"),
            Self::CH  => write!(f, "CH"),
            Self::HS  => write!(f, "HS"),
            Self::ALL => write!(f, "ALL"),
        }
    }
}

impl Default for QClass
{
    fn default() -> Self 
    {
        return Self::IN;    
    }
}

impl Into<u16> for QClass
{
    fn into(self) -> u16 
    {
        return self as u16;
    }
}

impl QClass
{
    /// Converts u16 to enum [QClass].
    /// 
    /// QCLASS fields appear in the question part of a query.  QCLASS are a
    /// superset of CLASSes, hence all CLASSes are valid QCLASSes.
    pub 
    fn u16_to_qclass(value: u16) -> CDnsResult<QClass>
    {
        match value
        {
            x if x == QClass::ALL as u16 => return Ok(QClass::ALL),
            _ => Self::u16_to_class(value),
        }
    }

    /// Converts u16 to enum [QClass], but for the response part of a query.
    pub 
    fn u16_to_class(value: u16) -> CDnsResult<QClass>
    {
        match value
        {
            x if x == QClass::IN as u16 => return Ok(QClass::IN),
            x if x == QClass::CS as u16 => return Ok(QClass::CS),
            x if x == QClass::CH as u16 => return Ok(QClass::CH),
            x if x == QClass::HS as u16 => return Ok(QClass::HS),
            _ => internal_error!(CDnsErrorType::DnsResponse, "unknown QCLASS type: '{}'", value),
        }
    }
}

// (req.status & !StatusBits::OPCODE_STANDARD) | ...
// () 

bitflags! {     
    /// Flags  which control the status of th DNS query    
    #[derive(Default, Debug, Copy, Clone, PartialEq, Eq)] 
    pub struct StatusBits: u16  
    {     
        // Pkt type Request/Result R/W    
        /// A request/response bit, when 1 - response
        const QR_RESP           = 0x8000;

        // Request Type (Write only)
        /// a standard query (QUERY) USE inverse to reset
        const OPCODE_STANDARD   = 0x87FF;
        /// an inverse query (IQUERY)
        const OPCODE_IQUERY     = 0x0040;
        /// a server status request (STATUS)
        const OPCODE_STATUS     = 0x0020;
        // reserved for future use 3-15
        // 0x4000 .. 0x0800

        /// AA  Authoritative Answer (Read only)
        /// Authoritative Answer - this bit is valid in responses,
        /// and specifies that the responding name server is an
        /// authority for the domain name in question section.
        const AUTH_ANSWER       = 0x0400;

        /// TrunCation (Read only)
        /// TrunCation - specifies that this message was truncated
        /// due to length greater than that permitted on the transmission channel.
        const TRUN_CATION       = 0x0200;

        /// RD Recursion desired (write only)
        /// Recursion Desired - this bit may be set in a query and
        /// is copied into the response.  If RD is set, it directs
        /// the name server to pursue the query recursively.
        /// Recursive query support is optional.
        const RECURSION_DESIRED = 0x0100;

        /// RA Recursion available (read only)
        /// Recursion Available - this be is set or cleared in a
        /// response, and denotes whether recursive query support is
        /// available in the name server.
        const RECURSION_AVAIL   = 0x0080;

        /// Z Zero reserver
        /// Reserved for future use.  Must be zero in all queries
        /// and responses.
        const RSERVER0          = 0x0040; 

        const ANSWER_AUTHN      = 0x0020; 
        const NON_AUTH_DATA     = 0x0010; 

        // RCODE response code 

        /// No error condition
        const RESP_NOERROR      = 0x0000; 
        /// Format error - The name server was unable to interpret the query.
        const RESP_FORMERR      = 0x0001; 
        /// Server failure - The name server was unable to process this query due to a
        /// problem with the name server.
        const RESP_SERVFAIL     = 0x0002; 
        /// Name Error - Meaningful only for responses from an authoritative name
        /// server, this code signifies that the domain name referenced in the query does
        /// not exist.
        const RESP_NXDOMAIN     = 0x0003;
        /// Not Implemented - The name server does not support the requested kind of query.
        const RESP_NOT_IMPL     = 0x0004; 
        /// Refused - The name server refuses to perform the specified operation for
        /// policy reasons.
        const RESP_REFUSED      = 0x0005; 
        // ..= 0x000F
    }
}

/// An structure for the target in request.
/// Implements From for [IpAddr], [Ipv4Addr], [Ipv6Addr], [str]
/// In case if IP address is in the human readable 'string' format
/// it will be stored as Name. And later the code will try to convert it
/// to IP address before returing as string.
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub enum QDnsName
{
    IpV4(Ipv4Addr),
    IpV6(Ipv6Addr),
    Name(Arc<String>),
}

impl fmt::Display for QDnsName
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            QDnsName::IpV4(ipv4_addr) => 
                write!(f, "{}", ipv4_addr),
            QDnsName::IpV6(ipv6_addr) => 
                write!(f, "{}", ipv6_addr),
            QDnsName::Name(name) => 
                write!(f, "{}", name),
        }
    }
}

impl QDnsName
{
    /// Answers if current type is IpV4.
    /// But does not performs check if Name is an IP in str format
    pub
    fn is_ipv4(&self) -> bool
    {
        match *self
        {
            Self::IpV4(_) => return true,
            _ => return false,
        }
    }

    /// Answers if current type is IpV6.
    /// But does not performs check if Name is an IP in str format
    pub 
    fn is_ipv6(&self) -> bool
    {
        match *self
        {
            Self::IpV6(_) => return true,
            _ => return false,
        }
    }

    /// Answers if current type is IpV4 or IpV6.
    /// But does not performs check if Name is an IP in str format
    pub 
    fn is_ip(&self) -> bool
    {
        match *self
        {
            Self::IpV4(_) => return true,
            Self::IpV6(_) => return true,
            _ => return false,
        }
    }

    /// Returns the type of the IP address version in [QType] format.
    pub 
    fn get_ip_qtype(&self) -> Option<QType>
    {
        match *self
        {
            Self::IpV4(_) => return Some(QType::A),
            Self::IpV6(_) => return Some(QType::AAAA),
            Self::Name(_) =>
            {
                return None;
            }
        }
    }
}


impl PartialEq<str> for QDnsName
{
    fn eq(&self, other: &str) -> bool 
    {
        match *self
        {
            Self::Name(ref name) => 
                return name.as_str() == other,
            Self::IpV4(ref ip) =>
            {
                if let Ok(other_ip) = other.parse::<Ipv4Addr>()
                {   
                    return &other_ip == ip;
                }
                
                return false;
            },
            Self::IpV6(ref ip) =>
            {
                if let Ok(other_ip) = other.parse::<Ipv6Addr>()
                {
                    return &other_ip == ip;
                }

                return false;
            }
        }
    }
}

/*
impl From<&IpAddr> for QDnsName
{
    fn from(ip: &IpAddr) -> Self 
    {
        match *ip
        {
            IpAddr::V4(ref ip) => 
                return Self::IpV4(ip.clone()),
            IpAddr::V6(ref ip) => 
                return Self::IpV6(ip.clone()),
        }
    }
}
*/

impl From<&IpAddr> for QDnsName
{
    fn from(ip: &IpAddr) -> Self
    {
        match *ip
        {
            IpAddr::V4(ref ip) => 
                return Self::IpV4(ip.clone()),
            IpAddr::V6(ref ip) => 
                return Self::IpV6(ip.clone()),
        }
    }
}

impl From<IpAddr> for QDnsName
{
    fn from(ip: IpAddr) -> Self
    {
        match ip
        {
            IpAddr::V4(ip) => 
                return Self::IpV4(ip),
            IpAddr::V6(ip) => 
                return Self::IpV6(ip),
        }
    }
}

impl From<&Ipv4Addr> for QDnsName
{
    fn from(ip: &Ipv4Addr) -> Self
    {
        return Self::IpV4(ip.clone());
    }
}

impl From<Ipv4Addr> for QDnsName
{
    fn from(ip: Ipv4Addr) -> Self
    {
        return Self::IpV4(ip);
    }
}

impl From<&Ipv6Addr> for QDnsName
{
    fn from(ip: &Ipv6Addr) -> Self
    {
        return Self::IpV6(ip.clone());
    }
}

impl From<Ipv6Addr> for QDnsName
{
    fn from(ip: Ipv6Addr) -> Self
    {
        return Self::IpV6(ip);
    }
}

impl From<&str> for QDnsName
{
    fn from(name: &str) -> Self
    {
        let ipp = name.parse::<IpAddr>();
        if ipp.is_err()
        {
            return Self::Name(Arc::new(name.to_string()));
        }
        else
        {
            return QDnsName::from(ipp.unwrap());
        }
    }
}

impl TryFrom<QDnsName> for Vec<u8>
{
    type Error = CDnsError;

    fn try_from(qns: QDnsName) -> Result<Self, Self::Error> 
    {
        match qns
        {
            QDnsName::IpV4(ref ip) =>
            {
                return ipv4_pkt(ip);
            },
            QDnsName::IpV6(ref ip) =>
            {
                return ipv6_pkt(ip);
            },
            QDnsName::Name(ref name) =>
            {
                if let Ok(ip) = name.parse::<Ipv4Addr>()
                {   
                    return ipv4_pkt(&ip);
                }
                else if let Ok(ip) = name.parse::<Ipv6Addr>()
                {
                    return ipv6_pkt(&ip);
                }
                else
                {
                    return name2pkt(name);
                }
            }
        }
    }
}

impl TryFrom<&QDnsName> for Vec<u8>
{
    type Error = CDnsError;

    fn try_from(qns: &QDnsName) -> Result<Self, Self::Error> 
    {
        match qns
        {
            QDnsName::IpV4(ip) =>
            {
                return ipv4_pkt(ip);
            },
            QDnsName::IpV6(ip) =>
            {
                return ipv6_pkt(ip);
            },
            QDnsName::Name(name) =>
            {
                if let Ok(ip) = name.parse::<Ipv4Addr>()
                {   
                    return ipv4_pkt(&ip);
                }
                else if let Ok(ip) = name.parse::<Ipv6Addr>()
                {
                    return ipv6_pkt(&ip);
                }
                else
                {
                    return name2pkt(name);
                }
            }
        }
    }
}

impl From<&QDnsName> for String
{
    fn from(dnsname: &QDnsName) -> Self 
    {
        match *dnsname
        {
            QDnsName::IpV4(ref ip) =>
            {
                return ip.to_string();
            },
            QDnsName::IpV6(ref ip) =>
            {
                return ip.to_string();
            },
            QDnsName::Name(ref name) =>
            {
                return name.to_string();
            }
        }
    }
}


impl TryFrom<&QDnsName> for IpAddr
{
    type Error = CDnsError;
    fn try_from(value: &QDnsName) -> Result<Self, Self::Error> 
    {
        match *value
        {
            QDnsName::IpV4(ref ip) =>
            {
                return Ok(IpAddr::V4(ip.clone()));
            },
            QDnsName::IpV6(ref ip) =>
            {
                return Ok(IpAddr::V6(ip.clone()));
            },
            QDnsName::Name(ref name) =>
            {
                if let Ok(ip) = name.parse::<Ipv4Addr>()
                {   
                    return Ok(IpAddr::V4(ip.clone()));
                }
                else if let Ok(ip) = name.parse::<Ipv6Addr>()
                {
                    return Ok(IpAddr::V6(ip.clone()));
                }
                else
                {
                    internal_error!(CDnsErrorType::InternalError, "not ip address!")
                }
            }
        }
    }
}


impl TryFrom<QDnsName> for IpAddr
{
    type Error = CDnsError;
    fn try_from(value: QDnsName) -> Result<Self, Self::Error> 
    {
        match value
        {
            QDnsName::IpV4(ip) =>
            {
                return Ok(IpAddr::V4(ip));
            },
            QDnsName::IpV6(ip) =>
            {
                return Ok(IpAddr::V6(ip));
            },
            QDnsName::Name(ref name) =>
            {
                if let Ok(ip) = name.parse::<Ipv4Addr>()
                {   
                    return Ok(IpAddr::V4(ip));
                }
                else if let Ok(ip) = name.parse::<Ipv6Addr>()
                {
                    return Ok(IpAddr::V6(ip));
                }
                else
                {
                    internal_error!(CDnsErrorType::InternalError, "not ip address!")
                }
            }
        }
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct DnsHeader
{
    /// A 16 bit identifier assigned by the program that
    /// generates any kind of query.
    pub id: u16,

    /// Query control flags
    pub status: StatusBits,

    /// an unsigned 16 bit integer specifying the number of
    /// entries in the question section.
    pub qdcount: u16,

    /// an unsigned 16 bit integer specifying the number of
    /// resource records in the answer section.
    pub ancount: u16,

    /// an unsigned 16 bit integer specifying the number of name
    /// server resource records in the authority records
    /// section.
    pub nscount: u16,

    /// an unsigned 16 bit integer specifying the number of
    /// resource records in the additional records section.
    pub arcount: u16,
}

impl fmt::Display for DnsHeader
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "ID:{} Status:{:?}, qdcnt:{}, ancnt:{}, nscnt:{}, arcnt:{}",
            self.id, self.status, self.qdcount, self.ancount, self.nscount, self.arcount)
    }
}


#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DnsRequestAnswer
{
    /// request header
    pub req_header: DnsRequestHeader,
    /// Resonse section
    pub response: Vec<DnsResponsePayload>,
    /// Additional RR
    pub additional: Vec<DnsResponsePayload>,
    /// Authortative nameservers
    pub authoratives: Vec<DnsResponsePayload>,
}

impl DnsRequestAnswer
{
    #[inline]
    pub 
    fn get_req_id(&self) -> u16
    {
        return self.req_header.get_id();
    }

    /// Validates the content
    /// 
    /// # Arguments
    /// 
    /// * `req` - a request which was sent 
    pub 
    fn verify(&self, req: &DnsRequestHeader) -> CDnsResult<()>
    {
        if self.get_req_id() != req.get_id()
        {
            internal_error!(
                CDnsErrorType::DnsResponse, 
                "request and response ID did not match: '{}' != '{}'", 
                req.header.id, self.get_req_id()
            );
        }

        // check if request matches with what we sent previously
        if self.req_header.payload != req.payload
        {
            internal_error!(CDnsErrorType::DnsResponse, 
                "received request section is different from sent");
        }
        else if req.payload.qtype != QType::ALL
        {
            // check qtype matches requested. (is it correct?)
            if req.payload.qtype != self.req_header.payload.qtype
            {
                internal_error!(
                    CDnsErrorType::DnsResponse, 
                    "requested QTYPE differ received TYPE: '{}' != '{}'", 
                    req.payload.qtype, 
                    self.req_header.payload.qtype
                );
            }
        }
        else if self.req_header.header.status.contains(StatusBits::TRUN_CATION) == true
        {
            internal_error!(CDnsErrorType::MessageTruncated, 
                "DNS response was truncated, aborting processing");
        }

        return Ok(());
    }

    /// Parses the raw data from received packet.
    /// 
    /// # Arguments
    /// 
    /// * `ans` - the received data
    pub(crate) 
    fn parse(ans: &[u8]) -> CDnsResult<Self>
    {
        // creating cursor
        let mut pkt = Cursor::new(ans);

        // parsing header
        let id = pkt.read_u16::<BigEndian>().map_err(map_read_err)?;

        let status = pkt.read_u16::<BigEndian>().map_err(map_read_err)?;

        let header = 
            DnsHeader
            {
                id: id,
                status: StatusBits::from_bits(status).ok_or_else(|| 
                    internal_error_map!(CDnsErrorType::DnsResponse, "unknown status bits: '{}'", status)
                )?,
                qdcount: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                ancount: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                nscount: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                arcount: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
            };

        // todo!("what about truncated messages");

        // check if there is no more than 1 answer
        if header.status.contains(StatusBits::QR_RESP) == false
        {
            internal_error!(
                CDnsErrorType::DnsResponse, 
                "incorret QR flag in STATUS register of response, expected 1 got 0"
            );
        }
       /*else if header.ancount > 1
        {
            internal_error!(
                CDnsErrorType::DnsRespose, 
                "too many responses = '{}', multiple responses are not supported", 
                header.ancount
            );
        }*/
        /*else if header.ancount == 0 && header.status.contains(StatusBits::RESP_NOERROR) == true
        {
            internal_error!(CDnsErrorType::DnsRespose, "answer count: 0 while response contains no error");
        }*/
        
        // reading request
        //let cur_offset = pkt.position();
    
        let request = 
            DnsRequestPayload
            {
                qname: pkt2name(&mut pkt)?,
                qtype: QType::u16_to_qtype(pkt.read_u16::<BigEndian>().map_err(map_read_err)?)?,
                qclass: QClass::u16_to_qclass(pkt.read_u16::<BigEndian>().map_err(map_read_err)?)?,
            };

        let mut an_list: Vec<DnsResponsePayload> = Vec::with_capacity(header.ancount as usize);
        let mut rr_list: Vec<DnsResponsePayload> = Vec::with_capacity(header.arcount as usize);
        let mut ns_list: Vec<DnsResponsePayload> = Vec::with_capacity(header.nscount as usize);

        for _ in 0..header.ancount
        {
            an_list.push(DnsResponsePayload::new(&mut pkt)?);
        }
        
        // reading authoritative section if any
        for _ in 0..header.nscount
        {
            ns_list.push(DnsResponsePayload::new(&mut pkt)?);
        }

        // reading additional if any
        for _ in 0..header.arcount
        {
            rr_list.push(DnsResponsePayload::new(&mut pkt)?);
        }

        return Ok(
            DnsRequestAnswer
            {
                req_header: DnsRequestHeader{ header, payload: request },
                response: an_list,
                additional: rr_list,
                authoratives: ns_list,
            }
        );
    }

}

#[derive(Clone, Debug, Default)]
pub struct DnsRequestHeader
{
    /// request header
    pub header: DnsHeader,
    /// Query content
    pub payload: DnsRequestPayload,
}

impl Eq for DnsRequestHeader {}

impl PartialEq for DnsRequestHeader
{
    fn eq(&self, other: &DnsRequestHeader) -> bool 
    {
        return self.header.id == other.header.id && self.payload == other.payload;
    }
}

impl Ord for DnsRequestHeader 
{
    fn cmp(&self, other: &Self) -> Ordering 
    {
        // Sort in reverse order
        return self.header.id.cmp(&other.header.id);
    }
}

impl PartialOrd for DnsRequestHeader 
{
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> 
    {
        return Some(self.cmp(other));
    }
}

impl Hash for DnsRequestHeader
{
    fn hash<H: Hasher>(&self, state: &mut H) 
    {
        self.header.id.hash(state);
        self.payload.hash(state);
    }
}

impl Borrow<u16> for DnsRequestHeader
{
    fn borrow(&self) -> &u16 
    {
        return &self.header.id;
    }
}

impl TryFrom<&QDnsReq> for DnsRequestHeader
{
    type Error = CDnsError;

    fn try_from(value: &QDnsReq) -> Result<Self, Self::Error> 
    {
        return DnsRequestHeader::construct_lookup(value);//qrec.get_req_name().clone(), *qrec.get_type());
    }
}

impl fmt::Display for DnsRequestHeader
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "Header: {}, Status: {}", self.header, self.payload)
    }
}


impl DnsRequestHeader
{
    pub 
    fn regenerate_id(&mut self)
    {
        self.header.id = rand::random();
    }

    pub 
    fn get_id(&self) -> u16
    {
        return self.header.id;
    }

   /* pub 
    fn from_qdns_req(qrec: &QDnsReq) -> CDnsResult<Self>
    {
        return DnsRequestHeader::construct_lookup(qrec.get_req_name().clone(), *qrec.get_type());
    }
    */

    pub 
    fn derive(&self) -> Self
    {
        let header = 
            DnsHeader
            {
                id: rand::random(),
                status: self.header.status,
                qdcount: self.header.qdcount,
                ancount: self.header.ancount,
                nscount: self.header.nscount,
                arcount: self.header.arcount,
            };

        return DnsRequestHeader{ header: header, payload: self.payload.clone() };
    }

    /// Constructs the request from input.
    pub
    fn construct_lookup(qreq: &QDnsReq) -> CDnsResult<DnsRequestHeader>
    {        
        // preparing status register
        let mut status: StatusBits = StatusBits::empty();
        status = (status & !StatusBits::OPCODE_STANDARD) | StatusBits::RECURSION_DESIRED;

        // constructing request structure
        let mut req: DnsRequestHeader = DnsRequestHeader{ ..Default::default() };

        req.header.id = rand::random();
        req.header.status = status;
        req.header.qdcount = 1;

        // creating payload request
        req.payload = DnsRequestPayload::new(qreq.get_req_name().try_into()?, *qreq.get_type(), QClass::IN);

        return Ok(req);
    }
    
    pub 
    fn to_bytes(&self, append_len: bool) -> CDnsResult<Vec<u8>>
    {
        let mut pkt_size: usize = size_of::<DnsHeader>() + self.payload.qname.len() + 4; 

        if append_len == true
        {
            pkt_size += 2;
        }

        let mut pkt = Cursor::new(vec![0_u8; pkt_size]);

        if append_len == true
        {
            pkt.write_u16::<BigEndian>((pkt_size-2) as u16).map_err(map_read_err)?;
        }

        pkt.write_u16::<BigEndian>(self.header.id).map_err(map_read_err)?;
        pkt.write_u16::<BigEndian>(self.header.status.bits()).map_err(map_read_err)?;
        pkt.write_u16::<BigEndian>(self.header.qdcount).map_err(map_read_err)?;
        pkt.write_u16::<BigEndian>(self.header.ancount).map_err(map_read_err)?;
        pkt.write_u16::<BigEndian>(self.header.nscount).map_err(map_read_err)?;
        pkt.write_u16::<BigEndian>(self.header.arcount).map_err(map_read_err)?;

        //for p in self.payload.iter()
        //{
            pkt.write(self.payload.qname.as_slice()).map_err(map_read_err)?;
            pkt.write_u16::<BigEndian>(self.payload.qtype.into()).map_err(map_read_err)?;
            pkt.write_u16::<BigEndian>(self.payload.qclass.into()).map_err(map_read_err)?;
        //}

        return Ok(pkt.into_inner());
    }
}

/// A request payload with (request) lines.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct DnsRequestPayload
{
    /// a domain name represented as a sequence of labels
    pub qname: Vec<u8>,

    /// a two octet code which specifies the type of the query.
    pub qtype: QType,
    
    /// a two octet code that specifies the class of the query.
    pub qclass: QClass,
}

impl fmt::Display for DnsRequestPayload
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "qname:{:?} qtype:{}, qclass:{}", self.qname, self.qtype, self.qclass)
    }
}

impl DnsRequestPayload
{
    pub 
    fn new(qname: Vec<u8>, qtype: QType, qclass: QClass) -> Self
    {
        return DnsRequestPayload{ qname: qname, qtype: qtype.into(), qclass: qclass.into() };
    }
}

/// A response section
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct DnsResponsePayload
{
    // A domain name that was queried, in the same format as the QNAME in the question
    pub name: String,
    /// Two octets containing one of th type codes.
    pub dtype: QType,
    /// Two octets which specify the class of the data in the RDATA field
    pub class: QClass,
    /// specifies the time interval that the resource record may be cached before the source
    /// of the information should again be consulted
    pub ttl: i32,
    /// specifies the length in octets of the RDATA field
    pub rdlength: u16,
    /// a variable length string of octets that describes the resource
    pub rdata: DnsRdata,
}

impl DnsResponsePayload
{
    /// Creates a record from [HostnameEntry], but only for types like
    /// A, AAAA, PTR
    pub(crate)
    fn new_local(dtype: QType, data: &HostnameEntry) -> Option<Vec<Self>>
    {
        match dtype
        {
            QType::A => 
            {
                let mut out: Vec<Self> = Vec::with_capacity(1);

                let IpAddr::V4(ipv4) = data.get_ip()
                else { return None; };

                out.push(
                    DnsResponsePayload
                    {
                        name: data.get_hostnames()[0].to_string(),
                        dtype: dtype,
                        class: QClass::IN,
                        ttl: i32::MAX,
                        rdlength: 0,
                        rdata: RecordA::wrap(RecordA{ ip: ipv4.clone()}),
                    }
                );

                return Some(out);
            },
            QType::AAAA => 
            {
                let mut out: Vec<Self> = Vec::with_capacity(1);

                let IpAddr::V6(ipv6) = data.get_ip()
                else { return None };

                out.push(
                    DnsResponsePayload
                    {
                        name: data.get_hostnames()[0].to_string(),
                        dtype: dtype,
                        class: QClass::IN,
                        ttl: i32::MAX,
                        rdlength: 0,
                        rdata: RecordAAAA::wrap(RecordAAAA{ ip: ipv6.clone() }),
                    }
                );

                return Some(out);
            },
            QType::PTR => 
            {
                let mut out: Vec<Self> = Vec::with_capacity(data.get_hostnames().len());

                // copy all hostnames from the list
                for h in data.get_hostnames_iter()
                {
                    out.push(
                        DnsResponsePayload
                        {
                            name: [data.get_ip().to_string().as_str(), ".in-addr.arpa"].concat(),
                            dtype: dtype,
                            class: QClass::IN,
                            ttl: i32::MAX,
                            rdlength: 0,
                            rdata: RecordPTR::wrap( RecordPTR { fqdn: h.clone() }),
                        }
                    );
                }
            
                return Some(out);
            },
            _ => 
                return None
        }
        
    }

    fn new(pkt: &mut Cursor<&[u8]>) -> CDnsResult<Self>
    {
        let name = name2str(pkt, None)?;
        let qtype = QType::u16_to_type(pkt.read_u16::<BigEndian>().map_err(map_read_err)?)?;
        let qclass = QClass::u16_to_class(pkt.read_u16::<BigEndian>().map_err(map_read_err)?)?;
        let ttl = pkt.read_i32::<BigEndian>().map_err(map_read_err)?;
        let rdlength = pkt.read_u16::<BigEndian>().map_err(map_read_err)?;
        let rdata = DnsRdata::convert(pkt, rdlength, qtype)?;

        return Ok(
            DnsResponsePayload
            {
                name: name,
                dtype: qtype,
                class: qclass,
                ttl: ttl,
                rdlength: rdlength,
                rdata: rdata,
            }
        );
    }

    pub 
    fn get_rdata(&self) -> &DnsRdata
    {
        return &self.rdata;
    }

    pub 
    fn borrow_rdata(self) -> DnsRdata
    {
        return self.rdata;
    }
}

/*impl Default for DnsResponsePayload
{
    fn default() -> Self 
    {
        return Self::Empty;    
    }
}*/

impl fmt::Display for DnsResponsePayload
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{} {} {} {} {}", 
            self.name, self.dtype, self.class, self.ttl, self.rdata)  
    }
}


/// Trait for decoding DNS record structures from bytes read over the wire.
pub trait RecordReader: Sized 
{

    /// A [QType] a record type for current instance
    const REC_TYPE: QType;

    /// A data size
    const RLEN: u16;

    /// Read at most `len` bytes from the given `Cursor`. This cursor travels
    /// throughout the complete data — by this point, we have read the entire
    /// response into a buffer.
    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self>;

    fn wrap(self) -> DnsRdata;
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordA
{
    pub ip: Ipv4Addr
}

impl RecordReader for RecordA
{
    const REC_TYPE: QType = QType::A;

    const RLEN: u16 = 4;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        // read 4 bytes (octets)
        if rlen != Self::RLEN
        {
            internal_error!(CDnsErrorType::DnsResponse, "RecordA len expected: '4', got: '{}'", rlen);
        }
        else if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        let ip = pkt.read_u32::<BigEndian>().map_err(map_read_err)?;

        return Ok(Self{ip: Ipv4Addr::from(ip) });
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::A(self);
    }
}

impl fmt::Display for RecordA
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.ip)
    }
}


#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordAAAA
{
    pub ip: Ipv6Addr
}

impl RecordReader for RecordAAAA
{
    const REC_TYPE: QType = QType::AAAA;

    const RLEN: u16 = 16;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if rlen != Self::RLEN
        {
            internal_error!(CDnsErrorType::DnsResponse, "RecordAAAA len expected: '{}', got: '{}'", Self::RLEN, rlen);
        }
        else if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        let ip = pkt.read_u128::<BigEndian>().map_err(map_read_err)?;
        
        return Ok(Self{ ip: Ipv6Addr::from(ip) });
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::AAAA(self);
    }
}

impl fmt::Display for RecordAAAA
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.ip)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordPTR
{
    pub fqdn: String
}

impl RecordReader for RecordPTR
{
    const REC_TYPE: QType = QType::PTR;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self{ fqdn: name2str(pkt, Some(rlen))? }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::PTR(self);
    }
}

impl fmt::Display for RecordPTR
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.fqdn)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordMX
{
    pub preference: u16, 
    pub exchange: String
}

impl RecordReader for RecordMX
{
    const REC_TYPE: QType = QType::MX;

    const RLEN: u16 = 2;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if rlen <= Self::RLEN
        {
            internal_error!(CDnsErrorType::DnsResponse, "RecordMX len expected: '{}', got: '{}'", Self::RLEN, rlen);
        }
        else if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self
            { 
                preference: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                exchange: name2str(pkt, Some(rlen - 2))?,
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::MX(self);
    }
}

impl fmt::Display for RecordMX
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {} {}", Self::REC_TYPE, self.preference, self.exchange)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordCNAME
{
    pub fqdn: String
}

impl RecordReader for RecordCNAME
{
    const REC_TYPE: QType = QType::CNAME;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self{ fqdn: name2str(pkt, Some(rlen))? }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::CNAME(self);
    }
}

impl fmt::Display for RecordCNAME
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.fqdn)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordNS
{
    pub fqdn: String
}

impl RecordReader for RecordNS
{
    const REC_TYPE: QType = QType::NS;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self{ fqdn: name2str(pkt, Some(rlen))? }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::NS(self);
    }
}

impl fmt::Display for RecordNS
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.fqdn)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordSOA
{
    /// primary name server
    pub pnm: String, 
    /// responsible authority mailbox
    pub ram: String,
    /// serial number
    pub serial: u32,
    /// refresh interval
    pub interv_refr: u32,
    /// retry interval
    pub interv_retry: u32,
    /// expire limit
    pub expire_limit: u32,
    /// minimum TTL
    pub min_ttl: u32,
}

impl RecordReader for RecordSOA
{
    const REC_TYPE: QType = QType::SOA;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, _rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self
            { 
                // primary name server
                pnm: name2str(pkt, None)?, 
                // responsible authority mailbox
                ram: name2str(pkt, None)?,
                // serial number
                serial: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                // refresh interval
                interv_refr: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                // retry interval
                interv_retry: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                // expire limit
                expire_limit: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                // minimum TTL
                min_ttl: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::SOA(self);
    }
}

impl fmt::Display for RecordSOA
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {} {} {} {} {} {} {}", Self::REC_TYPE, self.pnm, self.ram, self.serial, 
            self.interv_refr, self.interv_retry, self.expire_limit, self.min_ttl)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordSRV
{
    /// the priority of the target host, lower value means more preferred.
    pub priority: u16,

    /// A relative weight for records with the same priority, higher value 
    /// means higher chance of getting picked.
    pub weight: u16,

    /// the TCP or UDP port on which the service is to be found.
    pub port: u16,

    /// the canonical hostname of the machine providing the service, ending in a dot.
    pub target: String,
}

impl RecordReader for RecordSRV
{
    const REC_TYPE: QType = QType::SRV;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, _rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self
            { 
                priority: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                weight: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                port: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                target: name2str(pkt, None)?,
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::SRV(self);
    }
}

impl fmt::Display for RecordSRV
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {} {} {} \"{}\"", Self::REC_TYPE, self.priority, self.weight, self.port, self.target)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordTXT
{
    /// The character-strings.
    pub txt_strings: String,
}

impl RecordReader for RecordTXT
{
    const REC_TYPE: QType = QType::TXT;

    const RLEN: u16 = 2;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if rlen <= Self::RLEN
        {
            internal_error!(CDnsErrorType::DnsResponse, "RecordTXT len expected: '{}' >, got: '{}'", Self::RLEN, rlen);
        }
        else if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        let mut read_length = 0;
        

        let dmod = ((rlen % 255) > 0) as u16;
        let cap = rlen / 255 + dmod;

        let mut txt_datas = Vec::<String>::with_capacity(cap as usize);
    
        while read_length < rlen
        {
            let mut txt_data = Vec::new();

            loop
            {
                let blk_size = pkt.read_u8().map_err(map_read_err)?;

                read_length += blk_size as u16 + 1;

                let mut new_txt = Vec::with_capacity(blk_size as usize);//vec![0_u8; blk_size as usize];//Vec::with_capacity(blk_size as usize);// vec![0_u8; blk_size as usize];
                unsafe { new_txt.set_len(blk_size as usize); }

                pkt.read_exact(&mut new_txt).map_err(map_read_err)?;

                txt_data.push(new_txt);

                if blk_size < 255
                {
                    break;
                }
            }

            if txt_data.is_empty() == true
            {
                internal_error!(
                    CDnsErrorType::DnsResponse, 
                    "unexpected EOF in TXT rec cur position: '{}', data_length: '{}', read: '{}'",
                    pkt.position(), rlen, read_length
                );
            }

            let data = txt_data.concat();

            txt_datas.push(
                String::from_utf8(data)
                    .map_err(|e|
                        internal_error_map!(CDnsErrorType::InternalError, "UTF-8 decode error, {}", e)
                    )?
                );
        }

        return Ok(
            Self
            { 
                txt_strings: txt_datas.concat()
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::TXT(self);
    }
}

impl fmt::Display for RecordTXT
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {}", Self::REC_TYPE, self.txt_strings)
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordURI
{
    /// the priority of the target host, lower value means more preferred.
    pub priority: u16,

    /// A relative weight for records with the same priority, higher value 
    /// means higher chance of getting picked.
    pub weight: u16,

    /// This field holds the URI of the target, enclosed in double-quote characters ('"'),
    /// where the URI is as specified in RFC 3986
    pub target: String,
}

impl RecordReader for RecordURI
{
    const REC_TYPE: QType = QType::URI;

    const RLEN: u16 = 4;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        if rlen <= Self::RLEN
        {
            internal_error!(CDnsErrorType::DnsResponse, "RecordURI len expected: '{}' >, got: '{}'", Self::RLEN, rlen);
        }
        else if qtype != Self::REC_TYPE
        {
            internal_error!(CDnsErrorType::DnsResponse, "expexted '{}', got: '{}'", Self::REC_TYPE, qtype);
        }

        return Ok(
            Self
            { 
                priority: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                weight: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                target: pkt2string_exact(pkt, rlen - 4)?,
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::URI(self);
    }
}

impl fmt::Display for RecordURI
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {} {} \"{}\"", Self::REC_TYPE, self.priority, self.weight, self.target)
    }
}

// https://www.ietf.org/rfc/rfc4034.txt

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordRRSIG
{
    type_cov: u16,
    alg: u8,
    labels: u8,
    orig_ttl: u32,
    sig_exp: u32,
    sig_inc: u32,
    keytag: u16,
    sig_name: String,
    key: Vec<u8>,
}

impl RecordReader for RecordRRSIG
{
    const REC_TYPE: QType = QType::RRSIG;

    const RLEN: u16 = 19;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, _qtype: QType) -> CDnsResult<Self> 
    {
        let data = vec![0_u8; rlen as usize];

        let pos = pkt.position();

        let mut res = 
            Self
            {
                type_cov: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                alg: pkt.read_u8().map_err(map_read_err)?,
                labels: pkt.read_u8().map_err(map_read_err)?,
                orig_ttl: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                sig_exp: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                sig_inc: pkt.read_u32::<BigEndian>().map_err(map_read_err)?,
                keytag: pkt.read_u16::<BigEndian>().map_err(map_read_err)?,
                sig_name: name2str(pkt,None)?,
                key: Vec::new(),
            };

        let left_rdlen = rlen - (pkt.position() - pos) as u16;
        res.key = pkt2vec(pkt, Some(left_rdlen))?;

        return Ok(res);
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::RRSIG(self);
    }
}

impl fmt::Display for RecordRRSIG
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   {} {} {} {} {} {} {} {} {}", 
            Self::REC_TYPE, self.type_cov, self.alg, self.labels, self.orig_ttl,
            self.sig_exp, self.sig_inc, self.keytag, self.sig_name, 
            self.key.iter().map(|k| format!("{:02X}", k)).collect::<Vec<String>>().concat()
        )
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RecordOther
{
    // record type
    pub qtype: QType,

    // raw data
    pub data: Vec<u8>
}

impl RecordReader for RecordOther
{
    const REC_TYPE: QType = QType::ALL;

    const RLEN: u16 = 0;

    fn read(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self> 
    {
        let mut data = vec![0_u8; rlen as usize];

        pkt.read_exact(&mut data).map_err(map_read_err)?;

        return Ok(
            Self
            { 
                qtype: qtype,
                data: data,
            }
        );
    }

    fn wrap(self) -> DnsRdata 
    {
        return DnsRdata::OTHER(self);
    }
}

impl fmt::Display for RecordOther
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        write!(f, "{}   RAW:", self.qtype)?;

        for d in self.data.iter()
        {
            write!(f, "{:X}", d)?;
        }

        return Ok(());
    }
}

pub(crate)
fn sanitize_str_unicode(st: &str) -> String
{
    let mut out = String::with_capacity(st.len());

    for c in st.chars()
    {
        if c.is_alphanumeric() == true ||
            c.is_ascii_punctuation() == true ||
            c == ' '
        {
            out.push(c);
        }
        else
        {
            let mut buf = [0_u8; 4];
            c.encode_utf8(&mut buf);

            let formatted: String = 
                buf[0..c.len_utf8()].into_iter()
                    .map(|c| format!("\\x{:02x}", c))
                    .collect();

            out.push_str(&formatted);
        }
    }

    return out;
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DnsRdata
{
    None,
    A(RecordA),
    NS(RecordNS),
    CNAME(RecordCNAME),
    SOA(RecordSOA),
    PTR(RecordPTR),
    MX(RecordMX),
    TXT(RecordTXT),
    AAAA(RecordAAAA), 
    SRV(RecordSRV),
    URI(RecordURI),    
    RRSIG(RecordRRSIG),
    OTHER(RecordOther),
}

impl fmt::Display for DnsRdata
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            Self::None => 
                write!(f, "No record"),
            Self::A(ip) => 
                write!(f, "{}", ip),
            Self::NS(ns) => 
                write!(f, "{}", ns),
            Self::AAAA(aaaa) => 
                write!(f, "{}", aaaa),
            Self::MX(mx) =>
                write!(f, "{}", mx),
            Self::CNAME(cname) => 
                write!(f, "{}", cname),
            Self::PTR(ptr) => 
                write!(f, "{}", ptr),
            Self::SOA(soa) => 
                write!(f, "{}", soa),
            Self::TXT(txt) => 
                write!(f, "{}", txt),
            Self::SRV(srv) => 
                write!(f, "{}", srv),
            Self::URI(uri) =>
                write!(f, "{}", uri),
            Self::RRSIG(rrsig) =>
                write!(f, "{}", rrsig),
            Self::OTHER(other) => 
                write!(f, "{}", other),
        }
    }
}

impl Default for DnsRdata
{
    fn default() -> Self 
    {
        return Self::None;   
    }
}

impl DnsRdata
{
    #[inline]
    pub 
    fn is_some(&self) -> bool
    {
        return *self != Self::None;
    }
}


impl DnsRdata
{
    /// Reads the RData from pkt and converts it into QType container
    /// 
    /// # Arguments
    /// 
    /// * `pkt` - a [Cursor] mutable reference to raw DNS reply data
    /// 
    /// * `rlen` - a length of RData section
    /// 
    /// * `qtype` - a [QType] reference to the response answer Qtype
    /// 
    /// # Returns
    /// 
    /// * [CDnsResult] with Self or error
    pub 
    fn convert(pkt: &mut Cursor<&[u8]>, rlen: u16, qtype: QType) -> CDnsResult<Self>
    {
        match qtype
        {
            RecordA::REC_TYPE => 
                return Ok(RecordA::wrap(RecordA::read(pkt, rlen, qtype)?)),
            RecordAAAA::REC_TYPE => 
                return Ok(RecordAAAA::wrap(RecordAAAA::read(pkt, rlen, qtype)?)),
            RecordPTR::REC_TYPE => 
                return Ok(RecordPTR::wrap(RecordPTR::read(pkt, rlen, qtype)?)),
            RecordMX::REC_TYPE =>
                return Ok(RecordMX::wrap(RecordMX::read(pkt, rlen, qtype)?)),
            RecordCNAME::REC_TYPE =>
                return Ok(RecordCNAME::wrap(RecordCNAME::read(pkt, rlen, qtype)?)),
            RecordSOA::REC_TYPE =>
                return Ok(RecordSOA::wrap(RecordSOA::read(pkt, rlen, qtype)?)),
            RecordSRV::REC_TYPE => 
                return Ok(RecordSRV::wrap(RecordSRV::read(pkt, rlen, qtype)?)),
            RecordTXT::REC_TYPE =>
                return Ok(RecordTXT::wrap(RecordTXT::read(pkt, rlen, qtype)?)),
            RecordURI::REC_TYPE =>
                return Ok(RecordURI::wrap(RecordURI::read(pkt, rlen, qtype)?)),
            RecordNS::REC_TYPE => 
                return Ok(RecordNS::wrap(RecordNS::read(pkt, rlen, qtype)?)),
            RecordRRSIG::REC_TYPE =>
                return Ok(RecordRRSIG::wrap(RecordRRSIG::read(pkt, rlen, qtype)?)),
            _ =>
                return Ok(RecordOther::wrap(RecordOther::read(pkt, rlen, qtype)?)),
        }
    }

    pub 
    fn get_ip(&self) -> Option<IpAddr>
    {
        match self
        {
            Self::A(a) => return Some(IpAddr::V4(a.ip)),
            Self::AAAA(a) => return Some(IpAddr::V6(a.ip)),
            _ => return None
        }
    }
}

#[cfg(test)]
mod tests
{
    use std::io::Cursor;

    use crate::common::*;



    #[test]
    fn test_pkt2name()
    {
        use std::time::Instant;
    
        fn prepare(d: &[u8]) -> Cursor<&[u8]>
        {
           // let vd = d.to_vec();
    
            return Cursor::new(d);
        }
    
        let t1 = b"\x03\x64\x6e\x73\x06\x67\x6f\x6f\x67\x6c\x65\x00";
    
        let mut cur1 = prepare(t1);
    
        let now = Instant::now();
        let r1 = pkt2name(&mut cur1);
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(r1.is_ok(), true);
        assert_eq!(r1.as_ref().unwrap(), t1);
    
        let t2 = 
        b"\x0f\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74\x00";
    
        let mut cur2 = prepare(t2);
        let now = Instant::now();
        let r2 = pkt2name(&mut cur2);
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(r2.is_ok(), true);
        assert_eq!(r2.as_ref().unwrap(), t2);
    
        let t3 = 
        b"\x0f\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74";
    
        let r3 = pkt2name(&mut prepare(t3));
    
        assert_eq!(r3.is_ok(), false);
    
        let t4 = 
        b"\x10\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74";
    
        let r4 = pkt2name(&mut prepare(t4));
    
        assert_eq!(r4.is_ok(), false);
    }
    
    #[test]
    fn test_qname2str()
    {
        use std::time::Instant;
    
        fn prepare(d: &[u8]) -> Cursor<&[u8]>
        {
            //let vd = d.to_vec();
    
            return Cursor::new(d);
        }
    
        let t1 = b"\x03\x64\x6e\x73\x06\x67\x6f\x6f\x67\x6c\x65\x00";
    
        let mut cur1 = prepare(t1);
        let now = Instant::now();
        let r1 = name2str(&mut cur1, None);
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(r1.is_ok(), true);
        assert_eq!(r1.as_ref().unwrap(), "dns.google");
    
        let t2 = 
        b"\x0f\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74\x00";
    
        let mut cur2 = prepare(t2);
    
        let now = Instant::now();
        let r2 = name2str(&mut cur2, None);
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(r2.is_ok(), true);
        assert_eq!(r2.as_ref().unwrap(), "mad07s09-in-x0e.1e100.net");
    
        let t3 = 
        b"\x0f\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74";
    
        let r3 = name2str(&mut prepare(t3), None);
    
        assert_eq!(r3.is_ok(), false);
    
        let t4 = 
        b"\x10\x6d\x61\x64\x30\x37\x73\x30\x39\x2d\x69\x6e\x2d\x78\x30\x65\x05\x31\x65\x31\
        \x30\x30\x03\x6e\x65\x74";
    
        let r4 = name2str(&mut prepare(t4), None);
    
        assert_eq!(r4.is_ok(), false);
    }
    
    #[test]
    fn test_response_parser()
    {
        use std::time::Instant;
    
        let pkt = 
        b"\x15\xc8\x81\x80\x00\x01\x00\x01\x00\x00\x00\x02\x01\x38\x01\x38\
        \x01\x38\x01\x38\x07\x69\x6e\x2d\x61\x64\x64\x72\x04\x61\x72\x70\
        \x61\x00\x00\x0c\x00\x01\xc0\x0c\x00\x0c\x00\x01\x00\x01\x35\xf0\
        \x00\x0c\x03\x64\x6e\x73\x06\x67\x6f\x6f\x67\x6c\x65\x00\xc0\x32\
        \x00\x01\x00\x01\x00\x00\x00\xe8\x00\x04\x08\x08\x08\x08\xc0\x32\
        \x00\x01\x00\x01\x00\x00\x00\xe8\x00\x04\x08\x08\x04\x04";
    
        let dummy = 
            DnsRequestHeader
            {
                header: DnsHeader {id: 0x15c8, ..Default::default()},
                payload: DnsRequestPayload
                    {
                        qname: b"\x01\x38\x01\x38\x01\x38\x01\x38\x07\x69\x6e\x2d\x61\x64\x64\x72\x04\x61\x72\x70\x61\x00".to_vec(),
                        qtype: QType::PTR,
                        qclass: QClass::IN, 
                    }
            };
    
        let now = Instant::now();
        let ans = DnsRequestAnswer::parse(pkt.as_slice());
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(ans.is_ok(), true, "{}", ans.err().unwrap());
        
        let ans = ans.unwrap();
    
        let verif = ans.verify(&dummy);
        assert_eq!(verif.is_ok(), true, "{}", verif.err().unwrap());
    
        assert_eq!(ans.req_header.header.id, 0x15c8);
        assert_eq!(ans.req_header.header.ancount, 1);
        assert_eq!(ans.req_header.header.arcount, 2);
        assert_eq!(ans.req_header.header.nscount, 0);
        assert_eq!(ans.req_header.header.qdcount, 1);
    
        assert_eq!(ans.response[0].rdata, RecordPTR::wrap(RecordPTR { fqdn: "dns.google".to_string() }) );
        assert_eq!(ans.response[0].name, "8.8.8.8.in-addr.arpa".to_string());
        assert_eq!(ans.response[0].dtype, QType::PTR);
        assert_eq!(ans.response[0].class, QClass::IN);
        assert_eq!(ans.response[0].ttl, 79344);
        assert_eq!(ans.response[0].rdlength, 12);
    
        assert_eq!(ans.additional[0].rdata, RecordA::wrap(RecordA { ip: "8.8.8.8".parse().unwrap() }) );
        assert_eq!(ans.additional[0].name, "dns.google".to_string());
        assert_eq!(ans.additional[0].ttl, 232);
        assert_eq!(ans.additional[0].dtype, QType::A);
        assert_eq!(ans.additional[0].class, QClass::IN);

        assert_eq!(ans.additional[1].rdata, RecordA::wrap(RecordA { ip: "8.8.4.4".parse().unwrap() }) );
        assert_eq!(ans.additional[1].name, "dns.google".to_string());
        assert_eq!(ans.additional[1].ttl, 232);
        assert_eq!(ans.additional[1].dtype, QType::A);
        assert_eq!(ans.additional[1].class, QClass::IN);
    }
    
    #[test]
    fn test_response2()
    {
        use std::time::Instant;
    
        let pkt = 
        b"\x4b\x38\x81\x80\x00\x01\x00\x05\x00\x00\x00\x00\x05\x67\x6d\x61\
        \x69\x6c\x03\x63\x6f\x6d\x00\x00\x0f\x00\x01\xc0\x0c\x00\x0f\x00\
        \x01\x00\x00\x0b\x55\x00\x1b\x00\x05\x0d\x67\x6d\x61\x69\x6c\x2d\
        \x73\x6d\x74\x70\x2d\x69\x6e\x01\x6c\x06\x67\x6f\x6f\x67\x6c\x65\
        \xc0\x12\xc0\x0c\x00\x0f\x00\x01\x00\x00\x0b\x55\x00\x09\x00\x0a\
        \x04\x61\x6c\x74\x31\xc0\x29\xc0\x0c\x00\x0f\x00\x01\x00\x00\x0b\
        \x55\x00\x09\x00\x1e\x04\x61\x6c\x74\x33\xc0\x29\xc0\x0c\x00\x0f\
        \x00\x01\x00\x00\x0b\x55\x00\x09\x00\x14\x04\x61\x6c\x74\x32\xc0\
        \x29\xc0\x0c\x00\x0f\x00\x01\x00\x00\x0b\x55\x00\x09\x00\x28\x04\
        \x61\x6c\x74\x34\xc0\x29";
    
        let dummy = 
            DnsRequestHeader
            {
                header: DnsHeader {id: 0x4b38, ..Default::default()},
                payload: DnsRequestPayload
                    {
                        qname: b"\x05\x67\x6d\x61\x69\x6c\x03\x63\x6f\x6d\x00".to_vec(),
                        qtype: QType::MX,
                        qclass: QClass::IN, 
                    }
            };
    
        let now = Instant::now();
        let ans = DnsRequestAnswer::parse(pkt.as_slice());
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(ans.is_ok(), true, "{}", ans.err().unwrap());
        let ans = ans.unwrap();
    
        let verif = ans.verify(&dummy);
        assert_eq!(verif.is_ok(), true, "{}", verif.err().unwrap());
    
        assert_eq!(ans.req_header.header.id, 0x4b38);
        assert_eq!(ans.req_header.header.ancount, 5);
        assert_eq!(ans.req_header.header.arcount, 0);
        assert_eq!(ans.req_header.header.nscount, 0);
        assert_eq!(ans.req_header.header.qdcount, 1);
    
        assert_eq!(ans.response[0].rdata, RecordMX::wrap(RecordMX { preference: 5, exchange: "gmail-smtp-in.l.google.com".to_string() }) );
        assert_eq!(ans.response[0].name, "gmail.com".to_string());
        assert_eq!(ans.response[0].dtype, QType::MX);
        assert_eq!(ans.response[0].class, QClass::IN);
        assert_eq!(ans.response[0].ttl, 2901);
        assert_eq!(ans.response[0].rdlength, 27);
    
        assert_eq!(ans.response[1].rdata, RecordMX::wrap(RecordMX { preference: 10, exchange: "alt1.gmail-smtp-in.l.google.com".to_string() }) );
        assert_eq!(ans.response[1].name, "gmail.com".to_string());
        assert_eq!(ans.response[1].dtype, QType::MX);
        assert_eq!(ans.response[1].class, QClass::IN);
        assert_eq!(ans.response[1].ttl, 2901);
        assert_eq!(ans.response[1].rdlength, 9);
    
        assert_eq!(ans.response[2].rdata, RecordMX::wrap(RecordMX { preference: 30, exchange: "alt3.gmail-smtp-in.l.google.com".to_string() }) );
        assert_eq!(ans.response[2].name, "gmail.com".to_string());
        assert_eq!(ans.response[2].dtype, QType::MX);
        assert_eq!(ans.response[2].class, QClass::IN);
        assert_eq!(ans.response[2].ttl, 2901);
        assert_eq!(ans.response[2].rdlength, 9);
    
        assert_eq!(ans.response[3].rdata, RecordMX::wrap(RecordMX { preference: 20, exchange: "alt2.gmail-smtp-in.l.google.com".to_string() }) );
        assert_eq!(ans.response[3].name, "gmail.com".to_string());
        assert_eq!(ans.response[3].dtype, QType::MX);
        assert_eq!(ans.response[3].class, QClass::IN);
        assert_eq!(ans.response[3].ttl, 2901);
        assert_eq!(ans.response[3].rdlength, 9);
    
        assert_eq!(ans.response[4].rdata, RecordMX::wrap(RecordMX { preference: 40, exchange: "alt4.gmail-smtp-in.l.google.com".to_string() }) );
        assert_eq!(ans.response[4].name, "gmail.com".to_string());
        assert_eq!(ans.response[4].dtype, QType::MX);
        assert_eq!(ans.response[4].class, QClass::IN);
        assert_eq!(ans.response[4].ttl, 2901);
        assert_eq!(ans.response[4].rdlength, 9);
    }
    
    
    #[test]
    fn test_response3()
    {
        use std::time::Instant;
    
        let pkt = 
    b"\xd0\x79\x81\x80\x00\x01\x00\x17\x00\x00\x00\x00\x06\x72\
    \x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\x00\xff\x00\x01\xc0\x0c\x00\
    \x06\x00\x01\x00\x00\x0e\x10\x00\x30\x04\x6e\x73\x32\x31\x07\x63\
    \x6c\x6f\x75\x64\x6e\x73\x03\x6e\x65\x74\x00\x07\x73\x75\x70\x70\
    \x6f\x72\x74\xc0\x2c\x78\x77\xe2\xf1\x00\x00\x1c\x20\x00\x00\x07\
    \x08\x00\x12\x75\x00\x00\x00\x0e\x10\xc0\x0c\x00\x2e\x00\x01\x00\
    \x00\x0e\x10\x00\x5d\x00\x06\x0d\x02\x00\x00\x0e\x10\x61\xf2\xaf\
    \x39\x61\xcb\x22\x39\x28\xeb\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\
    \x6b\x00\x2f\x79\xed\x73\xd0\x75\xc8\xa9\xa2\x2a\x08\x3c\x78\xb9\
    \xfb\x43\xc5\x8e\x62\x4c\xbc\x36\xeb\x22\x96\x45\x59\x36\x1f\x69\
    \x3a\x7a\x5e\x67\xd0\x54\x1e\xf0\xf2\x11\x1a\x72\x00\x56\x89\x26\
    \x79\xf4\x06\x1a\x0c\x59\x41\x32\x60\x68\x75\x05\x3d\x90\xed\x1e\
    \x0f\xfc\xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\x10\x00\x02\xc0\x27\
    \xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\x10\x00\x08\x05\x70\x6e\x73\
    \x32\x33\xc0\x2c\xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\x10\x00\x07\
    \x04\x6e\x73\x32\x33\xc0\x2c\xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\
    \x10\x00\x08\x05\x70\x6e\x73\x32\x32\xc0\x2c\xc0\x0c\x00\x02\x00\
    \x01\x00\x00\x0e\x10\x00\x08\x05\x70\x6e\x73\x32\x34\xc0\x2c\xc0\
    \x0c\x00\x02\x00\x01\x00\x00\x0e\x10\x00\x07\x04\x6e\x73\x32\x34\
    \xc0\x2c\xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\x10\x00\x08\x05\x70\
    \x6e\x73\x32\x31\xc0\x2c\xc0\x0c\x00\x02\x00\x01\x00\x00\x0e\x10\
    \x00\x07\x04\x6e\x73\x32\x32\xc0\x2c\xc0\x0c\x00\x2e\x00\x01\x00\
    \x00\x0e\x10\x00\x5d\x00\x02\x0d\x02\x00\x00\x0e\x10\x61\xf2\xaf\
    \x39\x61\xcb\x22\x39\x28\xeb\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\
    \x6b\x00\xd1\xc5\x6c\xf1\xfb\xd0\x75\xf1\x38\x20\x28\x80\x4c\xe0\
    \x59\xa5\xa8\xab\x84\x79\xd8\x37\x48\xa7\xa5\x3f\x08\x9b\x4c\xca\
    \x40\x2b\xcb\x2c\xda\xcc\xc2\x18\xad\x07\x9e\xf8\x4e\x17\x8d\xb1\
    \x2b\x2d\xa2\xa6\x17\xdb\x55\x30\xbc\xa2\xb9\xa0\x01\x71\x01\xe5\
    \xdc\x4f\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xd9\x14\
    \x70\xd0\xc0\x0c\x00\x2e\x00\x01\x00\x00\x0e\x10\x00\x5d\x00\x01\
    \x0d\x02\x00\x00\x0e\x10\x61\xf2\xaf\x39\x61\xcb\x22\x39\x28\xeb\
    \x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\xf8\x57\x68\xf0\xad\
    \x9e\xfb\x3a\x0f\x66\xbd\xcc\x48\xe7\x29\x0a\xf4\xd8\xf6\xbe\xbc\
    \x04\x76\x02\x27\x64\xf2\xc9\x42\x6d\x75\x54\x83\x0a\x11\xda\x0a\
    \x02\x6b\x8c\xf1\x65\xc4\x21\x44\xea\x89\x09\x01\xc8\xa1\xe2\x11\
    \x8f\xed\x67\x39\x69\x33\xdd\x97\x22\x1a\xd3\xc0\x0c\x00\x0f\x00\
    \x01\x00\x00\x0e\x10\x00\x11\x00\x0a\x04\x6d\x61\x69\x6c\x04\x6e\
    \x69\x78\x64\x03\x6f\x72\x67\x00\xc0\x0c\x00\x2e\x00\x01\x00\x00\
    \x0e\x10\x00\x5d\x00\x0f\x0d\x02\x00\x00\x0e\x10\x61\xf2\xaf\x39\
    \x61\xcb\x22\x39\x28\xeb\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\
    \x00\xd4\xdd\x07\xd9\xb6\xb2\xba\x57\xa9\x1d\x3b\xaa\x6c\x55\xc4\
    \x3d\x73\x79\xea\x74\xfe\xd7\x23\x0c\xb4\xab\x8f\x4b\x1f\xd9\x8a\
    \xb2\x4a\x5c\xad\x3e\x8e\x4a\x85\xbb\xbd\x75\xf2\x47\x2c\xa8\x89\
    \x21\x75\x89\xb1\x12\xc4\xd2\xf7\x40\x06\x52\x57\x83\x8a\xaa\x7b\
    \x75\xc0\x0c\x00\x10\x00\x01\x00\x00\x0e\x10\x00\x34\x33\x76\x3d\
    \x73\x70\x66\x31\x20\x2b\x6d\x78\x20\x2b\x61\x3a\x6d\x61\x69\x6c\
    \x2e\x6e\x69\x78\x64\x2e\x6f\x72\x67\x20\x69\x70\x34\x3a\x32\x31\
    \x37\x2e\x32\x30\x2e\x31\x31\x32\x2e\x32\x30\x38\x20\x2d\x61\x6c\
    \x6c\xc0\x0c\x00\x2e\x00\x01\x00\x00\x0e\x10\x00\x5d\x00\x10\x0d\
    \x02\x00\x00\x0e\x10\x61\xf2\xaf\x39\x61\xcb\x22\x39\x28\xeb\x06\
    \x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\xd1\x6c\xd1\xf4\x3b\xe0\
    \x44\xba\xfe\xe9\xdb\x82\xbd\x89\x5f\xa1\x07\x72\xdd\x47\xad\x4e\
    \x91\xd5\xc3\xfe\x3e\x39\x74\xdb\x50\x50\x19\x6c\x3f\x6c\xb7\xa8\
    \x01\x03\x6a\xf5\xa7\xf3\x9b\xf7\x76\xd4\xff\xa3\xd5\x43\xfc\xec\
    \xa9\x89\x24\xf8\xd2\xb6\x76\xd4\x20\xbc\xc0\x0c\x00\x30\x00\x01\
    \x00\x00\x0e\x10\x00\x44\x01\x01\x03\x0d\xf3\x87\xe2\x7c\x2b\x82\
    \x40\x72\x7c\xfd\xc9\x2b\xe8\x22\xd6\xa9\x40\xc0\xab\x03\x25\x7d\
    \x92\xae\xf3\x17\x71\x82\x67\xc6\xcd\xb6\x4b\x11\x62\xc6\xfa\x06\
    \xec\x4c\x9f\xd9\xe6\xaf\x5c\x3d\xe4\x32\xde\x11\x1b\x09\x13\xe3\
    \xd0\xba\x66\xd1\xbc\x32\xdb\x13\xd7\x1d\xc0\x0c\x00\x30\x00\x01\
    \x00\x00\x0e\x10\x00\x44\x01\x00\x03\x0d\xd4\x43\xde\x96\xe5\xea\
    \x0a\xf9\x5d\x4f\x72\x88\x9c\xd9\x9c\xf7\xa6\x3f\x12\xd7\xf3\xea\
    \x8a\x6b\x44\x4c\x79\x23\x81\x94\x43\xa3\xbd\x9e\xb8\xde\xfe\x8c\
    \xe6\x21\xe3\x8a\x71\xba\x05\xd2\x0f\x98\x5b\xfc\x7e\x72\x8c\xe9\
    \x9a\xc0\x49\x00\xca\xd5\x62\x93\x7f\x03\xc0\x0c\x00\x2e\x00\x01\
    \x00\x00\x0e\x10\x00\x5d\x00\x30\x0d\x02\x00\x00\x0e\x10\x61\xf2\
    \xaf\x39\x61\xcb\x22\x39\x28\xeb\x06\x72\x65\x6c\x6b\x6f\x6d\x02\
    \x73\x6b\x00\xc0\x93\x23\x1d\xcb\x1e\x79\xfe\x7c\x40\x3e\xd4\x33\
    \x5f\xed\x69\x8e\x7d\x75\xff\x73\x6b\x24\x71\x8f\x50\xf8\xe0\x49\
    \xce\x5f\x62\x0c\x8c\xb3\x06\x8f\x26\xea\x20\xa0\xe3\x71\xe0\xa1\
    \x8b\xe0\x4a\x2f\x1d\x4b\x79\x2c\x52\x6b\xa4\x43\xb5\x70\x27\x01\
    \xb0\x63\x47\xc0\x0c\x00\x2e\x00\x01\x00\x00\x0e\x10\x00\x5d\x00\
    \x30\x0d\x02\x00\x00\x0e\x10\x61\xf2\xaf\x39\x61\xcb\x22\x39\x97\
    \x18\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\x41\x87\x75\x1d\
    \x30\x44\xd1\x94\x40\xd4\xe6\x40\x98\x62\x94\x53\xad\x53\xe2\xed\
    \xc0\xc0\xb7\xa3\x20\x15\xae\x59\xbb\x97\x45\xfb\x0e\xbf\x70\xf3\
    \xb1\x24\x79\xe8\x85\x6c\x2a\x66\x10\xb6\x75\x99\x7b\x77\x78\x65\
    \xa6\x67\x8d\x59\xa6\x14\xf7\xe6\x77\xab\x53\x9c\xc0\x0c\x00\x33\
    \x00\x01\x00\x00\x02\x58\x00\x0d\x01\x00\x00\x0a\x08\x90\xc7\xf1\
    \x74\x0b\x0c\xfb\x34\xc0\x0c\x00\x2e\x00\x01\x00\x00\x02\x58\x00\
    \x5d\x00\x33\x0d\x02\x00\x00\x00\x00\x61\xf2\xaf\x39\x61\xcb\x22\
    \x39\x28\xeb\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\xc4\x4d\
    \x00\x48\x9c\x86\x49\xac\x8d\x03\x28\x23\xac\xec\xf5\x5b\xb6\xe5\
    \x2f\xf6\xae\xaa\x01\x5a\x66\x52\xf7\x43\xc3\xb1\xe5\xef\xe5\xbf\
    \x5f\x71\x5d\xa1\x57\x64\x66\x5e\xa1\x6f\x96\xa8\xcd\x48\x85\xe4\
    \x20\xe2\xfb\xb0\xc1\x00\x47\x72\xc8\x72\x98\xc7\x41\xd9";
        
        let dummy = 
            DnsRequestHeader
            {
                header: DnsHeader {id: 0xd079, ..Default::default()},
                payload: DnsRequestPayload
                    {
                        qname: b"\x06\x72\x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00".to_vec(),
                        qtype: QType::ALL,
                        qclass: QClass::IN, 
                    }
            };
    
        let now = Instant::now();
        let ans = DnsRequestAnswer::parse(pkt.as_slice());
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(ans.is_ok(), true, "{}", ans.err().unwrap());
        let ans = ans.unwrap();
    
        let verif = ans.verify(&dummy);
        assert_eq!(verif.is_ok(), true, "{}", verif.err().unwrap());
    
        assert_eq!(ans.req_header.header.id, 0xd079);
        assert_eq!(ans.req_header.header.ancount, 23);
        assert_eq!(ans.req_header.header.arcount, 0);
        assert_eq!(ans.req_header.header.nscount, 0);
        assert_eq!(ans.req_header.header.qdcount, 1);
    
        let ansord = &ans.response[0];
        assert_eq!(
            ansord.rdata, 
                RecordSOA::wrap(
                    RecordSOA
                    { 
                        pnm: "ns21.cloudns.net".to_string(), 
                        ram: "support.cloudns.net".to_string(), 
                        serial: 2021122801,  
                        interv_refr: 7200,
                        interv_retry: 1800,
                        expire_limit: 1209600,
                        min_ttl: 3600
                    }
            )
        );
        assert_eq!(ansord.name, "relkom.sk".to_string());
        assert_eq!(ansord.dtype, QType::SOA);
        assert_eq!(ansord.class, QClass::IN);
        assert_eq!(ansord.ttl, 3600);
        assert_eq!(ansord.rdlength, 48);
    
        let a1 = 
    b"\x00\x06\x0d\x02\
    \x00\x00\x0e\x10\x61\xf2\xaf\x39\x61\xcb\x22\x39\x28\xeb\x06\x72\
    \x65\x6c\x6b\x6f\x6d\x02\x73\x6b\x00\x2f\x79\xed\x73\xd0\x75\xc8\
    \xa9\xa2\x2a\x08\x3c\x78\xb9\xfb\x43\xc5\x8e\x62\x4c\xbc\x36\xeb\
    \x22\x96\x45\x59\x36\x1f\x69\x3a\x7a\x5e\x67\xd0\x54\x1e\xf0\xf2\
    \x11\x1a\x72\x00\x56\x89\x26\x79\xf4\x06\x1a\x0c\x59\x41\x32\x60\
    \x68\x75\x05\x3d\x90\xed\x1e\x0f\xfc";
        let mut a1curs = Cursor::new(a1.as_slice());
        let a1len = a1.len();

        let ansord = &ans.response[1];
        assert_eq!(ansord.rdata, RecordRRSIG::wrap( RecordRRSIG::read(&mut a1curs, a1len as u16, QType::RRSIG).unwrap() ));
        assert_eq!(ansord.name, "relkom.sk".to_string());
        assert_eq!(ansord.dtype, QType::RRSIG);
        assert_eq!(ansord.class, QClass::IN);
        assert_eq!(ansord.ttl, 3600);
        assert_eq!(ansord.rdlength, a1len as u16);
    
        let ansord = &ans.response[2];
        assert_eq!(ansord.rdata, RecordNS::wrap( RecordNS{ fqdn: "ns21.cloudns.net".to_string() }));
        assert_eq!(ansord.name, "relkom.sk".to_string());
        assert_eq!(ansord.dtype, QType::NS);
        assert_eq!(ansord.class, QClass::IN);
        assert_eq!(ansord.ttl, 3600);
        assert_eq!(ansord.rdlength, 2);
    }
    
    
    #[test]
    fn test_request()
    {
        use std::time::Instant;
        use std::net::IpAddr;
    
        let ipp = IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8));
        let qdnsreq = QDnsReq::new_into(&ipp, QType::PTR);
    
        let now = Instant::now();
    
        let req = DnsRequestHeader::construct_lookup(&qdnsreq);
    
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(req.is_ok(), true, "{}", req.err().unwrap());
    
        let pkt = req.unwrap().to_bytes(false);
        assert_eq!(pkt.is_ok(), true);
        let pkt = pkt.unwrap();
    
        let ctrl = 
        b"\x15\xc8\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x01\x38\x01\x38\
        \x01\x38\x01\x38\x07\x69\x6e\x2d\x61\x64\x64\x72\x04\x61\x72\x70\
        \x61\x00\x00\x0c\x00\x01";
    
        assert_eq!(&pkt[2..], &ctrl[2..]);
    }
    
    #[test]
    fn test_request_1()
    {
        use std::time::Instant;
        use std::net::IpAddr;
    
        let ipp = IpAddr::V4("100.150.111.80".parse().unwrap());
        let qdnsreq = QDnsReq::new_into(&ipp, QType::PTR);
    
        let now = Instant::now();
    
        let req = DnsRequestHeader::construct_lookup(&qdnsreq);
    
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(req.is_ok(), true, "{}", req.err().unwrap());
    
        let pkt = req.unwrap().to_bytes(false);
        assert_eq!(pkt.is_ok(), true);
        let pkt = pkt.unwrap();
    
        let ctrl = 
        b"\x74\xa1\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x02\x38\x30\x03\
        \x31\x31\x31\x03\x31\x35\x30\x03\x31\x30\x30\x07\x69\x6e\x2d\x61\
        \x64\x64\x72\x04\x61\x72\x70\x61\x00\x00\x0c\x00\x01";
        
        assert_eq!(&pkt[2..], &ctrl[2..]);
    }
    
    #[test]
    fn test_request6()
    {
        use std::time::Instant;
        use std::net::IpAddr;
        
        let ipp =  IpAddr::V6("2a00:1450:4003:802::200e".parse().unwrap());
        let qdnsreq = QDnsReq::new_into(&ipp, QType::PTR);
    
        let now = Instant::now();
    
        let req = DnsRequestHeader::construct_lookup(&qdnsreq);
    
        let elapsed = now.elapsed();
        println!("Elapsed: {:.2?}", elapsed);
    
        assert_eq!(req.is_ok(), true, "{}", req.err().unwrap());
    
        let pkt = req.unwrap().to_bytes(false);
        assert_eq!(pkt.is_ok(), true);
        let pkt = pkt.unwrap();
    
        let ctrl = 
        b"\xee\xec\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x01\x65\x01\x30\
        \x01\x30\x01\x32\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\
        \x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x32\x01\x30\
        \x01\x38\x01\x30\x01\x33\x01\x30\x01\x30\x01\x34\x01\x30\x01\x35\
        \x01\x34\x01\x31\x01\x30\x01\x30\x01\x61\x01\x32\x03\x69\x70\x36\
        \x04\x61\x72\x70\x61\x00\x00\x0c\x00\x01";
    
        assert_eq!(&pkt[2..], &ctrl[2..]);
    }
    
    
}