use tokio::io::{AsyncBufRead, BufReader};
use tokio::net::TcpStream;
use tokio::time::{Duration, timeout};
use tracing::{debug, info, warn};
use crate::error::{Aria2Error, RecoverableError, Result};
pub struct RawFtpControl {
pub(super) reader: BufReader<TcpStream>,
pub(super) host: String,
pub(super) read_timeout: Duration,
}
impl RawFtpControl {
pub fn new(reader: BufReader<TcpStream>, host: String, read_timeout: Duration) -> Self {
Self {
reader,
host,
read_timeout,
}
}
pub async fn read_transfer_complete(&mut self) -> Result<bool> {
match self.read_response(self.read_timeout).await {
Ok((226, msg)) => {
debug!("Transfer complete (226): {}", msg.trim());
Ok(true)
}
Ok((code, msg)) => {
warn!("Transfer completion non-226: {} {}", code, msg);
Ok(false)
}
Err(e) => {
debug!("Transfer completion timeout/error (may be normal): {}", e);
Ok(false)
}
}
}
pub async fn quit(mut self) -> Result<()> {
debug!("Sending QUIT command");
if let Err(e) = self.send_command("QUIT").await {
warn!("Failed to send QUIT (connection may be closed): {}", e);
return Ok(());
}
match self.read_response(self.read_timeout).await {
Ok(resp) => {
info!("FTP disconnected: {}", resp.1.trim());
Ok(())
}
Err(e) => {
warn!("Failed to read QUIT response: {}", e);
Ok(())
}
}
}
pub fn stream(&self) -> &TcpStream {
self.reader.get_ref()
}
pub fn into_inner(self) -> BufReader<TcpStream> {
self.reader
}
pub fn host(&self) -> &str {
&self.host
}
pub(super) async fn send_command(&mut self, cmd: &str) -> Result<()> {
use tokio::io::AsyncWriteExt;
debug!("FTP CMD: {}", cmd.trim());
self.reader
.get_mut()
.write_all(format!("{}\r\n", cmd).as_bytes())
.await
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP write command failed: {}", e),
})
})?;
self.reader.get_mut().flush().await.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP flush failed: {}", e),
})
})?;
Ok(())
}
pub(super) async fn read_response(&mut self, timeout_dur: Duration) -> Result<(u16, String)> {
read_response_impl(&mut self.reader, timeout_dur).await
}
#[allow(dead_code)]
pub(super) async fn command(
&mut self,
cmd: &str,
timeout_dur: Duration,
) -> Result<(u16, String)> {
self.send_command(cmd).await?;
self.read_response(timeout_dur).await
}
}
pub(super) struct FreshControl {
pub(super) reader: BufReader<TcpStream>,
pub(super) command_timeout: Duration,
}
impl FreshControl {
pub(super) fn peer_ip(&self) -> Result<std::net::IpAddr> {
self.reader
.get_ref()
.peer_addr()
.map(|address| address.ip())
.map_err(|error| {
Aria2Error::Network(format!("FTP control peer unavailable: {}", error))
})
}
pub(super) async fn send_command(&mut self, cmd: &str) -> Result<()> {
use tokio::io::AsyncWriteExt;
debug!("FTP CMD: {}", cmd.trim());
self.reader
.get_mut()
.write_all(format!("{}\r\n", cmd).as_bytes())
.await
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP write failed: {}", e),
})
})?;
self.reader.get_mut().flush().await.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP flush failed: {}", e),
})
})?;
Ok(())
}
pub(super) async fn read_response(&mut self, timeout_dur: Duration) -> Result<(u16, String)> {
read_response_impl(&mut self.reader, timeout_dur).await
}
pub(super) async fn command(&mut self, cmd: &str) -> Result<(u16, String)> {
self.send_command(cmd).await?;
self.read_response(self.command_timeout).await
}
}
pub(super) struct PooledControl {
pub(super) reader: BufReader<TcpStream>,
pub(super) read_timeout: Duration,
}
impl PooledControl {
pub(super) fn peer_ip(&self) -> Result<std::net::IpAddr> {
self.reader
.get_ref()
.peer_addr()
.map(|address| address.ip())
.map_err(|error| {
Aria2Error::Network(format!("FTP control peer unavailable: {}", error))
})
}
pub(super) async fn send_command(&mut self, cmd: &str) -> Result<()> {
use tokio::io::AsyncWriteExt;
debug!("FTP CMD (pooled): {}", cmd.trim());
self.reader
.get_mut()
.write_all(format!("{}\r\n", cmd).as_bytes())
.await
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP write failed: {}", e),
})
})?;
self.reader.get_mut().flush().await.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP flush failed: {}", e),
})
})?;
Ok(())
}
pub(super) async fn read_response(&mut self, timeout_dur: Duration) -> Result<(u16, String)> {
let (code, msg) = read_response_impl(&mut self.reader, timeout_dur).await?;
debug!("FTP RESP (pooled): {} {}", code, msg.trim());
Ok((code, msg))
}
pub(super) async fn command(&mut self, cmd: &str) -> Result<(u16, String)> {
self.send_command(cmd).await?;
self.read_response(self.read_timeout).await
}
}
const MAX_RECV_BUFFER: usize = 65536;
pub(crate) async fn read_response_impl<R>(
reader: &mut R,
timeout_dur: Duration,
) -> Result<(u16, String)>
where
R: AsyncBufRead + Unpin,
{
use tokio::io::AsyncBufReadExt;
let mut line = String::new();
let mut code: Option<u16> = None;
let mut message = String::new();
let mut is_multiline = false;
let mut total_bytes: usize = 0;
loop {
line.clear();
let bytes_read = timeout(timeout_dur, reader.read_line(&mut line))
.await
.map_err(|_| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP response timeout after {:?}", timeout_dur),
})
})?
.map_err(|e| {
Aria2Error::Recoverable(RecoverableError::TemporaryNetworkFailure {
message: format!("FTP read response error: {}", e),
})
})?;
if bytes_read == 0 {
break;
}
total_bytes += bytes_read;
if total_bytes > MAX_RECV_BUFFER {
return Err(Aria2Error::Recoverable(
RecoverableError::TemporaryNetworkFailure {
message: format!("Max FTP recv buffer reached. length={}", total_bytes),
},
));
}
let trimmed = line.trim_end();
if trimmed.len() < 4 {
continue;
}
let response_code: u16 = trimmed[..3].parse().unwrap_or(0);
if code.is_none() {
code = Some(response_code);
}
let sep = trimmed.as_bytes()[3];
if sep == b'-' && !is_multiline {
is_multiline = true;
if trimmed.len() > 4 {
message.push_str(&trimmed[4..]);
}
message.push('\n');
continue;
}
if is_multiline {
if trimmed.starts_with(&format!("{} ", code.unwrap_or(0))) {
if trimmed.len() > 4 {
message.push_str(&trimmed[4..]);
}
break;
}
message.push_str(trimmed);
message.push('\n');
continue;
}
if trimmed.len() > 4 {
message = trimmed[4..].to_string();
}
break;
}
let code_val = code.unwrap_or(0);
debug!("FTP RESP: {} {}", code_val, message.trim());
Ok((code_val, message))
}