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    /// Prepare active mode using the extended `EPRT` command.
85    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    /// Send LIST command to get directory listing (detailed format).
119    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    /// Send NLST command to get directory listing (names only).
134    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    /// Borrow the FTP control stream.
149    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}