mirror of
https://github.com/shadowsocks/shadowsocks-rust.git
synced 2026-11-22 00:05:24 +00:00
fixed json and suppress warnings
This commit is contained in:
+6
-1
@@ -54,10 +54,15 @@ path = "src/bin/server.rs"
|
||||
|
||||
[dependencies]
|
||||
collect = "*"
|
||||
rustc-serialize = "*"
|
||||
# rustc-serialize = "*"
|
||||
log = "*"
|
||||
byteorder = "*"
|
||||
rand = "*"
|
||||
getopts = "*"
|
||||
|
||||
[dependencies.libsodium-sys]
|
||||
git = "https://github.com/zonyitoo/libsodium-sys.git"
|
||||
optional = true
|
||||
|
||||
[dependencies.rustc-serialize]
|
||||
git = "https://github.com/zonyitoo/rustc-serialize"
|
||||
|
||||
+26
-27
@@ -26,40 +26,39 @@
|
||||
//! in mod `config`.
|
||||
//!
|
||||
|
||||
#![allow(unstable)]
|
||||
#![feature(env, net)]
|
||||
|
||||
extern crate getopts;
|
||||
extern crate shadowsocks;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
|
||||
use getopts::{optopt, optflag, getopts, usage};
|
||||
use getopts::Options;
|
||||
|
||||
use std::os;
|
||||
use std::env;
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use shadowsocks::config::{Config, ServerConfig, ClientConfig, self};
|
||||
use shadowsocks::config::{Config, ServerConfig, self};
|
||||
use shadowsocks::config::DEFAULT_DNS_CACHE_CAPACITY;
|
||||
use shadowsocks::relay::{RelayLocal, Relay};
|
||||
|
||||
fn main() {
|
||||
let opts = [
|
||||
optflag("v", "version", "print version"),
|
||||
optflag("h", "help", "print this message"),
|
||||
optflag("u", "enable-udp", "enable UDP relay"),
|
||||
optopt("c", "config", "specify config file", "config.json"),
|
||||
optopt("s", "server-addr", "server address", ""),
|
||||
optopt("b", "local-addr", "local address, listen only to this address if specified", ""),
|
||||
optopt("k", "password", "password", ""),
|
||||
optopt("p", "server-port", "server port", ""),
|
||||
optopt("l", "local-port", "local socks5 proxy port", ""),
|
||||
optopt("m", "encrypt-method", "entryption method", "aes-256-cfb"),
|
||||
];
|
||||
let mut opts = Options::new();
|
||||
opts.optflag("v", "version", "print version");
|
||||
opts.optflag("h", "help", "print this message");
|
||||
opts.optflag("u", "enable-udp", "enable UDP relay");
|
||||
opts.optopt("c", "config", "specify config file", "config.json");
|
||||
opts.optopt("s", "server-addr", "server address", "");
|
||||
opts.optopt("b", "local-addr", "local address, listen only to this address if specified", "");
|
||||
opts.optopt("k", "password", "password", "");
|
||||
opts.optopt("p", "server-port", "server port", "");
|
||||
opts.optopt("l", "local-port", "local socks5 proxy port", "");
|
||||
opts.optopt("m", "encrypt-method", "entryption method", "aes-256-cfb");
|
||||
|
||||
let matches = getopts(os::args().tail(), &opts).unwrap();
|
||||
let matches = opts.parse(env::args().skip(1)).unwrap();
|
||||
|
||||
if matches.opt_present("h") {
|
||||
println!("{}", usage(format!("Usage: {} [Options]", os::args()[0]).as_slice(),
|
||||
&opts));
|
||||
println!("{}", opts.usage(&format!("Usage: {} [Options]", env::args().next().unwrap())[..]));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -71,7 +70,7 @@ fn main() {
|
||||
let mut config =
|
||||
if matches.opt_present("c") {
|
||||
let cfile = matches.opt_str("c").unwrap();
|
||||
match Config::load_from_file(cfile.as_slice(), config::ConfigType::Local) {
|
||||
match Config::load_from_file(&cfile[..], config::ConfigType::Local) {
|
||||
Ok(cfg) => cfg,
|
||||
Err(err) => {
|
||||
error!("{:?}", err);
|
||||
@@ -86,13 +85,13 @@ fn main() {
|
||||
let addr_str = matches.opt_str("s").unwrap();
|
||||
let sc = ServerConfig {
|
||||
addr: addr_str,
|
||||
port: matches.opt_str("p").unwrap().as_slice().parse().expect("`port` should be an integer"),
|
||||
port: matches.opt_str("p").unwrap().parse().ok().expect("`port` should be an integer"),
|
||||
password: matches.opt_str("k").unwrap(),
|
||||
method: match matches.opt_str("m") {
|
||||
Some(method_s) => {
|
||||
match method_s.parse() {
|
||||
Some(m) => m,
|
||||
None => panic!("`{}` is not a supported method", method_s),
|
||||
Ok(m) => m,
|
||||
Err(err) => panic!("`{}` is not a supported method: {:?}", method_s, err),
|
||||
}
|
||||
},
|
||||
None => panic!("failed to get method string"),
|
||||
@@ -109,10 +108,10 @@ fn main() {
|
||||
}
|
||||
|
||||
if matches.opt_present("b") && matches.opt_present("l") {
|
||||
let local = ClientConfig {
|
||||
ip: matches.opt_str("b").unwrap().as_slice().parse().expect("`local` is not a valid IP address"),
|
||||
port: matches.opt_str("l").unwrap().as_slice().parse().expect("`local_port` should be an integer"),
|
||||
};
|
||||
let local = SocketAddr::new(
|
||||
matches.opt_str("b").unwrap().parse().ok().expect("`local` is not a valid IP address"),
|
||||
matches.opt_str("l").unwrap().parse().ok().expect("`local_port` should be an integer"),
|
||||
);
|
||||
config.local = Some(local)
|
||||
}
|
||||
|
||||
|
||||
+26
-27
@@ -28,39 +28,38 @@
|
||||
//! *It should be notice that the extented configuration file is not suitable for the server
|
||||
//! side.*
|
||||
|
||||
#![allow(unstable)]
|
||||
#![feature(env, net)]
|
||||
|
||||
extern crate getopts;
|
||||
extern crate shadowsocks;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
|
||||
use getopts::{optopt, optflag, getopts, usage};
|
||||
use std::os;
|
||||
use getopts::Options;
|
||||
use std::env;
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use shadowsocks::config::{Config, ServerConfig, ClientConfig, self};
|
||||
use shadowsocks::config::{Config, ServerConfig, self};
|
||||
use shadowsocks::config::DEFAULT_DNS_CACHE_CAPACITY;
|
||||
use shadowsocks::relay::{RelayServer, Relay};
|
||||
|
||||
fn main() {
|
||||
let opts = [
|
||||
optflag("v", "version", "print version"),
|
||||
optflag("h", "help", "print this message"),
|
||||
optflag("u", "enable-udp", "enable UDP relay"),
|
||||
optopt("c", "config", "specify config file", "config.json"),
|
||||
optopt("s", "server-addr", "server address", ""),
|
||||
optopt("b", "local-addr", "local address, listen only to this address if specified", ""),
|
||||
optopt("k", "password", "password", ""),
|
||||
optopt("p", "server-port", "server port", ""),
|
||||
optopt("l", "local-port", "local socks5 proxy port", ""),
|
||||
optopt("m", "encrypt-method", "entryption method", "aes-256-cfb"),
|
||||
];
|
||||
let mut opts = Options::new();
|
||||
opts.optflag("v", "version", "print version");
|
||||
opts.optflag("h", "help", "print this message");
|
||||
opts.optflag("u", "enable-udp", "enable UDP relay");
|
||||
opts.optopt("c", "config", "specify config file", "config.json");
|
||||
opts.optopt("s", "server-addr", "server address", "");
|
||||
opts.optopt("b", "local-addr", "local address, listen only to this address if specified", "");
|
||||
opts.optopt("k", "password", "password", "");
|
||||
opts.optopt("p", "server-port", "server port", "");
|
||||
opts.optopt("l", "local-port", "local socks5 proxy port", "");
|
||||
opts.optopt("m", "encrypt-method", "entryption method", "aes-256-cfb");
|
||||
|
||||
let matches = getopts(os::args().tail(), &opts).unwrap();
|
||||
let matches = opts.parse(env::args().skip(1)).unwrap();
|
||||
|
||||
if matches.opt_present("h") {
|
||||
println!("{}", usage(format!("Usage: {} [Options]", os::args()[0]).as_slice(),
|
||||
&opts));
|
||||
println!("{}", opts.usage(&format!("Usage: {} [Options]", env::args().next().unwrap())[..]));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -72,7 +71,7 @@ fn main() {
|
||||
let mut config =
|
||||
if matches.opt_present("c") {
|
||||
let cfile = matches.opt_str("c").unwrap();
|
||||
match Config::load_from_file(cfile.as_slice(), config::ConfigType::Server) {
|
||||
match Config::load_from_file(&cfile[..], config::ConfigType::Server) {
|
||||
Ok(cfg) => cfg,
|
||||
Err(err) => {
|
||||
error!("{:?}", err);
|
||||
@@ -88,13 +87,13 @@ fn main() {
|
||||
let addr_str = matches.opt_str("s").unwrap();
|
||||
let sc = ServerConfig {
|
||||
addr: addr_str,
|
||||
port: matches.opt_str("p").unwrap().as_slice().parse().expect("`port` should be an integer"),
|
||||
port: matches.opt_str("p").unwrap().parse().ok().expect("`port` should be an integer"),
|
||||
password: matches.opt_str("k").unwrap(),
|
||||
method: match matches.opt_str("m") {
|
||||
Some(method_s) => {
|
||||
match method_s.parse() {
|
||||
Some(m) => m,
|
||||
None => panic!("`{}` is not a supported method", method_s),
|
||||
Ok(m) => m,
|
||||
Err(err) => panic!("`{}` is not a supported method: {:?}", method_s, err),
|
||||
}
|
||||
},
|
||||
None => panic!("failed to get method string"),
|
||||
@@ -111,10 +110,10 @@ fn main() {
|
||||
}
|
||||
|
||||
if matches.opt_present("b") && matches.opt_present("l") {
|
||||
let local = ClientConfig {
|
||||
ip: matches.opt_str("b").unwrap().as_slice().parse().expect("`local` is not a valid IP address"),
|
||||
port: matches.opt_str("l").unwrap().as_slice().parse().expect("`local_port` should be an integer"),
|
||||
};
|
||||
let local = SocketAddr::new(
|
||||
matches.opt_str("b").unwrap().parse().ok().expect("`local` is not a valid IP address"),
|
||||
matches.opt_str("l").unwrap().parse().ok().expect("`local_port` should be an integer"),
|
||||
);
|
||||
config.local = Some(local)
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -311,7 +311,7 @@ impl Config {
|
||||
"`local_address` should be a string",
|
||||
None)));
|
||||
let ip = try!(addr_str.parse()
|
||||
.map_err(|err| Error::new(ErrorKind::Malformed,
|
||||
.map_err(|_| Error::new(ErrorKind::Malformed,
|
||||
"`local_address` is not a valid IP address",
|
||||
None)));
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
|
||||
use std::str::FromStr;
|
||||
use std::fmt::{Debug, Display, self};
|
||||
use std::rand::{self, Rng};
|
||||
use rand::{self, Rng};
|
||||
|
||||
use crypto::openssl;
|
||||
use crypto::table;
|
||||
@@ -313,7 +313,7 @@ impl CipherType {
|
||||
if i > 0 {
|
||||
let mut vkey = m[i - 1].clone();
|
||||
vkey.push_all(key);
|
||||
md5.update(vkey.as_slice());
|
||||
md5.update(&vkey[..]);
|
||||
} else {
|
||||
md5.update(key);
|
||||
}
|
||||
@@ -322,7 +322,7 @@ impl CipherType {
|
||||
i += 1
|
||||
}
|
||||
|
||||
let whole = m.into_iter().fold(Vec::new(), |mut a, b| { a.push_all(b.as_slice()); a });
|
||||
let whole = m.into_iter().fold(Vec::new(), |mut a, b| { a.push_all(&b[..]); a });
|
||||
let key = whole[0..key_len].to_vec();
|
||||
key
|
||||
}
|
||||
@@ -483,8 +483,8 @@ mod test_cipher {
|
||||
let message = "HELLO WORLD";
|
||||
|
||||
let encrypted_msg = encryptor.update(message.as_bytes()).unwrap();
|
||||
let decrypted_msg = decryptor.update(encrypted_msg.as_slice()).unwrap();
|
||||
let decrypted_msg = decryptor.update(&encrypted_msg[..]).unwrap();
|
||||
|
||||
assert!(message.as_bytes() == decrypted_msg.as_slice());
|
||||
assert!(message.as_bytes() == &decrypted_msg[..]);
|
||||
}
|
||||
}
|
||||
|
||||
+16
-16
@@ -446,7 +446,7 @@ pub struct OpenSSLCipher {
|
||||
impl OpenSSLCipher {
|
||||
pub fn new(cipher_type: cipher::CipherType, key: &[u8], iv: &[u8], mode: CryptoMode) -> OpenSSLCipher {
|
||||
OpenSSLCipher {
|
||||
worker: OpenSSLCrypto::new(cipher_type, key.as_slice(), iv.as_slice(), mode),
|
||||
worker: OpenSSLCrypto::new(cipher_type, &key[..], &iv[..], mode),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -509,18 +509,18 @@ mod test_openssl {
|
||||
let k = t.bytes_to_key(key.as_bytes());
|
||||
let iv = t.gen_init_vec();
|
||||
|
||||
let mut enc = OpenSSLCipher::new(*t, k.as_slice(), iv.as_slice(), CryptoMode::Encrypt);
|
||||
let mut enc = OpenSSLCipher::new(*t, &k[..], &iv[..], CryptoMode::Encrypt);
|
||||
|
||||
let mut encrypted_msg = enc.update(message.as_bytes()).unwrap();
|
||||
encrypted_msg.push_all(enc.finalize().unwrap().as_slice());
|
||||
encrypted_msg.push_all(&enc.finalize().unwrap()[..]);
|
||||
println!("ENC {:?}", encrypted_msg);
|
||||
|
||||
let mut dec = OpenSSLCipher::new(*t, k.as_slice(), iv.as_slice(), CryptoMode::Decrypt);
|
||||
let mut decrypted_msg = dec.update(encrypted_msg.as_slice()).unwrap();
|
||||
decrypted_msg.push_all(dec.finalize().unwrap().as_slice());
|
||||
println!("DEC {:?}", decrypted_msg.as_slice());
|
||||
let mut dec = OpenSSLCipher::new(*t, &k[..], &iv[..], CryptoMode::Decrypt);
|
||||
let mut decrypted_msg = dec.update(&encrypted_msg[..]).unwrap();
|
||||
decrypted_msg.push_all(&dec.finalize().unwrap()[..]);
|
||||
println!("DEC {:?}", &decrypted_msg[..]);
|
||||
|
||||
assert_eq!(message.as_bytes(), decrypted_msg.as_slice());
|
||||
assert_eq!(message.as_bytes(), &decrypted_msg[..]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -534,7 +534,7 @@ mod test_openssl {
|
||||
for _ in range::<usize>(0, 100) {
|
||||
let msg = range(0, msg_size).map(|_| random::<u8>()).collect::<Vec<u8>>();
|
||||
let key = range(1, random::<usize>() % 63).map(|_| random::<u8>()).collect::<Vec<u8>>();
|
||||
let k = cipher::CipherType::Aes256Cfb.bytes_to_key(key.as_slice());
|
||||
let k = cipher::CipherType::Aes256Cfb.bytes_to_key(&key[..]);
|
||||
let v = cipher::CipherType::Aes256Cfb.gen_init_vec();
|
||||
|
||||
test_data.push((msg, k, v));
|
||||
@@ -544,8 +544,8 @@ mod test_openssl {
|
||||
let (ref msg, ref key, ref iv) = test_data[random::<usize>() % test_data.len()];
|
||||
|
||||
let mut enc = OpenSSLCipher::new(cipher::CipherType::Aes256Cfb,
|
||||
key.as_slice(), iv.as_slice(), CryptoMode::Encrypt);
|
||||
enc.update(msg.as_slice()).unwrap();
|
||||
&key[..], &iv[..], CryptoMode::Encrypt);
|
||||
enc.update(&msg[..]).unwrap();
|
||||
});
|
||||
b.bytes = msg_size as u64;
|
||||
}
|
||||
@@ -559,19 +559,19 @@ mod test_openssl {
|
||||
for _ in range::<usize>(0, 100) {
|
||||
let msg = range(0, msg_size).map(|_| random::<u8>()).collect::<Vec<u8>>();
|
||||
let key = range(1, random::<usize>() % 63).map(|_| random::<u8>()).collect::<Vec<u8>>();
|
||||
let k = cipher::CipherType::Aes256Cfb.bytes_to_key(key.as_slice());
|
||||
let k = cipher::CipherType::Aes256Cfb.bytes_to_key(&key[..]);
|
||||
let v = cipher::CipherType::Aes256Cfb.gen_init_vec();
|
||||
let mut cipher = OpenSSLCipher::new(cipher::CipherType::Aes256Cfb,
|
||||
k.as_slice(), v.as_slice(), CryptoMode::Encrypt);
|
||||
let encrypted_msg = cipher.update(msg.as_slice()).unwrap();
|
||||
&k[..], &v[..], CryptoMode::Encrypt);
|
||||
let encrypted_msg = cipher.update(&msg[..]).unwrap();
|
||||
test_data.push((k, v, encrypted_msg));
|
||||
}
|
||||
|
||||
b.iter(|| {
|
||||
let (ref key, ref iv, ref encrypted_msg) = test_data[random::<usize>() % test_data.len()];
|
||||
let mut cipher = OpenSSLCipher::new(cipher::CipherType::Aes256Cfb,
|
||||
key.as_slice(), iv.as_slice(), CryptoMode::Decrypt);
|
||||
cipher.update(encrypted_msg.as_slice()).unwrap();
|
||||
&key[..], &iv[..], CryptoMode::Decrypt);
|
||||
cipher.update(&encrypted_msg[..]).unwrap();
|
||||
});
|
||||
b.bytes = msg_size as u64;
|
||||
}
|
||||
|
||||
@@ -39,7 +39,7 @@ impl Rc4Md5Cipher {
|
||||
let key = md5_digest.digest();
|
||||
|
||||
Rc4Md5Cipher {
|
||||
crypto: OpenSSLCrypto::new(CipherType::Rc4, key.as_slice(), b"", mode)
|
||||
crypto: OpenSSLCrypto::new(CipherType::Rc4, &key[..], b"", mode)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -68,7 +68,7 @@ impl Cipher for SodiumCipher {
|
||||
data
|
||||
} else {
|
||||
pad = Some(repeat(0u8).take(padding_len).chain(data.iter().map(|&x| x)).collect::<Vec<u8>>());
|
||||
pad.as_ref().unwrap().as_slice()
|
||||
&pad.as_ref().unwrap()[..]
|
||||
};
|
||||
|
||||
if self.buf.len() < padding_len + data.len() {
|
||||
@@ -117,12 +117,12 @@ mod test_sodium {
|
||||
|
||||
let iv = ct.gen_init_vec();
|
||||
|
||||
let mut enc = SodiumCipher::new(ct, key.as_slice(), iv.as_slice());
|
||||
let mut enc = SodiumCipher::new(ct, &key[..], &iv[..]);
|
||||
let encrypted_msg = enc.update(message).unwrap();
|
||||
|
||||
let mut dec = SodiumCipher::new(ct, key.as_slice(), iv.as_slice());
|
||||
let mut dec = SodiumCipher::new(ct, &key[..], &iv[..]);
|
||||
let decrypted_msg = dec.update(&encrypted_msg[0..]).unwrap();
|
||||
|
||||
assert_eq!(message, decrypted_msg.as_slice());
|
||||
assert_eq!(message, &decrypted_msg[..]);
|
||||
}
|
||||
}
|
||||
|
||||
+6
-6
@@ -44,11 +44,11 @@ impl TableCipher {
|
||||
md5_digest.update(key);
|
||||
let key_digest = md5_digest.digest();
|
||||
|
||||
let mut bufr = BufReader::new(key_digest.as_slice());
|
||||
let mut bufr = BufReader::new(&key_digest[..]);
|
||||
let a = bufr.read_u64::<LittleEndian>().unwrap();
|
||||
let mut table = range(0, TABLE_SIZE).map(|idx| idx as u64).collect::<Vec<u64>>();
|
||||
let mut table = (0..TABLE_SIZE).map(|idx| idx as u64).collect::<Vec<u64>>();
|
||||
|
||||
for i in range(1, 1024) {
|
||||
for i in 1..1024 {
|
||||
table.as_mut_slice().sort_by(|x, y| {
|
||||
(a % (*x + i)).cmp(&(a % (*y + i)))
|
||||
})
|
||||
@@ -60,7 +60,7 @@ impl TableCipher {
|
||||
CryptoMode::Decrypt => {
|
||||
let mut t = Vec::with_capacity(table.len());
|
||||
unsafe { t.set_len(table.len()); }
|
||||
for idx in range(0, table.len()) {
|
||||
for idx in 0..table.len() {
|
||||
t[table[idx] as usize] = idx as u8;
|
||||
}
|
||||
t
|
||||
@@ -93,7 +93,7 @@ fn test_table_cipher() {
|
||||
let mut enc = TableCipher::new(key.as_bytes(), CryptoMode::Encrypt);
|
||||
let mut dec = TableCipher::new(key.as_bytes(), CryptoMode::Decrypt);
|
||||
let encrypted_msg = enc.update(message.as_bytes()).unwrap();
|
||||
let decrypted_msg = dec.update(encrypted_msg.as_slice()).unwrap();
|
||||
let decrypted_msg = dec.update(&encrypted_msg[..]).unwrap();
|
||||
|
||||
assert_eq!(decrypted_msg.as_slice(), message.as_bytes());
|
||||
assert_eq!(&decrypted_msg[..], message.as_bytes());
|
||||
}
|
||||
|
||||
+3
-5
@@ -23,11 +23,7 @@
|
||||
#![crate_type = "lib"]
|
||||
#![crate_name = "shadowsocks"]
|
||||
|
||||
#![allow(unstable)]
|
||||
|
||||
#![feature(unsafe_destructor)]
|
||||
#![feature(box_syntax)]
|
||||
#![feature(libc)]
|
||||
#![feature(unsafe_destructor, box_syntax, libc, core, io, old_path, net, fs, std_misc, collections, test)]
|
||||
|
||||
extern crate "rustc-serialize" as serialize;
|
||||
#[macro_use]
|
||||
@@ -37,6 +33,8 @@ extern crate collect;
|
||||
extern crate "libsodium-sys" as libsodium_ffi;
|
||||
|
||||
extern crate byteorder;
|
||||
extern crate rand;
|
||||
extern crate getopts;
|
||||
|
||||
use std::fmt::{Debug, Formatter, self};
|
||||
|
||||
|
||||
@@ -39,7 +39,7 @@ impl RoundRobin {
|
||||
|
||||
impl LoadBalancer for RoundRobin {
|
||||
fn pick_server<'a>(&'a mut self) -> &'a ServerConfig {
|
||||
match self.server.as_slice() {
|
||||
match &self.server[..] {
|
||||
[ref s] => s,
|
||||
_ => {
|
||||
let ref s = self.server[self.index];
|
||||
|
||||
+4
-4
@@ -21,7 +21,7 @@
|
||||
|
||||
//! Local side
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
use relay::Relay;
|
||||
use relay::tcprelay::local::TcpRelayLocal;
|
||||
@@ -93,7 +93,7 @@ impl Relay for RelayLocal {
|
||||
warn!("UDP relay feature is disabled, recompile with feature=\"enable-udp\" to enable this feature");
|
||||
}
|
||||
let tcprelay = self.tcprelay.clone();
|
||||
let tcp_thread = Thread::scoped(move || tcprelay.run());
|
||||
let tcp_thread = thread::scoped(move || tcprelay.run());
|
||||
info!("Enabled TCP relay");
|
||||
|
||||
tcp_thread.join();
|
||||
@@ -104,13 +104,13 @@ impl Relay for RelayLocal {
|
||||
let mut threads = Vec::with_capacity(2);
|
||||
|
||||
let tcprelay = self.tcprelay.clone();
|
||||
let tcp_thread = Thread::scoped(move || tcprelay.run());
|
||||
let tcp_thread = thread::scoped(move || tcprelay.run());
|
||||
threads.push(tcp_thread);
|
||||
info!("Enabled TCP relay");
|
||||
|
||||
if self.enable_udp {
|
||||
let udprelay = self.udprelay.clone();
|
||||
let udp_thread = Thread::scoped(move || udprelay.run());
|
||||
let udp_thread = thread::scoped(move || udprelay.run());
|
||||
threads.push(udp_thread);
|
||||
info!("Enabled UDP relay");
|
||||
}
|
||||
|
||||
+4
-4
@@ -21,7 +21,7 @@
|
||||
|
||||
//! Server side
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
#[cfg(feature = "enable-udp")]
|
||||
use relay::udprelay::server::UdpRelayServer;
|
||||
@@ -89,12 +89,12 @@ impl Relay for RelayServer {
|
||||
let mut threads = Vec::with_capacity(2);
|
||||
|
||||
let tcprelay = self.tcprelay.clone();
|
||||
threads.push(Thread::scoped(move || tcprelay.run()));
|
||||
threads.push(thread::scoped(move || tcprelay.run()));
|
||||
info!("Enabled TCP relay");
|
||||
|
||||
if self.enable_udp {
|
||||
let udprelay = self.udprelay.clone();
|
||||
let udp_thread = Thread::scoped(move || udprelay.run());
|
||||
let udp_thread = thread::scoped(move || udprelay.run());
|
||||
threads.push(udp_thread);
|
||||
info!("Enabled UDP relay");
|
||||
}
|
||||
@@ -111,7 +111,7 @@ impl Relay for RelayServer {
|
||||
}
|
||||
|
||||
let tcprelay = self.tcprelay.clone();
|
||||
let tcp_thread = Thread::scoped(move || tcprelay.run());
|
||||
let tcp_thread = thread::scoped(move || tcprelay.run());
|
||||
info!("Enabled TCP relay");
|
||||
|
||||
tcp_thread.join();
|
||||
|
||||
+15
-15
@@ -27,7 +27,7 @@ use std::io::{self, Read, ReadExt, Write};
|
||||
use std::vec;
|
||||
use std::error;
|
||||
|
||||
use byteorder::{self, ReadBytesExt, WriteBytesExt, BigEndian, LittleEndian};
|
||||
use byteorder::{self, ReadBytesExt, WriteBytesExt, BigEndian};
|
||||
|
||||
const SOCKS5_VERSION : u8 = 0x05;
|
||||
|
||||
@@ -163,7 +163,7 @@ impl fmt::Display for Error {
|
||||
|
||||
impl error::Error for Error {
|
||||
fn description(&self) -> &str {
|
||||
self.message.as_slice()
|
||||
&self.message[..]
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&error::Error> {
|
||||
@@ -195,7 +195,7 @@ pub enum Address {
|
||||
|
||||
impl Address {
|
||||
#[inline]
|
||||
pub fn read_from<R: ReadExt>(reader: &mut R) -> Result<Address, Error> {
|
||||
pub fn read_from<R: ReadExt + Sized>(reader: &mut R) -> Result<Address, Error> {
|
||||
match parse_request_header(reader) {
|
||||
Ok((_, addr)) => Ok(addr),
|
||||
Err(err) => Err(err),
|
||||
@@ -203,7 +203,7 @@ impl Address {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn write_to(&self, writer: &mut Write) -> io::Result<()> {
|
||||
pub fn write_to<W: Write + Sized>(&self, writer: &mut W) -> io::Result<()> {
|
||||
write_addr(self, writer)
|
||||
}
|
||||
|
||||
@@ -236,9 +236,9 @@ impl fmt::Display for Address {
|
||||
impl ToSocketAddrs for Address {
|
||||
type Iter = vec::IntoIter<SocketAddr>;
|
||||
fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
|
||||
match *self {
|
||||
match self.clone() {
|
||||
Address::SocketAddress(ip, port) => Ok(vec![SocketAddr::new(ip, port)].into_iter()),
|
||||
Address::DomainNameAddress(addr, port) => (addr.as_slice(), port).to_socket_addrs(),
|
||||
Address::DomainNameAddress(addr, port) => (&addr[..], port).to_socket_addrs(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -262,7 +262,7 @@ impl TcpRequestHeader {
|
||||
let mut buf = [0u8; 3];
|
||||
match stream.read(&mut buf) {
|
||||
Ok(_) => (),
|
||||
Err(err) => return Err(Error::new(Reply::GeneralFailure, err.to_string().as_slice()))
|
||||
Err(err) => return Err(Error::new(Reply::GeneralFailure, err.description()))
|
||||
}
|
||||
let [ver, cmd, _] = buf;
|
||||
|
||||
@@ -280,7 +280,7 @@ impl TcpRequestHeader {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn write_to(&self, stream: &mut Write) -> io::Result<()> {
|
||||
pub fn write_to<W: Write + Sized>(&self, stream: &mut W) -> io::Result<()> {
|
||||
try!(stream.write(&[SOCKS5_VERSION, self.command.code(), 0x00]));
|
||||
try!(self.address.write_to(stream));
|
||||
|
||||
@@ -312,7 +312,7 @@ impl TcpResponseHeader {
|
||||
let mut buf = [0u8; 3];
|
||||
match stream.read(&mut buf) {
|
||||
Ok(_) => (),
|
||||
Err(err) => return Err(Error::new(Reply::GeneralFailure, err.to_string().as_slice()))
|
||||
Err(err) => return Err(Error::new(Reply::GeneralFailure, err.description()))
|
||||
}
|
||||
let [ver, reply_code, _] = buf;
|
||||
|
||||
@@ -327,7 +327,7 @@ impl TcpResponseHeader {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn write_to(&self, stream: &mut Write) -> io::Result<()> {
|
||||
pub fn write_to<W: Write + Sized>(&self, stream: &mut W) -> io::Result<()> {
|
||||
try!(stream.write(&[SOCKS5_VERSION, self.reply.code(), 0x00]));
|
||||
try!(self.address.write_to(stream));
|
||||
|
||||
@@ -387,7 +387,7 @@ fn parse_request_header<R: ReadExt>(stream: &mut R) -> Result<(usize, Address),
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn write_addr(addr: &Address, buf: &mut Write) -> io::Result<()> {
|
||||
fn write_addr<W: Write + Sized>(addr: &Address, buf: &mut W) -> io::Result<()> {
|
||||
match addr {
|
||||
&Address::SocketAddress(ip, port) => {
|
||||
match ip {
|
||||
@@ -442,7 +442,7 @@ fn write_addr(addr: &Address, buf: &mut Write) -> io::Result<()> {
|
||||
byteorder::Error::Io(err) => err
|
||||
}
|
||||
}));
|
||||
try!(buf.write_all(dnaddr.as_slice().as_bytes()));
|
||||
try!(buf.write_all(dnaddr[..].as_bytes()));
|
||||
try!(buf.write_u16::<BigEndian>(port).map_err(|err| {
|
||||
match err {
|
||||
byteorder::Error::UnexpectedEOF => {
|
||||
@@ -512,7 +512,7 @@ impl HandshakeRequest {
|
||||
|
||||
pub fn write_to(&self, stream: &mut Write) -> io::Result<()> {
|
||||
try!(stream.write(&[SOCKS5_VERSION, self.methods.len() as u8]));
|
||||
try!(stream.write(self.methods.as_slice()));
|
||||
try!(stream.write(&self.methods[..]));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -577,7 +577,7 @@ impl UdpAssociateHeader {
|
||||
match reader.read(&mut buf[read_size..]) {
|
||||
Ok(l) => read_size += l,
|
||||
Err(err) => {
|
||||
return Err(Error::new(Reply::GeneralFailure, err.to_string().as_slice()));
|
||||
return Err(Error::new(Reply::GeneralFailure, err.description()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -587,7 +587,7 @@ impl UdpAssociateHeader {
|
||||
Ok(UdpAssociateHeader::new(frag, try!(Address::read_from(reader))))
|
||||
}
|
||||
|
||||
pub fn write_to(&self, writer: &mut Write) -> io::Result<()> {
|
||||
pub fn write_to<W: Write + Sized>(&self, writer: &mut W) -> io::Result<()> {
|
||||
try!(writer.write_all(&[0x00, 0x00, self.frag]));
|
||||
try!(self.address.write_to(writer));
|
||||
|
||||
|
||||
@@ -71,7 +71,7 @@ impl CachedDns {
|
||||
}
|
||||
}
|
||||
|
||||
let addrs = match lookup_host(addr) {
|
||||
let mut addrs = match lookup_host(addr) {
|
||||
Ok(addrs) => addrs,
|
||||
Err(err) => {
|
||||
error!("Failed to resolve {}: {}", addr, err);
|
||||
|
||||
+26
-23
@@ -25,7 +25,7 @@ use std::net::{TcpListener, TcpStream};
|
||||
use std::net::{SocketAddr, IpAddr, Shutdown};
|
||||
use std::net::lookup_host;
|
||||
use std::io::{self, BufStream, ErrorKind, Read, ReadExt, Write};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use config::Config;
|
||||
@@ -119,8 +119,7 @@ impl TcpRelayLocal {
|
||||
match err.kind() {
|
||||
ErrorKind::ConnectionAborted
|
||||
| ErrorKind::ConnectionReset
|
||||
| ErrorKind::ConnectionRefused
|
||||
| ErrorKind::ConnectionAborted => {
|
||||
| ErrorKind::ConnectionRefused => {
|
||||
socks5::TcpResponseHeader::new(socks5::Reply::HostUnreachable, addr.clone())
|
||||
.write_to(&mut stream).unwrap();
|
||||
},
|
||||
@@ -139,10 +138,10 @@ impl TcpRelayLocal {
|
||||
|
||||
let iv = encrypt_method.gen_init_vec();
|
||||
let encryptor = cipher::with_type(encrypt_method,
|
||||
password.as_slice(),
|
||||
iv.as_slice(),
|
||||
&password[..],
|
||||
&iv[..],
|
||||
CryptoMode::Encrypt);
|
||||
remote_stream.write_all(iv.as_slice()).unwrap();
|
||||
remote_stream.write_all(&iv[..]).unwrap();
|
||||
let mut encrypt_stream = EncryptedWriter::new(remote_stream.try_clone().unwrap(), encryptor);
|
||||
|
||||
{
|
||||
@@ -156,10 +155,10 @@ impl TcpRelayLocal {
|
||||
}
|
||||
|
||||
let addr_cloned = addr.clone();
|
||||
let mut remote_stream_cloned = remote_stream.try_clone().unwrap();
|
||||
let mut local_stream_cloned = stream.try_clone().unwrap();
|
||||
Thread::spawn(move || {
|
||||
match io::util::copy(&mut buffered_local_stream, &mut encrypt_stream) {
|
||||
let remote_stream_cloned = remote_stream.try_clone().unwrap();
|
||||
let local_stream_cloned = stream.try_clone().unwrap();
|
||||
thread::spawn(move || {
|
||||
match io::copy(&mut buffered_local_stream, &mut encrypt_stream) {
|
||||
Ok(..) => {},
|
||||
Err(err) => {
|
||||
match err.kind() {
|
||||
@@ -178,15 +177,19 @@ impl TcpRelayLocal {
|
||||
|
||||
let remote_iv = {
|
||||
let mut iv = Vec::new();
|
||||
remote_stream.take(encrypt_method.block_size() as u64).read_to_end(&mut iv).unwrap();
|
||||
remote_stream.try_clone()
|
||||
.unwrap()
|
||||
.take(encrypt_method.block_size() as u64)
|
||||
.read_to_end(&mut iv)
|
||||
.unwrap();
|
||||
iv
|
||||
};
|
||||
let decryptor = cipher::with_type(encrypt_method,
|
||||
password.as_slice(),
|
||||
remote_iv.as_slice(),
|
||||
&password[..],
|
||||
&remote_iv[..],
|
||||
CryptoMode::Decrypt);
|
||||
let mut decrypt_stream = DecryptedReader::new(remote_stream.try_clone().unwrap(), decryptor);
|
||||
match io::util::copy(&mut decrypt_stream, &mut stream) {
|
||||
match io::copy(&mut decrypt_stream, &mut stream) {
|
||||
Err(err) => {
|
||||
match err.kind() {
|
||||
ErrorKind::BrokenPipe => {
|
||||
@@ -231,7 +234,7 @@ impl Relay for TcpRelayLocal {
|
||||
|
||||
let local_conf = self.config.local.expect("need local configuration");
|
||||
|
||||
let mut acceptor = match TcpListener::bind(&local_conf) {
|
||||
let acceptor = match TcpListener::bind(&local_conf) {
|
||||
Ok(acpt) => acpt,
|
||||
Err(e) => {
|
||||
panic!("Error occurs while listening local address: {}", e.to_string());
|
||||
@@ -243,25 +246,25 @@ impl Relay for TcpRelayLocal {
|
||||
let mut cached_proxy: BTreeMap<String, IpAddr> = BTreeMap::new();
|
||||
|
||||
for s in acceptor.incoming() {
|
||||
let mut stream = s.unwrap();
|
||||
stream.set_keepalive(self.config.timeout);
|
||||
let stream = s.unwrap();
|
||||
let _ = stream.set_keepalive(self.config.timeout);
|
||||
|
||||
let mut succeed = false;
|
||||
for _ in range(0, server_load_balancer.total()) {
|
||||
for _ in 0..server_load_balancer.total() {
|
||||
let ref server_cfg = server_load_balancer.pick_server();
|
||||
let addr = {
|
||||
match cached_proxy.get(server_cfg.addr.as_slice()).map(|x| x.clone()) {
|
||||
match cached_proxy.get(&server_cfg.addr[..]).map(|x| x.clone()) {
|
||||
Some(addr) => addr,
|
||||
None => {
|
||||
match lookup_host(server_cfg.addr.as_slice()) {
|
||||
Ok(addr_itr) => {
|
||||
match lookup_host(&server_cfg.addr[..]) {
|
||||
Ok(mut addr_itr) => {
|
||||
match addr_itr.next() {
|
||||
None => {
|
||||
error!("cannot resolve proxy server `{}`", server_cfg.addr);
|
||||
continue;
|
||||
},
|
||||
Some(addr) => {
|
||||
cached_proxy.insert(server_cfg.addr.clone(), addr.unwrap().ip().clone());
|
||||
cached_proxy.insert(server_cfg.addr.clone(), addr.clone().unwrap().ip());
|
||||
addr.unwrap().ip()
|
||||
}
|
||||
}
|
||||
@@ -281,7 +284,7 @@ impl Relay for TcpRelayLocal {
|
||||
let pwd = encrypt_method.bytes_to_key(server_cfg.password.as_bytes());
|
||||
let enable_udp = self.config.enable_udp;
|
||||
|
||||
Thread::spawn(move ||
|
||||
thread::spawn(move ||
|
||||
TcpRelayLocal::handle_client(stream,
|
||||
server_addr,
|
||||
pwd,
|
||||
|
||||
@@ -21,17 +21,15 @@
|
||||
|
||||
//! TcpRelay server that running on the server side
|
||||
|
||||
use std::sync::Arc;
|
||||
// use std::sync::Arc;
|
||||
use std::net::{TcpListener, TcpStream, Shutdown};
|
||||
use std::net::SocketAddr;
|
||||
use std::io::{Read, ReadExt, Write, BufStream, ErrorKind, self};
|
||||
use std::time::duration::Duration;
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
use config::{Config, ServerConfig};
|
||||
use relay::Relay;
|
||||
use relay::socks5::{Address, self};
|
||||
use relay::tcprelay::cached_dns::CachedDns;
|
||||
use relay::socks5;
|
||||
// use relay::tcprelay::cached_dns::CachedDns;
|
||||
use relay::tcprelay::stream::{DecryptedReader, EncryptedWriter};
|
||||
use crypto::cipher;
|
||||
use crypto::CryptoMode;
|
||||
@@ -52,33 +50,37 @@ impl TcpRelayServer {
|
||||
}
|
||||
|
||||
fn accept_loop(s: ServerConfig) {
|
||||
let mut acceptor = TcpListener::bind(&(s.addr.as_slice(), s.port))
|
||||
.unwrap_or_else(|err| panic!("Failed to bind: {:?}", err));
|
||||
let acceptor = TcpListener::bind(&(&s.addr[..], s.port))
|
||||
.unwrap_or_else(|err| panic!("Failed to bind: {:?}", err));
|
||||
|
||||
info!("Shadowsocks listening on {}", s.addr);
|
||||
|
||||
let dnscache_arc = Arc::new(CachedDns::with_capacity(s.dns_cache_capacity));
|
||||
// let dnscache_arc = Arc::new(CachedDns::with_capacity(s.dns_cache_capacity));
|
||||
|
||||
let pwd = s.method.bytes_to_key(s.password.as_bytes());
|
||||
let timeout = s.timeout;
|
||||
let method = s.method;
|
||||
for s in acceptor.incoming() {
|
||||
let mut stream = s.unwrap();
|
||||
stream.set_keepalive(timeout);
|
||||
let _ = stream.set_keepalive(timeout);
|
||||
|
||||
let pwd = pwd.clone();
|
||||
let encrypt_method = method;
|
||||
let dnscache = dnscache_arc.clone();
|
||||
// let dnscache = dnscache_arc.clone();
|
||||
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
let remote_iv = {
|
||||
let mut iv = Vec::new();
|
||||
stream.take(encrypt_method.block_size() as u64).read_to_end(&mut iv).unwrap();
|
||||
stream.try_clone()
|
||||
.unwrap()
|
||||
.take(encrypt_method.block_size() as u64)
|
||||
.read_to_end(&mut iv)
|
||||
.unwrap();
|
||||
iv
|
||||
};
|
||||
let decryptor = cipher::with_type(encrypt_method,
|
||||
pwd.as_slice(),
|
||||
remote_iv.as_slice(),
|
||||
&pwd[..],
|
||||
&remote_iv[..],
|
||||
CryptoMode::Decrypt);
|
||||
|
||||
let buffered_client_stream = BufStream::new(stream.try_clone().unwrap());
|
||||
@@ -96,7 +98,7 @@ impl TcpRelayServer {
|
||||
|
||||
let mut remote_stream_cloned = remote_stream.try_clone().unwrap();
|
||||
let addr_cloned = addr.clone();
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
match io::copy(&mut decrypt_stream, &mut remote_stream_cloned) {
|
||||
Ok(..) => {},
|
||||
Err(err) => {
|
||||
@@ -116,13 +118,13 @@ impl TcpRelayServer {
|
||||
|
||||
let iv = encrypt_method.gen_init_vec();
|
||||
let encryptor = cipher::with_type(encrypt_method,
|
||||
pwd.as_slice(),
|
||||
iv.as_slice(),
|
||||
&pwd[..],
|
||||
&iv[..],
|
||||
CryptoMode::Encrypt);
|
||||
stream.write_all(iv.as_slice()).unwrap();
|
||||
stream.write_all(&iv[..]).unwrap();
|
||||
let mut buffered_remote_stream = BufStream::new(remote_stream.try_clone().unwrap());
|
||||
let mut encrypt_stream = EncryptedWriter::new(stream.try_clone().unwrap(), encryptor);
|
||||
match io::util::copy(&mut buffered_remote_stream, &mut encrypt_stream) {
|
||||
match io::copy(&mut buffered_remote_stream, &mut encrypt_stream) {
|
||||
Ok(..) => {},
|
||||
Err(err) => {
|
||||
match err.kind() {
|
||||
@@ -147,7 +149,7 @@ impl Relay for TcpRelayServer {
|
||||
let mut threads = Vec::new();
|
||||
for s in self.config.server.iter() {
|
||||
let s = s.clone();
|
||||
let fut = Thread::scoped(move || {
|
||||
let fut = thread::scoped(move || {
|
||||
TcpRelayServer::accept_loop(s);
|
||||
});
|
||||
threads.push(fut);
|
||||
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
#![allow(dead_code)]
|
||||
|
||||
use std::io::{self, ErrorKind, Read, BufRead, Write};
|
||||
use std::io::{self, Read, BufRead, Write};
|
||||
use std::cmp;
|
||||
use std::slice;
|
||||
|
||||
@@ -137,7 +137,7 @@ impl<W: Write> EncryptedWriter<W> {
|
||||
pub fn finalize(&mut self) -> io::Result<()> {
|
||||
match self.cipher.finalize() {
|
||||
Ok(fin) => {
|
||||
self.writer.write_all(fin.as_slice())
|
||||
self.writer.write_all(&fin[..])
|
||||
},
|
||||
Err(err) => {
|
||||
Err(io::Error::new(
|
||||
|
||||
+20
-20
@@ -58,7 +58,7 @@ use std::sync::{Arc, Mutex};
|
||||
use std::net::{UdpSocket, SocketAddr, lookup_host};
|
||||
use std::collections::HashMap;
|
||||
use std::io::{BufReader, self};
|
||||
use std::thread::Thread;
|
||||
use std::thread;
|
||||
|
||||
use collect::LruCache;
|
||||
|
||||
@@ -93,7 +93,7 @@ impl Relay for UdpRelayLocal {
|
||||
let mut server_set = HashMap::new();
|
||||
let mut server_addr = HashMap::new();
|
||||
for s in self.config.server.iter() {
|
||||
let addrs = match lookup_host(s.addr.as_slice()) {
|
||||
let mut addrs = match lookup_host(&s.addr[..]) {
|
||||
Ok(addr) => addr,
|
||||
Err(..) => continue,
|
||||
};
|
||||
@@ -112,7 +112,7 @@ impl Relay for UdpRelayLocal {
|
||||
let client_map_arc = Arc::new(Mutex::new(
|
||||
LruCache::<socks5::Address, SocketAddr>::new(UDP_RELAY_LOCAL_LRU_CACHE_CAPACITY)));
|
||||
|
||||
let mut socket = UdpSocket::bind(&addr).ok().expect("Failed to bind udp socket");
|
||||
let socket = UdpSocket::bind(&addr).ok().expect("Failed to bind udp socket");
|
||||
|
||||
let mut buf = [0u8; 0xffff];
|
||||
loop {
|
||||
@@ -130,9 +130,9 @@ impl Relay for UdpRelayLocal {
|
||||
match server_set.get(&source_addr) {
|
||||
Some(sref) => {
|
||||
let s = sref.clone();
|
||||
Thread::spawn(move ||
|
||||
thread::spawn(move ||
|
||||
handle_response(move_socket,
|
||||
request_message.as_slice(),
|
||||
&request_message[..],
|
||||
source_addr,
|
||||
&s,
|
||||
client_map));
|
||||
@@ -143,9 +143,9 @@ impl Relay for UdpRelayLocal {
|
||||
match server_addr.get(&s.addr) {
|
||||
Some(saddr) => {
|
||||
let saddr = saddr.clone();
|
||||
Thread::spawn(move ||
|
||||
thread::spawn(move ||
|
||||
handle_request(move_socket,
|
||||
request_message.as_slice(),
|
||||
&request_message[..],
|
||||
source_addr,
|
||||
saddr,
|
||||
&s,
|
||||
@@ -165,7 +165,7 @@ impl Relay for UdpRelayLocal {
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_request(mut socket: UdpSocket,
|
||||
fn handle_request(socket: UdpSocket,
|
||||
request_message: &[u8],
|
||||
from_addr: SocketAddr,
|
||||
server_addr: SocketAddr,
|
||||
@@ -196,22 +196,22 @@ fn handle_request(mut socket: UdpSocket,
|
||||
let key = config.method.bytes_to_key(config.password.as_bytes());
|
||||
let mut iv = config.method.gen_init_vec();
|
||||
let mut encryptor = cipher::with_type(config.method,
|
||||
key.as_slice(),
|
||||
iv.as_slice(),
|
||||
&key[..],
|
||||
&iv[..],
|
||||
CryptoMode::Encrypt);
|
||||
|
||||
let mut wbuf = Vec::new();
|
||||
request.write_to(&mut wbuf).unwrap();
|
||||
io::util::copy(&mut bufr, &mut wbuf).unwrap();
|
||||
io::copy(&mut bufr, &mut wbuf).unwrap();
|
||||
|
||||
iv.push_all(encryptor.update(wbuf.as_slice()).unwrap().as_slice());
|
||||
iv.push_all(encryptor.finalize().unwrap().as_slice());
|
||||
iv.push_all(&encryptor.update(&wbuf[..]).unwrap()[..]);
|
||||
iv.push_all(&encryptor.finalize().unwrap()[..]);
|
||||
|
||||
socket.send_to(iv.as_slice(), &server_addr)
|
||||
socket.send_to(&iv[..], &server_addr)
|
||||
.ok().expect("Error occurs while sending to remote");
|
||||
}
|
||||
|
||||
fn handle_response(mut socket: UdpSocket,
|
||||
fn handle_response(socket: UdpSocket,
|
||||
response_message: &[u8],
|
||||
from_addr: SocketAddr,
|
||||
config: &ServerConfig,
|
||||
@@ -219,13 +219,13 @@ fn handle_response(mut socket: UdpSocket,
|
||||
let key = config.method.bytes_to_key(config.password.as_bytes());
|
||||
|
||||
let mut decryptor = cipher::with_type(config.method,
|
||||
key.as_slice(),
|
||||
&key[..],
|
||||
&response_message[0..config.method.block_size()],
|
||||
CryptoMode::Decrypt);
|
||||
let mut decrypted_data = decryptor.update(&response_message[config.method.block_size()..]).unwrap();
|
||||
decrypted_data.push_all(decryptor.finalize().unwrap().as_slice());
|
||||
decrypted_data.push_all(&decryptor.finalize().unwrap()[..]);
|
||||
|
||||
let mut bufr = BufReader::new(decrypted_data.as_slice());
|
||||
let mut bufr = BufReader::new(&decrypted_data[..]);
|
||||
|
||||
let addr = socks5::Address::read_from(&mut bufr).unwrap();
|
||||
|
||||
@@ -242,8 +242,8 @@ fn handle_response(mut socket: UdpSocket,
|
||||
let mut bufw = Vec::new();
|
||||
socks5::UdpAssociateHeader::new(0, addr)
|
||||
.write_to(&mut bufw).unwrap();
|
||||
io::util::copy(&mut bufr, &mut bufw).unwrap();
|
||||
io::copy(&mut bufr, &mut bufw).unwrap();
|
||||
|
||||
socket.send_to(bufw.as_slice(), &client_addr)
|
||||
socket.send_to(&bufw[..], &client_addr)
|
||||
.ok().expect("Error occurs while sending to local");
|
||||
}
|
||||
|
||||
@@ -20,9 +20,9 @@
|
||||
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::net::{UdpSocket, SocketAddr, lookup_host, ToSocketAddrs};
|
||||
use std::io::{BufReader, ReadExt, Read, Write};
|
||||
use std::thread::Thread;
|
||||
use std::net::{UdpSocket, SocketAddr, lookup_host};
|
||||
use std::io::{BufReader, ReadExt};
|
||||
use std::thread;
|
||||
|
||||
use collect::LruCache;
|
||||
|
||||
@@ -46,7 +46,7 @@ impl UdpRelayServer {
|
||||
}
|
||||
|
||||
fn accept_loop(svr_config: ServerConfig) {
|
||||
let mut socket = UdpSocket::bind(&(svr_config.addr.as_slice(), svr_config.port))
|
||||
let socket = UdpSocket::bind(&(&svr_config.addr[..], svr_config.port))
|
||||
.ok().expect("Unable to bind UDP socket");
|
||||
debug!("UDP server is binding {}", svr_config.addr);
|
||||
|
||||
@@ -62,12 +62,12 @@ impl UdpRelayServer {
|
||||
let data = buf[..len].to_vec();
|
||||
let client_map = client_map_arc.clone();
|
||||
let remote_map = remote_map_arc.clone();
|
||||
let mut captured_socket = socket.try_clone().unwrap();
|
||||
let captured_socket = socket.try_clone().unwrap();
|
||||
|
||||
let method = svr_config.method;
|
||||
let password = svr_config.password.clone();
|
||||
|
||||
Thread::spawn(move || {
|
||||
thread::spawn(move || {
|
||||
match remote_map.lock().unwrap().get(&src) {
|
||||
Some(remote_addr) => {
|
||||
match client_map.lock().unwrap().get(remote_addr) {
|
||||
@@ -77,20 +77,20 @@ impl UdpRelayServer {
|
||||
// Make a header
|
||||
let mut response_buf = Vec::new();
|
||||
remote_addr.write_to(&mut response_buf).unwrap();
|
||||
response_buf.push_all(data.as_slice());
|
||||
response_buf.push_all(&data[..]);
|
||||
|
||||
let key = method.bytes_to_key(password.as_bytes());
|
||||
let mut iv = method.gen_init_vec();
|
||||
let mut encryptor =
|
||||
cipher::with_type(method,
|
||||
key.as_slice(),
|
||||
iv.as_slice(),
|
||||
&key[..],
|
||||
&iv[..],
|
||||
CryptoMode::Encrypt);
|
||||
iv.push_all(encryptor.update(response_buf.as_slice()).unwrap().as_slice());
|
||||
iv.push_all(encryptor.finalize().unwrap().as_slice());
|
||||
iv.push_all(&encryptor.update(&response_buf[..]).unwrap()[..]);
|
||||
iv.push_all(&encryptor.finalize().unwrap()[..]);
|
||||
|
||||
captured_socket
|
||||
.send_to(iv.as_slice(), &client_addr)
|
||||
.send_to(&iv[..], &client_addr)
|
||||
.unwrap();
|
||||
},
|
||||
None => {
|
||||
@@ -108,12 +108,12 @@ impl UdpRelayServer {
|
||||
let key = method.bytes_to_key(password.as_bytes());
|
||||
let mut decryptor =
|
||||
cipher::with_type(method,
|
||||
key.as_slice(),
|
||||
&key[..],
|
||||
&data[0..method.block_size()],
|
||||
CryptoMode::Decrypt);
|
||||
let mut decrypted_data = decryptor.update(&data[method.block_size()..]).unwrap();
|
||||
decrypted_data.push_all(decryptor.finalize().unwrap().as_slice());
|
||||
let mut bufr = BufReader::new(decrypted_data.as_slice());
|
||||
decrypted_data.push_all(&decryptor.finalize().unwrap()[..]);
|
||||
let mut bufr = BufReader::new(&decrypted_data[..]);
|
||||
|
||||
let header = socks5::UdpAssociateHeader::read_from(bufr.by_ref()).unwrap();
|
||||
|
||||
@@ -136,7 +136,7 @@ impl UdpRelayServer {
|
||||
SocketAddr::new(ip, port)
|
||||
},
|
||||
&Address::DomainNameAddress(ref dnaddr, port) => {
|
||||
let ipaddrs = lookup_host(dnaddr.as_slice())
|
||||
let mut ipaddrs = lookup_host(&dnaddr[..])
|
||||
.unwrap_or_else(|err| {
|
||||
panic!("Unable to resolve {}: {}", dnaddr, err);
|
||||
});
|
||||
@@ -153,7 +153,7 @@ impl UdpRelayServer {
|
||||
remote_addr
|
||||
}
|
||||
};
|
||||
captured_socket.send_to(&decrypted_data.as_slice()[header.len()..], &sockaddr).unwrap();
|
||||
captured_socket.send_to(&decrypted_data[..][header.len()..], &sockaddr).unwrap();
|
||||
});
|
||||
},
|
||||
Err(err) => {
|
||||
@@ -170,7 +170,7 @@ impl Relay for UdpRelayServer {
|
||||
let mut threads = Vec::new();
|
||||
for s in self.config.server.iter() {
|
||||
let s = s.clone();
|
||||
let fut = Thread::scoped(move || UdpRelayServer::accept_loop(s));
|
||||
let fut = thread::scoped(move || UdpRelayServer::accept_loop(s));
|
||||
threads.push(fut);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user