whoxydse 0.1.1

Discover related top-level domains using Whoxy API: historical WHOIS, reverse WHOIS, and DNS verification
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

use crate::models::DomainResult;
use anyhow::Result;
use std::time::Duration;
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
use trust_dns_resolver::TokioAsyncResolver;

/// Verify that a domain has DNS records (A or AAAA)
pub async fn verify_domain_exists(domain: &str) -> Result<bool> {
    // Create resolver with default configuration
    let resolver = TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());

    // Try to resolve A or AAAA records with timeout
    let lookup_future = resolver.lookup_ip(domain);
    let timeout_future = tokio::time::sleep(Duration::from_secs(5));

    tokio::select! {
        result = lookup_future => {
            match result {
                Ok(_) => Ok(true),
                Err(_) => Ok(false), // Domain doesn't resolve, but that's not an error
            }
        }
        _ = timeout_future => {
            Ok(false) // Timeout - assume domain doesn't exist
        }
    }
}

/// Verify multiple domains concurrently
pub async fn verify_domains_concurrent(domains: Vec<DomainResult>) -> Vec<DomainResult> {
    use futures::future::join_all;

    let verification_futures: Vec<_> = domains
        .into_iter()
        .map(|domain| {
            let domain_name = domain.domain_name.clone();
            async move {
                match verify_domain_exists(&domain_name).await {
                    Ok(true) => Some(domain),
                    _ => None,
                }
            }
        })
        .collect();

    let results = join_all(verification_futures).await;
    results.into_iter().flatten().collect()
}