Skip to main content

aria2_protocol/ftp/connection/
data.rs

1use 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    /// Prepare active mode using the IPv4 `PORT` command.
43    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    /// Enter active mode using PORT command (IPv4).
85    ///
86    /// This legacy method returns only the port. Call
87    /// [`Self::prepare_port_active`] when the listener must remain alive until
88    /// the server opens the data connection.
89    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    /// Prepare active mode using the extended `EPRT` command.
95    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    /// Enter active mode using EPRT and return the advertised endpoint.
129    ///
130    /// This legacy method returns only the endpoint. Call
131    /// [`Self::prepare_eprt_active`] when the listener must remain alive until
132    /// the server opens the data connection.
133    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    /// Send LIST command to get directory listing (detailed format).
140    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    /// Send NLST command to get directory listing (names only).
155    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    /// Borrow the FTP control stream.
170    pub fn control_stream(&mut self) -> &mut BufReader<TcpStream> {
171        &mut self.stream
172    }
173
174    /// Legacy misnamed accessor that returns the control stream, not a data
175    /// connection. Use [`Self::control_stream`] or the data-channel methods.
176    #[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}