tried to migrate to new standard library, still lots of work to do

This commit is contained in:
Y. T. Chung
2015-02-23 18:13:05 +08:00
parent 31607000e0
commit 7943d85177
15 changed files with 538 additions and 564 deletions
+1
View File
@@ -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"
+111 -100
View File
@@ -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<u64>,
pub timeout: Option<u32>,
pub dns_cache_capacity: usize,
}
@@ -105,7 +105,7 @@ pub struct Config {
pub server: Vec<ServerConfig>,
pub local: Option<ClientConfig>,
pub enable_udp: bool,
pub timeout: Option<u64>,
pub timeout: Option<u32>,
}
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::<CipherType>(),
"`method` should be a string",
None)));
let method = try!(method_str.parse::<CipherType>().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::<CipherType>(),
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::<CipherType>()
.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<Config, Error> {
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,
+46 -34
View File
@@ -47,6 +47,7 @@ pub type CipherResult<T> = Result<T, Error>;
#[derive(Copy)]
pub enum ErrorKind {
UnknownCipherType,
OpenSSLError,
}
@@ -56,6 +57,16 @@ pub struct Error {
pub detail: Option<String>,
}
impl Error {
pub fn new(kind: ErrorKind, desc: &'static str, detail: Option<String>) -> 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<CipherType> {
type Err = Error;
fn from_str(s: &str) -> Result<CipherType, Error> {
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))
}
}
}
+4 -2
View File
@@ -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::<LittleEndian>().unwrap();
let mut table = range(0, TABLE_SIZE).map(|idx| idx as u64).collect::<Vec<u64>>();
for i in range(1, 1024) {
+4 -1
View File
@@ -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)
+1 -1
View File
@@ -32,7 +32,7 @@ impl RoundRobin {
pub fn new(config: Vec<ServerConfig>) -> RoundRobin {
RoundRobin {
server: config,
index: 0us,
index: 0usize,
}
}
}
+2 -2
View File
@@ -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();
}
}
}
+2 -2
View File
@@ -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();
}
}
+172 -102
View File
@@ -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<Command> {
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<io::Error> for Error {
fn from_error(err: io::Error) -> Error {
Error::new(Reply::GeneralFailure, err.description())
}
}
impl error::FromError<byteorder::Error> 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<Address, Error> {
#[inline]
pub fn read_from<R: ReadExt>(reader: &mut R) -> Result<Address, Error> {
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<SocketAddr>;
fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
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<TcpRequestHeader, Error> {
#[inline]
pub fn read_from<R: ReadExt>(stream: &mut R) -> Result<TcpRequestHeader, Error> {
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<TcpResponseHeader, Error> {
#[inline]
pub fn read_from<R: ReadExt>(stream: &mut R) -> Result<TcpResponseHeader, Error> {
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<R: ReadExt>(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::<BigEndian>());
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::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()));
let port = try!(stream.read_u16::<BigEndian>());
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::<BigEndian>());
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::<BigEndian>(*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::<BigEndian>(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::<BigEndian>(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<HandshakeRequest> {
pub fn read_from<R: ReadExt>(stream: &mut R) -> io::Result<HandshakeRequest> {
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<HandshakeResponse> {
pub fn read_from<R: ReadExt>(stream: &mut R) -> io::Result<HandshakeResponse> {
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<UdpAssociateHeader, Error> {
pub fn read_from<R: ReadExt>(reader: &mut R) -> Result<UdpAssociateHeader, Error> {
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(())
+11 -7
View File
@@ -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<String, Vec<IpAddr>>,
cache: LruCache<String, IpAddr>,
totally_matched: usize,
totally_missed: usize,
}
@@ -51,7 +51,7 @@ impl CachedDns {
}
}
pub fn resolve(&self, addr: &str) -> Option<Vec<IpAddr>> {
pub fn resolve(&self, addr: &str) -> Option<IpAddr> {
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)
}
}
+73 -117
View File
@@ -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<String>) -> 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<u8>,
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<String, Vec<IpAddr>> = BTreeMap::new();
let mut cached_proxy: BTreeMap<String, IpAddr> = 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());
+33 -99
View File
@@ -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();
}
}
}
+46 -58
View File
@@ -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<R: Reader> {
pub struct DecryptedReader<R: Read> {
reader: R,
buffer: Vec<u8>,
cipher: Box<Cipher + Send>,
@@ -37,7 +37,7 @@ pub struct DecryptedReader<R: Reader> {
const BUFFER_SIZE: usize = 2048;
impl<R: Reader> DecryptedReader<R> {
impl<R: Read> DecryptedReader<R> {
pub fn new(r: R, cipher: Box<Cipher + Send>) -> DecryptedReader<R> {
DecryptedReader {
reader: r,
@@ -71,44 +71,28 @@ impl<R: Reader> DecryptedReader<R> {
}
}
impl<R: Reader> Buffer for DecryptedReader<R> {
fn fill_buf<'b>(&'b mut self) -> IoResult<&'b [u8]> {
impl<R: Read> BufRead for DecryptedReader<R> {
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<R: Reader> Buffer for DecryptedReader<R> {
}
}
impl<R: Reader> Reader for DecryptedReader<R> {
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
impl<R: Read> Read for DecryptedReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let nread = {
let available = try!(self.fill_buf());
let nread = cmp::min(available.len(), buf.len());
@@ -137,12 +121,12 @@ impl<R: Reader> Reader for DecryptedReader<R> {
}
}
pub struct EncryptedWriter<W: Writer> {
pub struct EncryptedWriter<W: Write> {
writer: W,
cipher: Box<Cipher + Send>,
}
impl<W: Writer> EncryptedWriter<W> {
impl<W: Write> EncryptedWriter<W> {
pub fn new(w: W, cipher: Box<Cipher + Send>) -> EncryptedWriter<W> {
EncryptedWriter {
writer: w,
@@ -150,17 +134,17 @@ impl<W: Writer> EncryptedWriter<W> {
}
}
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<W: Writer> EncryptedWriter<W> {
}
}
impl<W: Writer> Writer for EncryptedWriter<W> {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
impl<W: Write> Write for EncryptedWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
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<W: Writer> Drop for EncryptedWriter<W> {
impl<W: Write> Drop for EncryptedWriter<W> {
fn drop(&mut self) {
self.finalize().unwrap()
}
+14 -18
View File
@@ -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::<socks5::Address, SocketAddr>::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");
}
+18 -21
View File
@@ -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();
}
}
}