diff --git a/Cargo.toml b/Cargo.toml index adf5fd8d..0b09c127 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/src/bin/local.rs b/src/bin/local.rs index 9e4f85ba..b8bb833c 100644 --- a/src/bin/local.rs +++ b/src/bin/local.rs @@ -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) } diff --git a/src/bin/server.rs b/src/bin/server.rs index 68a52ee4..49d972e5 100644 --- a/src/bin/server.rs +++ b/src/bin/server.rs @@ -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) } diff --git a/src/config.rs b/src/config.rs index f8f08c56..8aa3c9ea 100644 --- a/src/config.rs +++ b/src/config.rs @@ -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))); diff --git a/src/crypto/cipher.rs b/src/crypto/cipher.rs index 442fc694..84a1e538 100644 --- a/src/crypto/cipher.rs +++ b/src/crypto/cipher.rs @@ -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[..]); } } diff --git a/src/crypto/openssl.rs b/src/crypto/openssl.rs index 444ce979..04a83283 100644 --- a/src/crypto/openssl.rs +++ b/src/crypto/openssl.rs @@ -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::(0, 100) { let msg = range(0, msg_size).map(|_| random::()).collect::>(); let key = range(1, random::() % 63).map(|_| random::()).collect::>(); - 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::() % 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::(0, 100) { let msg = range(0, msg_size).map(|_| random::()).collect::>(); let key = range(1, random::() % 63).map(|_| random::()).collect::>(); - 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::() % 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; } diff --git a/src/crypto/rc4_md5.rs b/src/crypto/rc4_md5.rs index 2ee0c291..bc6b3aa3 100644 --- a/src/crypto/rc4_md5.rs +++ b/src/crypto/rc4_md5.rs @@ -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) } } } diff --git a/src/crypto/sodium.rs b/src/crypto/sodium.rs index e3a30297..a5401545 100644 --- a/src/crypto/sodium.rs +++ b/src/crypto/sodium.rs @@ -68,7 +68,7 @@ impl Cipher for SodiumCipher { data } else { pad = Some(repeat(0u8).take(padding_len).chain(data.iter().map(|&x| x)).collect::>()); - 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[..]); } } diff --git a/src/crypto/table.rs b/src/crypto/table.rs index 4459e0c3..b9035202 100644 --- a/src/crypto/table.rs +++ b/src/crypto/table.rs @@ -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::().unwrap(); - let mut table = range(0, TABLE_SIZE).map(|idx| idx as u64).collect::>(); + let mut table = (0..TABLE_SIZE).map(|idx| idx as u64).collect::>(); - 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()); } diff --git a/src/lib.rs b/src/lib.rs index 0f8cebac..c51a5283 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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}; diff --git a/src/relay/loadbalancing/server/roundrobin.rs b/src/relay/loadbalancing/server/roundrobin.rs index 209c03d9..400bc108 100644 --- a/src/relay/loadbalancing/server/roundrobin.rs +++ b/src/relay/loadbalancing/server/roundrobin.rs @@ -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]; diff --git a/src/relay/local.rs b/src/relay/local.rs index c3e59440..c0a9c803 100644 --- a/src/relay/local.rs +++ b/src/relay/local.rs @@ -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"); } diff --git a/src/relay/server.rs b/src/relay/server.rs index 12bd30b8..b03f8269 100644 --- a/src/relay/server.rs +++ b/src/relay/server.rs @@ -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(); diff --git a/src/relay/socks5.rs b/src/relay/socks5.rs index dfe77ec6..15f0ac28 100644 --- a/src/relay/socks5.rs +++ b/src/relay/socks5.rs @@ -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(reader: &mut R) -> Result { + pub fn read_from(reader: &mut R) -> Result { 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(&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; fn to_socket_addrs(&self) -> io::Result> { - 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(&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(&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(stream: &mut R) -> Result<(usize, Address), } #[inline] -fn write_addr(addr: &Address, buf: &mut Write) -> io::Result<()> { +fn write_addr(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::(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(&self, writer: &mut W) -> io::Result<()> { try!(writer.write_all(&[0x00, 0x00, self.frag])); try!(self.address.write_to(writer)); diff --git a/src/relay/tcprelay/cached_dns.rs b/src/relay/tcprelay/cached_dns.rs index 723a5622..e193867b 100644 --- a/src/relay/tcprelay/cached_dns.rs +++ b/src/relay/tcprelay/cached_dns.rs @@ -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); diff --git a/src/relay/tcprelay/local.rs b/src/relay/tcprelay/local.rs index 628ae0d1..99bce08d 100644 --- a/src/relay/tcprelay/local.rs +++ b/src/relay/tcprelay/local.rs @@ -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 = 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, diff --git a/src/relay/tcprelay/server.rs b/src/relay/tcprelay/server.rs index 84ae9882..2088dcc5 100644 --- a/src/relay/tcprelay/server.rs +++ b/src/relay/tcprelay/server.rs @@ -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); diff --git a/src/relay/tcprelay/stream.rs b/src/relay/tcprelay/stream.rs index 0a436e9b..f73cdd90 100644 --- a/src/relay/tcprelay/stream.rs +++ b/src/relay/tcprelay/stream.rs @@ -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 EncryptedWriter { 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( diff --git a/src/relay/udprelay/local.rs b/src/relay/udprelay/local.rs index d6fc5f2b..cc57ad0a 100644 --- a/src/relay/udprelay/local.rs +++ b/src/relay/udprelay/local.rs @@ -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::::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"); } diff --git a/src/relay/udprelay/server.rs b/src/relay/udprelay/server.rs index 6a8be37c..7f41e9a4 100644 --- a/src/relay/udprelay/server.rs +++ b/src/relay/udprelay/server.rs @@ -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); }