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 port_active(&mut self) -> Result<u16, String> {
90 let listener = self.prepare_port_active().await?;
91 Ok(listener.port())
92 }
93
94 pub async fn prepare_eprt_active(&mut self) -> Result<FtpActiveDataListener, String> {
96 debug!("Requesting extended active mode data connection");
97 let control_addr = self
98 .stream
99 .get_ref()
100 .local_addr()
101 .map_err(|e| format!("Failed to get control local address: {}", e))?;
102 let listener =
103 tokio::net::TcpListener::bind(std::net::SocketAddr::new(control_addr.ip(), 0))
104 .await
105 .map_err(|e| format!("Failed to bind local port: {}", e))?;
106 let local_addr = listener
107 .local_addr()
108 .map_err(|e| format!("Failed to get local address: {}", e))?;
109 let ip = local_addr.ip();
110 let port = local_addr.port();
111 let (proto, addr_str) = match ip {
112 std::net::IpAddr::V4(v4) => ("1", v4.to_string()),
113 std::net::IpAddr::V6(v6) => ("2", v6.to_string()),
114 };
115 let eprt_cmd = format!("EPRT |{}|{}|{}", proto, addr_str, port);
116
117 debug!("Sending EPRT command: {}", eprt_cmd);
118 self.send_command(&eprt_cmd).await?;
119 let resp = self.read_response().await?;
120 if !resp.is_positive_completion() {
121 return Err(format!("EPRT failed: {} {}", resp.code, resp.message));
122 }
123
124 debug!("EPRT successful, listening {}:{}", addr_str, port);
125 Ok(FtpActiveDataListener::new(listener, local_addr))
126 }
127
128 pub async fn eprt_active(&mut self) -> Result<(String, u16), String> {
134 let listener = self.prepare_eprt_active().await?;
135 let addr = listener.local_addr();
136 Ok((addr.ip().to_string(), addr.port()))
137 }
138
139 pub async fn list(&mut self, path: Option<&str>) -> Result<FtpResponse, String> {
141 match path {
142 Some(p) => {
143 debug!("Listing directory details: {}", p);
144 self.send_command(&format!("LIST {}", p)).await?
145 }
146 None => {
147 debug!("Listing current directory details");
148 self.send_command("LIST").await?
149 }
150 };
151 self.read_response().await
152 }
153
154 pub async fn nlst(&mut self, path: Option<&str>) -> Result<FtpResponse, String> {
156 match path {
157 Some(p) => {
158 debug!("Listing directory names: {}", p);
159 self.send_command(&format!("NLST {}", p)).await?
160 }
161 None => {
162 debug!("Listing current directory names");
163 self.send_command("NLST").await?
164 }
165 };
166 self.read_response().await
167 }
168
169 pub fn control_stream(&mut self) -> &mut BufReader<TcpStream> {
171 &mut self.stream
172 }
173
174 #[deprecated(note = "this returns the control stream; use control_stream")]
177 pub fn get_data_stream(&mut self) -> &mut BufReader<TcpStream> {
178 self.control_stream()
179 }
180
181 pub(crate) fn parse_pasv_response(message: &str) -> Option<(String, u16)> {
182 let start = message.find('(')?;
183 let end = message.find(')')?;
184 let inner = &message[start + 1..end];
185 let parts: Vec<&str> = inner.split(',').collect();
186 if parts.len() != 6 {
187 return None;
188 }
189
190 let h1: u8 = parts[0].trim().parse().ok()?;
191 let h2: u8 = parts[1].trim().parse().ok()?;
192 let h3: u8 = parts[2].trim().parse().ok()?;
193 let h4: u8 = parts[3].trim().parse().ok()?;
194 let p1: u16 = parts[4].trim().parse().ok()?;
195 let p2: u16 = parts[5].trim().parse().ok()?;
196
197 Some((format!("{}.{}.{}.{}", h1, h2, h3, h4), p1 * 256 + p2))
198 }
199
200 pub(crate) fn parse_epsv_response(message: &str) -> Option<u16> {
201 let start = message.rfind('|')?;
202 let prev_pipe = message[..start].rfind('|')?;
203 message[prev_pipe + 1..start].parse::<u16>().ok()
204 }
205}
206
207#[cfg(test)]
208mod tests {
209 use super::*;
210
211 #[tokio::test]
212 async fn active_data_listener_accepts_connection_after_preparation() {
213 let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
214 .await
215 .expect("bind active data listener");
216 let local_addr = listener.local_addr().expect("read listener address");
217 let active = FtpActiveDataListener::new(listener, local_addr);
218
219 let connector = tokio::spawn(async move {
220 tokio::net::TcpStream::connect(local_addr)
221 .await
222 .expect("connect to active data listener")
223 });
224 let accepted = tokio::time::timeout(std::time::Duration::from_secs(1), active.accept())
225 .await
226 .expect("active data connection should not time out")
227 .expect("accept active data connection");
228
229 assert_eq!(
230 accepted.peer_addr().expect("read peer address").ip(),
231 local_addr.ip()
232 );
233 connector.await.expect("connector task should finish");
234 }
235}