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

updated log format

Browse Source
This commit is contained in:
Y. T. Chung
2016-07-24 09:02:02 +08:00
parent 6ed65fd143
commit b278d67b3e
2 changed files with 72 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -51,9 +51,7 @@ impl TcpRelayLocal {
panic!("You have to provide configuration for server and local");
}
TcpRelayLocal {
config: Arc::new(c),
}
TcpRelayLocal { config: Arc::new(c) }
}
fn do_handshake<R: Read, W: Write>(reader: &mut R, writer: &mut W) -> io::Result<()> {
@@ -66,7 +64,8 @@ impl TcpRelayLocal {
try!(resp.write_to(writer));
warn!("Currently shadowsocks-rust does not support authentication");
return Err(io::Error::new(io::ErrorKind::Other,
"Currently shadowsocks-rust does not support authentication"));
"Currently shadowsocks-rust does not support \
authentication"));
}
// Reply to client
@@ -79,7 +78,7 @@ impl TcpRelayLocal {
_addr: SocketAddr,
_dest_addr: &socks5::Address,
local_conf: ClientConfig)
-> io::Result<()> {
-> io::Result<()> {
let reply = socks5::TcpResponseHeader::new(socks5::Reply::Succeeded,
socks5::Address::SocketAddress(local_conf));
trace!("Replying Header for UDP ASSOCIATE, {:?}", reply);
@@ -126,10 +125,9 @@ impl TcpRelayLocal {
}
let header = match socks5::TcpRequestHeader::read_from(&mut local_reader) {
Ok(h) => { h },
Ok(h) => h,
Err(err) => {
let header = socks5::TcpResponseHeader::new(err.reply,
socks5::Address::SocketAddress(sockname));
let header = socks5::TcpResponseHeader::new(err.reply, socks5::Address::SocketAddress(sockname));
error!("Failed to read request header: {}", err);
if let Err(err) = header.write_to(&mut local_writer) {
error!("Failed to write response header to local stream: {}", err);
@@ -149,13 +147,13 @@ impl TcpRelayLocal {
let mut remote_stream = match TcpStream::connect(&server_addr) {
Err(err) => {
match err.kind() {
ErrorKind::ConnectionAborted
| ErrorKind::ConnectionReset
| ErrorKind::ConnectionRefused => {
ErrorKind::ConnectionAborted |
ErrorKind::ConnectionReset |
ErrorKind::ConnectionRefused => {
let header = socks5::TcpResponseHeader::new(socks5::Reply::HostUnreachable,
addr.clone());
let _ = header.write_to(&mut local_writer);
},
}
_ => {
let header = socks5::TcpResponseHeader::new(socks5::Reply::NetworkUnreachable,
addr.clone());
@@ -164,8 +162,8 @@ impl TcpRelayLocal {
}
error!("Failed to connect remote server: {}", err);
return;
},
Ok(s) => { s },
}
Ok(s) => s,
};
// Send header to client
@@ -173,7 +171,8 @@ impl TcpRelayLocal {
let header = socks5::TcpResponseHeader::new(socks5::Reply::Succeeded,
socks5::Address::SocketAddress(sockname));
trace!("Send header to client {:?}", header);
if let Err(err) = header.write_to(&mut local_writer).and_then(|_| local_writer.flush()) {
if let Err(err) = header.write_to(&mut local_writer)
.and_then(|_| local_writer.flush()) {
error!("Error occurs while writing header to local stream: {}", err);
return;
}
@@ -214,15 +213,14 @@ impl TcpRelayLocal {
Scheduler::spawn(move || {
match relay::copy(&mut local_reader, &mut encrypt_stream, "Local to remote") {
Ok(..) => {},
Ok(..) => {}
Err(err) => {
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)
ErrorKind::BrokenPipe => debug!("{} local -> remote: {}", addr_cloned, err),
ErrorKind::TimedOut => {
info!("SYSTEM Connect {} local -> remote is timedout", addr_cloned);
}
_ => error!("{} local -> remote: {}", addr_cloned, err),
}
}
}
@@ -233,7 +231,7 @@ impl TcpRelayLocal {
let _ = local_reader.get_ref().shutdown(Shutdown::Both);
});
Scheduler::spawn(move|| {
Scheduler::spawn(move || {
let remote_iv = {
let mut iv = Vec::with_capacity(encrypt_method.block_size());
unsafe {
@@ -248,7 +246,7 @@ impl TcpRelayLocal {
debug!("Already read: {:?}", &iv[..total_len]);
let _ = local_writer.get_ref().shutdown(Shutdown::Both);
return;
},
}
Ok(n) => total_len += n,
Err(err) => {
error!("Error while reading initialize vector: {}", err);
@@ -276,15 +274,12 @@ impl TcpRelayLocal {
match relay::copy(&mut decrypt_stream, &mut local_writer, "Remote to local") {
Err(err) => {
match err.kind() {
ErrorKind::BrokenPipe => {
debug!("{} relay from remote to local stream: {}", addr, err)
},
_ => {
error!("{} relay from remote to local stream: {}", addr, err)
}
ErrorKind::BrokenPipe => debug!("{} local <- remote: {}", addr, err),
ErrorKind::TimedOut => info!("SYSTEM Connect {} local <- remote is timedout", addr),
_ => error!("{} local <- remote: {}", addr, err),
}
},
Ok(..) => {},
}
Ok(..) => {}
}
let _ = local_writer.flush();
@@ -294,13 +289,13 @@ impl TcpRelayLocal {
let _ = decrypt_stream.get_mut().shutdown(Shutdown::Both);
let _ = local_writer.shutdown(Shutdown::Both);
});
},
}
socks5::Command::TcpBind => {
warn!("BIND is not supported");
socks5::TcpResponseHeader::new(socks5::Reply::CommandNotSupported, addr)
.write_to(&mut local_writer)
.unwrap_or_else(|err| error!("Failed to write BIND response: {}", err));
},
}
socks5::Command::UdpAssociate => {
info!("{} requests for UDP ASSOCIATE", sockname);
if cfg!(feature = "enable-udp") && enable_udp {
@@ -326,7 +321,8 @@ impl TcpRelayLocal {
let acceptor = match TcpListener::bind(&local_conf) {
Ok(acpt) => acpt,
Err(e) => {
panic!("Error occurs while listening local address: {}", e.to_string());
panic!("Error occurs while listening local address: {}",
e.to_string());
}
};
@@ -339,7 +335,7 @@ impl TcpRelayLocal {
Ok((s, addr)) => {
debug!("Got connection from client {:?}", addr);
s
},
}
Err(err) => {
panic!("Error occurs while accepting: {:?}", err);
}
@@ -368,14 +364,14 @@ impl TcpRelayLocal {
None => {
error!("cannot resolve proxy server `{}`", server_cfg.addr);
continue;
},
}
Some(addr) => {
let addr = addr.clone();
cached_proxy.insert(server_cfg.addr.clone(), addr.clone());
addr
}
}
},
}
Err(err) => {
error!("cannot resolve proxy server `{}`: {}", server_cfg.addr, err);
continue;
@@ -386,9 +382,7 @@ impl TcpRelayLocal {
};
let server_addr = match addr {
SocketAddr::V4(addr) => {
SocketAddr::V4(SocketAddrV4::new(addr.ip().clone(), server_cfg.port))
},
SocketAddr::V4(addr) => SocketAddr::V4(SocketAddrV4::new(addr.ip().clone(), server_cfg.port)),
SocketAddr::V6(addr) => {
SocketAddr::V6(SocketAddrV6::new(addr.ip().clone(),
server_cfg.port,
@@ -402,19 +396,18 @@ impl TcpRelayLocal {
continue;
}
debug!("Using proxy `{}:{}` (`{}`)", server_cfg.addr, server_cfg.port, server_addr);
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());
let enable_udp = self.config.enable_udp;
let conf = self.config.clone();
Scheduler::spawn(move ||
TcpRelayLocal::handle_client(stream,
server_addr,
pwd,
encrypt_method,
enable_udp,
conf));
Scheduler::spawn(move || {
TcpRelayLocal::handle_client(stream, server_addr, pwd, encrypt_method, enable_udp, conf)
});
succeed = true;
break;
}

88
src/relay/tcprelay/server.rs
View File

@@ -53,7 +53,7 @@ impl TcpRelayServer {
fn accept_loop(s: ServerConfig, forbidden_ip: Arc<HashSet<IpAddr>>) {
let acceptor = TcpListener::bind(&(&s.addr[..], s.port))
.unwrap_or_else(|err| panic!("Failed to bind a TCP socket: {}", err));
.unwrap_or_else(|err| panic!("Failed to bind a TCP socket: {}", err));
info!("Shadowsocks listening on {}:{}", s.addr, s.port);
@@ -62,6 +62,9 @@ impl TcpRelayServer {
let pwd = s.method.bytes_to_key(s.password.as_bytes());
let timeout = s.timeout;
let method = s.method;
info!("Method {}, Timeout: {:?}", method, timeout);
for s in acceptor.incoming() {
let mut stream = match s {
Ok((s, addr)) => {
@@ -126,10 +129,7 @@ impl TcpRelayServer {
let mut client_writer = stream;
let iv = encrypt_method.gen_init_vec();
let encryptor = cipher::with_type(encrypt_method,
&pwd[..],
&iv[..],
CryptoMode::Encrypt);
let encryptor = cipher::with_type(encrypt_method, &pwd[..], &iv[..], CryptoMode::Encrypt);
if let Err(err) = client_writer.write_all(&iv[..]) {
error!("Error occurs while writing initialize vector: {}", err);
return;
@@ -174,9 +174,7 @@ impl TcpRelayServer {
let mut last_err: Option<io::Result<TcpStream>> = None;
for addr in addrs.into_iter() {
let addr = match addr {
SocketAddr::V4(addr) => {
SocketAddr::V4(SocketAddrV4::new(addr.ip().clone(), *port))
}
SocketAddr::V4(addr) => SocketAddr::V4(SocketAddrV4::new(addr.ip().clone(), *port)),
SocketAddr::V6(addr) => {
SocketAddr::V6(SocketAddrV6::new(addr.ip().clone(),
*port,
@@ -188,8 +186,7 @@ impl TcpRelayServer {
if forbidden_ip.contains(&::relay::take_ip_addr(&addr)) {
info!("{} has been blocked by `forbidden_ip`", addr);
last_err = Some(Err(io::Error::new(io::ErrorKind::Other,
"Blocked by \
`forbidden_ip`")));
"Blocked by `forbidden_ip`")));
continue;
}
@@ -224,31 +221,22 @@ impl TcpRelayServer {
Scheduler::spawn(move || {
let mut remote_reader = BufReader::new(remote_stream);
let mut encrypt_stream = EncryptedWriter::new(client_writer, encryptor);
match ::relay::copy(&mut remote_reader,
&mut encrypt_stream,
"Remote to local") {
let remote_addr = remote_reader.get_ref().peer_addr().unwrap();
let client_addr = encrypt_stream.get_ref().peer_addr().unwrap();
match ::relay::copy(&mut remote_reader, &mut encrypt_stream, "Remote to local") {
Ok(n) => {
let _ = remote_reader.get_ref()
.peer_addr()
.map(|remote_addr| {
encrypt_stream.get_ref()
.peer_addr()
.map(|client_addr| {
debug!("Remote to local: \
relayed {} bytes \
from {} to {}",
n,
remote_addr,
client_addr);
})
});
debug!("{} local <- remote: relayed {} bytes from {} to {}",
addr,
n,
remote_addr,
client_addr)
}
Err(err) => {
match err.kind() {
ErrorKind::BrokenPipe => {
debug!("{} relay from remote to local stream: {}", addr, err)
}
_ => error!("{} relay from remote to local stream: {}", addr, err),
ErrorKind::BrokenPipe => debug!("{} local <- remote: {}", addr, err),
ErrorKind::TimedOut => info!("{} local <- remote: {}", addr, err),
_ => error!("{} local <- remote: {}", addr, err),
}
}
}
@@ -260,36 +248,22 @@ impl TcpRelayServer {
});
Scheduler::spawn(move || {
match ::relay::copy(&mut decrypt_stream,
&mut remote_writer,
"Local to remote") {
let client_addr = decrypt_stream.get_ref().peer_addr().unwrap();
let remote_addr = remote_writer.peer_addr().unwrap();
match ::relay::copy(&mut decrypt_stream, &mut remote_writer, "Local to remote") {
Ok(n) => {
let _ = decrypt_stream.get_ref()
.peer_addr()
.map(|client_addr| {
remote_writer.peer_addr()
.map(|remote_addr| {
debug!("Local to remote: \
relayed {} bytes \
from {} to {}",
n,
client_addr,
remote_addr);
})
});
debug!("{} local -> remote: relayed {} bytes from {} to {}",
addr_cloned,
n,
client_addr,
remote_addr)
}
Err(err) => {
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)
}
ErrorKind::BrokenPipe => debug!("{} local -> remote: {}", addr_cloned, err),
ErrorKind::TimedOut => info!("{} local -> remote: {}", addr_cloned, err),
_ => error!("{} local -> remote: {}", addr_cloned, err),
}
}
}