use std::time::Duration;
use tracing::{debug, info, warn};
use crate::constants;
use crate::error::{Aria2Error, RecoverableError, Result};
use crate::ftp::connection::{
active_data_bind_addr, cwd_targets, parse_mdtm_timestamp, parse_pwd_response,
split_decoded_remote_path,
};
pub(super) use super::connection::RawFtpControl;
pub(crate) use crate::ftp::connection::percent_decode as urlencoding_decode;
pub(super) use crate::ftp::connection::{parse_epsv_response, parse_pasv_response};
impl RawFtpControl {
pub(super) async fn authenticate(&mut self, username: &str, password: &str) -> Result<()> {
info!("Authenticating as user: {}", username);
let user_resp = self.command(&format!("USER {}", username)).await?;
match user_resp.0 {
230 => {
info!("FTP login successful (no password required)");
Ok(())
}
331 | 332 => {
debug!("Password required, sending PASS command");
let pass_resp = self.command(&format!("PASS {}", password)).await?;
if !(200..300).contains(&pass_resp.0) {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("Login failed: {} {}", pass_resp.0, pass_resp.1),
},
));
}
info!("FTP login successful");
Ok(())
}
_ => Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("Unexpected USER response: {} {}", user_resp.0, user_resp.1),
},
)),
}
}
pub(super) async fn set_transfer_type(&mut self, transfer_type: &str) -> Result<()> {
let (command, label) = if transfer_type.eq_ignore_ascii_case("ascii") {
("TYPE A", "ASCII")
} else {
("TYPE I", "binary")
};
debug!(command, "Setting FTP transfer mode");
let resp = self.command(command).await?;
if resp.0 != 200 {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("{} ({}) failed: {} {}", command, label, resp.0, resp.1),
},
));
}
Ok(())
}
pub(super) async fn prepare_remote_path(&mut self, remote_path: &str) -> Result<String> {
let pwd = self.command("PWD").await?;
if pwd.0 != 257 {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("PWD failed: {} {}", pwd.0, pwd.1),
},
));
}
let base_working_dir = parse_pwd_response(&pwd.1).ok_or_else(|| {
Aria2Error::Recoverable(RecoverableError::FtpProtocolError {
message: format!("PWD response missing quoted path: {}", pwd.1.trim()),
})
})?;
let (directory, file) = split_decoded_remote_path(remote_path);
for target in cwd_targets(&base_working_dir, &directory) {
let response = self.command(&format!("CWD {}", target)).await?;
if response.0 == 550 {
return Err(Aria2Error::Recoverable(RecoverableError::ResourceNotFound));
}
if response.0 != 250 {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("CWD failed: {} {}", response.0, response.1),
},
));
}
}
Ok(file)
}
pub(super) async fn get_modification_time(
&mut self,
remote_path: &str,
) -> Result<Option<std::time::SystemTime>> {
let response = self.command(&format!("MDTM {}", remote_path)).await?;
if response.0 != 213 {
debug!(
code = response.0,
message = %response.1,
"FTP MDTM is unavailable for remote file"
);
return Ok(None);
}
let response_message = response.1.trim();
let timestamp = response_message
.strip_prefix("213")
.unwrap_or(response_message)
.trim()
.get(..14)
.and_then(parse_mdtm_timestamp);
if timestamp.is_none() {
warn!(response = %response.1, "FTP MDTM response has no valid timestamp");
}
Ok(timestamp)
}
pub(super) async fn set_resume_offset(&mut self, offset: u64) -> Result<bool> {
debug!("Setting resume offset: {} bytes", offset);
let resp = self.command(&format!("REST {}", offset)).await?;
if resp.0 != 350 {
warn!("REST command not accepted by server: {} {}", resp.0, resp.1);
return Ok(offset == 0);
}
Ok(true)
}
pub(super) async fn get_file_size(&mut self, remote_path: &str) -> Result<Option<u64>> {
debug!("Querying file size: {}", remote_path);
let resp = self.command(&format!("SIZE {}", remote_path)).await?;
if resp.0 == 213 {
let size = parse_ftp_size_response(&resp.1)?;
debug!("File size: {} bytes", size);
return Ok(Some(size));
}
if resp.0 == 550 {
return Err(Aria2Error::Recoverable(RecoverableError::ResourceNotFound));
}
debug!("SIZE command returned: {} {}", resp.0, resp.1);
Ok(None)
}
pub(super) async fn enter_passive_mode(&mut self) -> Result<tokio::net::TcpStream> {
let port;
debug!("Attempting extended passive mode (EPSV)");
let epsv_resp = self.command("EPSV").await;
match epsv_resp {
Ok(resp) if resp.0 == 229 => {
if let Some(parsed_port) = parse_epsv_response(&resp.1) {
debug!("EPSV successful, using port: {}", parsed_port);
port = parsed_port;
} else {
warn!("Failed to parse EPSV response, falling back to PASV");
port = self.enter_passive_mode_pasv().await?;
}
}
_ => {
debug!("EPSV not supported, trying PASV");
port = self.enter_passive_mode_pasv().await?;
}
};
let data_addr = std::net::SocketAddr::new(self.connection.peer_addr.ip(), port);
tokio::time::timeout(
Duration::from_secs(constants::FTP_DATA_CONNECTION_TIMEOUT_SECS),
tokio::net::TcpStream::connect(data_addr),
)
.await
.map_err(|_| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Data connection timeout via {}", data_addr),
})
})?
.map_err(|error| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("Data connection failed via {}: {}", data_addr, error),
})
})
}
async fn enter_passive_mode_pasv(&mut self) -> Result<u16> {
debug!("Entering passive mode (PASV)");
let pasv_resp = self.command("PASV").await?;
if pasv_resp.0 != 227 {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("PASV failed: {} {}", pasv_resp.0, pasv_resp.1),
},
));
}
match parse_pasv_response(&pasv_resp.1) {
Some((advertised_host, port)) => {
debug!(
advertised_host,
control_peer = %self.connection.peer_addr,
port,
"PASV successful; using control peer address for data channel"
);
Ok(port)
}
None => Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: "Cannot parse PASV response".into(),
},
)),
}
}
pub(super) async fn enter_active_mode(&mut self) -> Result<tokio::net::TcpListener> {
let local_addr = self
.reader
.get_ref()
.get_ref()
.ok_or_else(|| Aria2Error::Network("FTP local address unavailable".into()))?
.local_addr()
.map_err(|e| Aria2Error::Network(format!("FTP local address unavailable: {}", e)))?;
let listener = tokio::net::TcpListener::bind(active_data_bind_addr(local_addr))
.await
.map_err(|e| Aria2Error::Network(format!("FTP active listener bind failed: {}", e)))?;
let port = listener
.local_addr()
.map_err(|e| {
Aria2Error::Network(format!("FTP active listener address unavailable: {}", e))
})?
.port();
let ip = local_addr.ip();
let eprt = format!(
"EPRT |{}|{}|{}|",
if ip.is_ipv4() { 1 } else { 2 },
ip,
port
);
let response = self.command(&eprt).await?;
if !(200..300).contains(&response.0) {
if let std::net::IpAddr::V4(ipv4) = ip {
let octets = ipv4.octets();
let port_cmd = format!(
"PORT {},{},{},{},{},{}",
octets[0],
octets[1],
octets[2],
octets[3],
port / 256,
port % 256
);
let port_response = self.command(&port_cmd).await?;
if !(200..300).contains(&port_response.0) {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!(
"PORT failed: {} {}",
port_response.0, port_response.1
),
},
));
}
} else {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("EPRT failed for IPv6: {} {}", response.0, response.1),
},
));
}
}
Ok(listener)
}
pub(super) async fn initiate_retr(&mut self, remote_path: &str) -> Result<()> {
debug!("Initiating file retrieval: {}", remote_path);
let resp = self.command(&format!("RETR {}", remote_path)).await?;
if resp.0 != 150 && resp.0 != 125 {
if resp.0 == 550 {
return Err(Aria2Error::Recoverable(RecoverableError::ResourceNotFound));
}
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("RETR unexpected response: {} {}", resp.0, resp.1),
},
));
}
Ok(())
}
pub(super) async fn read_transfer_complete(&mut self) -> Result<()> {
match self
.read_response(Duration::from_secs(
constants::FTP_TRANSFER_COMPLETE_TIMEOUT_SECS,
))
.await
{
Ok((226, msg)) => {
debug!("Transfer complete: {}", msg);
Ok(())
}
Ok((code, msg)) => {
warn!("Transfer response non-226: {} {}", code, msg);
Ok(())
}
Err(e) => {
debug!("Transfer completion timeout/error (may be normal): {}", e);
Ok(())
}
}
}
pub(super) async fn abort_transfer(&mut self) {
let _ = self.command("ABOR").await;
}
pub(super) async fn quit(mut self) -> Result<()> {
debug!("Sending QUIT command");
let _ = self.command("QUIT").await.ok(); Ok(())
}
}
pub(super) fn parse_ftp_size_response(response: &str) -> Result<u64> {
let size = response.trim().parse::<u64>().map_err(|error| {
Aria2Error::Recoverable(RecoverableError::FtpProtocolError {
message: format!("Invalid FTP SIZE response {:?}: {}", response, error),
})
})?;
if size > i64::MAX as u64 {
return Err(Aria2Error::Recoverable(
RecoverableError::FtpProtocolError {
message: format!("FTP SIZE response is too large: {}", size),
},
));
}
Ok(size)
}