mod capabilities;
mod control;
mod fresh_flow;
mod parsing;
mod pooled_flow;
#[cfg(test)]
mod tests;
use std::time::SystemTime;
use tokio::time::Duration;
use tracing::{debug, info, warn};
use crate::error::{Aria2Error, RecoverableError, Result};
use crate::ftp::connection::negotiation::control::PooledControl;
use crate::ftp::connection::negotiation::parsing::{
cwd_traversal_pooled, extract_directory_part, extract_file_part, query_mdtm_pooled,
query_size_pooled, send_rest_pooled, send_retr_pooled,
};
use crate::ftp::connection::types::FtpMode;
pub use capabilities::ServerCapabilities;
pub use control::RawFtpControl;
pub(crate) use control::read_response_impl;
pub(crate) use parsing::{
cwd_targets, parse_mdtm_timestamp, parse_pwd_response, percent_decode,
split_decoded_remote_path,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum FtpTransferType {
#[default]
Binary,
Ascii,
}
pub(super) use crate::ftp::connection::active_data_bind_addr;
#[derive(Debug, Clone)]
pub struct FtpDataProxyConfig {
pub proxy_host: String,
pub proxy_port: u16,
pub proxy_username: String,
pub proxy_password: String,
pub user_agent: String,
}
pub struct FtpNegotiationResult {
pub data_stream: tokio::net::TcpStream,
pub control: RawFtpControl,
pub file_size: Option<u64>,
pub modification_time: Option<SystemTime>,
pub base_working_dir: String,
pub capabilities: ServerCapabilities,
}
#[derive(Debug, Clone)]
pub struct FtpNegotiationConfig {
pub host: String,
pub port: u16,
pub username: String,
pub password: String,
pub remote_path: String,
pub mode: FtpMode,
pub transfer_type: FtpTransferType,
pub resume_offset: u64,
pub remote_time: bool,
pub connect_timeout: Duration,
pub command_timeout: Duration,
pub is_pooled: bool,
pub pooled_base_working_dir: Option<String>,
pub data_proxy: Option<FtpDataProxyConfig>,
}
impl Default for FtpNegotiationConfig {
fn default() -> Self {
Self {
host: String::new(),
port: 21,
username: String::new(),
password: String::new(),
remote_path: String::new(),
mode: FtpMode::Passive,
transfer_type: FtpTransferType::Binary,
resume_offset: 0,
remote_time: false,
connect_timeout: Duration::from_secs(30),
command_timeout: Duration::from_secs(60),
is_pooled: false,
pooled_base_working_dir: None,
data_proxy: None,
}
}
}
pub struct FtpNegotiator;
impl FtpNegotiator {
pub async fn negotiate(config: FtpNegotiationConfig) -> Result<FtpNegotiationResult> {
let FtpNegotiationConfig {
host,
port,
username,
password,
remote_path,
mode,
transfer_type,
resume_offset,
remote_time,
connect_timeout,
command_timeout,
is_pooled,
pooled_base_working_dir: _,
data_proxy,
} = config;
let (mut ctrl, mut capabilities) = if is_pooled {
return Err(Aria2Error::DownloadFailed(
"Pooled connection negotiation requires a pre-established control stream".into(),
));
} else {
Self::connect_and_authenticate(
&host,
port,
&username,
&password,
connect_timeout,
command_timeout,
)
.await?
};
capabilities.syst = capabilities::query_syst(&mut ctrl).await?;
let is_binary = transfer_type == FtpTransferType::Binary;
parsing::set_transfer_mode(&mut ctrl, is_binary).await?;
let base_working_dir = parsing::query_pwd(&mut ctrl).await?;
info!("Base working directory: {}", base_working_dir);
let dir_part = extract_directory_part(&remote_path);
parsing::cwd_traversal(&mut ctrl, &base_working_dir, &dir_part).await?;
let modification_time = if remote_time {
let file_part = extract_file_part(&remote_path);
parsing::query_mdtm(&mut ctrl, &file_part).await?
} else {
None
};
let file_part = extract_file_part(&remote_path);
let file_size = parsing::query_size(&mut ctrl, &file_part).await?;
let data_stream = match mode {
FtpMode::Passive => {
let pasv_result = Self::enter_passive_mode_get_port(
&mut ctrl,
&host,
connect_timeout,
&capabilities,
)
.await?;
let data_stream = if let Some(proxy) = &data_proxy {
Self::establish_pasv_data_via_proxy(
proxy,
&host,
pasv_result.port,
connect_timeout,
)
.await?
} else {
pasv_result.stream.unwrap()
};
Self::verify_data_connection(&data_stream)?;
data_stream
}
FtpMode::Active => {
Self::enter_active_mode(&mut ctrl, connect_timeout, &capabilities).await?
}
};
parsing::send_rest(&mut ctrl, resume_offset).await?;
parsing::send_retr(&mut ctrl, &file_part).await?;
let ctrl_reader = ctrl.reader;
let result = FtpNegotiationResult {
data_stream,
control: RawFtpControl::new(ctrl_reader, host.clone(), command_timeout),
file_size,
modification_time,
base_working_dir,
capabilities,
};
Ok(result)
}
pub async fn negotiate_pooled(
control: RawFtpControl,
config: FtpNegotiationConfig,
) -> Result<FtpNegotiationResult> {
let FtpNegotiationConfig {
host,
port: _,
username: _,
password: _,
remote_path,
mode,
transfer_type: _,
resume_offset,
remote_time,
connect_timeout,
command_timeout,
is_pooled: _,
pooled_base_working_dir,
data_proxy,
} = config;
let mut ctrl = PooledControl {
reader: control.reader,
read_timeout: command_timeout,
};
let base_working_dir = pooled_base_working_dir.unwrap_or_else(|| "/".to_string());
let capabilities = ServerCapabilities::new();
let dir_part = extract_directory_part(&remote_path);
cwd_traversal_pooled(&mut ctrl, &base_working_dir, &dir_part).await?;
let modification_time = if remote_time {
let file_part = extract_file_part(&remote_path);
query_mdtm_pooled(&mut ctrl, &file_part).await?
} else {
None
};
let file_part = extract_file_part(&remote_path);
let file_size = query_size_pooled(&mut ctrl, &file_part).await?;
let data_stream = match mode {
FtpMode::Passive => {
let pasv_result = Self::enter_passive_mode_pooled_get_port(
&mut ctrl,
&host,
connect_timeout,
&capabilities,
)
.await?;
let data_stream = if let Some(proxy) = &data_proxy {
Self::establish_pasv_data_via_proxy(
proxy,
&host,
pasv_result.port,
connect_timeout,
)
.await?
} else {
pasv_result.stream.unwrap()
};
Self::verify_data_connection(&data_stream)?;
data_stream
}
FtpMode::Active => {
Self::enter_active_mode_pooled(&mut ctrl, connect_timeout, &capabilities).await?
}
};
send_rest_pooled(&mut ctrl, resume_offset).await?;
send_retr_pooled(&mut ctrl, &file_part).await?;
let result = FtpNegotiationResult {
data_stream,
control: RawFtpControl::new(ctrl.reader, host.clone(), command_timeout),
file_size,
modification_time,
base_working_dir,
capabilities,
};
Ok(result)
}
pub async fn finish_download(
control: &mut RawFtpControl,
reuse_connection: bool,
) -> Option<()> {
let transfer_ok = control.read_transfer_complete().await.ok()?;
if transfer_ok && reuse_connection {
return Some(());
}
Some(())
}
fn verify_data_connection(data_stream: &tokio::net::TcpStream) -> Result<()> {
match data_stream.try_read(&mut [0u8; 0]) {
Ok(0) => {
warn!("Data connection closed by peer before REST command");
Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: "Data connection establishment failed (peer closed)".into(),
},
))
}
Ok(_) => Ok(()),
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
Ok(())
}
Err(e) => {
warn!("Data connection error before REST: {}", e);
Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("Data connection error: {}", e),
},
))
}
}
}
async fn establish_pasv_data_via_proxy(
proxy: &FtpDataProxyConfig,
target_host: &str,
target_port: u16,
connect_timeout: Duration,
) -> Result<tokio::net::TcpStream> {
use crate::ftp::connection::proxy_tunnel::{FtpProxyTunnel, FtpProxyTunnelConfig};
debug!(
"Establishing PASV data tunnel via proxy {}:{} to {}:{}",
proxy.proxy_host, proxy.proxy_port, target_host, target_port
);
let tunnel_config = FtpProxyTunnelConfig {
proxy_host: proxy.proxy_host.clone(),
proxy_port: proxy.proxy_port,
target_host: target_host.to_string(),
target_port,
proxy_username: proxy.proxy_username.clone(),
proxy_password: proxy.proxy_password.clone(),
connect_timeout,
read_timeout: connect_timeout,
user_agent: proxy.user_agent.clone(),
};
let result = FtpProxyTunnel::establish(&tunnel_config).await?;
Ok(result)
}
}
struct PasvResult {
port: u16,
stream: Option<tokio::net::TcpStream>,
}