cdns_rs/a_sync/

request.rs

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

use std::collections::VecDeque;
use std::net::IpAddr;
use std::sync::Arc;

use crate::error::*;
use crate::internal_error;

use super::caches::CACHE;
use super::query::QDns;
use super::{QuerySetup, QDnsQueriesRes, ResolveConfig};
use super::common::{QType, DnsRdata, DnsSoa};

/// Resolves the A and AAAA query.
///
/// # Arguments
/// 
/// * `fqdn` - [AsRef] [str] a domain name
/// 
/// * `custom_resolv` - a custom [ResolveConfig] wrapped in [Arc]
/// 
/// # Returns
/// 
/// [CDnsResult] - Ok with inner type [Vec] [DnsSoa]. If vector is empty
///     then no results found.
/// 
/// [CDnsResult] - Err with error description 
pub async 
fn resolve_fqdn<C>(fqdn: C, custom_resolv: Option<Arc<ResolveConfig>>) -> CDnsResult<Vec<IpAddr>>
where C: AsRef<str>
{
    let resolvers = 
        custom_resolv.map_or(CACHE.clone_resolve_list().await?, |f| f);

    // forming request
    let dns = 
        QDns::make_a_aaaa_request(resolvers, fqdn.as_ref(), QuerySetup::default());

    // sending request and receiving results
    let res = dns.query().await;
  
    // extracting data
    let mut iplist: Vec<IpAddr> = vec![];

    match res
    {
        QDnsQueriesRes::DnsOk{ res } =>
        {
            for r in res
            {
                if r.is_ok() == false
                {
                    // skip errors
                    continue;
                }

                for dnsr in r.get_responses()
                {
                    match dnsr.rdata
                    {
                        DnsRdata::A{ ip } => iplist.push(IpAddr::from(ip)),
                        DnsRdata::AAAA{ ip } => iplist.push(IpAddr::from(ip)),
                        _ => continue,
                    }
                }
            }
        },
        QDnsQueriesRes::DnsNotAvailable =>
        {
            internal_error!(CDnsErrorType::DnsNotAvailable, "");
        }
    }

    return Ok(iplist);
}

/// Resolves the MX record by domain name. It returns a list of domains.
/// The list is sorted by the `preference`.
/// 
/// # Arguments
/// 
/// * `fqdn` - [AsRef] [str] a domain name
/// 
/// * `custom_resolv` - a custom [ResolveConfig] wrapped in [Arc]
/// 
/// # Returns
/// 
/// [CDnsResult] - Ok with inner type [Vec] [DnsSoa]. If vector is empty
///     then no results found.
/// 
/// [CDnsResult] - Err with error description 
pub async 
fn resolve_mx<C>(fqdn: C, custom_resolv: Option<Arc<ResolveConfig>>) -> CDnsResult<Vec<String>>
where C: AsRef<str>
{
    let resolvers = 
        custom_resolv.map_or(CACHE.clone_resolve_list().await?, |f| f);

    let mut dns_req = 
        QDns::make_empty(resolvers, 1, QuerySetup::default());

    dns_req.add_request(QType::MX, fqdn.as_ref());

    // sending request and receiving results
    let res = dns_req.query().await;
  
    // extracting data
    let mut mxlist: VecDeque<(u16, String)> = VecDeque::with_capacity(5);

    match res
    {
        QDnsQueriesRes::DnsOk{ res } =>
        {
            for r in res
            {
                if r.is_ok() == false
                {
                    // skip errors
                    continue;
                }

                for dnsr in r.get_responses()
                {
                    match dnsr.rdata
                    {
                        DnsRdata::MX{ ref preference, ref exchange } => 
                        {
                            //iterate and search for the suitable place
                            let mut index: usize = 0;

                            for (pref, _) in mxlist.iter()
                            {
                                if *pref >= *preference
                                {
                                    break;
                                }

                                index += 1;
                            }

                            if index == mxlist.len()
                            {
                                // push back
                                mxlist.push_back((*preference, exchange.clone()));
                            }
                            else
                            {
                                mxlist.insert(index, (*preference, exchange.clone()));
                            }
                        }
                        _ => continue,
                    }
                }
            }
        },
        QDnsQueriesRes::DnsNotAvailable =>
        {
            internal_error!(CDnsErrorType::DnsNotAvailable, "");
        }
    }

    return Ok(mxlist.into_iter().map( |(_, ip)| ip).collect());
}

/// Resolves the SOA record
/// 
/// # Arguments
/// 
/// * `fqdn` - [AsRef] [str] a domain name
/// 
/// * `custom_resolv` - a custom [ResolveConfig] wrapped in [Arc]
/// 
/// # Returns
/// 
/// [CDnsResult] - Ok with inner type [Vec] [DnsSoa]. If vector is empty
///     then no results found.
/// 
/// [CDnsResult] - Err with error description 
pub async 
fn resolve_soa<C>(fqdn: C, custom_resolv: Option<Arc<ResolveConfig>>) -> CDnsResult<Vec<DnsSoa>>
where C: AsRef<str>
{
    let resolvers = 
        custom_resolv.map_or(CACHE.clone_resolve_list().await?, |f| f);

    let mut dns_req = 
        QDns::make_empty(resolvers, 1, QuerySetup::default());

    dns_req.add_request(QType::SOA, fqdn.as_ref());

    // sending request and receiving results
    let res = dns_req.query().await;

    let mut soa_list: Vec<DnsSoa> = Vec::new();

    match res
    {
        QDnsQueriesRes::DnsOk{ res } =>
        {
            for r in res
            {
                if r.is_ok() == false
                {
                    // skip errors
                    continue;
                }

                for dnsr in r.move_responses()
                {
                    match dnsr.rdata
                    {
                        DnsRdata::SOA{ soa } =>
                        {
                            soa_list.push(soa);
                        },
                        _ => {}
                    }
                }
            }
        },
        QDnsQueriesRes::DnsNotAvailable => {}
    }

    return Ok(soa_list);
}

/// Resolves the IP address to FQDN
/// 
/// # Arguments
/// 
/// * `ipaddr` - [AsRef] [str] an IP address
/// 
/// * `custom_resolv` - a custom [ResolveConfig] wrapped in [Arc]
/// 
/// # Returns
/// 
/// [CDnsResult] - Ok with inner type [Vec] [DnsSoa]. If vector is empty
///     then no results found.
/// 
/// [CDnsResult] - Err with error description 
pub async 
fn resolve_reverse<C>(ipaddr: C, custom_resolv: Option<Arc<ResolveConfig>>) -> CDnsResult<Vec<String>>
where C: AsRef<str>
{
    let resolvers = 
        custom_resolv.map_or(CACHE.clone_resolve_list().await?, |f| f);

    let mut dns_req = 
        QDns::make_empty(resolvers, 1, QuerySetup::default());

    dns_req.add_request(QType::PTR, ipaddr.as_ref());

    // sending request and receiving results
    let res = dns_req.query().await;

    let mut ptr_list: Vec<String> = Vec::new();

    match res
    {
        QDnsQueriesRes::DnsOk{ res } =>
        {
            for r in res
            {
                if r.is_ok() == false
                {
                    // skip errors
                    continue;
                }

                for dnsr in r.move_responses()
                {
                    match dnsr.rdata
                    {
                        DnsRdata::PTR{ fqdn } =>
                        {
                            ptr_list.push(fqdn);
                        },
                        _ => {}
                    }
                }
            }
        },
        QDnsQueriesRes::DnsNotAvailable => {}
    }

    return Ok(ptr_list);
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_mx_resolve()
{
    let mx_doms = resolve_mx("protonmail.com", None).await;

    assert_eq!(mx_doms.is_err(), false);

    let mx_doms = mx_doms.unwrap();

    let mut index = 0;
    for di in mx_doms
    {
        match index
        {
            0 => assert_eq!(di.as_str(), "mail.protonmail.ch"),
            1 => assert_eq!(di.as_str(), "mailsec.protonmail.ch"),
            _ => panic!("test is required to be modified")
        }

        index += 1;

        println!("{}", di);
    }
    
}


#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_a_aaaa_resolve()
{
    let a_aaaa = resolve_fqdn("protonmail.com", None).await;

    assert_eq!(a_aaaa.is_ok(), true);

    let a_aaaa = a_aaaa.unwrap();

    for di in a_aaaa
    {
        println!("{}", di);
    }
    
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn test_ptr_resolve_fail()
{
    let ptr = resolve_reverse("protonmail.com", None).await;

    assert_eq!(ptr.is_ok(), true);

    let ptr = ptr.unwrap();

    assert_eq!(ptr.len(), 0);
    
}