use std::sync::Arc;
use crate::dns::{DnsResolver, dns_cache::DnsCache};
use crate::error::Result;
use crate::network::OutboundNetworkPolicy;
use crate::rate_limiter::RateLimiter;
use crate::request::request_group::{DownloadOptions, RequestGroup};
use crate::util::rwlock_ext::RwLockRecover;
use super::client_config::{ResolvedNetworkAddresses, http_proxy_origin};
use super::download_command::DownloadCommand;
pub(crate) async fn create_download_command(
group: Arc<std::sync::RwLock<RequestGroup>>,
uri: &str,
options: &DownloadOptions,
dns_cache: Arc<tokio::sync::Mutex<DnsCache>>,
outbound_network_policy: Arc<OutboundNetworkPolicy>,
global_limiter: Option<RateLimiter>,
) -> Result<DownloadCommand> {
let dns_resolver = DnsResolver::new(Arc::clone(&dns_cache), options.async_dns);
let resolver: Option<Arc<dyn reqwest::dns::Resolve>> =
Some(dns_resolver.reqwest_resolver(Arc::clone(&outbound_network_policy)));
let proxy_origin = http_proxy_origin(uri, options);
let resolved_target = if proxy_origin.is_none() {
if let Some((hostname, port)) = http_origin(uri) {
if let Ok(address) = hostname.parse::<std::net::IpAddr>() {
options
.async_dns
.then(|| vec![std::net::SocketAddr::new(address, port)])
} else if options.async_dns {
Some(dns_resolver.resolve(&hostname, port).await?)
} else if !outbound_network_policy.is_direct() {
dns_resolver.resolve(&hostname, port).await.ok()
} else {
None
}
} else {
None
}
} else {
None
};
let resolved_proxy = if let Some((hostname, port)) = proxy_origin {
if let Ok(address) = hostname.parse::<std::net::IpAddr>() {
Some(vec![std::net::SocketAddr::new(address, port)])
} else if options.async_dns {
Some(dns_resolver.resolve(&hostname, port).await?)
} else if !outbound_network_policy.is_direct() {
dns_resolver.resolve(&hostname, port).await.ok()
} else {
None
}
} else {
None
};
let output_dir = options.dir.as_deref();
let group_output_name = group.recover().output_name();
let output_name = group_output_name.as_deref().or(options.out.as_deref());
let mut command = DownloadCommand::new_with_group_and_resolved_network_addresses(
group,
uri,
options,
output_dir,
output_name,
ResolvedNetworkAddresses {
target: resolved_target,
proxy: resolved_proxy,
resolver,
},
outbound_network_policy,
)?;
command.set_dns_resolver(dns_resolver);
if let Some(limiter) = global_limiter {
command.set_global_limiter(limiter);
}
Ok(command)
}
fn http_origin(uri: &str) -> Option<(String, u16)> {
let parsed = url::Url::parse(uri).ok()?;
if !matches!(parsed.scheme(), "http" | "https") {
return None;
}
Some((
parsed.host_str()?.to_owned(),
parsed.port_or_known_default()?,
))
}