mirror of
https://github.com/shadowsocks/shadowsocks-rust.git
synced 2026-11-18 08:17:37 +00:00
tried to migrate to new standard library, still lots of work to do
This commit is contained in:
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
|
||||
@@ -32,7 +32,7 @@ impl RoundRobin {
|
||||
pub fn new(config: Vec<ServerConfig>) -> RoundRobin {
|
||||
RoundRobin {
|
||||
server: config,
|
||||
index: 0us,
|
||||
index: 0usize,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+2
-2
@@ -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
@@ -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
@@ -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(())
|
||||
|
||||
@@ -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
@@ -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());
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
@@ -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");
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user