aria2_protocol/ftp/connection/
data.rs1use tokio::io::BufReader;
2use tokio::net::TcpStream;
3use tracing::{debug, warn};
4
5use super::{FtpActiveDataListener, FtpConnection, FtpResponse};
6
7impl FtpConnection {
8 pub async fn pasv(&mut self) -> Result<(String, u16), String> {
9 debug!("Requesting passive mode data connection");
10 self.send_command("PASV").await?;
11 let resp = self.read_response().await?;
12 if resp.code != 227 {
13 return Err(format!("PASV failed: {} {}", resp.code, resp.message));
14 }
15
16 match Self::parse_pasv_response(&resp.message) {
17 Some(addr) => {
18 debug!("PASV data channel: {}:{}", addr.0, addr.1);
19 Ok(addr)
20 }
21 None => Err("Failed to parse PASV response".to_string()),
22 }
23 }
24
25 pub async fn epsv(&mut self) -> Result<u16, String> {
26 debug!("Requesting extended passive mode");
27 self.send_command("EPSV").await?;
28 let resp = self.read_response().await?;
29 if resp.code == 229 {
30 if let Some(port) = Self::parse_epsv_response(&resp.message) {
31 debug!("EPSV port: {}", port);
32 return Ok(port);
33 }
34 } else if resp.code == 590 || resp.code == 500 || resp.code == 501 {
35 warn!("Server does not support EPSV, falling back to PASV mode");
36 let (_, port) = self.pasv().await?;
37 return Ok(port);
38 }
39 Err(format!("EPSV failed: {} {}", resp.code, resp.message))
40 }
41
42 pub async fn prepare_port_active(&mut self) -> Result<FtpActiveDataListener, String> {
44 debug!("Requesting active mode data connection (IPv4)");
45 let control_addr = self
46 .stream
47 .get_ref()
48 .local_addr()
49 .map_err(|e| format!("Failed to get control local address: {}", e))?;
50 let ip = control_addr.ip();
51 let listener = tokio::net::TcpListener::bind(std::net::SocketAddr::new(ip, 0))
52 .await
53 .map_err(|e| format!("Failed to bind local port: {}", e))?;
54 let local_addr = listener
55 .local_addr()
56 .map_err(|e| format!("Failed to get local address: {}", e))?;
57 let port = local_addr.port();
58 let octets = match ip {
59 std::net::IpAddr::V4(v4) => v4.octets(),
60 std::net::IpAddr::V6(_) => {
61 return Err(
62 "IPv6 address not supported for PORT command, use EPRT instead".to_string(),
63 );
64 }
65 };
66 let p1 = port / 256;
67 let p2 = port % 256;
68 let port_cmd = format!(
69 "PORT {},{},{},{},{},{}",
70 octets[0], octets[1], octets[2], octets[3], p1, p2
71 );
72
73 debug!("Sending PORT command: {}", port_cmd);
74 self.send_command(&port_cmd).await?;
75 let resp = self.read_response().await?;
76 if !resp.is_positive_completion() {
77 return Err(format!("PORT failed: {} {}", resp.code, resp.message));
78 }
79
80 debug!("Waiting for active mode data connection on port {}", port);
81 Ok(FtpActiveDataListener::new(listener, local_addr))
82 }
83
84 pub async fn prepare_eprt_active(&mut self) -> Result<FtpActiveDataListener, String> {
86 debug!("Requesting extended active mode data connection");
87 let control_addr = self
88 .stream
89 .get_ref()
90 .local_addr()
91 .map_err(|e| format!("Failed to get control local address: {}", e))?;
92 let listener =
93 tokio::net::TcpListener::bind(std::net::SocketAddr::new(control_addr.ip(), 0))
94 .await
95 .map_err(|e| format!("Failed to bind local port: {}", e))?;
96 let local_addr = listener
97 .local_addr()
98 .map_err(|e| format!("Failed to get local address: {}", e))?;
99 let ip = local_addr.ip();
100 let port = local_addr.port();
101 let (proto, addr_str) = match ip {
102 std::net::IpAddr::V4(v4) => ("1", v4.to_string()),
103 std::net::IpAddr::V6(v6) => ("2", v6.to_string()),
104 };
105 let eprt_cmd = format!("EPRT |{}|{}|{}", proto, addr_str, port);
106
107 debug!("Sending EPRT command: {}", eprt_cmd);
108 self.send_command(&eprt_cmd).await?;
109 let resp = self.read_response().await?;
110 if !resp.is_positive_completion() {
111 return Err(format!("EPRT failed: {} {}", resp.code, resp.message));
112 }
113
114 debug!("EPRT successful, listening {}:{}", addr_str, port);
115 Ok(FtpActiveDataListener::new(listener, local_addr))
116 }
117
118 pub async fn list(&mut self, path: Option<&str>) -> Result<FtpResponse, String> {
120 match path {
121 Some(p) => {
122 debug!("Listing directory details: {}", p);
123 self.send_command(&format!("LIST {}", p)).await?
124 }
125 None => {
126 debug!("Listing current directory details");
127 self.send_command("LIST").await?
128 }
129 };
130 self.read_response().await
131 }
132
133 pub async fn nlst(&mut self, path: Option<&str>) -> Result<FtpResponse, String> {
135 match path {
136 Some(p) => {
137 debug!("Listing directory names: {}", p);
138 self.send_command(&format!("NLST {}", p)).await?
139 }
140 None => {
141 debug!("Listing current directory names");
142 self.send_command("NLST").await?
143 }
144 };
145 self.read_response().await
146 }
147
148 pub fn control_stream(&mut self) -> &mut BufReader<TcpStream> {
150 &mut self.stream
151 }
152
153 pub(crate) fn parse_pasv_response(message: &str) -> Option<(String, u16)> {
154 let start = message.find('(')?;
155 let end = message.find(')')?;
156 let inner = &message[start + 1..end];
157 let parts: Vec<&str> = inner.split(',').collect();
158 if parts.len() != 6 {
159 return None;
160 }
161
162 let h1: u8 = parts[0].trim().parse().ok()?;
163 let h2: u8 = parts[1].trim().parse().ok()?;
164 let h3: u8 = parts[2].trim().parse().ok()?;
165 let h4: u8 = parts[3].trim().parse().ok()?;
166 let p1: u16 = parts[4].trim().parse().ok()?;
167 let p2: u16 = parts[5].trim().parse().ok()?;
168
169 Some((format!("{}.{}.{}.{}", h1, h2, h3, h4), p1 * 256 + p2))
170 }
171
172 pub(crate) fn parse_epsv_response(message: &str) -> Option<u16> {
173 let start = message.rfind('|')?;
174 let prev_pipe = message[..start].rfind('|')?;
175 message[prev_pipe + 1..start].parse::<u16>().ok()
176 }
177}
178
179#[cfg(test)]
180mod tests {
181 use super::*;
182
183 #[tokio::test]
184 async fn active_data_listener_accepts_connection_after_preparation() {
185 let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
186 .await
187 .expect("bind active data listener");
188 let local_addr = listener.local_addr().expect("read listener address");
189 let active = FtpActiveDataListener::new(listener, local_addr);
190
191 let connector = tokio::spawn(async move {
192 tokio::net::TcpStream::connect(local_addr)
193 .await
194 .expect("connect to active data listener")
195 });
196 let accepted = tokio::time::timeout(std::time::Duration::from_secs(1), active.accept())
197 .await
198 .expect("active data connection should not time out")
199 .expect("accept active data connection");
200
201 assert_eq!(
202 accepted.peer_addr().expect("read peer address").ip(),
203 local_addr.ip()
204 );
205 connector.await.expect("connector task should finish");
206 }
207}