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
|
extern crate getopts;
extern crate utp;
use super::common;
use std::string::String;
use std::env;
use std::process;
use std::process::exit;
use std::process::Command;
use getopts::Options;
use utp::{UtpSocket};
pub fn run_client(host: &str, local_file: &str, remote_file: &str, remote_is_dir: bool, is_recv: bool) {
println!("\thost: {}", host);
println!("\tlocal_file: {}", local_file);
println!("\tremote_file: {}", remote_file);
println!("\tis_recv: {}", is_recv);
let mut ssh_cmd = Command::new("ssh");
ssh_cmd.arg(host)
.arg("--")
.arg("ucp")
.arg("server")
.arg(if is_recv {"-f"} else {"-t"})
.arg(remote_file);
if remote_is_dir {
ssh_cmd.arg("-d");
}
let ssh_output = ssh_cmd.output().expect("couldn't get SSH sub-process output");
if !ssh_output.status.success() {
panic!("SSH problem: {}", String::from_utf8_lossy(&ssh_output.stderr));
}
let reply = String::from_utf8_lossy(&ssh_output.stdout);
println!("SSH reply: {}", reply);
let words: Vec<&str> = reply.split_whitespace().collect();
if words.len() != 5 || words[0] != "UCP" || words[1] != "CONNECT" {
panic!("Unexpected data via SSH pipe (TCP)");
}
let remote_host = words[2];
let remote_port = words[3].parse::<u16>().expect("failed to parse remote port number");
let remote_secret = words[4];
println!("Got remote details:");
println!("\tport: {}", remote_port);
println!("\thost: {}", remote_host);
println!("\tsecret: {}", remote_secret);
let mut socket = UtpSocket::connect((remote_host, remote_port)).unwrap();;
let mut stream = socket.into();
if is_recv {
common::sink_files(&mut stream, local_file, remote_is_dir);
} else {
common::source_files(&mut stream, local_file, remote_is_dir);
}
stream.close().unwrap();
}
fn usage_client(opts: Options) {
let brief = "usage:\tucp client ..."; // XXX:
println!("");
println!("IMPORTANT: this is the client mode of ucp. Unless you are developing/debugging, you probably want the 'regular' one (from the 'client' from you command)");
print!("{}", opts.usage(&brief));
}
pub fn main_client() {
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 (client side)");
opts.optopt("f", "from", "file or dir to read from (client side)", "FILE");
opts.optopt("t", "to", "file or dir to write to (client side)", "FILE");
opts.reqopt("", "host", "remote hostname to connect to", "HOSTNAME");
opts.reqopt("", "port", "remote port to connect to", "PORT");
assert!(args.len() >= 2 && args[1] == "client");
let matches = match opts.parse(&args[2..]) {
Ok(m) => { m }
Err(f) => { println!("Error parsing args!"); usage_client(opts); exit(-1); }
};
if matches.opt_present("h") {
usage_client(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);
},
_ => {},
}
let port = matches.opt_str("port").unwrap().parse::<u16>().unwrap();
let mut socket = UtpSocket::connect((matches.opt_str("host").unwrap().as_str(), port)).unwrap();
let mut stream = socket.into();
println!("opened socket");
if matches.opt_present("f") {
common::source_files(&mut stream, &matches.opt_str("f").unwrap(), dir_mode);
}
if matches.opt_present("t") {
common::sink_files(&mut stream, &matches.opt_str("t").unwrap(), dir_mode);
}
stream.close().unwrap();
}
|
