source/shadowsocks-rust
1
0
Fork 0
mirror of https://github.com/shadowsocks/shadowsocks-rust.git synced 2026-02-09 01:59:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

better logs

Browse Source
This commit is contained in:
Y. T. Chung
2016-10-21 00:38:48 +08:00
parent 30b47b6a56
commit d27d7414b7
3 changed files with 97 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/relay/local.rs
View File

@@ -95,13 +95,17 @@ impl Relay for RelayLocal {
let mut futs = Vec::new();
let tcprelay = self.tcprelay.clone();
let tcp_fut = Scheduler::spawn(move || tcprelay.run_tcp());
info!("Enabled TCP relay");
let tcp_fut = Scheduler::spawn(move || {
info!("Enabled TCP relay");
tcprelay.run_tcp()
});
futs.push(tcp_fut);
let tcprelay = self.tcprelay.clone();
let tcp_fut = Scheduler::spawn(move || tcprelay.run_http());
info!("Enabled HTTP relay");
let tcp_fut = Scheduler::spawn(move || {
info!("Enabled HTTP relay");
tcprelay.run_http()
});
futs.push(tcp_fut);
for fut in futs {
@@ -113,20 +117,27 @@ impl Relay for RelayLocal {
let mut futs = Vec::new();
let tcprelay = self.tcprelay.clone();
let tcp_fut = Scheduler::spawn(move || tcprelay.run_tcp());
info!("Enabled TCP relay");
let tcp_fut = Scheduler::spawn(move || {
info!("Enabled TCP relay");
tcprelay.run_tcp()
});
futs.push(tcp_fut);
if self.enable_udp {
let udprelay = self.udprelay.clone();
let udp_fut = Scheduler::spawn(move || udprelay.run());
info!("Enabled UDP relay");
let udp_fut = Scheduler::spawn(move || {
info!("Enabled UDP relay");
udprelay.run()
});
futs.push(udp_fut);
}
let tcprelay = self.tcprelay.clone();
let tcp_fut = Scheduler::spawn(move || tcprelay.run_http());
info!("Enabled HTTP relay");
let tcp_fut = Scheduler::spawn(move || {
info!("Enabled HTTP relay");
tcprelay.run_http()
});
futs.push(tcp_fut);
for fut in futs {

88
src/relay/socks5.rs
View File

@@ -30,30 +30,30 @@ use std::convert::From;
use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
const SOCKS5_VERSION : u8 = 0x05;
const SOCKS5_VERSION: u8 = 0x05;
pub const SOCKS5_AUTH_METHOD_NONE : u8 = 0x00;
pub const SOCKS5_AUTH_METHOD_GSSAPI : u8 = 0x01;
pub const SOCKS5_AUTH_METHOD_PASSWORD : u8 = 0x02;
pub const SOCKS5_AUTH_METHOD_NOT_ACCEPTABLE : u8 = 0xff;
pub const SOCKS5_AUTH_METHOD_NONE: u8 = 0x00;
pub const SOCKS5_AUTH_METHOD_GSSAPI: u8 = 0x01;
pub const SOCKS5_AUTH_METHOD_PASSWORD: u8 = 0x02;
pub const SOCKS5_AUTH_METHOD_NOT_ACCEPTABLE: u8 = 0xff;
const SOCKS5_CMD_TCP_CONNECT : u8 = 0x01;
const SOCKS5_CMD_TCP_BIND : u8 = 0x02;
const SOCKS5_CMD_UDP_ASSOCIATE : u8 = 0x03;
const SOCKS5_CMD_TCP_CONNECT: u8 = 0x01;
const SOCKS5_CMD_TCP_BIND: u8 = 0x02;
const SOCKS5_CMD_UDP_ASSOCIATE: u8 = 0x03;
const SOCKS5_ADDR_TYPE_IPV4 : u8 = 0x01;
const SOCKS5_ADDR_TYPE_DOMAIN_NAME : u8 = 0x03;
const SOCKS5_ADDR_TYPE_IPV6 : u8 = 0x04;
const SOCKS5_ADDR_TYPE_IPV4: u8 = 0x01;
const SOCKS5_ADDR_TYPE_DOMAIN_NAME: u8 = 0x03;
const SOCKS5_ADDR_TYPE_IPV6: u8 = 0x04;
const SOCKS5_REPLY_SUCCEEDED : u8 = 0x00;
const SOCKS5_REPLY_GENERAL_FAILURE : u8 = 0x01;
const SOCKS5_REPLY_CONNECTION_NOT_ALLOWED : u8 = 0x02;
const SOCKS5_REPLY_NETWORK_UNREACHABLE : u8 = 0x03;
const SOCKS5_REPLY_HOST_UNREACHABLE : u8 = 0x04;
const SOCKS5_REPLY_CONNECTION_REFUSED : u8 = 0x05;
const SOCKS5_REPLY_TTL_EXPIRED : u8 = 0x06;
const SOCKS5_REPLY_COMMAND_NOT_SUPPORTED : u8 = 0x07;
const SOCKS5_REPLY_ADDRESS_TYPE_NOT_SUPPORTED : u8 = 0x08;
const SOCKS5_REPLY_SUCCEEDED: u8 = 0x00;
const SOCKS5_REPLY_GENERAL_FAILURE: u8 = 0x01;
const SOCKS5_REPLY_CONNECTION_NOT_ALLOWED: u8 = 0x02;
const SOCKS5_REPLY_NETWORK_UNREACHABLE: u8 = 0x03;
const SOCKS5_REPLY_HOST_UNREACHABLE: u8 = 0x04;
const SOCKS5_REPLY_CONNECTION_REFUSED: u8 = 0x05;
const SOCKS5_REPLY_TTL_EXPIRED: u8 = 0x06;
const SOCKS5_REPLY_COMMAND_NOT_SUPPORTED: u8 = 0x07;
const SOCKS5_REPLY_ADDRESS_TYPE_NOT_SUPPORTED: u8 = 0x08;
#[allow(dead_code)]
#[derive(Clone, Debug, Copy)]
@@ -96,7 +96,7 @@ pub enum Reply {
CommandNotSupported,
AddressTypeNotSupported,
OtherReply(u8)
OtherReply(u8),
}
impl Reply {
@@ -128,7 +128,7 @@ impl Reply {
SOCKS5_REPLY_TTL_EXPIRED => Reply::TtlExpired,
SOCKS5_REPLY_COMMAND_NOT_SUPPORTED => Reply::CommandNotSupported,
SOCKS5_REPLY_ADDRESS_TYPE_NOT_SUPPORTED => Reply::AddressTypeNotSupported,
_ => Reply::OtherReply(code)
_ => Reply::OtherReply(code),
}
}
}
@@ -174,7 +174,8 @@ impl error::Error for Error {
impl From<io::Error> for Error {
fn from(err: io::Error) -> Error {
Error::new(Reply::GeneralFailure, <io::Error as error::Error>::description(&err))
Error::new(Reply::GeneralFailure,
<io::Error as error::Error>::description(&err))
}
}
@@ -329,7 +330,7 @@ impl TcpResponseHeader {
fn parse_request_header<R: Read>(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"))
Err(_) => return Err(Error::new(Reply::GeneralFailure, "Error while reading address type")),
};
match atyp {
@@ -340,7 +341,7 @@ fn parse_request_header<R: Read>(stream: &mut R) -> Result<(usize, Address), Err
try!(stream.read_u8()));
let port = try!(stream.read_u16::<BigEndian>());
Ok((7usize, Address::SocketAddress(SocketAddr::V4(SocketAddrV4::new(v4addr, port)))))
},
}
SOCKS5_ADDR_TYPE_IPV6 => {
let v6addr = Ipv6Addr::new(try!(stream.read_u16::<BigEndian>()),
try!(stream.read_u16::<BigEndian>()),
@@ -353,7 +354,7 @@ fn parse_request_header<R: Read>(stream: &mut R) -> Result<(usize, Address), Err
let port = try!(stream.read_u16::<BigEndian>());
Ok((19usize, Address::SocketAddress(SocketAddr::V6(SocketAddrV6::new(v6addr, port, 0, 0)))))
},
}
SOCKS5_ADDR_TYPE_DOMAIN_NAME => {
let addr_len = try!(stream.read_u8()) as usize;
let mut raw_addr = Vec::with_capacity(addr_len);
@@ -366,7 +367,7 @@ fn parse_request_header<R: Read>(stream: &mut R) -> Result<(usize, Address), Err
};
Ok((4 + addr_len, Address::DomainNameAddress(addr, port)))
},
}
_ => {
// Address type not supported
Err(Error::new(Reply::AddressTypeNotSupported, "Not supported address type"))
@@ -382,7 +383,7 @@ fn write_addr<W: Write + Sized>(addr: &Address, buf: &mut W) -> io::Result<()> {
SocketAddr::V4(addr) => {
try!(buf.write_all(&[SOCKS5_ADDR_TYPE_IPV4]));
try!(buf.write_all(&addr.ip().octets()));
},
}
SocketAddr::V6(addr) => {
try!(buf.write_u8(SOCKS5_ADDR_TYPE_IPV6));
for seg in &addr.ip().segments() {
@@ -391,7 +392,7 @@ fn write_addr<W: Write + Sized>(addr: &Address, buf: &mut W) -> io::Result<()> {
}
}
try!(buf.write_u16::<BigEndian>(addr.port()));
},
}
&Address::DomainNameAddress(ref dnaddr, port) => {
try!(buf.write_u8(SOCKS5_ADDR_TYPE_DOMAIN_NAME));
try!(buf.write_u8(dnaddr.len() as u8));
@@ -409,12 +410,10 @@ fn get_addr_len(atyp: &Address) -> usize {
&Address::SocketAddress(addr) => {
match addr {
SocketAddr::V4(..) => 1 + 4 + 2,
SocketAddr::V6(..) => 1 + 8 * 2 + 2
SocketAddr::V6(..) => 1 + 8 * 2 + 2,
}
},
&Address::DomainNameAddress(ref dmname, _) => {
1 + 1 + dmname.len() + 2
},
}
&Address::DomainNameAddress(ref dmname, _) => 1 + 1 + dmname.len() + 2,
}
}
@@ -430,18 +429,13 @@ pub struct HandshakeRequest {
impl HandshakeRequest {
pub fn new(methods: Vec<u8>) -> HandshakeRequest {
HandshakeRequest {
methods: methods,
}
HandshakeRequest { methods: methods }
}
pub fn read_from<R: Read>(stream: &mut R) -> io::Result<HandshakeRequest> {
let ver = try!(stream.read_u8());
if ver != SOCKS5_VERSION {
return Err(io::Error::new(
io::ErrorKind::Other,
"Invalid Socks5 version",
));
return Err(io::Error::new(io::ErrorKind::Other, "Invalid Socks5 version"));
}
let nmet = try!(stream.read_u8());
@@ -449,9 +443,7 @@ impl HandshakeRequest {
let mut methods = Vec::new();
try!(stream.take(nmet as u64).read_to_end(&mut methods));
Ok(HandshakeRequest {
methods: methods,
})
Ok(HandshakeRequest { methods: methods })
}
pub fn write_to(&self, stream: &mut Write) -> io::Result<()> {
@@ -474,9 +466,7 @@ pub struct HandshakeResponse {
impl HandshakeResponse {
pub fn new(cm: u8) -> HandshakeResponse {
HandshakeResponse {
chosen_method: cm,
}
HandshakeResponse { chosen_method: cm }
}
pub fn read_from<R: Read>(stream: &mut R) -> io::Result<HandshakeResponse> {
@@ -487,9 +477,7 @@ impl HandshakeResponse {
let met = try!(stream.read_u8());
Ok(HandshakeResponse {
chosen_method: met,
})
Ok(HandshakeResponse { chosen_method: met })
}
pub fn write_to(&self, stream: &mut Write) -> io::Result<()> {

60
src/relay/tcprelay/local.rs
View File

@@ -256,25 +256,31 @@ impl TcpRelayLocal {
encrypt_method: CipherType,
remain: &[u8])
-> io::Result<()> {
info!("CONNECT (Http) {}", addr);
info!("CONNECT (HTTP) {}", addr);
let mut local_reader = BufReader::new(stream);
let mut local_writer = stream_writer;
if let Err(err) = local_writer.write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n") {
const HANDSHAKE: &'static [u8] = b"HTTP/1.1 200 Connection Established\r\n\r\n";
if let Err(err) = local_writer.write_all(HANDSHAKE) {
error!("Failed to send handshake: {:?}", err);
return Err(err);
}
trace!("HTTP Connect: Sent HTTP tunnel handshakes");
let (mut decrypt_stream, mut encrypt_stream) =
match super::connect_proxy_server(&server_addr, encrypt_method, &password[..], &addr) {
Ok(x) => x,
Err(err) => {
error!("Failed to connect to proxy server: {:?}", err);
error!("Failed to connect to proxy server: {}", err);
return Err(err);
}
};
trace!("HTTP Connect: Connected remote server");
try!(encrypt_stream.write_all(remain));
let addr_cloned = addr.clone();
@@ -283,20 +289,25 @@ impl TcpRelayLocal {
loop {
match ::relay::copy_once(&mut local_reader, &mut encrypt_stream) {
Ok(0) => {
trace!("{} local -> remote: EOF", addr_cloned);
trace!("HTTP Connect: {} local -> remote: EOF", addr_cloned);
break;
}
Ok(n) => {
trace!("{} local -> remote: relayed {} bytes", addr_cloned, n);
trace!("HTTP Connect: {} local -> remote: relayed {} bytes",
addr_cloned,
n);
}
Err(err) => {
error!("SYSTEM Connect {} local -> remote: {}", addr_cloned, err);
error!("SYSTEM HTTP Connect {} local -> remote: {}",
addr_cloned,
err);
break;
}
}
}
debug!("SYSTEM Connect {} local -> remote is closing", addr_cloned);
debug!("SYSTEM HTTP Connect {} local -> remote is closing",
addr_cloned);
let _ = encrypt_stream.get_ref().shutdown(Shutdown::Both);
let _ = local_reader.get_ref().shutdown(Shutdown::Both);
@@ -306,14 +317,16 @@ impl TcpRelayLocal {
loop {
match ::relay::copy_once(&mut decrypt_stream, &mut local_writer) {
Ok(0) => {
trace!("{} local <- remote: EOF", addr);
trace!("HTTP Connect: {} local <- remote: EOF", addr);
break;
}
Ok(n) => {
trace!("{} local <- remote: relayed {} bytes", addr, n);
trace!("HTTP Connect: {} local <- remote: relayed {} bytes",
addr,
n);
}
Err(err) => {
error!("SYSTEM Connect {} local <- remote: {}", addr, err);
error!("SYSTEM HTTP Connect {} local <- remote: {}", addr, err);
break;
}
}
@@ -321,7 +334,7 @@ impl TcpRelayLocal {
let _ = local_writer.flush();
debug!("SYSTEM Connect {} local <- remote is closing", addr);
debug!("SYSTEM HTTP Connect {} local <- remote is closing", addr);
let _ = decrypt_stream.get_mut().shutdown(Shutdown::Both);
let _ = local_writer.shutdown(Shutdown::Both);
@@ -339,7 +352,7 @@ impl TcpRelayLocal {
encrypt_method: CipherType,
remain: &[u8])
-> io::Result<()> {
info!("{} (Http) {}", req.method, addr);
info!("{} (HTTP) {}", req.method, addr);
let mut local_reader = BufReader::new(stream);
let mut local_writer = stream_writer;
@@ -348,11 +361,14 @@ impl TcpRelayLocal {
match super::connect_proxy_server(&server_addr, encrypt_method, &password[..], &addr) {
Ok(x) => x,
Err(err) => {
error!("Failed to connect to proxy server: {:?}", err);
error!("Failed to connect to proxy server: {}", err);
return Err(err);
}
};
trace!("HTTP Proxy: Connected remote server");
trace!("HTTP Proxy: {} Target url {}", req.method, req.request_uri);
req.clear_request_uri_host();
try!(req.write_to(&mut encrypt_stream));
@@ -366,6 +382,8 @@ impl TcpRelayLocal {
Scheduler::spawn(move || {
let mut buf = [0u8; 1024];
let mut content_len = content_len;
'outer: loop {
// 1. Send body
match ::relay::copy_exact(&mut local_reader, &mut encrypt_stream, remain_len) {
@@ -376,6 +394,8 @@ impl TcpRelayLocal {
}
}
trace!("HTTP Proxy: Written body {} bytes", content_len);
if let Err(err) = encrypt_stream.flush() {
error!("Failed to flush: {}", err);
return;
@@ -406,6 +426,10 @@ impl TcpRelayLocal {
}
};
trace!("HTTP Proxy: {} Target url {}",
request.method,
request.request_uri);
request.clear_request_uri_host();
if let Err(err) = request.write_to(&mut encrypt_stream) {
error!("Failed to write HttpRequest: {}", err);
@@ -417,7 +441,7 @@ impl TcpRelayLocal {
break;
}
let content_len = request.headers
content_len = request.headers
.get::<header::ContentLength>()
.unwrap_or(&header::ContentLength(0))
.0 as usize;
@@ -475,14 +499,6 @@ impl TcpRelayLocal {
encrypt_method: CipherType) {
use super::http::{get_address, write_response};
// let sockname = match stream.peer_addr() {
// Ok(sockname) => sockname,
// Err(err) => {
// error!("Failed to get peer addr: {}", err);
// return;
// }
// };
let mut stream_writer = match stream.try_clone() {
Ok(s) => s,
Err(err) => {