use std::fmt;
use std::time::Duration;
use tracing::debug;
use url::Url;
use crate::error::Result;
#[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"),
}
}
}
#[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 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::*;
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: "aria2-rust/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: aria2-rust/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: "aria2-rust/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: aria2-rust/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"
);
}
}