aboutsummaryrefslogtreecommitdiffstats
path: root/src/server.rs
blob: e1b414ee0500a815e28e027f2cfd518c623a2ced (plain)
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

extern crate getopts;
extern crate utp;
extern crate daemonize;

use std::str;
use std::env;
use std::env::home_dir;
use std::process::exit;
use getopts::Options;
use utp::{UtpSocket, UtpListener};

fn run_server(path: &str, is_receive: bool) {

    // TODO: try to detect the address the SSH connection came in on via the SSH_CONNECTION env
    // variable.

    // Connect to an hypothetical local server running on port 61000
    let addr = "127.0.0.1:61000";

    // Accept connection from anybody
    let listener = UtpListener::bind(addr).expect("Error binding to local port");

    let listen_port = listener.local_addr().unwrap().port();
    let listen_addr = listener.local_addr().unwrap().ip();

    // Send back details so client can connect
    println!("UDP CONNECT {} {} {}", listen_addr, listen_port, "<SECRET>");

    // TODO: maybe wait for an ACK of some sort here before daemonizing?

    // At this point we partially daemonize (fork and redirect terminal), so that SSH will drop us.
    // But, don't clobber working dir.
    let working_dir = match env::home_dir() {
        Some(path) => path,
        None => env::current_dir().unwrap(),
    };
    // XXX: should maybe use log/syslog from here on?
    let daemonizer = daemonize::Daemonize::new().working_directory(working_dir);

    match daemonizer.start() {
         Ok(_) => println!("Success, daemonized"),
         Err(e) => println!("{}", e),
     }

    let (mut socket, _src) = listener.accept().unwrap();
    println!("Got connection from {}", socket.peer_addr().unwrap());

    loop {

        let mut buf = [0; 1000];
        let (amt, _src) = socket.recv_from(&mut buf).ok().unwrap();
        if amt <= 0 {
            break;
        }
        let buf = &buf[..amt];
        let s = str::from_utf8(buf).unwrap();
        println!("\tgot: {}", s);
        socket.send_to(buf);
    }
}

fn usage_server(opts: Options) {
    let brief = "usage:\tucp server ..."; // XXX:
    println!("");
    println!("IMPORTANT: this is the server mode of ucp. Unless you are developing/debugging, you probably want the 'regular' one (from the 'server' from you command)");
    print!("{}", opts.usage(&brief));
}

pub fn main_server() {

    let args: Vec<String> = env::args().collect();

    let mut opts = Options::new();
    opts.optflag("h", "help", "print this help menu");
    //opts.optflag("v", "verbose", "more debugging messages");
    opts.optflag("d", "dir-mode", "read/write a dir instead of file (server side)");
    opts.optopt("f", "from", "file or dir to read from (server side)", "FILE");
    opts.optopt("t", "to", "file or dir to write to (server side)", "FILE");

    assert!(args.len() >= 2 && args[1] == "server");
    let matches = match opts.parse(&args[2..]) {
        Ok(m) => { m }
        Err(f) => { println!("Error parsing args!"); usage_server(opts); exit(-1); }
    };

    if matches.opt_present("h") {
        usage_server(opts);
        return;
    }

    //let verbose: bool = matches.opt_present("v");
    let dir_mode: bool = matches.opt_present("d");

    match (matches.opt_present("f"), matches.opt_present("t")) {
        (true, true) | (false, false) => {
            println!("Must be either 'from' or 'to', but not both");
            exit(-1);
            },
        _ => {},
    }

    if matches.opt_present("f") {
        run_server(&matches.opt_str("f").unwrap(), false);
    }
    if matches.opt_present("t") {
        run_server(&matches.opt_str("t").unwrap(), true);
    }
}