D1: lutra-deploy crate: SFTP, FTP/FTPS and folder transports, keychain secrets, known hosts, path mappings
Pure Rust (D27): russh + russh-sftp with ring, suppaftp with rustls/ring, keyring (Windows Credential Manager, macOS Keychain). Lutra's own known-hosts file, refuse on mismatch. In-process SFTP and FTP test servers behind the testserver feature. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
33a7185d75
commit
0644b044f2
16 changed files with 5250 additions and 13 deletions
664
crates/deploy/src/testserver.rs
Normal file
664
crates/deploy/src/testserver.rs
Normal file
|
|
@ -0,0 +1,664 @@
|
|||
//! Local servers for tests and live checks (feature `testserver`): an SFTP
|
||||
//! server built on `russh` and a small FTP server, both bound to
|
||||
//! `127.0.0.1` on a free port and serving one folder. They never listen on
|
||||
//! another interface and are not part of the shipped app.
|
||||
//!
|
||||
//! The SFTP server has a fixed Ed25519 host key (from a seed) and accepts
|
||||
//! one user with one password, or one public key. The FTP server speaks
|
||||
//! enough of RFC 959 for Lutra's client: USER, PASS, SYST, FEAT, TYPE,
|
||||
//! PWD, CWD, MKD, SIZE, PASV, STOR, RETR, LIST, NOOP, QUIT. Both stop when
|
||||
//! dropped.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
|
||||
use std::net::{SocketAddr, TcpListener, TcpStream};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::time::Duration;
|
||||
|
||||
use russh::keys::ssh_key::private::Ed25519Keypair;
|
||||
use russh::keys::{HashAlg, PrivateKey, PublicKey};
|
||||
use russh::server::{Auth, Msg, Session};
|
||||
use russh::{Channel, ChannelId};
|
||||
use russh_sftp::protocol::{
|
||||
Attrs, Data, File as SftpFile, FileAttributes, Handle, Name, OpenFlags, Status, StatusCode,
|
||||
Version,
|
||||
};
|
||||
use tokio::sync::Notify;
|
||||
|
||||
use crate::mapping::normalize_relative;
|
||||
|
||||
/// The path under `root` of the server path `path`, relative to `cwd`;
|
||||
/// `None` when it would leave the root.
|
||||
fn resolve(root: &Path, cwd: &str, path: &str) -> Option<PathBuf> {
|
||||
let joined = if path.starts_with('/') {
|
||||
path.to_string()
|
||||
} else {
|
||||
format!("{cwd}/{path}")
|
||||
};
|
||||
let rel = normalize_relative(&joined)?;
|
||||
Some(if rel.is_empty() {
|
||||
root.to_path_buf()
|
||||
} else {
|
||||
root.join(rel)
|
||||
})
|
||||
}
|
||||
|
||||
/// SFTP attributes of a local file, with the POSIX type bits.
|
||||
fn attrs(meta: &std::fs::Metadata) -> FileAttributes {
|
||||
FileAttributes {
|
||||
size: Some(meta.len()),
|
||||
permissions: Some(if meta.is_dir() { 0o040_755 } else { 0o100_644 }),
|
||||
mtime: Some(0),
|
||||
atime: Some(0),
|
||||
..FileAttributes::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// A running SFTP server.
|
||||
pub struct SftpServer {
|
||||
/// Its address.
|
||||
pub addr: SocketAddr,
|
||||
/// Its host key's fingerprint, `SHA256:…`.
|
||||
pub fingerprint: String,
|
||||
/// Its host key's algorithm.
|
||||
pub algorithm: String,
|
||||
/// Stops it.
|
||||
stop: Arc<Notify>,
|
||||
}
|
||||
|
||||
impl Drop for SftpServer {
|
||||
fn drop(&mut self) {
|
||||
self.stop.notify_waiters();
|
||||
self.stop.notify_one();
|
||||
}
|
||||
}
|
||||
|
||||
/// Who may sign in to the SFTP server.
|
||||
#[derive(Clone)]
|
||||
struct Credentials {
|
||||
/// The user name.
|
||||
user: String,
|
||||
/// The accepted password.
|
||||
password: Option<String>,
|
||||
/// The accepted public key.
|
||||
key: Option<PublicKey>,
|
||||
}
|
||||
|
||||
/// A fixed host key for the test server, from `seed`.
|
||||
pub fn host_key(seed: u8) -> PrivateKey {
|
||||
PrivateKey::from(Ed25519Keypair::from_seed(&[seed; 32]))
|
||||
}
|
||||
|
||||
impl SftpServer {
|
||||
/// Starts a server for `root` that accepts `user` with `password` or
|
||||
/// with `key`. `seed` picks the host key, so a test can simulate a
|
||||
/// changed one.
|
||||
///
|
||||
/// # Errors
|
||||
/// An I/O error when no port can be bound or the runtime fails.
|
||||
pub fn start(
|
||||
root: &Path,
|
||||
user: &str,
|
||||
password: Option<&str>,
|
||||
key: Option<PublicKey>,
|
||||
seed: u8,
|
||||
) -> std::io::Result<Self> {
|
||||
let host = host_key(seed);
|
||||
let fingerprint = host.public_key().fingerprint(HashAlg::Sha256).to_string();
|
||||
let algorithm = host.public_key().algorithm().to_string();
|
||||
let config = Arc::new(russh::server::Config {
|
||||
keys: vec![host],
|
||||
auth_rejection_time: Duration::from_millis(10),
|
||||
auth_rejection_time_initial: Some(Duration::from_millis(0)),
|
||||
inactivity_timeout: Some(Duration::from_secs(60)),
|
||||
..Default::default()
|
||||
});
|
||||
let listener = TcpListener::bind("127.0.0.1:0")?;
|
||||
listener.set_nonblocking(true)?;
|
||||
let addr = listener.local_addr()?;
|
||||
let stop = Arc::new(Notify::new());
|
||||
let stopped = Arc::clone(&stop);
|
||||
let creds = Credentials {
|
||||
user: user.to_string(),
|
||||
password: password.map(str::to_string),
|
||||
key,
|
||||
};
|
||||
let root = root.to_path_buf();
|
||||
let runtime = tokio::runtime::Builder::new_multi_thread()
|
||||
.worker_threads(2)
|
||||
.enable_all()
|
||||
.build()?;
|
||||
std::thread::Builder::new()
|
||||
.name("lutra-test-sftp".into())
|
||||
.spawn(move || {
|
||||
runtime.block_on(async move {
|
||||
let Ok(listener) = tokio::net::TcpListener::from_std(listener) else {
|
||||
return;
|
||||
};
|
||||
loop {
|
||||
let accepted = tokio::select! {
|
||||
a = listener.accept() => a,
|
||||
() = stopped.notified() => return,
|
||||
};
|
||||
let Ok((socket, _)) = accepted else {
|
||||
continue;
|
||||
};
|
||||
let handler = SshHandler {
|
||||
creds: creds.clone(),
|
||||
root: root.clone(),
|
||||
channels: HashMap::new(),
|
||||
};
|
||||
let config = Arc::clone(&config);
|
||||
tokio::spawn(async move {
|
||||
if let Ok(session) =
|
||||
russh::server::run_stream(config, socket, handler).await
|
||||
{
|
||||
let _ = session.await;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
})?;
|
||||
Ok(Self {
|
||||
addr,
|
||||
fingerprint,
|
||||
algorithm,
|
||||
stop,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// One SSH connection.
|
||||
struct SshHandler {
|
||||
/// Who may sign in.
|
||||
creds: Credentials,
|
||||
/// The served folder.
|
||||
root: PathBuf,
|
||||
/// Open session channels, until they ask for SFTP.
|
||||
channels: HashMap<ChannelId, Channel<Msg>>,
|
||||
}
|
||||
|
||||
impl russh::server::Handler for SshHandler {
|
||||
type Error = russh::Error;
|
||||
|
||||
async fn auth_password(&mut self, user: &str, password: &str) -> Result<Auth, Self::Error> {
|
||||
Ok(
|
||||
if user == self.creds.user && self.creds.password.as_deref() == Some(password) {
|
||||
Auth::Accept
|
||||
} else {
|
||||
Auth::reject()
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
async fn auth_publickey_offered(
|
||||
&mut self,
|
||||
user: &str,
|
||||
key: &PublicKey,
|
||||
) -> Result<Auth, Self::Error> {
|
||||
self.auth_publickey(user, key).await
|
||||
}
|
||||
|
||||
async fn auth_publickey(&mut self, user: &str, key: &PublicKey) -> Result<Auth, Self::Error> {
|
||||
Ok(
|
||||
if user == self.creds.user
|
||||
&& self
|
||||
.creds
|
||||
.key
|
||||
.as_ref()
|
||||
.is_some_and(|k| k.key_data() == key.key_data())
|
||||
{
|
||||
Auth::Accept
|
||||
} else {
|
||||
Auth::reject()
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
async fn channel_open_session(
|
||||
&mut self,
|
||||
channel: Channel<Msg>,
|
||||
reply: russh::server::ChannelOpenHandle,
|
||||
_session: &mut Session,
|
||||
) -> Result<(), Self::Error> {
|
||||
self.channels.insert(channel.id(), channel);
|
||||
reply.accept().await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn subsystem_request(
|
||||
&mut self,
|
||||
id: ChannelId,
|
||||
name: &str,
|
||||
session: &mut Session,
|
||||
) -> Result<(), Self::Error> {
|
||||
match (name, self.channels.remove(&id)) {
|
||||
("sftp", Some(channel)) => {
|
||||
session.channel_success(id)?;
|
||||
let handler = SftpHandler {
|
||||
root: self.root.clone(),
|
||||
handles: HashMap::new(),
|
||||
next: 0,
|
||||
};
|
||||
tokio::spawn(russh_sftp::server::run(channel.into_stream(), handler));
|
||||
}
|
||||
_ => session.channel_failure(id)?,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// What an SFTP handle refers to.
|
||||
enum Open {
|
||||
/// An open file.
|
||||
File(std::fs::File),
|
||||
/// A folder listing; `None` once sent.
|
||||
Dir(Option<Vec<SftpFile>>),
|
||||
}
|
||||
|
||||
/// The SFTP subsystem over a local folder.
|
||||
struct SftpHandler {
|
||||
/// The served folder.
|
||||
root: PathBuf,
|
||||
/// Open handles.
|
||||
handles: HashMap<String, Open>,
|
||||
/// The next handle number.
|
||||
next: u64,
|
||||
}
|
||||
|
||||
impl SftpHandler {
|
||||
/// The local path of `path`.
|
||||
fn path(&self, path: &str) -> Result<PathBuf, StatusCode> {
|
||||
resolve(&self.root, "/", path).ok_or(StatusCode::PermissionDenied)
|
||||
}
|
||||
|
||||
/// Stores `open` under a fresh handle.
|
||||
fn add(&mut self, id: u32, open: Open) -> Handle {
|
||||
self.next += 1;
|
||||
let handle = format!("h{}", self.next);
|
||||
self.handles.insert(handle.clone(), open);
|
||||
Handle { id, handle }
|
||||
}
|
||||
}
|
||||
|
||||
/// An `Ok` status.
|
||||
fn ok(id: u32) -> Status {
|
||||
Status {
|
||||
id,
|
||||
status_code: StatusCode::Ok,
|
||||
error_message: "Ok".into(),
|
||||
language_tag: "en-US".into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A local I/O error as an SFTP status.
|
||||
fn io_status(e: &std::io::Error) -> StatusCode {
|
||||
match e.kind() {
|
||||
std::io::ErrorKind::NotFound => StatusCode::NoSuchFile,
|
||||
std::io::ErrorKind::PermissionDenied => StatusCode::PermissionDenied,
|
||||
_ => StatusCode::Failure,
|
||||
}
|
||||
}
|
||||
|
||||
impl russh_sftp::server::Handler for SftpHandler {
|
||||
type Error = StatusCode;
|
||||
|
||||
fn unimplemented(&self) -> Self::Error {
|
||||
StatusCode::OpUnsupported
|
||||
}
|
||||
|
||||
async fn init(
|
||||
&mut self,
|
||||
_version: u32,
|
||||
_extensions: HashMap<String, String>,
|
||||
) -> Result<Version, Self::Error> {
|
||||
Ok(Version::new())
|
||||
}
|
||||
|
||||
async fn open(
|
||||
&mut self,
|
||||
id: u32,
|
||||
filename: String,
|
||||
flags: OpenFlags,
|
||||
_attrs: FileAttributes,
|
||||
) -> Result<Handle, Self::Error> {
|
||||
let path = self.path(&filename)?;
|
||||
let file = std::fs::OpenOptions::new()
|
||||
.read(flags.contains(OpenFlags::READ))
|
||||
.write(flags.contains(OpenFlags::WRITE))
|
||||
.create(flags.contains(OpenFlags::CREATE))
|
||||
.truncate(flags.contains(OpenFlags::TRUNCATE))
|
||||
.open(path)
|
||||
.map_err(|e| io_status(&e))?;
|
||||
Ok(self.add(id, Open::File(file)))
|
||||
}
|
||||
|
||||
async fn close(&mut self, id: u32, handle: String) -> Result<Status, Self::Error> {
|
||||
self.handles.remove(&handle);
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn read(
|
||||
&mut self,
|
||||
id: u32,
|
||||
handle: String,
|
||||
offset: u64,
|
||||
len: u32,
|
||||
) -> Result<Data, Self::Error> {
|
||||
let Some(Open::File(file)) = self.handles.get_mut(&handle) else {
|
||||
return Err(StatusCode::Failure);
|
||||
};
|
||||
file.seek(SeekFrom::Start(offset))
|
||||
.map_err(|e| io_status(&e))?;
|
||||
let mut data = vec![0u8; len.min(256 * 1024) as usize];
|
||||
let n = file.read(&mut data).map_err(|e| io_status(&e))?;
|
||||
if n == 0 {
|
||||
return Err(StatusCode::Eof);
|
||||
}
|
||||
data.truncate(n);
|
||||
Ok(Data { id, data })
|
||||
}
|
||||
|
||||
async fn write(
|
||||
&mut self,
|
||||
id: u32,
|
||||
handle: String,
|
||||
offset: u64,
|
||||
data: Vec<u8>,
|
||||
) -> Result<Status, Self::Error> {
|
||||
let Some(Open::File(file)) = self.handles.get_mut(&handle) else {
|
||||
return Err(StatusCode::Failure);
|
||||
};
|
||||
file.seek(SeekFrom::Start(offset))
|
||||
.map_err(|e| io_status(&e))?;
|
||||
file.write_all(&data).map_err(|e| io_status(&e))?;
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn stat(&mut self, id: u32, path: String) -> Result<Attrs, Self::Error> {
|
||||
let meta = std::fs::metadata(self.path(&path)?).map_err(|e| io_status(&e))?;
|
||||
Ok(Attrs {
|
||||
id,
|
||||
attrs: attrs(&meta),
|
||||
})
|
||||
}
|
||||
|
||||
async fn lstat(&mut self, id: u32, path: String) -> Result<Attrs, Self::Error> {
|
||||
self.stat(id, path).await
|
||||
}
|
||||
|
||||
async fn fstat(&mut self, id: u32, handle: String) -> Result<Attrs, Self::Error> {
|
||||
let Some(Open::File(file)) = self.handles.get(&handle) else {
|
||||
return Err(StatusCode::Failure);
|
||||
};
|
||||
let meta = file.metadata().map_err(|e| io_status(&e))?;
|
||||
Ok(Attrs {
|
||||
id,
|
||||
attrs: attrs(&meta),
|
||||
})
|
||||
}
|
||||
|
||||
async fn setstat(
|
||||
&mut self,
|
||||
id: u32,
|
||||
_path: String,
|
||||
_attrs: FileAttributes,
|
||||
) -> Result<Status, Self::Error> {
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn fsetstat(
|
||||
&mut self,
|
||||
id: u32,
|
||||
_handle: String,
|
||||
_attrs: FileAttributes,
|
||||
) -> Result<Status, Self::Error> {
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn mkdir(
|
||||
&mut self,
|
||||
id: u32,
|
||||
path: String,
|
||||
_attrs: FileAttributes,
|
||||
) -> Result<Status, Self::Error> {
|
||||
std::fs::create_dir(self.path(&path)?).map_err(|e| io_status(&e))?;
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn opendir(&mut self, id: u32, path: String) -> Result<Handle, Self::Error> {
|
||||
let dir = self.path(&path)?;
|
||||
let mut files = Vec::new();
|
||||
for entry in std::fs::read_dir(dir).map_err(|e| io_status(&e))?.flatten() {
|
||||
if let Ok(meta) = entry.metadata() {
|
||||
files.push(SftpFile::new(
|
||||
entry.file_name().to_string_lossy(),
|
||||
attrs(&meta),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(self.add(id, Open::Dir(Some(files))))
|
||||
}
|
||||
|
||||
async fn readdir(&mut self, id: u32, handle: String) -> Result<Name, Self::Error> {
|
||||
let Some(Open::Dir(files)) = self.handles.get_mut(&handle) else {
|
||||
return Err(StatusCode::Failure);
|
||||
};
|
||||
match files.take() {
|
||||
Some(files) if !files.is_empty() => Ok(Name { id, files }),
|
||||
_ => Err(StatusCode::Eof),
|
||||
}
|
||||
}
|
||||
|
||||
async fn realpath(&mut self, id: u32, path: String) -> Result<Name, Self::Error> {
|
||||
let rel = normalize_relative(&path).ok_or(StatusCode::NoSuchFile)?;
|
||||
Ok(Name {
|
||||
id,
|
||||
files: vec![SftpFile::dummy(format!("/{rel}"))],
|
||||
})
|
||||
}
|
||||
|
||||
async fn remove(&mut self, id: u32, filename: String) -> Result<Status, Self::Error> {
|
||||
std::fs::remove_file(self.path(&filename)?).map_err(|e| io_status(&e))?;
|
||||
Ok(ok(id))
|
||||
}
|
||||
|
||||
async fn rmdir(&mut self, id: u32, path: String) -> Result<Status, Self::Error> {
|
||||
std::fs::remove_dir(self.path(&path)?).map_err(|e| io_status(&e))?;
|
||||
Ok(ok(id))
|
||||
}
|
||||
}
|
||||
|
||||
/// A running FTP server.
|
||||
pub struct FtpServer {
|
||||
/// Its address.
|
||||
pub addr: SocketAddr,
|
||||
/// Stops it.
|
||||
stop: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl Drop for FtpServer {
|
||||
fn drop(&mut self) {
|
||||
self.stop.store(true, Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
impl FtpServer {
|
||||
/// Starts a server for `root` that accepts `user` with `password`.
|
||||
///
|
||||
/// # Errors
|
||||
/// An I/O error when no port can be bound.
|
||||
pub fn start(root: &Path, user: &str, password: &str) -> std::io::Result<Self> {
|
||||
let listener = TcpListener::bind("127.0.0.1:0")?;
|
||||
listener.set_nonblocking(true)?;
|
||||
let addr = listener.local_addr()?;
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let stopped = Arc::clone(&stop);
|
||||
let root = root.to_path_buf();
|
||||
let (user, password) = (user.to_string(), password.to_string());
|
||||
std::thread::Builder::new()
|
||||
.name("lutra-test-ftp".into())
|
||||
.spawn(move || {
|
||||
while !stopped.load(Ordering::SeqCst) {
|
||||
match listener.accept() {
|
||||
Ok((stream, _)) => {
|
||||
let (root, user, password) =
|
||||
(root.clone(), user.clone(), password.clone());
|
||||
let _ = std::thread::Builder::new()
|
||||
.name("lutra-test-ftp-conn".into())
|
||||
.spawn(move || {
|
||||
let _ = ftp_session(stream, &root, &user, &password);
|
||||
});
|
||||
}
|
||||
Err(_) => std::thread::sleep(Duration::from_millis(20)),
|
||||
}
|
||||
}
|
||||
})?;
|
||||
Ok(Self { addr, stop })
|
||||
}
|
||||
}
|
||||
|
||||
/// Serves one FTP control connection until QUIT or a closed socket.
|
||||
fn ftp_session(stream: TcpStream, root: &Path, user: &str, password: &str) -> std::io::Result<()> {
|
||||
stream.set_nonblocking(false)?;
|
||||
stream.set_read_timeout(Some(Duration::from_secs(60)))?;
|
||||
let mut out = stream.try_clone()?;
|
||||
let mut reader = BufReader::new(stream);
|
||||
let mut send = |line: &str| out.write_all(format!("{line}\r\n").as_bytes());
|
||||
send("220 Lutra test FTP")?;
|
||||
let mut given_user = String::new();
|
||||
let mut signed_in = false;
|
||||
let mut cwd = String::from("/");
|
||||
let mut passive: Option<TcpListener> = None;
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
if reader.read_line(&mut line)? == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
let line = line.trim_end_matches(['\r', '\n']);
|
||||
let (cmd, arg) = line.split_once(' ').unwrap_or((line, ""));
|
||||
let cmd = cmd.to_ascii_uppercase();
|
||||
if !signed_in
|
||||
&& !matches!(
|
||||
cmd.as_str(),
|
||||
"USER" | "PASS" | "QUIT" | "FEAT" | "SYST" | "AUTH"
|
||||
)
|
||||
{
|
||||
send("530 Not logged in")?;
|
||||
continue;
|
||||
}
|
||||
let here = cwd.clone();
|
||||
let path = |arg: &str| resolve(root, &here, arg);
|
||||
match cmd.as_str() {
|
||||
"USER" => {
|
||||
given_user = arg.to_string();
|
||||
send("331 Password required")?;
|
||||
}
|
||||
"PASS" => {
|
||||
signed_in = given_user == user && arg == password;
|
||||
send(if signed_in {
|
||||
"230 Logged in"
|
||||
} else {
|
||||
"530 Login incorrect"
|
||||
})?;
|
||||
}
|
||||
"SYST" => send("215 UNIX Type: L8")?,
|
||||
"FEAT" | "AUTH" => send("502 Not implemented")?,
|
||||
"TYPE" | "NOOP" | "OPTS" => send("200 OK")?,
|
||||
"PWD" => send(&format!("257 \"{cwd}\" is the current directory"))?,
|
||||
"CWD" => match (path(arg), virtual_path(&here, arg)) {
|
||||
(Some(p), Some(v)) if p.is_dir() => {
|
||||
cwd = v;
|
||||
send("250 OK")?;
|
||||
}
|
||||
_ => send("550 No such directory")?,
|
||||
},
|
||||
"MKD" => match path(arg).map(std::fs::create_dir) {
|
||||
Some(Ok(())) => send(&format!("257 \"{arg}\" created"))?,
|
||||
_ => send("550 Cannot create")?,
|
||||
},
|
||||
"SIZE" => match path(arg).and_then(|p| std::fs::metadata(p).ok()) {
|
||||
Some(m) if m.is_file() => send(&format!("213 {}", m.len()))?,
|
||||
_ => send("550 No such file")?,
|
||||
},
|
||||
"PASV" => {
|
||||
let l = TcpListener::bind("127.0.0.1:0")?;
|
||||
let port = l.local_addr()?.port();
|
||||
passive = Some(l);
|
||||
send(&format!(
|
||||
"227 Entering Passive Mode (127,0,0,1,{},{})",
|
||||
port >> 8,
|
||||
port & 0xff
|
||||
))?;
|
||||
}
|
||||
"STOR" | "RETR" | "LIST" => {
|
||||
let Some(listener) = passive.take() else {
|
||||
send("425 Use PASV first")?;
|
||||
continue;
|
||||
};
|
||||
let target = if cmd == "LIST" && arg.is_empty() {
|
||||
path(".")
|
||||
} else {
|
||||
path(arg)
|
||||
};
|
||||
let Some(target) = target else {
|
||||
send("550 Bad path")?;
|
||||
continue;
|
||||
};
|
||||
if cmd == "RETR" && !target.is_file() {
|
||||
send("550 No such file")?;
|
||||
continue;
|
||||
}
|
||||
send("150 Opening data connection")?;
|
||||
let (mut data, _) = listener.accept()?;
|
||||
let result = match cmd.as_str() {
|
||||
"STOR" => std::fs::File::create(&target)
|
||||
.and_then(|mut f| std::io::copy(&mut data, &mut f).map(|_| ())),
|
||||
"RETR" => std::fs::File::open(&target)
|
||||
.and_then(|mut f| std::io::copy(&mut f, &mut data).map(|_| ())),
|
||||
_ => list_dir(&target).and_then(|text| data.write_all(text.as_bytes())),
|
||||
};
|
||||
drop(data);
|
||||
send(if result.is_ok() {
|
||||
"226 Transfer complete"
|
||||
} else {
|
||||
"451 Transfer failed"
|
||||
})?;
|
||||
}
|
||||
"QUIT" => {
|
||||
send("221 Bye")?;
|
||||
return Ok(());
|
||||
}
|
||||
_ => send("502 Not implemented")?,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The FTP path of `arg`, relative to `cwd`, as an absolute path.
|
||||
fn virtual_path(cwd: &str, arg: &str) -> Option<String> {
|
||||
let joined = if arg.starts_with('/') {
|
||||
arg.to_string()
|
||||
} else {
|
||||
format!("{cwd}/{arg}")
|
||||
};
|
||||
normalize_relative(&joined).map(|r| format!("/{r}"))
|
||||
}
|
||||
|
||||
/// A POSIX `ls -l` style listing of `dir`.
|
||||
fn list_dir(dir: &Path) -> std::io::Result<String> {
|
||||
let mut text = String::new();
|
||||
for entry in std::fs::read_dir(dir)?.flatten() {
|
||||
let Ok(meta) = entry.metadata() else {
|
||||
continue;
|
||||
};
|
||||
let kind = if meta.is_dir() { 'd' } else { '-' };
|
||||
text.push_str(&format!(
|
||||
"{kind}rw-r--r-- 1 lutra lutra {} Jan 01 00:00 {}\r\n",
|
||||
if meta.is_dir() { 0 } else { meta.len() },
|
||||
entry.file_name().to_string_lossy()
|
||||
));
|
||||
}
|
||||
Ok(text)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue