From d27d7414b797fdcfa875842ad176a39c49b1c96e Mon Sep 17 00:00:00 2001 From: "Y. T. Chung" Date: Fri, 21 Oct 2016 00:38:48 +0800 Subject: [PATCH] better logs --- src/relay/local.rs | 31 ++++++++----- src/relay/socks5.rs | 88 ++++++++++++++++--------------------- src/relay/tcprelay/local.rs | 60 +++++++++++++++---------- 3 files changed, 97 insertions(+), 82 deletions(-) diff --git a/src/relay/local.rs b/src/relay/local.rs index 5dd686f4..92dfe698 100644 --- a/src/relay/local.rs +++ b/src/relay/local.rs @@ -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 { diff --git a/src/relay/socks5.rs b/src/relay/socks5.rs index 1cd1b9a6..4e5aea3c 100644 --- a/src/relay/socks5.rs +++ b/src/relay/socks5.rs @@ -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 for Error { fn from(err: io::Error) -> Error { - Error::new(Reply::GeneralFailure, ::description(&err)) + Error::new(Reply::GeneralFailure, + ::description(&err)) } } @@ -329,7 +330,7 @@ impl TcpResponseHeader { fn parse_request_header(stream: &mut R) -> Result<(usize, Address), Error> { let atyp = match stream.read_u8() { Ok(atyp) => atyp, - Err(_) => return Err(Error::new(Reply::GeneralFailure, "Error while reading address type")) + Err(_) => return Err(Error::new(Reply::GeneralFailure, "Error while reading address type")), }; match atyp { @@ -340,7 +341,7 @@ fn parse_request_header(stream: &mut R) -> Result<(usize, Address), Err try!(stream.read_u8())); let port = try!(stream.read_u16::()); Ok((7usize, Address::SocketAddress(SocketAddr::V4(SocketAddrV4::new(v4addr, port))))) - }, + } SOCKS5_ADDR_TYPE_IPV6 => { let v6addr = Ipv6Addr::new(try!(stream.read_u16::()), try!(stream.read_u16::()), @@ -353,7 +354,7 @@ fn parse_request_header(stream: &mut R) -> Result<(usize, Address), Err let port = try!(stream.read_u16::()); 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(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(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(addr: &Address, buf: &mut W) -> io::Result<()> { } } try!(buf.write_u16::(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) -> HandshakeRequest { - HandshakeRequest { - methods: methods, - } + HandshakeRequest { methods: methods } } pub fn read_from(stream: &mut R) -> io::Result { 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(stream: &mut R) -> io::Result { @@ -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<()> { diff --git a/src/relay/tcprelay/local.rs b/src/relay/tcprelay/local.rs index c0f2a8d0..98c92f1e 100644 --- a/src/relay/tcprelay/local.rs +++ b/src/relay/tcprelay/local.rs @@ -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::() .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) => {