rootftp 0.3.1

A simple FTP server tool that allows you to play with files. Multiple users can share their files with each other. You can also build custom plugins see examples for more info.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::constants::{create_rooted_storage, SimpleAuthenticator, UserEntry};
use directories::ProjectDirs;
use libunftp::auth::Authenticator;
use libunftp::ServerBuilder;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
use std::sync::Arc;

fn pid_path() -> Option<PathBuf> {
    ProjectDirs::from("net", "runner", "rootftp")
        .map(|d| d.config_dir().join("rootftp.pid"))
}

fn write_pid() {
    if let Some(path) = pid_path() {
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent).ok();
        }
        fs::write(&path, std::process::id().to_string()).ok();
    }
}

fn remove_pid() {
    if let Some(path) = pid_path() {
        fs::remove_file(path).ok();
    }
}

/// Must be called before tokio runtime starts. Exits the parent process.
pub fn daemonize() -> Result<(), Box<dyn std::error::Error>> {
    use std::os::unix::io::AsRawFd;
    match unsafe { libc::fork() } {
        -1 => return Err("first fork failed".into()),
        0 => {}
        _ => std::process::exit(0),
    }
    unsafe { libc::setsid(); }
    match unsafe { libc::fork() } {
        -1 => return Err("second fork failed".into()),
        0 => {}
        _ => std::process::exit(0),
    }
    let devnull = fs::File::open("/dev/null")?;
    let fd = devnull.as_raw_fd();
    unsafe {
        libc::dup2(fd, 0);
        libc::dup2(fd, 1);
        libc::dup2(fd, 2);
    }
    Ok(())
}

pub async fn start_server(
    daemon: bool,
    auth: SimpleAuthenticator,
    root_dir: PathBuf,
    addr: String,
) -> Result<(), Box<dyn std::error::Error>> {
    if daemon {
        return Ok(());
    }

    let dir = root_dir.join("ftpd");
    let storage = create_rooted_storage(dir.clone());
    crate::init::init().await?;

    write_pid();

    let auth_arc: Arc<dyn Authenticator<UserEntry> + Send + Sync> = Arc::new(auth);
    let server = ServerBuilder::with_authenticator(storage, auth_arc)
        .passive_ports(50000u16..=50100u16)
        .build()
        .expect("Failed to build server");

    println!("Listening on {}", addr);

    let server_fut = server.listen(addr);
    let ctrl_c_fut = tokio::signal::ctrl_c();
    let mut term_signal = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?;
    let term_fut = term_signal.recv();

    tokio::select! {
        result = server_fut => {
            remove_pid();
            result?;
        }
        _ = ctrl_c_fut => {
            println!("\nShutting down...");
            remove_pid();
        }
        _ = term_fut => {
            println!("\nShutting down...");
            remove_pid();
        }
    }

    Ok(())
}

pub async fn stop_server() {
    let path = match pid_path() {
        Some(p) => p,
        None => {
            println!("Could not determine PID file location.");
            return;
        }
    };

    let pid_str = match fs::read_to_string(&path) {
        Ok(s) => s,
        Err(_) => {
            println!("Server PID file not found. Is the server running?");
            return;
        }
    };

    let pid: i32 = match pid_str.trim().parse() {
        Ok(n) => n,
        Err(_) => {
            println!("Invalid PID in file.");
            return;
        }
    };

    let status = Command::new("kill")
        .arg(pid.to_string())
        .status()
        .expect("Failed to run kill");

    if status.success() {
        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
        fs::remove_file(&path).ok();
        println!("Server (PID {}) stopped.", pid);
    } else {
        println!("Failed to stop server (PID {}).", pid);
    }
}