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_url = self.build_request_url();
let mut request = format!("GET {} HTTP/1.1\r\n", request_url);
let host_header = Self::build_host_header(&self.ftp_url);
request.push_str(&format!("Host: {}\r\n", host_header));
request.push_str(&format!("User-Agent: {}\r\n", self.proxy_config.user_agent));
request.push_str("Accept: */*\r\n");
if self.no_cache {
request.push_str("Pragma: no-cache\r\n");
request.push_str("Cache-Control: no-cache\r\n");
}
request.push_str("Connection: Keep-Alive\r\n");
if self.range_start > 0 {
request.push_str(&format!("Range: bytes={}-\r\n", self.range_start));
}
if !self.proxy_config.proxy_username.is_empty() {
let auth_header = build_basic_proxy_auth(
&self.proxy_config.proxy_username,
&self.proxy_config.proxy_password,
);
request.push_str(&format!("Proxy-Authorization: {}\r\n", auth_header));
}
request.push_str("\r\n");
debug!(
"Built FTP proxy GET request ({} bytes) for {}",
request.len(),
request_url
);
Ok(FtpProxyGetRequest {
request_bytes: request.into_bytes(),
request_url,
})
}
fn build_request_url(&self) -> String {
let has_embedded_username = !self.ftp_url.username().is_empty();
if !has_embedded_username && !self.proxy_config.ftp_username.is_empty() {
let encoded_user = percent_encode_username(&self.proxy_config.ftp_username);
let url_str = self.ftp_url.to_string();
if let Some(pos) = url_str.find("://") {
let scheme_end = pos + 3;
let mut result = String::with_capacity(url_str.len() + encoded_user.len() + 1);
result.push_str(&url_str[..scheme_end]);
result.push_str(&encoded_user);
result.push('@');
result.push_str(&url_str[scheme_end..]);
return result;
}
}
self.ftp_url.to_string()
}
fn build_host_header(url: &Url) -> String {
let host = url.host_str().unwrap_or("");
let port = url.port();
match port {
Some(21) | None => host.to_string(),
Some(p) => format!("{}:{}", host, p),
}
}
}
fn build_basic_proxy_auth(username: &str, password: &str) -> String {
use base64::Engine;
let credentials = format!("{}:{}", username, password);
let encoded = base64::engine::general_purpose::STANDARD.encode(credentials.as_bytes());
format!("Basic {}", encoded)
}
fn percent_encode_username(username: &str) -> String {
const UNRESERVED: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789\
-._~";
let mut result = String::with_capacity(username.len());
for byte in username.bytes() {
if UNRESERVED.contains(&byte) {
result.push(byte as char);
} else {
result.push_str(&format!("%{:02X}", byte));
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn proxy_get_binding_reaches_the_proxy_socket() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
.await
.expect("proxy fixture should bind");
let address = listener.local_addr().expect("proxy fixture address");
let server = tokio::spawn(async move {
let (mut stream, peer) = listener.accept().await.expect("proxy should accept");
let mut request = [0u8; 4096];
let bytes = stream.read(&mut request).await.expect("read proxy request");
assert!(bytes > 0, "proxy request should not be empty");
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
.await
.expect("write proxy response");
peer.ip()
});
let proxy = FtpProxyConfig {
proxy_host: "127.0.0.1".to_string(),
proxy_port: address.port(),
..FtpProxyConfig::default()
};
let response = execute_proxy_get_with_policy(
Url::parse("ftp://ftp.example.com/file.bin").expect("valid FTP URL"),
&proxy,
0,
false,
&OutboundNetworkPolicy::single(std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST)),
)
.await
.expect("proxy GET should connect with the configured source address");
assert_eq!(response.head.status_code, 200);
assert_eq!(
server.await.expect("proxy fixture should finish"),
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST)
);
}
fn build_request_string(ftp_url: Url, proxy_config: FtpProxyConfig) -> String {
let result = FtpProxyGetRequestBuilder::new(ftp_url, proxy_config)
.build()
.unwrap();
String::from_utf8(result.request_bytes).unwrap()
}
#[test]
fn test_proxy_method_default() {
assert_eq!(ProxyMethod::default(), ProxyMethod::Get);
}
#[test]
fn test_proxy_method_display() {
assert_eq!(format!("{}", ProxyMethod::Get), "GET");
assert_eq!(format!("{}", ProxyMethod::Tunnel), "TUNNEL");
}
#[test]
fn test_resolve_proxy_method_default_ftp() {
let config = FtpProxyConfig::default();
assert_eq!(resolve_proxy_method(&config, "ftp"), ProxyMethod::Get);
}
#[test]
fn test_resolve_proxy_method_explicit_tunnel() {
let config = FtpProxyConfig {
explicit_proxy_method: Some(ProxyMethod::Tunnel),
..Default::default()
};
assert_eq!(resolve_proxy_method(&config, "ftp"), ProxyMethod::Tunnel);
}
#[test]
fn test_resolve_proxy_method_https_always_tunnel() {
let config = FtpProxyConfig::default();
assert_eq!(resolve_proxy_method(&config, "https"), ProxyMethod::Tunnel);
}
#[test]
fn test_resolve_proxy_method_sftp_always_tunnel() {
let config = FtpProxyConfig::default();
assert_eq!(resolve_proxy_method(&config, "sftp"), ProxyMethod::Tunnel);
}
#[test]
fn test_resolve_proxy_method_https_ignores_explicit_get() {
let config = FtpProxyConfig {
explicit_proxy_method: Some(ProxyMethod::Get),
..Default::default()
};
assert_eq!(resolve_proxy_method(&config, "https"), ProxyMethod::Tunnel);
}
#[test]
fn test_ftp_proxy_config_default() {
let config = FtpProxyConfig::default();
assert_eq!(config.proxy_port, 8080);
assert!(config.proxy_username.is_empty());
assert!(config.proxy_password.is_empty());
assert!(config.ftp_username.is_empty());
assert!(config.explicit_proxy_method.is_none());
}
#[test]
fn test_build_basic_proxy_auth() {
let header = build_basic_proxy_auth("proxyuser", "proxypass");
assert!(header.starts_with("Basic "));
assert_eq!(header, "Basic cHJveHl1c2VyOnByb3h5cGFzcw==");
}
#[test]
fn test_percent_encode_username_simple() {
assert_eq!(percent_encode_username("user"), "user");
}
#[test]
fn test_percent_encode_username_special_chars() {
assert_eq!(percent_encode_username("user@domain"), "user%40domain");
assert_eq!(percent_encode_username("user name"), "user%20name");
assert_eq!(percent_encode_username("user/pass"), "user%2Fpass");
}
#[test]
fn test_build_request_simple() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/file.tar.gz").unwrap();
let proxy_config = FtpProxyConfig {
proxy_host: "proxy.example.com".to_string(),
proxy_port: 8080,
user_agent: "test-client/1.0".to_string(),
..Default::default()
};
let s = build_request_string(ftp_url, proxy_config);
assert!(s.starts_with("GET ftp://ftp.example.com/pub/file.tar.gz HTTP/1.1\r\n"));
assert!(s.contains("Host: ftp.example.com\r\n"));
assert!(s.contains("User-Agent: test-client/1.0\r\n"));
assert!(s.contains("Connection: Keep-Alive\r\n"));
assert!(!s.contains("Proxy-Authorization"));
assert!(!s.contains("Range:"));
assert!(s.ends_with("\r\n\r\n"));
}
#[test]
fn test_build_request_with_proxy_auth() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/file.tar.gz").unwrap();
let proxy_config = FtpProxyConfig {
proxy_username: "proxyuser".to_string(),
proxy_password: "proxypass".to_string(),
..Default::default()
};
let s = build_request_string(ftp_url, proxy_config);
assert!(s.contains("Proxy-Authorization: Basic cHJveHl1c2VyOnByb3h5cGFzcw==\r\n"));
}
#[test]
fn test_build_request_with_ftp_username_embedded() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/file.tar.gz").unwrap();
let proxy_config = FtpProxyConfig {
ftp_username: "ftpuser".to_string(),
..Default::default()
};
let s = build_request_string(ftp_url, proxy_config);
assert!(s.contains("GET ftp://ftpuser@ftp.example.com/pub/file.tar.gz HTTP/1.1\r\n"));
}
#[test]
fn test_build_request_no_double_username() {
let ftp_url = Url::parse("ftp://existing@ftp.example.com/pub/file.tar.gz").unwrap();
let proxy_config = FtpProxyConfig {
ftp_username: "ftpuser".to_string(),
..Default::default()
};
let s = build_request_string(ftp_url, proxy_config);
assert!(s.contains("ftp://existing@ftp.example.com"));
assert!(!s.contains("ftp://ftpuser@"));
}
#[test]
fn test_build_request_with_range() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/file.tar.gz").unwrap();
let result = FtpProxyGetRequestBuilder::new(ftp_url, FtpProxyConfig::default())
.range_start(1024)
.build()
.unwrap();
let s = String::from_utf8(result.request_bytes).unwrap();
assert!(s.contains("Range: bytes=1024-\r\n"));
}
#[test]
fn test_build_request_with_no_cache() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/file.tar.gz").unwrap();
let result = FtpProxyGetRequestBuilder::new(ftp_url, FtpProxyConfig::default())
.no_cache(true)
.build()
.unwrap();
let s = String::from_utf8(result.request_bytes).unwrap();
assert!(s.contains("Pragma: no-cache\r\n"));
assert!(s.contains("Cache-Control: no-cache\r\n"));
}
#[test]
fn test_build_host_header_default_port() {
let url = Url::parse("ftp://ftp.example.com/pub/file").unwrap();
assert_eq!(
FtpProxyGetRequestBuilder::build_host_header(&url),
"ftp.example.com"
);
}
#[test]
fn test_build_host_header_non_default_port() {
let url = Url::parse("ftp://ftp.example.com:2121/pub/file").unwrap();
assert_eq!(
FtpProxyGetRequestBuilder::build_host_header(&url),
"ftp.example.com:2121"
);
}
#[test]
fn test_build_request_full_round_trip() {
let ftp_url = Url::parse("ftp://ftp.example.com/pub/linux/file.tar.gz").unwrap();
let proxy_config = FtpProxyConfig {
proxy_host: "proxy.local".to_string(),
proxy_port: 3128,
proxy_username: "puser".to_string(),
proxy_password: "ppass".to_string(),
ftp_username: "anonymous".to_string(),
user_agent: "test-client/2.0".to_string(),
..Default::default()
};
let result = FtpProxyGetRequestBuilder::new(ftp_url, proxy_config)
.range_start(4096)
.no_cache(true)
.build()
.unwrap();
let s = String::from_utf8(result.request_bytes).unwrap();
assert!(
s.contains("GET ftp://anonymous@ftp.example.com/pub/linux/file.tar.gz HTTP/1.1\r\n")
);
assert!(s.contains("Host: ftp.example.com\r\n"));
assert!(s.contains("User-Agent: test-client/2.0\r\n"));
assert!(s.contains("Pragma: no-cache\r\n"));
assert!(s.contains("Connection: Keep-Alive\r\n"));
assert!(s.contains("Range: bytes=4096-\r\n"));
assert!(s.contains("Proxy-Authorization: Basic"));
assert!(s.ends_with("\r\n\r\n"));
assert_eq!(
result.request_url,
"ftp://anonymous@ftp.example.com/pub/linux/file.tar.gz"
);
}
}