diff --git a/Cargo.toml b/Cargo.toml index 7c19d38a..adf5fd8d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,6 +56,7 @@ path = "src/bin/server.rs" collect = "*" rustc-serialize = "*" log = "*" +byteorder = "*" [dependencies.libsodium-sys] git = "https://github.com/zonyitoo/libsodium-sys.git" diff --git a/src/config.rs b/src/config.rs index dde80d24..f8f08c56 100644 --- a/src/config.rs +++ b/src/config.rs @@ -67,8 +67,8 @@ use serialize::json; -use std::io::{File, Read, Open}; -use std::io::net::ip::{Port, SocketAddr}; +use std::fs::OpenOptions; +use std::net::SocketAddr; use std::string::ToString; use std::option::Option; use std::default::Default; @@ -83,10 +83,10 @@ pub const DEFAULT_DNS_CACHE_CAPACITY: usize = 65536; #[derive(Clone, Debug)] pub struct ServerConfig { pub addr: String, - pub port: Port, + pub port: u16, pub password: String, pub method: CipherType, - pub timeout: Option, + pub timeout: Option, pub dns_cache_capacity: usize, } @@ -105,7 +105,7 @@ pub struct Config { pub server: Vec, pub local: Option, pub enable_udp: bool, - pub timeout: Option, + pub timeout: Option, } impl Default for Config { @@ -149,21 +149,6 @@ impl Debug for Error { } } -macro_rules! try_config( - ($inp:expr, $kind:expr, $desc:expr) => ( - match $inp { - Some(s) => s, - None => return Err(Error::new($kind, $desc, None)), - } - ); - ($inp:expr, $kind:expr, $desc:expr, $detail:expr) => ( - match $inp { - Some(s) => s, - None => return Err(Error::new($kind, $desc, Some($detail))), - } - ); -); - impl Config { pub fn new() -> Config { Config { @@ -178,57 +163,70 @@ impl Config { let mut config = Config::new(); config.timeout = match o.get(&"timeout".to_string()) { - Some(t_str) => Some(try_config!(t_str.as_u64(), - ErrorKind::Malformed, "`timeout` should be an integer") * 1000), + Some(t_str) => Some(try!(t_str.as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`timeout` should be an integer", + None))) as u32 * 1000), None => None, }; if o.contains_key(&"servers".to_string()) { let server_list = - try_config!(o.get(&"servers".to_string()).unwrap().as_array(), - ErrorKind::Malformed, "`servers` should be a list"); + try!(o.get(&"servers".to_string()).unwrap().as_array().ok_or( + Error::new(ErrorKind::Malformed, "`servers` should be a list", None))); for server in server_list.iter() { let method_o = - try_config!(server.find("method"), ErrorKind::MissingField, "need to specify a method"); - let method_str = try_config!(method_o.as_string(), + try!(server.find("method").ok_or(Error::new(ErrorKind::MissingField, "need to specify a method", None))); + let method_str = try!(method_o.as_string().ok_or(Error::new( ErrorKind::Malformed, - "`method` should be a string"); - let method = try_config!(method_str.parse::(), + "`method` should be a string", + None))); + let method = try!(method_str.parse::().map_err(|_| Error::new( ErrorKind::Invalid, "not supported method", - format!("`{}` is not a supported method", method_str)); + Some(format!("`{}` is not a supported method", method_str))))); - let addr_o = try_config!(server.find("address"), - ErrorKind::MissingField, "need to specify a server address"); - let addr_str = try_config!(addr_o.as_string(), - ErrorKind::Malformed, "`address` should be a string"); + let addr_o = try!(server.find("address") + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify a server address", + None))); + let addr_str = try!(addr_o.as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`address` should be a string", + None))); let cfg = ServerConfig { addr: addr_str.to_string(), - port: try_config!( - try_config!(server.find("port"), - ErrorKind::MissingField, - "need to specify a server port").as_u64(), - ErrorKind::Malformed, - "`port` should be an integer") as Port, - password: try_config!( - try_config!(server.find("password"), - ErrorKind::MissingField, - "need to specify a password").as_string(), - ErrorKind::Malformed, - "`password` should be a string").to_string(), + port: try!(try!(server.find("port") + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify a server port", + None))) + .as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`port` should be an integer", + None))) as u16, + password: try!(try!(server.find("password") + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify a password", + None))) + .as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`password` should be a string", + None))).to_string(), method: method, timeout: match server.find("timeout") { - Some(t) => Some(try_config!(t.as_u64(), - ErrorKind::Malformed, - "`timeout` should be an integer") * 1000), + Some(t) => Some(try!(t.as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`timeout` should be an integer", + None))) as u32 * 1000), None => None, }, dns_cache_capacity: match server.find("dns_cache_capacity") { - Some(t) => try_config!(t.as_u64(), - ErrorKind::Malformed, - "`dns_cache_capacity` should be an integer") as usize, + Some(t) => try!(t.as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`dns_cache_capacity` should be an integer", + None))) as usize, None => DEFAULT_DNS_CACHE_CAPACITY, } }; @@ -241,50 +239,61 @@ impl Config { && o.contains_key(&"password".to_string()) && o.contains_key(&"method".to_string()) { // Traditional configuration file - let method_o = try_config!(o.get(&"method".to_string()), - ErrorKind::MissingField, - "need to specify method"); - let method_str = try_config!(method_o.as_string(), - ErrorKind::Malformed, - "`method` should be a string"); - let method = try_config!(method_str.parse::(), - ErrorKind::Invalid, - "not supported method", - format!("`{}` is not a supported method", method_str)); - let addr_o = try_config!(o.get(&"server".to_string()), - ErrorKind::MissingField, - "need to specify server address"); - let addr_str = try_config!(addr_o.as_string(), - ErrorKind::Malformed, - "`server` should be a string"); + let method_o = try!(o.get(&"method".to_string()) + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify method", + None))); + let method_str = try!(method_o.as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`method` should be a string", + None))); + let method = try!(method_str.parse::() + .map_err(|_| Error::new(ErrorKind::Invalid, + "not supported method", + Some(format!("`{}` is not a supported method", + method_str))))); + let addr_o = try!(o.get(&"server".to_string()) + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify server address", + None))); + let addr_str = try!(addr_o.as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`server` should be a string", + None))); let single_server = ServerConfig { addr: addr_str.to_string(), - port: try_config!( - try_config!(o.get("port"), - ErrorKind::MissingField, - "need to specify a server port").as_u64(), - ErrorKind::Malformed, - "`port` should be an integer") as Port, - password: try_config!( - try_config!(o.get("password"), - ErrorKind::MissingField, - "need to specify a password").as_string(), - ErrorKind::Malformed, - "`password` should be a string").to_string(), + port: try!(try!(o.get("port") + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify a server port", + None))) + .as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`port` should be an integer", + None))) as u16, + password: try!(try!(o.get("password") + .ok_or(Error::new(ErrorKind::MissingField, + "need to specify a password", + None))) + .as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`password` should be a string", + None))).to_string(), method: method, timeout: match o.get("timeout") { - Some(t) => Some(try_config!(t.as_u64(), - ErrorKind::Malformed, - "`timeout` should be an integer") * 1000), + Some(t) => Some(try!(t.as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`timeout` should be an integer", + None))) as u32 * 1000), None => None, }, dns_cache_capacity: match o.get("dns_cache_capacity") { - Some(t) => try_config!(t.as_u64(), - ErrorKind::Malformed, - "`dns_cache_capacity` should be an integer") as usize, + Some(t) => try!(t.as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`dns_cache_capacity` should be an integer", + None))) as usize, None => DEFAULT_DNS_CACHE_CAPACITY, - }, + } }; config.server = vec![single_server]; @@ -297,21 +306,23 @@ impl Config { if has_local_address && has_local_port { config.local = match o.get(&"local_address".to_string()) { Some(local_addr) => { - let addr_str = try_config!(local_addr.as_string(), - ErrorKind::Malformed, - "`local_address` should be a string"); - let ip = try_config!(addr_str.parse(), - ErrorKind::Malformed, - "`local_address` is not a valid IP address"); + let addr_str = try!(local_addr.as_string() + .ok_or(Error::new(ErrorKind::Malformed, + "`local_address` should be a string", + None))); + let ip = try!(addr_str.parse() + .map_err(|err| Error::new(ErrorKind::Malformed, + "`local_address` is not a valid IP address", + None))); - let port = try_config!(o.get(&"local_port".to_string()).unwrap().as_u64(), - ErrorKind::Malformed, - "`local_port` should be an integer") as Port; + let port = try!(o.get(&"local_port".to_string()) + .unwrap() + .as_u64() + .ok_or(Error::new(ErrorKind::Malformed, + "`local_port` should be an integer", + None))) as u16; - Some(SocketAddr { - ip: ip, - port: port, - }) + Some(SocketAddr::new(ip, port)) }, None => None, }; @@ -345,7 +356,7 @@ impl Config { } pub fn load_from_file(filename: &str, config_type: ConfigType) -> Result { - let mut readeropt = File::open_mode(&Path::new(filename), Open, Read); + let mut readeropt = OpenOptions::new().read(true).open(&Path::new(filename)); let reader = match readeropt { Ok(ref mut r) => r, diff --git a/src/crypto/cipher.rs b/src/crypto/cipher.rs index 35d142c8..442fc694 100644 --- a/src/crypto/cipher.rs +++ b/src/crypto/cipher.rs @@ -47,6 +47,7 @@ pub type CipherResult = Result; #[derive(Copy)] pub enum ErrorKind { + UnknownCipherType, OpenSSLError, } @@ -56,6 +57,16 @@ pub struct Error { pub detail: Option, } +impl Error { + pub fn new(kind: ErrorKind, desc: &'static str, detail: Option) -> Error { + Error { + kind: kind, + desc: desc, + detail: detail, + } + } +} + impl Debug for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{}", self.desc)); @@ -327,112 +338,113 @@ impl CipherType { } impl FromStr for CipherType { - fn from_str(s: &str) -> Option { + type Err = Error; + fn from_str(s: &str) -> Result { match s { - CIPHER_TABLE | "" => Some(CipherType::Table), + CIPHER_TABLE | "" => Ok(CipherType::Table), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_128_CFB => - Some(CipherType::Aes128Cfb), + Ok(CipherType::Aes128Cfb), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_128_CFB_1 => - Some(CipherType::Aes128Cfb1), + Ok(CipherType::Aes128Cfb1), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_128_CFB_8 => - Some(CipherType::Aes128Cfb8), + Ok(CipherType::Aes128Cfb8), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_128_CFB_128 => - Some(CipherType::Aes128Cfb128), + Ok(CipherType::Aes128Cfb128), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_192_CFB => - Some(CipherType::Aes192Cfb), + Ok(CipherType::Aes192Cfb), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_192_CFB_1 => - Some(CipherType::Aes192Cfb1), + Ok(CipherType::Aes192Cfb1), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_192_CFB_8 => - Some(CipherType::Aes192Cfb8), + Ok(CipherType::Aes192Cfb8), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_192_CFB_128 => - Some(CipherType::Aes192Cfb128), + Ok(CipherType::Aes192Cfb128), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_256_CFB => - Some(CipherType::Aes256Cfb), + Ok(CipherType::Aes256Cfb), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_256_CFB_1 => - Some(CipherType::Aes256Cfb1), + Ok(CipherType::Aes256Cfb1), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_256_CFB_8 => - Some(CipherType::Aes256Cfb8), + Ok(CipherType::Aes256Cfb8), #[cfg(feature = "cipher-aes-cfb")] CIPHER_AES_256_CFB_128 => - Some(CipherType::Aes256Cfb128), + Ok(CipherType::Aes256Cfb128), #[cfg(feature = "cipher-aes-ofb")] CIPHER_AES_128_OFB => - Some(CipherType::Aes128Ofb), + Ok(CipherType::Aes128Ofb), #[cfg(feature = "cipher-aes-ofb")] CIPHER_AES_192_OFB => - Some(CipherType::Aes192Ofb), + Ok(CipherType::Aes192Ofb), #[cfg(feature = "cipher-aes-ofb")] CIPHER_AES_256_OFB => - Some(CipherType::Aes256Ofb), + Ok(CipherType::Aes256Ofb), #[cfg(feature = "cipher-aes-ctr")] CIPHER_AES_128_CTR => - Some(CipherType::Aes128Ctr), + Ok(CipherType::Aes128Ctr), #[cfg(feature = "cipher-aes-ctr")] CIPHER_AES_192_CTR => - Some(CipherType::Aes192Ctr), + Ok(CipherType::Aes192Ctr), #[cfg(feature = "cipher-aes-ctr")] CIPHER_AES_256_CTR => - Some(CipherType::Aes256Ctr), + Ok(CipherType::Aes256Ctr), #[cfg(feature = "cipher-bf-cfb")] CIPHER_BF_CFB => - Some(CipherType::BfCfb), + Ok(CipherType::BfCfb), #[cfg(feature = "cipher-camellia-cfb")] CIPHER_CAMELLIA_128_CFB => - Some(CipherType::Camellia128Cfb), + Ok(CipherType::Camellia128Cfb), #[cfg(feature = "cipher-camellia-cfb")] CIPHER_CAMELLIA_192_CFB => - Some(CipherType::Camellia192Cfb), + Ok(CipherType::Camellia192Cfb), #[cfg(feature = "cipher-camellia-cfb")] CIPHER_CAMELLIA_256_CFB => - Some(CipherType::Camellia256Cfb), + Ok(CipherType::Camellia256Cfb), #[cfg(feature = "cipher-cast5-cfb")] CIPHER_CAST5_CFB => - Some(CipherType::Cast5Cfb), + Ok(CipherType::Cast5Cfb), #[cfg(feature = "cipher-des-cfb")] CIPHER_DES_CFB => - Some(CipherType::DesCfb), + Ok(CipherType::DesCfb), #[cfg(feature = "cipher-idea-cfb")] CIPHER_IDEA_CFB => - Some(CipherType::IdeaCfb), + Ok(CipherType::IdeaCfb), #[cfg(feature = "cipher-rc2-cfb")] CIPHER_RC2_CFB => - Some(CipherType::Rc2Cfb), + Ok(CipherType::Rc2Cfb), #[cfg(feature = "cipher-rc4")] CIPHER_RC4 => - Some(CipherType::Rc4), + Ok(CipherType::Rc4), #[cfg(feature = "cipher-rc4")] CIPHER_RC4_MD5 => - Some(CipherType::Rc4Md5), + Ok(CipherType::Rc4Md5), #[cfg(feature = "cipher-seed-cfb")] CIPHER_SEED_CFB => - Some(CipherType::SeedCfb), + Ok(CipherType::SeedCfb), #[cfg(feature = "cipher-chacha20")] CIPHER_CHACHA20 => - Some(CipherType::ChaCha20), + Ok(CipherType::ChaCha20), #[cfg(feature = "cipher-salsa20")] CIPHER_SALSA20 => - Some(CipherType::Salsa20), + Ok(CipherType::Salsa20), - _ => None + _ => Err(Error::new(ErrorKind::UnknownCipherType, "Unknown cipher type", None)) } } } diff --git a/src/crypto/table.rs b/src/crypto/table.rs index cbb703b5..4459e0c3 100644 --- a/src/crypto/table.rs +++ b/src/crypto/table.rs @@ -29,7 +29,9 @@ use crypto::digest::Digest; use crypto::digest::DigestType; use crypto::CryptoMode; -const TABLE_SIZE: usize = 256us; +use byteorder::{ReadBytesExt, LittleEndian}; + +const TABLE_SIZE: usize = 256usize; #[derive(Clone)] pub struct TableCipher { @@ -43,7 +45,7 @@ impl TableCipher { let key_digest = md5_digest.digest(); let mut bufr = BufReader::new(key_digest.as_slice()); - let a = bufr.read_le_u64().unwrap(); + let a = bufr.read_u64::().unwrap(); let mut table = range(0, TABLE_SIZE).map(|idx| idx as u64).collect::>(); for i in range(1, 1024) { diff --git a/src/lib.rs b/src/lib.rs index 9fe999bc..0f8cebac 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -19,7 +19,7 @@ // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -#![experimental] +#![unstable(reason = "Waiting for Rust 1.0.0 final release")] #![crate_type = "lib"] #![crate_name = "shadowsocks"] @@ -27,6 +27,7 @@ #![feature(unsafe_destructor)] #![feature(box_syntax)] +#![feature(libc)] extern crate "rustc-serialize" as serialize; #[macro_use] @@ -35,6 +36,8 @@ extern crate collect; extern crate "libsodium-sys" as libsodium_ffi; +extern crate byteorder; + use std::fmt::{Debug, Formatter, self}; /// VersionCode(major, minor, patch) diff --git a/src/relay/loadbalancing/server/roundrobin.rs b/src/relay/loadbalancing/server/roundrobin.rs index 7f9f835d..209c03d9 100644 --- a/src/relay/loadbalancing/server/roundrobin.rs +++ b/src/relay/loadbalancing/server/roundrobin.rs @@ -32,7 +32,7 @@ impl RoundRobin { pub fn new(config: Vec) -> RoundRobin { RoundRobin { server: config, - index: 0us, + index: 0usize, } } } diff --git a/src/relay/local.rs b/src/relay/local.rs index 599a6366..c3e59440 100644 --- a/src/relay/local.rs +++ b/src/relay/local.rs @@ -96,7 +96,7 @@ impl Relay for RelayLocal { let tcp_thread = Thread::scoped(move || tcprelay.run()); info!("Enabled TCP relay"); - tcp_thread.join().ok().expect("A thread failed and exited"); + tcp_thread.join(); } #[cfg(feature = "enable-udp")] @@ -116,7 +116,7 @@ impl Relay for RelayLocal { } for fut in threads.into_iter() { - fut.join().ok().expect("A thread failed and exited"); + fut.join(); } } } diff --git a/src/relay/server.rs b/src/relay/server.rs index af91981a..12bd30b8 100644 --- a/src/relay/server.rs +++ b/src/relay/server.rs @@ -100,7 +100,7 @@ impl Relay for RelayServer { } for fut in threads.into_iter() { - fut.join().ok().expect("A relay thread failed and exited"); + fut.join(); } } @@ -114,6 +114,6 @@ impl Relay for RelayServer { let tcp_thread = Thread::scoped(move || tcprelay.run()); info!("Enabled TCP relay"); - tcp_thread.join().ok().expect("TCP relay thread failed and exited"); + tcp_thread.join(); } } diff --git a/src/relay/socks5.rs b/src/relay/socks5.rs index b3e8d9ea..dfe77ec6 100644 --- a/src/relay/socks5.rs +++ b/src/relay/socks5.rs @@ -22,9 +22,12 @@ #![allow(dead_code)] use std::fmt::{self, Debug, Formatter}; -use std::io::net::ip::{IpAddr, Port}; -use std::io::net::ip::{Ipv4Addr, Ipv6Addr}; -use std::io::{Reader, IoResult, IoError, OtherIoError}; +use std::net::{Ipv4Addr, Ipv6Addr, IpAddr, ToSocketAddrs, SocketAddr}; +use std::io::{self, Read, ReadExt, Write}; +use std::vec; +use std::error; + +use byteorder::{self, ReadBytesExt, WriteBytesExt, BigEndian, LittleEndian}; const SOCKS5_VERSION : u8 = 0x05; @@ -60,6 +63,7 @@ pub enum Command { } impl Command { + #[inline] fn code(&self) -> u8 { match *self { Command::TcpConnect => SOCKS5_CMD_TCP_CONNECT, @@ -68,6 +72,7 @@ impl Command { } } + #[inline] fn from_code(code: u8) -> Option { match code { SOCKS5_CMD_TCP_CONNECT => Some(Command::TcpConnect), @@ -94,6 +99,7 @@ pub enum Reply { } impl Reply { + #[inline] fn code(&self) -> u8 { match *self { Reply::Succeeded => SOCKS5_REPLY_SUCCEEDED, @@ -109,6 +115,7 @@ impl Reply { } } + #[inline] fn from_code(code: u8) -> Reply { match code { SOCKS5_REPLY_SUCCEEDED => Reply::Succeeded, @@ -141,74 +148,73 @@ impl Error { } impl Debug for Error { + #[inline] fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "{}", self.message) } } impl fmt::Display for Error { + #[inline] fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "{}", self.message) } } -macro_rules! try_io{ - ($do_io:expr, $errtype:expr, $message:expr) => ( { - let io_result = $do_io; - let errtype = $errtype; - let message = $message; - match io_result { - Ok(ret) => { ret }, - Err(err) => { - return Err(Error::new(errtype, message)); - } - } - }); - ($do_io:expr, $errtype:expr) => ( { - let io_result = $do_io; - let errtype = $errtype; - match io_result { - Ok(ret) => { ret }, - Err(err) => { - return Err(Error::new(errtype, err.desc)); - } - } - }); - ($do_io:expr) => ( { - let io_result = $do_io; - match io_result { - Ok(ret) => { ret }, - Err(err) => { - return Err(Error::new(Reply::GeneralFailure, err.desc)); - } - } - }); +impl error::Error for Error { + fn description(&self) -> &str { + self.message.as_slice() + } + + fn cause(&self) -> Option<&error::Error> { + None + } +} + +impl error::FromError for Error { + fn from_error(err: io::Error) -> Error { + Error::new(Reply::GeneralFailure, err.description()) + } +} + +impl error::FromError for Error { + fn from_error(err: byteorder::Error) -> Error { + let desc = { + use std::error::Error; + err.description() + }; + Error::new(Reply::GeneralFailure, desc) + } } #[derive(Clone, PartialEq, Eq, Hash)] pub enum Address { - SocketAddress(IpAddr, Port), - DomainNameAddress(String, Port), + SocketAddress(IpAddr, u16), + DomainNameAddress(String, u16), } impl Address { - pub fn read_from(reader: &mut Reader) -> Result { + #[inline] + pub fn read_from(reader: &mut R) -> Result { match parse_request_header(reader) { Ok((_, addr)) => Ok(addr), Err(err) => Err(err), } } - pub fn write_to(&self, writer: &mut Writer) -> IoResult<()> { + #[inline] + pub fn write_to(&self, writer: &mut Write) -> io::Result<()> { write_addr(self, writer) } + #[inline] pub fn len(&self) -> usize { get_addr_len(self) } } impl Debug for Address { + #[inline] fn fmt(&self, f: &mut Formatter) -> fmt::Result { match *self { Address::SocketAddress(ref ip, ref port) => write!(f, "{}:{}", ip, port), @@ -218,6 +224,7 @@ impl Debug for Address { } impl fmt::Display for Address { + #[inline] fn fmt(&self, f: &mut Formatter) -> fmt::Result { match *self { Address::SocketAddress(ref ip, ref port) => write!(f, "{}:{}", ip, port), @@ -226,6 +233,16 @@ impl fmt::Display for Address { } } +impl ToSocketAddrs for Address { + type Iter = vec::IntoIter; + fn to_socket_addrs(&self) -> io::Result> { + match *self { + Address::SocketAddress(ip, port) => Ok(vec![SocketAddr::new(ip, port)].into_iter()), + Address::DomainNameAddress(addr, port) => (addr.as_slice(), port).to_socket_addrs(), + } + } +} + #[derive(Clone, Debug)] pub struct TcpRequestHeader { pub command: Command, @@ -240,7 +257,8 @@ impl TcpRequestHeader { } } - pub fn read_from(stream: &mut Reader) -> Result { + #[inline] + pub fn read_from(stream: &mut R) -> Result { let mut buf = [0u8; 3]; match stream.read(&mut buf) { Ok(_) => (), @@ -261,13 +279,15 @@ impl TcpRequestHeader { }) } - pub fn write_to(&self, stream: &mut Writer) -> IoResult<()> { + #[inline] + pub fn write_to(&self, stream: &mut Write) -> io::Result<()> { try!(stream.write(&[SOCKS5_VERSION, self.command.code(), 0x00])); try!(self.address.write_to(stream)); Ok(()) } + #[inline] pub fn len(&self) -> usize { self.address.len() + 3 } @@ -287,7 +307,8 @@ impl TcpResponseHeader { } } - pub fn read_from(stream: &mut Reader) -> Result { + #[inline] + pub fn read_from(stream: &mut R) -> Result { let mut buf = [0u8; 3]; match stream.read(&mut buf) { Ok(_) => (), @@ -305,50 +326,54 @@ impl TcpResponseHeader { }) } - pub fn write_to(&self, stream: &mut Writer) -> IoResult<()> { + #[inline] + pub fn write_to(&self, stream: &mut Write) -> io::Result<()> { try!(stream.write(&[SOCKS5_VERSION, self.reply.code(), 0x00])); try!(self.address.write_to(stream)); Ok(()) } + #[inline] pub fn len(&self) -> usize { self.address.len() + 3 } } -fn parse_request_header(stream: &mut Reader) -> Result<(usize, Address), Error> { - let atyp = match stream.read_byte() { +#[inline] +fn parse_request_header(stream: &mut R) -> Result<(usize, Address), Error> { + let atyp = match stream.read_u8() { Ok(atyp) => atyp, Err(_) => return Err(Error::new(Reply::GeneralFailure, "Error while reading address type")) }; match atyp { SOCKS5_ADDR_TYPE_IPV4 => { - let v4addr = Ipv4Addr(try_io!(stream.read_byte(), Reply::GeneralFailure), - try_io!(stream.read_byte(), Reply::GeneralFailure), - try_io!(stream.read_byte(), Reply::GeneralFailure), - try_io!(stream.read_byte(), Reply::GeneralFailure)); - let port = try_io!(stream.read_be_u16(), Reply::GeneralFailure); - Ok((7us, Address::SocketAddress(v4addr, port))) + let v4addr = Ipv4Addr::new(try!(stream.read_u8()), + try!(stream.read_u8()), + try!(stream.read_u8()), + try!(stream.read_u8())); + let port = try!(stream.read_u16::()); + Ok((7usize, Address::SocketAddress(IpAddr::V4(v4addr), port))) }, SOCKS5_ADDR_TYPE_IPV6 => { - let v6addr = Ipv6Addr(try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16()), - try_io!(stream.read_be_u16())); - let port = try_io!(stream.read_be_u16()); + let v6addr = Ipv6Addr::new(try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::()), + try!(stream.read_u16::())); + let port = try!(stream.read_u16::()); - Ok((19us, Address::SocketAddress(v6addr, port))) + Ok((19usize, Address::SocketAddress(IpAddr::V6(v6addr), port))) }, SOCKS5_ADDR_TYPE_DOMAIN_NAME => { - let addr_len = try_io!(stream.read_byte()) as usize; - let raw_addr = try_io!(stream.read_exact(addr_len)); - let port = try_io!(stream.read_be_u16()); + let addr_len = try!(stream.read_u8()) as usize; + let mut raw_addr = Vec::with_capacity(addr_len); + try!(stream.take(addr_len as u64).read_to_end(&mut raw_addr)); + let port = try!(stream.read_u16::()); Ok((4 + addr_len, Address::DomainNameAddress(String::from_utf8(raw_addr).unwrap(), port, @@ -361,45 +386,84 @@ fn parse_request_header(stream: &mut Reader) -> Result<(usize, Address), Error> } } -fn write_addr(addr: &Address, buf: &mut Writer) -> IoResult<()> { +#[inline] +fn write_addr(addr: &Address, buf: &mut Write) -> io::Result<()> { match addr { &Address::SocketAddress(ip, port) => { match ip { - Ipv4Addr(v1, v2, v3, v4) => { - try!(buf.write(&[SOCKS5_ADDR_TYPE_IPV4, - v1, v2, v3, v4])); + IpAddr::V4(addr) => { + try!(buf.write_all(&[SOCKS5_ADDR_TYPE_IPV4])); + try!(buf.write_all(&addr.octets())); }, - Ipv6Addr(v1, v2, v3, v4, v5, v6, v7, v8) => { - try!(buf.write_u8(SOCKS5_ADDR_TYPE_IPV6)); - try!(buf.write_be_u16(v1)); - try!(buf.write_be_u16(v2)); - try!(buf.write_be_u16(v3)); - try!(buf.write_be_u16(v4)); - try!(buf.write_be_u16(v5)); - try!(buf.write_be_u16(v6)); - try!(buf.write_be_u16(v7)); - try!(buf.write_be_u16(v8)); + IpAddr::V6(addr) => { + try!(buf.write_u8(SOCKS5_ADDR_TYPE_IPV6).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); + for seg in addr.segments().iter() { + try!(buf.write_u16::(*seg).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); + } } } - try!(buf.write_be_u16(port)); + try!(buf.write_u16::(port).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); }, &Address::DomainNameAddress(ref dnaddr, port) => { - try!(buf.write_u8(SOCKS5_ADDR_TYPE_DOMAIN_NAME)); - try!(buf.write_u8(dnaddr.len() as u8)); - try!(buf.write_str(dnaddr.as_slice())); - try!(buf.write_be_u16(port)); + try!(buf.write_u8(SOCKS5_ADDR_TYPE_DOMAIN_NAME).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); + try!(buf.write_u8(dnaddr.len() as u8).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); + try!(buf.write_all(dnaddr.as_slice().as_bytes())); + try!(buf.write_u16::(port).map_err(|err| { + match err { + byteorder::Error::UnexpectedEOF => { + io::Error::new(io::ErrorKind::Other, "Unexpected EOF", None) + }, + byteorder::Error::Io(err) => err + } + })); } } Ok(()) } +#[inline] fn get_addr_len(atyp: &Address) -> usize { match atyp { &Address::SocketAddress(ip, _) => { match ip { - Ipv4Addr(_, _, _, _) => 1 + 4 + 2, - Ipv6Addr(_, _, _, _, _, _, _, _) => 1 + 8 * 2 + 2 + IpAddr::V4(..) => 1 + 4 + 2, + IpAddr::V6(..) => 1 + 8 * 2 + 2 } }, &Address::DomainNameAddress(ref dmname, _) => { @@ -425,25 +489,28 @@ impl HandshakeRequest { } } - pub fn read_from(stream: &mut Reader) -> IoResult { + pub fn read_from(stream: &mut R) -> io::Result { let mut buf = [0; 2]; try!(stream.read(&mut buf)); let [ver, nmet] = buf; if ver != SOCKS5_VERSION { - return Err(IoError { - kind: OtherIoError, - desc: "Invalid Socks5 version", - detail: None, - }); + return Err(io::Error::new( + io::ErrorKind::Other, + "Invalid Socks5 version", + None, + )); } + let mut methods = Vec::new(); + try!(stream.take(nmet as u64).read_to_end(&mut methods)); + Ok(HandshakeRequest { - methods: try!(stream.read_exact(nmet as usize)), + methods: methods, }) } - pub fn write_to(&self, stream: &mut Writer) -> IoResult<()> { + 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())); @@ -468,13 +535,13 @@ impl HandshakeResponse { } } - pub fn read_from(stream: &mut Reader) -> IoResult { + pub fn read_from(stream: &mut R) -> io::Result { let mut buf = [0; 2]; try!(stream.read(&mut buf)); let [ver, met] = buf; if ver != SOCKS5_VERSION { - return Err(IoError {kind: OtherIoError, desc: "Invalid Socks5 version", detail: None}); + return Err(io::Error::new(io::ErrorKind::Other, "Invalid Socks5 version", None)); } Ok(HandshakeResponse { @@ -482,7 +549,7 @@ impl HandshakeResponse { }) } - pub fn write_to(&self, stream: &mut Writer) -> IoResult<()> { + pub fn write_to(&self, stream: &mut Write) -> io::Result<()> { try!(stream.write(&[SOCKS5_VERSION, self.chosen_method])); Ok(()) @@ -503,12 +570,15 @@ impl UdpAssociateHeader { } } - pub fn read_from(reader: &mut Reader) -> Result { + pub fn read_from(reader: &mut R) -> Result { let mut buf = [0u8; 3]; - match reader.read(&mut buf) { - Ok(_) => (), - Err(err) => { - return Err(Error::new(Reply::GeneralFailure, err.to_string().as_slice())); + let mut read_size = 0; + while read_size < 3 { + 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())); + } } } @@ -517,8 +587,8 @@ impl UdpAssociateHeader { Ok(UdpAssociateHeader::new(frag, try!(Address::read_from(reader)))) } - pub fn write_to(&self, writer: &mut Writer) -> IoResult<()> { - try!(writer.write(&[0x00, 0x00, self.frag])); + pub fn write_to(&self, writer: &mut Write) -> io::Result<()> { + try!(writer.write_all(&[0x00, 0x00, self.frag])); try!(self.address.write_to(writer)); Ok(()) diff --git a/src/relay/tcprelay/cached_dns.rs b/src/relay/tcprelay/cached_dns.rs index fa2e7b6b..723a5622 100644 --- a/src/relay/tcprelay/cached_dns.rs +++ b/src/relay/tcprelay/cached_dns.rs @@ -21,15 +21,15 @@ use std::sync::{Arc, Mutex, TaskPool}; // use std::sync::atomic::{AtomicOption, SeqCst}; -use std::io::net::addrinfo::get_host_addresses; -use std::io::net::ip::IpAddr; +use std::net::lookup_host; +use std::net::IpAddr; use collect::LruCache; const TASK_POOL_SIZE: usize = 4; struct DnsLruCache { - cache: LruCache>, + cache: LruCache, totally_matched: usize, totally_missed: usize, } @@ -51,7 +51,7 @@ impl CachedDns { } } - pub fn resolve(&self, addr: &str) -> Option> { + pub fn resolve(&self, addr: &str) -> Option { let addr_string = addr.to_string(); { @@ -71,7 +71,7 @@ impl CachedDns { } } - let addrs = match get_host_addresses(addr) { + let addrs = match lookup_host(addr) { Ok(addrs) => addrs, Err(err) => { error!("Failed to resolve {}: {}", addr, err); @@ -80,12 +80,16 @@ impl CachedDns { }; let cloned_mutex = self.lru_cache.clone(); - let cloned_addr = addrs.clone(); + let addr = match addrs.next() { + Some(Ok(addr)) => addr.ip(), + _ => return None, + }; + let cloned_addr = addr.clone(); self.pool.execute(move || { let mut cache = cloned_mutex.lock().unwrap(); cache.cache.insert(addr_string, cloned_addr); }); - Some(addrs) + Some(addr) } } diff --git a/src/relay/tcprelay/local.rs b/src/relay/tcprelay/local.rs index 88665682..628ae0d1 100644 --- a/src/relay/tcprelay/local.rs +++ b/src/relay/tcprelay/local.rs @@ -21,21 +21,10 @@ //! TcpRelay server that running on local environment -use std::io::{Listener, TcpListener, Acceptor, TcpStream}; -use std::io::{ - IoResult, - IoError, - EndOfFile, - ConnectionFailed, - ConnectionRefused, - ConnectionReset, - ConnectionAborted, - BrokenPipe, - OtherIoError, -}; -use std::io::net::ip::{SocketAddr, IpAddr}; -use std::io::net::addrinfo::get_host_addresses; -use std::io::{self, BufferedStream}; +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::collections::BTreeMap; @@ -55,50 +44,6 @@ pub struct TcpRelayLocal { config: Config, } -#[inline] -fn make_io_error(desc: &'static str, detail: Option) -> IoError { - IoError { - kind: OtherIoError, - desc: desc, - detail: detail, - } -} - -macro_rules! try_result{ - ($res:expr) => ({ - let res = $res; - match res { - Ok(r) => { r }, - Err(err) => { - error!("{}", err); - return; - } - } - }); - ($res:expr, prefix: $prefix:expr) => ({ - let res = $res; - let prefix = $prefix; - match res { - Ok(r) => { r }, - Err(err) => { - error!("{} {}", prefix, err); - return; - } - } - }); - ($res:expr, message: $message:expr) => ({ - let res = $res; - let message = $message; - match res { - Ok(r) => { r }, - Err(..) => { - error!("{}", message); - return; - } - } - }); -} - impl TcpRelayLocal { pub fn new(c: Config) -> TcpRelayLocal { if c.server.is_empty() || c.local.is_none() { @@ -110,7 +55,7 @@ impl TcpRelayLocal { } } - fn do_handshake(stream: &mut TcpStream) -> IoResult<()> { + fn do_handshake(stream: &mut TcpStream) -> io::Result<()> { // Read the handshake header let req = try!(socks5::HandshakeRequest::read_from(stream)); @@ -118,7 +63,9 @@ impl TcpRelayLocal { let resp = socks5::HandshakeResponse::new(socks5::SOCKS5_AUTH_METHOD_NOT_ACCEPTABLE); try!(resp.write_to(stream)); warn!("Currently shadowsocks-rust does not support authentication"); - return Err(make_io_error("Currently shadowsocks-rust does not support authentication", None)); + return Err(io::Error::new(io::ErrorKind::Other, + "Currently shadowsocks-rust does not support authentication", + None)); } // Reply to client @@ -127,11 +74,11 @@ impl TcpRelayLocal { Ok(()) } - fn handle_udp_associate_local(stream: &mut TcpStream, _: &socks5::Address) -> IoResult<()> { - let sockname = try!(stream.socket_name()); + fn handle_udp_associate_local(stream: &mut TcpStream, _: &socks5::Address) -> io::Result<()> { + let sockname = try!(stream.socket_addr()); let reply = socks5::TcpResponseHeader::new(socks5::Reply::Succeeded, - socks5::Address::SocketAddress(sockname.ip, sockname.port)); + socks5::Address::SocketAddress(sockname.ip(), sockname.port())); try!(reply.write_to(stream)); // TODO: record this client's information for udprelay local server to validate @@ -145,15 +92,17 @@ impl TcpRelayLocal { password: Vec, encrypt_method: CipherType, enable_udp: bool) { - try_result!(TcpRelayLocal::do_handshake(&mut stream), prefix: "Error occurs while doing handshake:"); + TcpRelayLocal::do_handshake(&mut stream) + .unwrap_or_else(|err| panic!("Error occurs while doing handshake: {:?}", err)); - let sockname = try_result!(stream.socket_name(), prefix: "Failed to get socket name:"); + let sockname = stream.socket_addr() + .unwrap_or_else(|err| panic!("Failed to get socket name: {:?}", err)); let header = match socks5::TcpRequestHeader::read_from(&mut stream) { Ok(h) => { h }, Err(err) => { socks5::TcpResponseHeader::new(err.reply, - socks5::Address::SocketAddress(sockname.ip, sockname.port)); + socks5::Address::SocketAddress(sockname.ip(), sockname.port())); error!("Failed to read request header: {}", err); return; } @@ -165,10 +114,13 @@ impl TcpRelayLocal { socks5::Command::TcpConnect => { info!("CONNECT {}", addr); - let mut remote_stream = match TcpStream::connect((server_addr.ip, server_addr.port)) { + let mut remote_stream = match TcpStream::connect(&server_addr) { Err(err) => { - match err.kind { - ConnectionAborted | ConnectionReset | ConnectionRefused | ConnectionFailed => { + match err.kind() { + ErrorKind::ConnectionAborted + | ErrorKind::ConnectionReset + | ErrorKind::ConnectionRefused + | ErrorKind::ConnectionAborted => { socks5::TcpResponseHeader::new(socks5::Reply::HostUnreachable, addr.clone()) .write_to(&mut stream).unwrap(); }, @@ -183,86 +135,90 @@ impl TcpRelayLocal { Ok(s) => { s }, }; - let mut buffered_local_stream = BufferedStream::new(stream.clone()); + let mut buffered_local_stream = BufStream::new(stream.try_clone().unwrap()); let iv = encrypt_method.gen_init_vec(); let encryptor = cipher::with_type(encrypt_method, password.as_slice(), iv.as_slice(), CryptoMode::Encrypt); - try_result!(remote_stream.write(iv.as_slice())); - let mut encrypt_stream = EncryptedWriter::new(remote_stream.clone(), encryptor); + remote_stream.write_all(iv.as_slice()).unwrap(); + let mut encrypt_stream = EncryptedWriter::new(remote_stream.try_clone().unwrap(), encryptor); { - try_result!(socks5::TcpResponseHeader::new( - socks5::Reply::Succeeded, - socks5::Address::SocketAddress(sockname.ip, sockname.port)) - .write_to(&mut buffered_local_stream), - prefix: "Error occurs while writing header to local stream:"); - try_result!(buffered_local_stream.flush()); - try_result!(addr.write_to(&mut encrypt_stream)); + socks5::TcpResponseHeader::new(socks5::Reply::Succeeded, + socks5::Address::SocketAddress(sockname.ip(), sockname.port())) + .write_to(&mut buffered_local_stream) + .unwrap_or_else(|err| + panic!("Error occurs while writing header to local stream: {:?}", err)); + // buffered_local_stream.flush().unwrap(); + addr.write_to(&mut encrypt_stream).unwrap(); } let addr_cloned = addr.clone(); - let mut remote_stream_cloned = remote_stream.clone(); - let mut local_stream_cloned = stream.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) { Ok(..) => {}, Err(err) => { - match err.kind { - EndOfFile | BrokenPipe => { + match err.kind() { + ErrorKind::BrokenPipe => { debug!("{} relay from local to remote stream: {}", addr_cloned, err) }, _ => { error!("{} relay from local to remote stream: {}", addr_cloned, err) } } - remote_stream_cloned.close_write().or(Ok(())).unwrap(); - local_stream_cloned.close_read().or(Ok(())).unwrap(); + remote_stream_cloned.shutdown(Shutdown::Write).or(Ok(())).unwrap(); + local_stream_cloned.shutdown(Shutdown::Read).or(Ok(())).unwrap(); } } }); - let remote_iv = try_result!(remote_stream.read_exact(encrypt_method.block_size())); + let remote_iv = { + let mut iv = Vec::new(); + remote_stream.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(), CryptoMode::Decrypt); - let mut decrypt_stream = DecryptedReader::new(remote_stream.clone(), decryptor); + let mut decrypt_stream = DecryptedReader::new(remote_stream.try_clone().unwrap(), decryptor); match io::util::copy(&mut decrypt_stream, &mut stream) { Err(err) => { - match err.kind { - EndOfFile | BrokenPipe => { + match err.kind() { + ErrorKind::BrokenPipe => { debug!("{} relay from local to remote stream: {}", addr, err) }, _ => { error!("{} relay from local to remote stream: {}", addr, err) } } - remote_stream.close_write().or(Ok(())).unwrap(); - stream.close_read().or(Ok(())).unwrap(); + remote_stream.shutdown(Shutdown::Write).or(Ok(())).unwrap(); + stream.shutdown(Shutdown::Read).or(Ok(())).unwrap(); }, Ok(..) => {}, } }, socks5::Command::TcpBind => { warn!("BIND is not supported"); - try_result!(socks5::TcpResponseHeader::new(socks5::Reply::CommandNotSupported, addr) - .write_to(&mut stream), - prefix: "Failed to write BIND response:"); + socks5::TcpResponseHeader::new(socks5::Reply::CommandNotSupported, addr) + .write_to(&mut stream) + .unwrap_or_else(|err| panic!("Failed to write BIND response: {:?}", err)); }, socks5::Command::UdpAssociate => { - let sockname = stream.peer_name().unwrap(); + let sockname = stream.peer_addr().unwrap(); info!("{} requests for UDP ASSOCIATE", sockname); if cfg!(feature = "enable-udp") && enable_udp { - try_result!(TcpRelayLocal::handle_udp_associate_local(&mut stream, &addr), - prefix: "Failed to write UDP ASSOCIATE response:"); + TcpRelayLocal::handle_udp_associate_local(&mut stream, &addr) + .unwrap_or_else(|err| panic!("Failed to write UDP ASSOCIATE response: {:?}", err)); } else { warn!("UDP ASSOCIATE is disabled"); - try_result!(socks5::TcpResponseHeader::new(socks5::Reply::CommandNotSupported, addr) - .write_to(&mut stream), - prefix: "Failed to write UDP ASSOCIATE response:"); + socks5::TcpResponseHeader::new(socks5::Reply::CommandNotSupported, addr) + .write_to(&mut stream) + .unwrap_or_else(|err| panic!("Failed to write UDP ASSOCIATE response: {:?}", err)); } } } @@ -275,8 +231,7 @@ impl Relay for TcpRelayLocal { let local_conf = self.config.local.expect("need local configuration"); - let mut acceptor = match TcpListener::bind( - format!("{}:{}", local_conf.ip, local_conf.port).as_slice()).listen() { + let mut acceptor = match TcpListener::bind(&local_conf) { Ok(acpt) => acpt, Err(e) => { panic!("Error occurs while listening local address: {}", e.to_string()); @@ -285,27 +240,31 @@ impl Relay for TcpRelayLocal { info!("Shadowsocks listening on {}", local_conf); - let mut cached_proxy: BTreeMap> = BTreeMap::new(); + let mut cached_proxy: BTreeMap = BTreeMap::new(); for s in acceptor.incoming() { let mut stream = s.unwrap(); - stream.set_timeout(self.config.timeout); + stream.set_keepalive(self.config.timeout); let mut succeed = false; for _ in range(0, server_load_balancer.total()) { let ref server_cfg = server_load_balancer.pick_server(); - let addrs = { + let addr = { match cached_proxy.get(server_cfg.addr.as_slice()).map(|x| x.clone()) { Some(addr) => addr, None => { - match get_host_addresses(server_cfg.addr.as_slice()) { - Ok(addr) => { - if addr.is_empty() { - error!("cannot resolve proxy server `{}`", server_cfg.addr); - continue; + match lookup_host(server_cfg.addr.as_slice()) { + Ok(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()); + addr.unwrap().ip() + } } - cached_proxy.insert(server_cfg.addr.clone(), addr.clone()); - addr }, Err(err) => { error!("cannot resolve proxy server `{}`: {}", server_cfg.addr, err); @@ -316,10 +275,7 @@ impl Relay for TcpRelayLocal { } }; - let server_addr = SocketAddr { - ip: addrs.first().unwrap().clone(), - port: server_cfg.port, - }; + let server_addr = SocketAddr::new(addr.clone(), server_cfg.port); debug!("Using proxy `{}:{}` (`{}`)", server_cfg.addr, server_cfg.port, server_addr); let encrypt_method = server_cfg.method.clone(); let pwd = encrypt_method.bytes_to_key(server_cfg.password.as_bytes()); diff --git a/src/relay/tcprelay/server.rs b/src/relay/tcprelay/server.rs index 7a589d6a..84ae9882 100644 --- a/src/relay/tcprelay/server.rs +++ b/src/relay/tcprelay/server.rs @@ -22,10 +22,9 @@ //! TcpRelay server that running on the server side use std::sync::Arc; -use std::io::{Listener, TcpListener, Acceptor, TcpStream}; -use std::io::{EndOfFile, BrokenPipe}; -use std::io::net::ip::SocketAddr; -use std::io::{BufferedStream, self}; +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; @@ -37,41 +36,6 @@ use relay::tcprelay::stream::{DecryptedReader, EncryptedWriter}; use crypto::cipher; use crypto::CryptoMode; -macro_rules! try_result{ - ($res:expr) => ({ - let res = $res; - match res { - Ok(r) => { r }, - Err(err) => { - error!("{}", err); - return; - } - } - }); - ($res:expr, prefix: $prefix:expr) => ({ - let res = $res; - let prefix = $prefix; - match res { - Ok(r) => { r }, - Err(err) => { - error!("{} {}", prefix, err); - return; - } - } - }); - ($res:expr, message: $message:expr) => ({ - let res = $res; - let message = $message; - match res { - Ok(r) => { r }, - Err(..) => { - error!("{}", message); - return; - } - } - }); -} - #[derive(Clone)] pub struct TcpRelayServer { config: Config, @@ -88,8 +52,8 @@ impl TcpRelayServer { } fn accept_loop(s: ServerConfig) { - let mut acceptor = try_result!(TcpListener::bind((s.addr.as_slice(), s.port)).listen(), - prefix: "Failed to bind: "); + let mut acceptor = TcpListener::bind(&(s.addr.as_slice(), s.port)) + .unwrap_or_else(|err| panic!("Failed to bind: {:?}", err)); info!("Shadowsocks listening on {}", s.addr); @@ -100,82 +64,52 @@ impl TcpRelayServer { let method = s.method; for s in acceptor.incoming() { let mut stream = s.unwrap(); - stream.set_timeout(timeout); + stream.set_keepalive(timeout); let pwd = pwd.clone(); let encrypt_method = method; let dnscache = dnscache_arc.clone(); Thread::spawn(move || { - let remote_iv = try_result!(stream.read_exact(encrypt_method.block_size())); + let remote_iv = { + let mut iv = Vec::new(); + stream.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(), CryptoMode::Decrypt); - let buffered_client_stream = BufferedStream::new(stream.clone()); + let buffered_client_stream = BufStream::new(stream.try_clone().unwrap()); let mut decrypt_stream = DecryptedReader::new(buffered_client_stream, decryptor); - let addr = try_result!(socks5::Address::read_from(&mut decrypt_stream), - prefix: "Error occurs while parsing request header, maybe wrong crypto method or password: " - ); + let addr = socks5::Address::read_from(&mut decrypt_stream).unwrap_or_else(|err| { + panic!("Error occurs while parsing request header, maybe wrong crypto method or password: {:?}", + err); + }); info!("Connecting to {}", addr); - let remote_stream = match addr { - Address::SocketAddress(ip, port) => { - try_result!(TcpStream::connect_timeout(SocketAddr {ip: ip, port: port}, Duration::seconds(30)), - prefix: format!("Unable to connect {}:", addr) - ) - }, - Address::DomainNameAddress(ref name, ref port) => { - let ipaddrs = { - // Cannot fail inside, which will cause other tasks fail, too. - match dnscache.resolve(name.as_slice()) { - Some(v) => { v }, - None => { - error!("Unable to resolve {}:{}", name, port); - return; - } - } - }; + let remote_stream = TcpStream::connect(&addr).unwrap_or_else(|err| { + panic!("Unable to connect {:?}: {:?}", addr, err); + }); - let connector = |&:| { - for ipaddr in ipaddrs.iter() { - let result = TcpStream::connect_timeout(SocketAddr { - ip: *ipaddr, - port: *port - }, - Duration::seconds(30)); - match result { - Err(err) => debug!("{} trying {}: {}", addr, ipaddr, err), - Ok(host) => { - debug!("{} trying {}: succeed", addr, ipaddr); - return host; - } - } - } - panic!("Unable to connect {}", addr); - }; - connector() - } - }; - - let mut remote_stream_cloned = remote_stream.clone(); + let mut remote_stream_cloned = remote_stream.try_clone().unwrap(); let addr_cloned = addr.clone(); Thread::spawn(move || { - match io::util::copy(&mut decrypt_stream, &mut remote_stream_cloned) { + match io::copy(&mut decrypt_stream, &mut remote_stream_cloned) { Ok(..) => {}, Err(err) => { - match err.kind { - EndOfFile | BrokenPipe => { + match err.kind() { + ErrorKind::BrokenPipe => { debug!("{} relay from local to remote stream: {}", addr_cloned, err) }, _ => { error!("{} relay from local to remote stream: {}", addr_cloned, err) } } - remote_stream_cloned.close_write().or(Ok(())).unwrap(); - decrypt_stream.get_mut().get_mut().close_read().or(Ok(())).unwrap(); + remote_stream_cloned.shutdown(Shutdown::Write).or(Ok(())).unwrap(); + decrypt_stream.get_mut().get_mut().shutdown(Shutdown::Write).or(Ok(())).unwrap(); } } }); @@ -185,22 +119,22 @@ impl TcpRelayServer { pwd.as_slice(), iv.as_slice(), CryptoMode::Encrypt); - try_result!(stream.write(iv.as_slice())); - let mut buffered_remote_stream = BufferedStream::new(remote_stream.clone()); - let mut encrypt_stream = EncryptedWriter::new(stream.clone(), encryptor); + stream.write_all(iv.as_slice()).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) { Ok(..) => {}, Err(err) => { - match err.kind { - EndOfFile | BrokenPipe => { + match err.kind() { + ErrorKind::BrokenPipe => { debug!("{} relay from remote to local stream: {}", addr, err) }, _ => { error!("{} relay from remote to local stream: {}", addr, err) } } - encrypt_stream.get_mut().close_write().or(Ok(())).unwrap(); - buffered_remote_stream.get_mut().close_read().or(Ok(())).unwrap(); + encrypt_stream.get_mut().shutdown(Shutdown::Write).or(Ok(())).unwrap(); + buffered_remote_stream.get_mut().shutdown(Shutdown::Write).or(Ok(())).unwrap(); } } }); @@ -220,7 +154,7 @@ impl Relay for TcpRelayServer { } for fut in threads.into_iter() { - fut.join().ok().expect("A thread failed and exited"); + fut.join(); } } } diff --git a/src/relay/tcprelay/stream.rs b/src/relay/tcprelay/stream.rs index c8d8bfe0..0a436e9b 100644 --- a/src/relay/tcprelay/stream.rs +++ b/src/relay/tcprelay/stream.rs @@ -21,13 +21,13 @@ #![allow(dead_code)] -use std::io::{IoResult, IoError, IoErrorKind}; +use std::io::{self, ErrorKind, Read, BufRead, Write}; use std::cmp; use std::slice; use crypto::cipher::Cipher; -pub struct DecryptedReader { +pub struct DecryptedReader { reader: R, buffer: Vec, cipher: Box, @@ -37,7 +37,7 @@ pub struct DecryptedReader { const BUFFER_SIZE: usize = 2048; -impl DecryptedReader { +impl DecryptedReader { pub fn new(r: R, cipher: Box) -> DecryptedReader { DecryptedReader { reader: r, @@ -71,44 +71,28 @@ impl DecryptedReader { } } -impl Buffer for DecryptedReader { - fn fill_buf<'b>(&'b mut self) -> IoResult<&'b [u8]> { +impl BufRead for DecryptedReader { + fn fill_buf<'b>(&'b mut self) -> io::Result<&'b [u8]> { if self.pos == self.buffer.len() { let mut incoming = [0u8; BUFFER_SIZE]; match self.reader.read(&mut incoming) { + Ok(0) => { + // EOF + self.buffer = try!(self.cipher + .finalize() + .map_err(|err| io::Error::new(io::ErrorKind::Other, + err.desc, + err.detail))); + } Ok(l) => { - self.buffer = match self.cipher.update(&incoming[0..l]) { - Ok(ret) => ret, - Err(err) => return Err(IoError { - kind: IoErrorKind::OtherIoError, - desc: err.desc, - detail: err.detail, - }), - } + self.buffer = try!(self.cipher + .update(&incoming[0..l]) + .map_err(|err| io::Error::new(io::ErrorKind::Other, + err.desc, + err.detail))); }, Err(err) => { - match err.kind { - IoErrorKind::EndOfFile => { - if self.sent_final { - return Err(err); - } - - self.sent_final = true; - self.buffer = match self.cipher.finalize() { - Ok(ret) => ret, - Err(err) => return Err(IoError { - kind: IoErrorKind::OtherIoError, - desc: err.desc, - detail: err.detail, - }), - }; - - if self.buffer.len() == 0 { - return Err(err); - } - }, - _ => return Err(err), - } + return Err(err); } }; @@ -124,8 +108,8 @@ impl Buffer for DecryptedReader { } } -impl Reader for DecryptedReader { - fn read(&mut self, buf: &mut [u8]) -> IoResult { +impl Read for DecryptedReader { + fn read(&mut self, buf: &mut [u8]) -> io::Result { let nread = { let available = try!(self.fill_buf()); let nread = cmp::min(available.len(), buf.len()); @@ -137,12 +121,12 @@ impl Reader for DecryptedReader { } } -pub struct EncryptedWriter { +pub struct EncryptedWriter { writer: W, cipher: Box, } -impl EncryptedWriter { +impl EncryptedWriter { pub fn new(w: W, cipher: Box) -> EncryptedWriter { EncryptedWriter { writer: w, @@ -150,17 +134,17 @@ impl EncryptedWriter { } } - pub fn finalize(&mut self) -> IoResult<()> { + pub fn finalize(&mut self) -> io::Result<()> { match self.cipher.finalize() { Ok(fin) => { - self.writer.write(fin.as_slice()) + self.writer.write_all(fin.as_slice()) }, Err(err) => { - Err(IoError { - kind: IoErrorKind::OtherIoError, - desc: err.desc, - detail: err.detail, - }) + Err(io::Error::new( + io::ErrorKind::Other, + err.desc, + err.detail, + )) } } } @@ -180,29 +164,33 @@ impl EncryptedWriter { } } -impl Writer for EncryptedWriter { - fn write(&mut self, buf: &[u8]) -> IoResult<()> { +impl Write for EncryptedWriter { + fn write(&mut self, buf: &[u8]) -> io::Result { match self.cipher.update(buf) { Ok(ret) => { - self.writer.write(ret.as_slice()) + match self.writer.write_all(ret.as_slice()) { + Ok(..) => Ok(buf.len()), + Err(err) => return Err(err), + } }, Err(err) => { - Err(IoError { - kind: IoErrorKind::OtherIoError, - desc: err.desc, - detail: err.detail, - }) + Err(io::Error::new( + io::ErrorKind::Other, + err.desc, + err.detail, + )) } } } - // fn flush(&mut self) -> IoResult<()> { - // self.finalize() - // } + fn flush(&mut self) -> io::Result<()> { + // self.finalize() + Ok(()) + } } #[unsafe_destructor] -impl Drop for EncryptedWriter { +impl Drop for EncryptedWriter { fn drop(&mut self) { self.finalize().unwrap() } diff --git a/src/relay/udprelay/local.rs b/src/relay/udprelay/local.rs index 5f6d20ce..d6fc5f2b 100644 --- a/src/relay/udprelay/local.rs +++ b/src/relay/udprelay/local.rs @@ -55,11 +55,9 @@ // +-------+--------------+ use std::sync::{Arc, Mutex}; -use std::io::net::udp::UdpSocket; -use std::io::net::ip::SocketAddr; -use std::io::net::addrinfo::get_host_addresses; +use std::net::{UdpSocket, SocketAddr, lookup_host}; use std::collections::HashMap; -use std::io::{BufReader, MemWriter, self}; +use std::io::{BufReader, self}; use std::thread::Thread; use collect::LruCache; @@ -95,19 +93,17 @@ 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 get_host_addresses(s.addr.as_slice()) { + let addrs = match lookup_host(s.addr.as_slice()) { Ok(addr) => addr, Err(..) => continue, }; - if !addrs.is_empty() { - let addr = SocketAddr { - ip: addrs.first().unwrap().clone(), - port: s.port, - }; - - server_set.insert(addr, s.clone()); - server_addr.insert(s.addr.clone(), addr); + match addrs.next() { + Some(Ok(addr)) => { + server_set.insert(addr, s.clone()); + server_addr.insert(s.addr.clone(), addr); + }, + _ => {} } } (server_set, server_addr) @@ -116,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 mut socket = UdpSocket::bind(&addr).ok().expect("Failed to bind udp socket"); let mut buf = [0u8; 0xffff]; loop { @@ -128,7 +124,7 @@ impl Relay for UdpRelayLocal { } let request_message = buf[..len].to_vec(); - let move_socket = socket.clone(); + let move_socket = socket.try_clone().unwrap(); let client_map = client_map_arc.clone(); match server_set.get(&source_addr) { @@ -211,7 +207,7 @@ fn handle_request(mut socket: UdpSocket, iv.push_all(encryptor.update(wbuf.as_slice()).unwrap().as_slice()); iv.push_all(encryptor.finalize().unwrap().as_slice()); - socket.send_to(iv.as_slice(), server_addr) + socket.send_to(iv.as_slice(), &server_addr) .ok().expect("Error occurs while sending to remote"); } @@ -243,11 +239,11 @@ fn handle_response(mut socket: UdpSocket, debug!("UDP response {} -> {}", from_addr, client_addr); - let mut bufw = MemWriter::new(); + let mut bufw = Vec::new(); socks5::UdpAssociateHeader::new(0, addr) .write_to(&mut bufw).unwrap(); io::util::copy(&mut bufr, &mut bufw).unwrap(); - socket.send_to(bufw.into_inner().as_slice(), client_addr) + socket.send_to(bufw.as_slice(), &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 17788e4e..6a8be37c 100644 --- a/src/relay/udprelay/server.rs +++ b/src/relay/udprelay/server.rs @@ -20,10 +20,8 @@ // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. use std::sync::{Arc, Mutex}; -use std::io::net::udp::UdpSocket; -use std::io::net::ip::SocketAddr; -use std::io::net::addrinfo::get_host_addresses; -use std::io::BufReader; +use std::net::{UdpSocket, SocketAddr, lookup_host, ToSocketAddrs}; +use std::io::{BufReader, ReadExt, Read, Write}; use std::thread::Thread; use collect::LruCache; @@ -48,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 mut socket = UdpSocket::bind(&(svr_config.addr.as_slice(), svr_config.port)) .ok().expect("Unable to bind UDP socket"); debug!("UDP server is binding {}", svr_config.addr); @@ -64,7 +62,7 @@ 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.clone(); + let mut captured_socket = socket.try_clone().unwrap(); let method = svr_config.method; let password = svr_config.password.clone(); @@ -79,7 +77,7 @@ impl UdpRelayServer { // Make a header let mut response_buf = Vec::new(); remote_addr.write_to(&mut response_buf).unwrap(); - response_buf.write(data.as_slice()).unwrap(); + response_buf.push_all(data.as_slice()); let key = method.bytes_to_key(password.as_bytes()); let mut iv = method.gen_init_vec(); @@ -92,7 +90,7 @@ impl UdpRelayServer { iv.push_all(encryptor.finalize().unwrap().as_slice()); captured_socket - .send_to(iv.as_slice(), client_addr.clone()) + .send_to(iv.as_slice(), &client_addr) .unwrap(); }, None => { @@ -117,7 +115,7 @@ impl UdpRelayServer { decrypted_data.push_all(decryptor.finalize().unwrap().as_slice()); let mut bufr = BufReader::new(decrypted_data.as_slice()); - let header = socks5::UdpAssociateHeader::read_from(&mut bufr).unwrap(); + let header = socks5::UdpAssociateHeader::read_from(bufr.by_ref()).unwrap(); if header.frag != 0 { // Drop it @@ -134,19 +132,18 @@ impl UdpRelayServer { .insert(header.address.clone(), src); remote_map.lock() .unwrap() - .insert(SocketAddr {ip: ip, port: port}, header.address.clone()); - SocketAddr {ip: ip, port: port} + .insert(SocketAddr::new(ip, port), header.address.clone()); + SocketAddr::new(ip, port) }, &Address::DomainNameAddress(ref dnaddr, port) => { - let ref ipaddrs = get_host_addresses(dnaddr.as_slice()) - .unwrap_or_else(|err| { - panic!("Unable to resolve {}: {}", dnaddr, err); - }); + let ipaddrs = lookup_host(dnaddr.as_slice()) + .unwrap_or_else(|err| { + panic!("Unable to resolve {}: {}", dnaddr, err); + }); + + let remote_addr = + SocketAddr::new(ipaddrs.next().unwrap().unwrap().ip().clone(), port); - let remote_addr = SocketAddr { - ip: ipaddrs.first().unwrap().clone(), - port: port, - }; client_map.lock() .unwrap() .insert(header.address.clone(), src); @@ -156,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.as_slice()[header.len()..], &sockaddr).unwrap(); }); }, Err(err) => { @@ -178,7 +175,7 @@ impl Relay for UdpRelayServer { } for fut in threads.into_iter() { - fut.join().ok().expect("A thread failed and exited"); + fut.join(); } } }