From 2a4a9c7c2af82548e0fa720f8921a168d6f996ed Mon Sep 17 00:00:00 2001 From: ssrlive <30760636+ssrlive@users.noreply.github.com> Date: Sun, 1 Oct 2023 14:17:35 +0800 Subject: [PATCH] refine code --- src/lib.rs | 6 ++-- src/main.rs | 6 ++-- src/tun2proxy.rs | 5 +-- src/wintuninterface.rs | 72 ++++++++++++++++-------------------------- 4 files changed, 37 insertions(+), 52 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 65b8b22..4e7de1a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -104,7 +104,7 @@ pub struct Options { dns_over_tcp: bool, dns_addr: Option, ipv6_enabled: bool, - bypass_ip: Option, + bypass: Option, } impl Options { @@ -139,8 +139,8 @@ impl Options { self } - pub fn with_bypass_ip(mut self, ip: Option) -> Self { - self.bypass_ip = ip; + pub fn with_bypass(mut self, ip: Option) -> Self { + self.bypass = ip; self } } diff --git a/src/main.rs b/src/main.rs index ac29b0b..404c341 100644 --- a/src/main.rs +++ b/src/main.rs @@ -120,18 +120,18 @@ fn main() -> ExitCode { Some(addr) => addr, None => args.proxy.addr.ip(), }; - options = options.with_bypass_ip(Some(bypass_tun_ip)); + options = options.with_bypass(Some(bypass_tun_ip)); let block = || -> Result<(), Error> { #[cfg(target_os = "linux")] { let mut setup: Setup; if args.setup == Some(ArgSetup::Auto) { - let bypass_tun_ip = match args.bypass_ip { + let bypass_tun_ip = match args.bypass { Some(addr) => addr, None => args.proxy.addr.ip(), }; - setup = Setup::new(&args.tun, &bypass_tun_ip, get_default_cidrs(), args.bypass_ip.is_some()); + setup = Setup::new(&args.tun, &bypass_tun_ip, get_default_cidrs(), args.bypass.is_some()); setup.configure()?; diff --git a/src/tun2proxy.rs b/src/tun2proxy.rs index 7dafcfc..a13c83c 100644 --- a/src/tun2proxy.rs +++ b/src/tun2proxy.rs @@ -257,7 +257,7 @@ impl<'a> TunToProxy<'a> { }; #[cfg(target_os = "windows")] - tun.setup_config(options.bypass_ip, options.dns_addr)?; + tun.setup_config(options.bypass, options.dns_addr)?; let poll = Poll::new()?; @@ -938,8 +938,9 @@ impl<'a> TunToProxy<'a> { rx_token.consume(|frame| self.receive_tun(frame))?; } } + #[cfg(target_os = "windows")] if event.is_writable() { - log::trace!("tun send"); + // log::trace!("Tun writable"); let tx_token = self.tun.transmit(Instant::now()).ok_or("tx token not available")?; // Just consume the cached packets, do nothing else. tx_token.consume(0, |_buf| {}); diff --git a/src/wintuninterface.rs b/src/wintuninterface.rs index 8a572a4..462abeb 100644 --- a/src/wintuninterface.rs +++ b/src/wintuninterface.rs @@ -115,7 +115,7 @@ impl WinTunInterface { // Take the old data from pipe_client_cache and append the new data let old_data = pipe_client_cache_clone.lock()?.drain(..).collect::>(); - let bytes = old_data.into_iter().chain(bytes.into_iter()).collect::>(); + let bytes = old_data.into_iter().chain(bytes).collect::>(); if bytes.is_empty() { continue; } @@ -131,7 +131,7 @@ impl WinTunInterface { } } Err(err) if err.kind() == io::ErrorKind::WouldBlock => { - log::trace!("Wintun pipe_client write data len {} WouldBlock", len); + log::trace!("Wintun pipe_client write WouldBlock (1) len {}", len); pipe_client_cache_clone.lock()?.extend_from_slice(&bytes); } Err(err) => log::error!("Wintun pipe_client write data len {} error \"{}\"", len, err), @@ -163,18 +163,16 @@ impl WinTunInterface { pub fn pipe_client_event(&self, event: &event::Event) -> Result<(), io::Error> { if event.is_readable() { self.pipe_client_event_readable() + .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; } else if event.is_writable() { self.pipe_client_event_writable() - } else { - Ok(()) + .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; } + Ok(()) } - fn pipe_client_event_readable(&self) -> Result<(), io::Error> { - let mut reader = self - .pipe_client - .lock() - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; + fn pipe_client_event_readable(&self) -> Result<(), Box> { + let mut reader = self.pipe_client.lock()?; let mut buffer = vec![0; self.mtu]; loop { // some data arieved to pipe_client from pipe_server @@ -191,46 +189,31 @@ impl WinTunInterface { }, Err(err) if err.kind() == io::ErrorKind::WouldBlock => break, Err(err) if err.kind() == io::ErrorKind::Interrupted => continue, - Err(err) => return Err(err), + Err(err) => return Err(err.into()), } } Ok(()) } - fn pipe_client_event_writable(&self) -> Result<(), io::Error> { - let cache = self - .pipe_client_cache - .lock() - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))? - .drain(..) - .collect::>(); + fn pipe_client_event_writable(&self) -> Result<(), Box> { + let cache = self.pipe_client_cache.lock()?.drain(..).collect::>(); if cache.is_empty() { return Ok(()); } - let result = self - .pipe_client - .lock() - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))? - .write(&cache[..]); + let len = cache.len(); + let result = self.pipe_client.lock()?.write(&cache[..]); match result { - Ok(len) => { - let len0 = cache.len(); - if len < len0 { - log::trace!("Wintun pipe_client write data {} less than buffer {}", len, len0); - self.pipe_client_cache - .lock() - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))? - .extend_from_slice(&cache[len..]); + Ok(n) => { + if n < len { + log::trace!("Wintun pipe_client write data {} less than buffer {}", n, len); + self.pipe_client_cache.lock()?.extend_from_slice(&cache[n..]); } } Err(err) if err.kind() == io::ErrorKind::WouldBlock => { - log::trace!("Wintun pipe_client write data len {} WouldBlock", cache.len()); - self.pipe_client_cache - .lock() - .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))? - .extend_from_slice(&cache); + log::trace!("Wintun pipe_client write WouldBlock (2) len {}", len); + self.pipe_client_cache.lock()?.extend_from_slice(&cache); } - Err(err) => log::error!("Wintun pipe_client write data len {} error \"{}\"", cache.len(), err), + Err(err) => log::error!("Wintun pipe_client write data len {} error \"{}\"", len, err), } Ok(()) } @@ -385,25 +368,26 @@ impl phy::TxToken for TxToken { .pipe_server_cache .borrow_mut() .drain(..) - .chain(buffer.into_iter()) + .chain(buffer) .collect::>(); if buffer.is_empty() { + // log::trace!("Wintun TxToken (pipe_server) is empty"); return result; } + let len = buffer.len(); match self.pipe_server.borrow_mut().write(&buffer[..]) { - Ok(len) => { - let len0 = buffer.len(); - if len < len0 { - log::trace!("Wintun TxToken consumed data len {} less than buffer len {}", len, len0); - self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[len..]); + Ok(n) => { + if n < len { + log::trace!("Wintun TxToken (pipe_server) sent {} less than buffer len {}", n, len); + self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[n..]); } } Err(err) if err.kind() == io::ErrorKind::WouldBlock => { self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[..]); - log::trace!("Wintun TxToken: WouldBlock data len: {}", len) + log::trace!("Wintun TxToken (pipe_server) WouldBlock data len: {}", len) } - Err(err) => log::error!("Wintun TxToken data len {} error \"{}\"", len, err), + Err(err) => log::error!("Wintun TxToken (pipe_server) len {} error \"{}\"", len, err), } result }