use std::fmt;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use crate::network::OutboundNetworkPolicy;
use tracing::debug;
use url::Url;
use crate::error::{Aria2Error, RecoverableError, Result};
use crate::http::{HttpHeaderProcessor, HttpResponseHead};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ProxyMethod {
#[default]
Get,
Tunnel,
}
impl fmt::Display for ProxyMethod {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ProxyMethod::Get => write!(f, "GET"),
ProxyMethod::Tunnel => write!(f, "TUNNEL"),
}
}
}
impl ProxyMethod {
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"get" => Some(Self::Get),
"tunnel" => Some(Self::Tunnel),
_ => None,
}
}
}
#[derive(Debug, Clone)]
pub struct FtpProxyConfig {
pub proxy_host: String,
pub proxy_port: u16,
pub proxy_username: String,
pub proxy_password: String,
pub ftp_username: String,
pub connect_timeout: Duration,
pub user_agent: String,
pub explicit_proxy_method: Option<ProxyMethod>,
}
impl Default for FtpProxyConfig {
fn default() -> Self {
Self {
proxy_host: String::new(),
proxy_port: 8080,
proxy_username: String::new(),
proxy_password: String::new(),
ftp_username: String::new(),
connect_timeout: Duration::from_secs(30),
user_agent: crate::constants::USER_AGENT.to_string(),
explicit_proxy_method: None,
}
}
}
pub fn resolve_proxy_method(config: &FtpProxyConfig, protocol: &str) -> ProxyMethod {
if protocol.eq_ignore_ascii_case("https") || protocol.eq_ignore_ascii_case("sftp") {
debug!("Protocol {} requires Tunnel proxy method", protocol);
return ProxyMethod::Tunnel;
}
match config.explicit_proxy_method {
Some(ProxyMethod::Tunnel) => {
debug!("Explicit proxy method override: Tunnel");
ProxyMethod::Tunnel
}
_ => {
debug!("Default proxy method for FTP: Get");
ProxyMethod::Get
}
}
}
#[derive(Debug, Clone)]
pub struct FtpProxyGetRequest {
pub request_bytes: Vec<u8>,
pub request_url: String,
}
pub struct FtpProxyGetResponse {
pub head: HttpResponseHead,
stream: TcpStream,
buffered_body: Vec<u8>,
}
impl FtpProxyGetResponse {
pub async fn read_body(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
if !self.buffered_body.is_empty() {
let count = buffer.len().min(self.buffered_body.len());
buffer[..count].copy_from_slice(&self.buffered_body[..count]);
self.buffered_body.drain(..count);
return Ok(count);
}
self.stream.read(buffer).await
}
}
pub async fn execute_proxy_get(
ftp_url: Url,
proxy_config: &FtpProxyConfig,
range_start: u64,
no_cache: bool,
) -> Result<FtpProxyGetResponse> {
execute_proxy_get_with_policy(
ftp_url,
proxy_config,
range_start,
no_cache,
&OutboundNetworkPolicy::direct(),
)
.await
}
pub async fn execute_proxy_get_with_policy(
ftp_url: Url,
proxy_config: &FtpProxyConfig,
range_start: u64,
no_cache: bool,
policy: &OutboundNetworkPolicy,
) -> Result<FtpProxyGetResponse> {
let request = FtpProxyGetRequestBuilder::new(ftp_url, proxy_config.clone())
.range_start(range_start)
.no_cache(no_cache)
.build()?;
let connect = async {
if policy.is_direct() {
TcpStream::connect((proxy_config.proxy_host.as_str(), proxy_config.proxy_port))
.await
.map_err(|error| Aria2Error::Network(error.to_string()))
} else {
policy
.connect_host(&proxy_config.proxy_host, proxy_config.proxy_port)
.await
.map_err(|error| Aria2Error::Network(error.to_string()))
}
};
let mut stream = tokio::time::timeout(proxy_config.connect_timeout, connect)
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!(
"FTP proxy connection failed to {}:{}: {}",
proxy_config.proxy_host, proxy_config.proxy_port, error
),
})
})?;
stream.set_nodelay(true).map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP proxy set_nodelay failed: {}", error),
})
})?;
tokio::time::timeout(
proxy_config.connect_timeout,
stream.write_all(&request.request_bytes),
)
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP proxy request failed: {}", error),
})
})?;
stream.flush().await.map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP proxy request flush failed: {}", error),
})
})?;
let mut processor = HttpHeaderProcessor::new();
let mut read_buffer = [0u8; 4096];
let mut body_prefix = Vec::new();
loop {
let bytes_read =
tokio::time::timeout(proxy_config.connect_timeout, stream.read(&mut read_buffer))
.await
.map_err(|_| Aria2Error::Recoverable(RecoverableError::Timeout))?
.map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP proxy response failed: {}", error),
})
})?;
if bytes_read == 0 {
return Err(Aria2Error::Recoverable(
RecoverableError::TemporaryNetworkFailure {
message: "FTP proxy closed before response headers".into(),
},
));
}
let state = processor.feed(&read_buffer[..bytes_read]).clone();
let header_bytes = processor.last_bytes_processed();
if state.is_complete() {
if header_bytes < bytes_read {
body_prefix.extend_from_slice(&read_buffer[header_bytes..bytes_read]);
}
let head = processor.get_result()?;
debug!(status = head.status_code, "Received FTP proxy GET response");
return Ok(FtpProxyGetResponse {
head,
stream,
buffered_body: body_prefix,
});
}
if state.is_error() {
return Err(Aria2Error::HttpProtocol(
"Invalid FTP proxy response headers".into(),
));
}
}
}
pub struct FtpProxyGetRequestBuilder {
ftp_url: Url,
proxy_config: FtpProxyConfig,
range_start: u64,
no_cache: bool,
}
impl FtpProxyGetRequestBuilder {
pub fn new(ftp_url: Url, proxy_config: FtpProxyConfig) -> Self {
Self {
ftp_url,
proxy_config,
range_start: 0,
no_cache: false,
}
}
pub fn range_start(mut self, start: u64) -> Self {
self.range_start = start;
self
}
pub fn no_cache(mut self, enabled: bool) -> Self {
self.no_cache = enabled;
self
}
pub fn build(self) -> Result<FtpProxyGetRequest> {
let request = aria2_protocol::ftp::proxy::try_build_get_request(
&self.ftp_url,
&aria2_protocol::ftp::proxy::ProxyGetRequestOptions {
ftp_username: &self.proxy_config.ftp_username,
proxy_username: &self.proxy_config.proxy_username,
proxy_password: &self.proxy_config.proxy_password,
user_agent: &self.proxy_config.user_agent,
range_start: self.range_start,
no_cache: self.no_cache,
},
)
.map_err(|error| match error {
aria2_protocol::ftp::proxy::ProxyGetRequestError::InvalidUserAgent => {
Aria2Error::InvalidArgument(
"user-agent contains invalid HTTP field characters".to_string(),
)
}
aria2_protocol::ftp::proxy::ProxyGetRequestError::InvalidRequest(_) => {
Aria2Error::InvalidArgument("invalid FTP proxy HTTP request fields".to_string())
}
})?;
Ok(FtpProxyGetRequest {
request_bytes: request.request_bytes,
request_url: request.request_url,
})
}
}
#[cfg(test)]
mod tests;