use anyhow::Result;
use sqlx::Row;
use crate::storage::DbPool;
use super::queries::{fetch_filtered_http_headers, fetch_string_list, HttpHeadersTable};
const EXPORT_LIMIT: i64 = crate::config::MAX_EXPORT_RELATED_RECORDS;
#[derive(Debug, Clone)]
pub struct NameserverRecord {
pub nameserver: String,
}
#[derive(Debug, Clone)]
pub struct TxtRecord {
pub record_type: String,
pub record_value: String,
}
#[derive(Debug, Clone)]
pub struct MxRecord {
pub priority: i64,
pub mail_exchange: String,
}
#[derive(Debug, Clone)]
pub struct StructuredDataEntry {
pub data_type: String,
pub property_name: String,
pub property_value: String,
}
#[derive(Debug, Clone)]
pub struct SocialMediaLink {
pub platform: String,
pub profile_url: String,
pub identifier: Option<String>,
}
#[derive(Debug, Clone)]
pub struct ContactLinkRecord {
pub contact_type: String,
pub contact_value: String,
}
#[derive(Debug, Clone)]
pub struct ExposedSecretRecord {
pub secret_type: String,
pub matched_value: String,
pub severity: String,
pub location: String,
pub context: Option<String>,
pub jwt_algorithm: Option<String>,
pub jwt_issuer: Option<String>,
pub jwt_subject: Option<String>,
pub jwt_audience: Option<String>,
pub jwt_expiration_ms: Option<i64>,
pub jwt_issued_at_ms: Option<i64>,
pub jwt_header_json: Option<String>,
pub jwt_payload_json: Option<String>,
}
#[derive(Debug, Clone)]
pub struct PartialFailure {
pub error_type: String,
pub error_message: String,
}
#[derive(Debug, Clone)]
pub struct HttpHeader {
pub name: String,
pub value: String,
}
#[derive(Debug)]
pub struct MainRowData {
pub id: i64,
pub initial_domain: String,
pub final_domain: String,
pub initial_url: Option<String>,
pub final_url: Option<String>,
pub ip_address: String,
pub reverse_dns: Option<String>,
pub status: u16,
pub status_desc: String,
pub response_time: f64,
pub title: String,
pub description: Option<String>,
pub meta_robots: Option<String>,
pub tls_version: Option<String>,
pub ssl_cert_subject: Option<String>,
pub ssl_cert_issuer: Option<String>,
pub ssl_cert_valid_to_ms: Option<i64>,
pub cipher_suite: Option<String>,
pub key_algorithm: Option<String>,
pub spf_record: Option<String>,
pub dmarc_record: Option<String>,
pub mta_sts_record: Option<String>,
pub tls_rpt_record: Option<String>,
pub bimi_record: Option<String>,
pub hsts_max_age: Option<i64>,
pub hsts_include_subdomains: Option<bool>,
pub hsts_preload: Option<bool>,
pub cdn_provider: Option<String>,
pub timestamp: i64,
pub run_id: Option<String>,
pub body_sha256: Option<String>,
pub content_length: Option<i64>,
pub http_version: Option<String>,
pub content_type: Option<String>,
pub canonical_url: Option<String>,
pub cert_fingerprint_sha256: Option<String>,
pub body_truncated: bool,
}
#[derive(Debug)]
pub struct RedirectEntry {
pub redirect_url: String,
pub sequence_order: i64,
pub http_status: Option<i64>,
}
#[derive(Debug, Default)]
pub struct GeoIpData {
pub country_code: Option<String>,
pub country_name: Option<String>,
pub region: Option<String>,
pub city: Option<String>,
pub latitude: Option<f64>,
pub longitude: Option<f64>,
pub asn: Option<i64>,
pub asn_org: Option<String>,
}
#[derive(Debug, Default)]
pub struct WhoisData {
pub registrar: Option<String>,
pub creation_date_ms: Option<i64>,
pub expiration_date_ms: Option<i64>,
pub registrant_country: Option<String>,
}
#[derive(Debug)]
pub struct TechnologyRecord {
pub name: String,
pub version: Option<String>,
pub category: Option<String>,
pub is_implied: bool,
pub detection_source: Option<String>,
}
#[derive(Debug)]
pub struct AnalyticsIdRecord {
pub provider: String,
pub tracking_id: String,
}
#[derive(Debug, Clone)]
pub struct ScriptHostRecord {
pub host: String,
pub registrable_domain: Option<String>,
pub is_first_party: bool,
}
#[derive(Debug)]
pub struct CaaRecord {
pub flag: i64,
pub tag: String,
pub value: String,
}
#[derive(Debug)]
pub struct ExportRow {
pub main: MainRowData,
pub redirects: Vec<RedirectEntry>,
pub redirect_count: usize,
pub final_redirect_url: String,
pub technologies_str: String,
pub technology_categories_str: String,
pub technology_count: usize,
pub technologies: Vec<TechnologyRecord>,
pub certificate_sans_str: String,
pub certificate_san_count: usize,
pub oids_str: String,
pub oid_count: usize,
pub nameserver_count: usize,
pub txt_count: usize,
pub mx_count: usize,
pub nameservers: Vec<NameserverRecord>,
pub txt_records: Vec<TxtRecord>,
pub mx_records: Vec<MxRecord>,
pub analytics_ids_str: String,
pub analytics_count: usize,
pub analytics_ids: Vec<AnalyticsIdRecord>,
pub script_hosts: Vec<ScriptHostRecord>,
pub script_hosts_str: String,
pub social_media_links_str: String,
pub social_media_count: usize,
pub social_media_links: Vec<SocialMediaLink>,
pub structured_data_types_str: String,
pub structured_data_count: usize,
pub structured_data_entries: Vec<StructuredDataEntry>,
pub http_headers_str: String,
pub http_header_count: usize,
pub security_headers_str: String,
pub security_header_count: usize,
pub all_http_headers: Vec<HttpHeader>,
pub all_security_headers: Vec<HttpHeader>,
pub partial_failures: Vec<PartialFailure>,
pub geoip: GeoIpData,
pub whois: WhoisData,
pub favicon_hash: Option<i32>,
pub favicon_url: Option<String>,
pub contact_links: Vec<ContactLinkRecord>,
pub contact_link_count: usize,
pub exposed_secrets: Vec<ExposedSecretRecord>,
pub exposed_secret_count: usize,
pub cname_records: Vec<String>,
pub cname_count: usize,
pub ipv6_addresses: Vec<String>,
pub ipv6_count: usize,
pub caa_records: Vec<CaaRecord>,
pub caa_count: usize,
}
const HTTP_KEY_HEADERS: &[&str] = &[
"Content-Type",
"Server",
"X-Powered-By",
"X-Frame-Options",
"X-Content-Type-Options",
"Strict-Transport-Security",
"Content-Security-Policy",
];
const SECURITY_KEY_HEADERS: &[&str] = &[
"Content-Security-Policy",
"X-Frame-Options",
"X-Content-Type-Options",
"Strict-Transport-Security",
"Referrer-Policy",
"Permissions-Policy",
];
pub fn extract_main_row_data(row: &sqlx::sqlite::SqliteRow) -> MainRowData {
MainRowData {
id: row.get("id"),
initial_domain: row.get("initial_domain"),
final_domain: row.get("final_domain"),
initial_url: row.get("initial_url"),
final_url: row.get("final_url"),
ip_address: row.get("ip_address"),
reverse_dns: row.get("reverse_dns_name"),
status: row.get("http_status"),
status_desc: row.get("http_status_text"),
response_time: row.get("response_time_seconds"),
title: row.get("title"),
description: row.get("description"),
meta_robots: row.get("meta_robots"),
tls_version: row.get("tls_version"),
ssl_cert_subject: row.get("ssl_cert_subject"),
ssl_cert_issuer: row.get("ssl_cert_issuer"),
ssl_cert_valid_to_ms: row.get("ssl_cert_valid_to_ms"),
cipher_suite: row.get("cipher_suite"),
key_algorithm: row.get("key_algorithm"),
spf_record: row.get("spf_record"),
dmarc_record: row.get("dmarc_record"),
mta_sts_record: row.get("mta_sts_record"),
tls_rpt_record: row.get("tls_rpt_record"),
bimi_record: row.get("bimi_record"),
hsts_max_age: row.get("hsts_max_age"),
hsts_include_subdomains: row.get("hsts_include_subdomains"),
hsts_preload: row.get("hsts_preload"),
cdn_provider: row.get("cdn_provider"),
timestamp: row.get("observed_at_ms"),
run_id: row.get("run_id"),
body_sha256: row.get("body_sha256"),
content_length: row.get("content_length"),
http_version: row.get("http_version"),
content_type: row.get("content_type"),
canonical_url: row.get("canonical_url"),
cert_fingerprint_sha256: row.get("cert_fingerprint_sha256"),
body_truncated: row.get("body_truncated"),
}
}
async fn fetch_dns_records(
pool: &DbPool,
url_status_id: i64,
) -> Result<(Vec<NameserverRecord>, Vec<TxtRecord>, Vec<MxRecord>)> {
let nameservers: Vec<NameserverRecord> = sqlx::query(
"SELECT nameserver FROM url_nameservers WHERE url_status_id = ? ORDER BY nameserver LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| NameserverRecord {
nameserver: r.get("nameserver"),
})
.collect();
let txt_records: Vec<TxtRecord> = sqlx::query(
"SELECT record_type, record_value FROM url_txt_records WHERE url_status_id = ? ORDER BY record_type, record_value LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| TxtRecord {
record_type: r.get("record_type"),
record_value: r.get("record_value"),
})
.collect();
let mx_records: Vec<MxRecord> = sqlx::query(
"SELECT priority, mail_exchange FROM url_mx_records WHERE url_status_id = ? ORDER BY priority, mail_exchange LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| MxRecord {
priority: r.get("priority"),
mail_exchange: r.get("mail_exchange"),
})
.collect();
Ok((nameservers, txt_records, mx_records))
}
async fn fetch_headers_and_failures(
pool: &DbPool,
url_status_id: i64,
) -> Result<(Vec<HttpHeader>, Vec<HttpHeader>, Vec<PartialFailure>)> {
let all_http_headers: Vec<HttpHeader> = sqlx::query(
"SELECT header_name, header_value FROM url_http_headers WHERE url_status_id = ? ORDER BY header_name LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| HttpHeader {
name: r.get("header_name"),
value: r.get("header_value"),
})
.collect();
let all_security_headers: Vec<HttpHeader> = sqlx::query(
"SELECT header_name, header_value FROM url_security_headers WHERE url_status_id = ? ORDER BY header_name LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| HttpHeader {
name: r.get("header_name"),
value: r.get("header_value"),
})
.collect();
let partial_failures: Vec<PartialFailure> = sqlx::query(
"SELECT error_type, error_message FROM url_partial_failures WHERE url_status_id = ? ORDER BY observed_at_ms LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| PartialFailure {
error_type: r.get("error_type"),
error_message: r.get("error_message"),
})
.collect();
Ok((all_http_headers, all_security_headers, partial_failures))
}
async fn fetch_social_and_structured(
pool: &DbPool,
url_status_id: i64,
) -> Result<(Vec<SocialMediaLink>, Vec<StructuredDataEntry>)> {
let social_media_links: Vec<SocialMediaLink> = sqlx::query(
"SELECT platform, profile_url, identifier FROM url_social_media_links WHERE url_status_id = ? ORDER BY platform, profile_url LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| SocialMediaLink {
platform: r.get("platform"),
profile_url: r.get("profile_url"),
identifier: r.get("identifier"),
})
.collect();
let structured_data_entries: Vec<StructuredDataEntry> = sqlx::query(
"SELECT data_type, property_name, property_value FROM url_structured_data WHERE url_status_id = ? ORDER BY data_type, property_name LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| StructuredDataEntry {
data_type: r.get("data_type"),
property_name: r.get("property_name"),
property_value: r.get("property_value"),
})
.collect();
Ok((social_media_links, structured_data_entries))
}
fn join_colon_pairs<'a, I>(pairs: I) -> String
where
I: IntoIterator<Item = (&'a str, &'a str)>,
{
pairs
.into_iter()
.map(|(k, v)| format!("{k}:{v}"))
.collect::<Vec<_>>()
.join(",")
}
#[allow(clippy::too_many_lines)] #[allow(clippy::cognitive_complexity)] pub async fn build_export_row(
pool: &DbPool,
main: MainRowData,
include_implied_tech: bool,
) -> Result<ExportRow> {
let url_status_id = main.id;
let redirect_rows = sqlx::query(
"SELECT redirect_url, sequence_order, http_status FROM url_redirect_chain
WHERE url_status_id = ? ORDER BY sequence_order LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?;
let redirects: Vec<RedirectEntry> = redirect_rows
.iter()
.map(|r| RedirectEntry {
redirect_url: r.get("redirect_url"),
sequence_order: r.get("sequence_order"),
http_status: r.get("http_status"),
})
.collect();
let redirect_count = redirects.len();
let final_redirect_url = redirects
.last()
.map(|r| r.redirect_url.clone())
.unwrap_or_default();
let tech_filter = if include_implied_tech {
""
} else {
" AND COALESCE(is_implied, 0) = 0"
};
let tech_struct_sql = format!(
"SELECT technology_name, technology_version, technology_category, is_implied, detection_source
FROM url_technologies WHERE url_status_id = ?{tech_filter} ORDER BY technology_name LIMIT ?"
);
let technologies: Vec<TechnologyRecord> = crate::sql::query(tech_struct_sql)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| TechnologyRecord {
name: r.get("technology_name"),
version: r.get("technology_version"),
category: r.get("technology_category"),
is_implied: r.get::<i64, _>("is_implied") != 0,
detection_source: r.get("detection_source"),
})
.collect();
let technologies_str = join_colon_pairs(
technologies
.iter()
.map(|t| (t.name.as_str(), t.version.as_deref().unwrap_or(""))),
);
let technology_count = technologies.len();
let technology_categories_str = technologies
.iter()
.filter_map(|t| t.category.as_deref())
.collect::<Vec<_>>()
.join(", ");
let (certificate_sans_str, certificate_san_count) = fetch_string_list(
pool,
"SELECT san_value FROM url_certificate_sans WHERE url_status_id = ? ORDER BY san_value",
url_status_id,
)
.await?;
let (oids_str, oid_count) = fetch_string_list(
pool,
"SELECT oid FROM url_certificate_oids WHERE url_status_id = ? ORDER BY oid",
url_status_id,
)
.await?;
let (nameservers, txt_records, mx_records) = fetch_dns_records(pool, url_status_id).await?;
#[allow(clippy::cast_possible_wrap)]
let nameserver_count = nameservers.len() as i64;
#[allow(clippy::cast_possible_wrap)]
let txt_count = txt_records.len() as i64;
#[allow(clippy::cast_possible_wrap)]
let mx_count = mx_records.len() as i64;
let cname_records: Vec<String> = sqlx::query(
"SELECT cname_target FROM url_cname_records WHERE url_status_id = ? ORDER BY cname_target LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| r.get::<String, _>("cname_target"))
.collect();
let cname_count = cname_records.len();
let ipv6_addresses: Vec<String> = sqlx::query(
"SELECT ipv6_address FROM url_ipv6_addresses WHERE url_status_id = ? ORDER BY ipv6_address LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| r.get::<String, _>("ipv6_address"))
.collect();
let ipv6_count = ipv6_addresses.len();
let caa_records: Vec<CaaRecord> = sqlx::query(
"SELECT flag, tag, value FROM url_caa_records WHERE url_status_id = ? ORDER BY tag, value LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| CaaRecord {
flag: r.get("flag"),
tag: r.get("tag"),
value: r.get("value"),
})
.collect();
let caa_count = caa_records.len();
let analytics_ids: Vec<AnalyticsIdRecord> = sqlx::query(
"SELECT provider, tracking_id FROM url_analytics_ids WHERE url_status_id = ? ORDER BY provider, tracking_id LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| AnalyticsIdRecord {
provider: r.get("provider"),
tracking_id: r.get("tracking_id"),
})
.collect();
let analytics_ids_str = join_colon_pairs(
analytics_ids
.iter()
.map(|a| (a.provider.as_str(), a.tracking_id.as_str())),
);
let analytics_count = analytics_ids.len();
let script_hosts: Vec<ScriptHostRecord> = sqlx::query(
"SELECT host, registrable_domain, is_first_party FROM url_script_hosts WHERE url_status_id = ? ORDER BY host LIMIT ?",
)
.bind(main.id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| ScriptHostRecord {
host: r.get("host"),
registrable_domain: r.get("registrable_domain"),
is_first_party: r.get::<i64, _>("is_first_party") != 0,
})
.collect();
let script_hosts_str = script_hosts
.iter()
.map(|h| {
if h.is_first_party {
format!("{} (1p)", h.host)
} else {
h.host.clone()
}
})
.collect::<Vec<_>>()
.join("; ");
let (social_media_links, structured_data_entries) =
fetch_social_and_structured(pool, url_status_id).await?;
let social_media_links_str = join_colon_pairs(
social_media_links
.iter()
.map(|s| (s.platform.as_str(), s.profile_url.as_str())),
);
let social_media_count = social_media_links.len();
let mut structured_data_types: Vec<&str> = structured_data_entries
.iter()
.map(|e| e.data_type.as_str())
.collect();
structured_data_types.sort_unstable();
structured_data_types.dedup();
let structured_data_types_str = structured_data_types.join(",");
let structured_data_count = structured_data_entries.len();
let (http_headers_str, http_header_count) = fetch_filtered_http_headers(
pool,
HttpHeadersTable::Standard,
url_status_id,
HTTP_KEY_HEADERS,
)
.await?;
let (security_headers_str, security_header_count) = fetch_filtered_http_headers(
pool,
HttpHeadersTable::Security,
url_status_id,
SECURITY_KEY_HEADERS,
)
.await?;
let (all_http_headers, all_security_headers, partial_failures) =
fetch_headers_and_failures(pool, url_status_id).await?;
let geoip_row = sqlx::query(
"SELECT country_code, country_name, region, city, latitude, longitude, asn, asn_org
FROM url_geoip WHERE url_status_id = ?",
)
.bind(url_status_id)
.fetch_optional(pool.as_ref())
.await?;
let geoip = if let Some(row) = geoip_row {
GeoIpData {
country_code: row.get("country_code"),
country_name: row.get("country_name"),
region: row.get("region"),
city: row.get("city"),
latitude: row.get("latitude"),
longitude: row.get("longitude"),
asn: row.get("asn"),
asn_org: row.get("asn_org"),
}
} else {
GeoIpData::default()
};
let whois_row = sqlx::query(
"SELECT registrar, creation_date_ms, expiration_date_ms, registrant_country
FROM url_whois WHERE url_status_id = ?",
)
.bind(url_status_id)
.fetch_optional(pool.as_ref())
.await?;
let whois = if let Some(row) = whois_row {
WhoisData {
registrar: row.get("registrar"),
creation_date_ms: row.get("creation_date_ms"),
expiration_date_ms: row.get("expiration_date_ms"),
registrant_country: row.get("registrant_country"),
}
} else {
WhoisData::default()
};
let favicon_row =
sqlx::query("SELECT hash, favicon_url FROM url_favicons WHERE url_status_id = ?")
.bind(url_status_id)
.fetch_optional(pool.as_ref())
.await?;
let (favicon_hash, favicon_url) = if let Some(row) = favicon_row {
(
Some(row.get::<i32, _>("hash")),
Some(row.get::<String, _>("favicon_url")),
)
} else {
(None, None)
};
let contact_links: Vec<ContactLinkRecord> = sqlx::query(
"SELECT contact_type, contact_value FROM url_contact_links WHERE url_status_id = ? ORDER BY contact_type, contact_value LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| ContactLinkRecord {
contact_type: r.get("contact_type"),
contact_value: r.get("contact_value"),
})
.collect();
let contact_link_count = contact_links.len();
let exposed_secrets: Vec<ExposedSecretRecord> = sqlx::query(
"SELECT es.secret_type, es.matched_value, es.severity, es.location, es.context,
jc.algorithm AS jwt_algorithm, jc.issuer AS jwt_issuer,
jc.subject AS jwt_subject, jc.audience AS jwt_audience,
jc.expiration_ms AS jwt_expiration_ms, jc.issued_at_ms AS jwt_issued_at_ms,
jc.header_json AS jwt_header_json, jc.payload_json AS jwt_payload_json
FROM url_exposed_secrets es
LEFT JOIN url_jwt_claims jc ON jc.exposed_secret_id = es.id
WHERE es.url_status_id = ? ORDER BY es.secret_type LIMIT ?",
)
.bind(url_status_id)
.bind(EXPORT_LIMIT)
.fetch_all(pool.as_ref())
.await?
.iter()
.map(|r| ExposedSecretRecord {
secret_type: r.get("secret_type"),
matched_value: r.get("matched_value"),
severity: r.get("severity"),
location: r.get("location"),
context: r.get("context"),
jwt_algorithm: r.get("jwt_algorithm"),
jwt_issuer: r.get("jwt_issuer"),
jwt_subject: r.get("jwt_subject"),
jwt_audience: r.get("jwt_audience"),
jwt_expiration_ms: r.get("jwt_expiration_ms"),
jwt_issued_at_ms: r.get("jwt_issued_at_ms"),
jwt_header_json: r.get("jwt_header_json"),
jwt_payload_json: r.get("jwt_payload_json"),
})
.collect();
let exposed_secret_count = exposed_secrets.len();
#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
Ok(ExportRow {
main,
redirects,
redirect_count,
final_redirect_url,
technologies_str,
technology_categories_str,
technology_count,
technologies,
certificate_sans_str,
certificate_san_count,
oids_str,
oid_count,
nameserver_count: nameserver_count as usize,
txt_count: txt_count as usize,
mx_count: mx_count as usize,
nameservers,
txt_records,
mx_records,
analytics_ids_str,
analytics_count,
analytics_ids,
script_hosts,
script_hosts_str,
social_media_links_str,
social_media_count,
social_media_links,
structured_data_types_str,
structured_data_count,
structured_data_entries,
http_headers_str,
http_header_count: http_header_count as usize,
security_headers_str,
security_header_count: security_header_count as usize,
all_http_headers,
all_security_headers,
partial_failures,
geoip,
whois,
favicon_hash,
favicon_url,
contact_links,
contact_link_count,
exposed_secrets,
exposed_secret_count,
cname_records,
cname_count,
ipv6_addresses,
ipv6_count,
caa_records,
caa_count,
})
}
pub fn parse_string_list(list_str: &str) -> Vec<String> {
if list_str.is_empty() {
return vec![];
}
list_str
.split(',')
.map(std::string::ToString::to_string)
.collect()
}
pub fn build_url(final_domain: &str) -> String {
if final_domain.starts_with("http://") || final_domain.starts_with("https://") {
final_domain.to_string()
} else {
format!("https://{final_domain}")
}
}