fixed json and suppress warnings

This commit is contained in:
Y. T. Chung
2015-02-23 22:00:48 +08:00
parent 7943d85177
commit a80bd24f4f
20 changed files with 208 additions and 202 deletions
+6 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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)));
+5 -5
View File
@@ -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
View File
@@ -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;
}
+1 -1
View File
@@ -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)
}
}
}
+4 -4
View File
@@ -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
View File
@@ -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
View File
@@ -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};
+1 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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));
+1 -1
View File
@@ -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
View File
@@ -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,
+23 -21
View File
@@ -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);
+2 -2
View File
@@ -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
View File
@@ -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");
}
+18 -18
View File
@@ -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);
}