mod additional;
mod tls_dns;
mod types;
use anyhow::Error;
pub(crate) use types::{AdditionalDnsData, TlsDnsData};
use additional::fetch_additional_dns_records;
use tls_dns::fetch_tls_and_dns;
pub(crate) async fn fetch_all_dns_data(
resp_data: &crate::fetch::response::ResponseData,
resolver: &hickory_resolver::TokioResolver,
error_stats: &crate::error_handling::ProcessingStats,
) -> Result<
(
TlsDnsData,
AdditionalDnsData,
Vec<(crate::error_handling::ErrorType, String)>,
(u64, u64, u64, u64), // Timing metrics
),
Error,
> {
let (tls_dns_result, (dns_forward_us, dns_reverse_us, tls_handshake_us)) = fetch_tls_and_dns(
&resp_data.final_url,
&resp_data.host,
resolver,
&resp_data.final_domain,
error_stats,
)
.await?;
let tls_dns_data = tls_dns_result.data;
let mut partial_failures = tls_dns_result.partial_failures;
let additional_dns_start = std::time::Instant::now();
let additional_dns_result =
fetch_additional_dns_records(&resp_data.final_domain, resolver, error_stats).await;
let dns_additional_us = crate::utils::duration_to_us(additional_dns_start.elapsed());
let additional_dns = additional_dns_result.data;
partial_failures.extend(additional_dns_result.partial_failures);
Ok((
tls_dns_data,
additional_dns,
partial_failures,
(
dns_forward_us,
dns_reverse_us,
dns_additional_us,
tls_handshake_us,
),
))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error_handling::ProcessingStats;
use crate::fetch::response::ResponseData;
use crate::initialization::test_resolver;
use std::collections::HashMap;
use std::sync::Arc;
fn create_test_response_data() -> ResponseData {
ResponseData {
initial_url: "https://example.com".to_string(),
final_url: "https://example.com".to_string(),
initial_domain: "example.com".to_string(),
final_domain: "example.com".to_string(),
host: "example.com".to_string(),
status: 200,
status_desc: "OK".to_string(),
headers: reqwest::header::HeaderMap::new(),
security_headers: HashMap::new(),
http_headers: HashMap::new(),
body: std::sync::Arc::<str>::from("<html><body>Test</body></html>"),
body_sha256: None,
body_truncated: false,
content_length: None,
http_version: None,
content_type: None,
}
}
#[tokio::test]
async fn test_fetch_all_dns_data_partial_failures_merged() {
crate::initialization::init_crypto_provider();
let resolver = test_resolver();
let error_stats = Arc::new(ProcessingStats::new());
let resp_data = create_test_response_data();
let result = fetch_all_dns_data(&resp_data, &resolver, error_stats.as_ref()).await;
assert!(result.is_ok());
let (_tls_dns_data, _additional_dns, partial_failures, _timings) = result.unwrap();
for (error_type, error_msg) in &partial_failures {
let _ = error_type;
assert!(!error_msg.is_empty(), "Error message should not be empty");
assert!(
error_msg.len() <= 500,
"Error message should be sanitized/truncated"
);
}
}
#[tokio::test]
async fn test_fetch_all_dns_data_http_url_handled() {
crate::initialization::init_crypto_provider();
let resolver = test_resolver();
let error_stats = Arc::new(ProcessingStats::new());
let mut resp_data = create_test_response_data();
resp_data.final_url = "http://example.com".to_string();
let result = fetch_all_dns_data(&resp_data, &resolver, error_stats.as_ref()).await;
assert!(result.is_ok());
let (tls_dns_data, _additional_dns, _partial_failures, _timings) = result.unwrap();
assert!(tls_dns_data.tls_version.is_none());
}
}