luckyimnotanigger/tun2proxy
1
0
Fork 0
mirror of https://github.com/tun2proxy/tun2proxy.git synced 2025-06-21 00:20:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

refine code

Browse source
This commit is contained in:
ssrlive 2023-10-01 14:17:35 +08:00
parent da24bffa70
commit 2a4a9c7c2a
4 changed files with 37 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/lib.rs
View file

@ -104,7 +104,7 @@ pub struct Options {
dns_over_tcp: bool, dns_over_tcp: bool,
dns_addr: Option<std::net::IpAddr>, dns_addr: Option<std::net::IpAddr>,
ipv6_enabled: bool, ipv6_enabled: bool,
bypass_ip: Option<std::net::IpAddr>, bypass: Option<std::net::IpAddr>,
} }
impl Options { impl Options {
@ -139,8 +139,8 @@ impl Options {
self self
} }
pub fn with_bypass_ip(mut self, ip: Option<std::net::IpAddr>) -> Self { pub fn with_bypass(mut self, ip: Option<std::net::IpAddr>) -> Self {
self.bypass_ip = ip; self.bypass = ip;
self self
} }
} }

6
src/main.rs
View file

@ -120,18 +120,18 @@ fn main() -> ExitCode {
Some(addr) => addr, Some(addr) => addr,
None => args.proxy.addr.ip(), 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> { let block = || -> Result<(), Error> {
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
{ {
let mut setup: Setup; let mut setup: Setup;
if args.setup == Some(ArgSetup::Auto) { if args.setup == Some(ArgSetup::Auto) {
let bypass_tun_ip = match args.bypass_ip { let bypass_tun_ip = match args.bypass {
Some(addr) => addr, Some(addr) => addr,
None => args.proxy.addr.ip(), 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()?; setup.configure()?;

5
src/tun2proxy.rs
View file

@ -257,7 +257,7 @@ impl<'a> TunToProxy<'a> {
}; };
#[cfg(target_os = "windows")] #[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()?; let poll = Poll::new()?;
@ -938,8 +938,9 @@ impl<'a> TunToProxy<'a> {
rx_token.consume(|frame| self.receive_tun(frame))?; rx_token.consume(|frame| self.receive_tun(frame))?;
} }
} }
#[cfg(target_os = "windows")]
if event.is_writable() { 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")?; let tx_token = self.tun.transmit(Instant::now()).ok_or("tx token not available")?;
// Just consume the cached packets, do nothing else. // Just consume the cached packets, do nothing else.
tx_token.consume(0, |_buf| {}); tx_token.consume(0, |_buf| {});

72
src/wintuninterface.rs
View file

@ -115,7 +115,7 @@ impl WinTunInterface {
// Take the old data from pipe_client_cache and append the new data // Take the old data from pipe_client_cache and append the new data
let old_data = pipe_client_cache_clone.lock()?.drain(..).collect::<Vec<u8>>(); let old_data = pipe_client_cache_clone.lock()?.drain(..).collect::<Vec<u8>>();
let bytes = old_data.into_iter().chain(bytes.into_iter()).collect::<Vec<u8>>(); let bytes = old_data.into_iter().chain(bytes).collect::<Vec<u8>>();
if bytes.is_empty() { if bytes.is_empty() {
continue; continue;
} }
@ -131,7 +131,7 @@ impl WinTunInterface {
} }
} }
Err(err) if err.kind() == io::ErrorKind::WouldBlock => { 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); pipe_client_cache_clone.lock()?.extend_from_slice(&bytes);
} }
Err(err) => log::error!("Wintun pipe_client write data len {} error \"{}\"", len, err), 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> { pub fn pipe_client_event(&self, event: &event::Event) -> Result<(), io::Error> {
if event.is_readable() { if event.is_readable() {
self.pipe_client_event_readable() self.pipe_client_event_readable()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
} else if event.is_writable() { } else if event.is_writable() {
self.pipe_client_event_writable() self.pipe_client_event_writable()
} else { .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
Ok(())
} }
Ok(())
} }
fn pipe_client_event_readable(&self) -> Result<(), io::Error> { fn pipe_client_event_readable(&self) -> Result<(), Box<dyn std::error::Error + '_>> {
let mut reader = self let mut reader = self.pipe_client.lock()?;
.pipe_client
.lock()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
let mut buffer = vec![0; self.mtu]; let mut buffer = vec![0; self.mtu];
loop { loop {
// some data arieved to pipe_client from pipe_server // 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::WouldBlock => break,
Err(err) if err.kind() == io::ErrorKind::Interrupted => continue, Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
Err(err) => return Err(err), Err(err) => return Err(err.into()),
} }
} }
Ok(()) Ok(())
} }
fn pipe_client_event_writable(&self) -> Result<(), io::Error> { fn pipe_client_event_writable(&self) -> Result<(), Box<dyn std::error::Error + '_>> {
let cache = self let cache = self.pipe_client_cache.lock()?.drain(..).collect::<Vec<u8>>();
.pipe_client_cache
.lock()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
.drain(..)
.collect::<Vec<u8>>();
if cache.is_empty() { if cache.is_empty() {
return Ok(()); return Ok(());
} }
let result = self let len = cache.len();
.pipe_client let result = self.pipe_client.lock()?.write(&cache[..]);
.lock()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
.write(&cache[..]);
match result { match result {
Ok(len) => { Ok(n) => {
let len0 = cache.len(); if n < len {
if len < len0 { log::trace!("Wintun pipe_client write data {} less than buffer {}", n, len);
log::trace!("Wintun pipe_client write data {} less than buffer {}", len, len0); self.pipe_client_cache.lock()?.extend_from_slice(&cache[n..]);
self.pipe_client_cache
.lock()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
.extend_from_slice(&cache[len..]);
} }
} }
Err(err) if err.kind() == io::ErrorKind::WouldBlock => { Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
log::trace!("Wintun pipe_client write data len {} WouldBlock", cache.len()); log::trace!("Wintun pipe_client write WouldBlock (2) len {}", len);
self.pipe_client_cache self.pipe_client_cache.lock()?.extend_from_slice(&cache);
.lock()
.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
.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(()) Ok(())
} }
@ -385,25 +368,26 @@ impl phy::TxToken for TxToken {
.pipe_server_cache .pipe_server_cache
.borrow_mut() .borrow_mut()
.drain(..) .drain(..)
.chain(buffer.into_iter()) .chain(buffer)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
if buffer.is_empty() { if buffer.is_empty() {
// log::trace!("Wintun TxToken (pipe_server) is empty");
return result; return result;
} }
let len = buffer.len();
match self.pipe_server.borrow_mut().write(&buffer[..]) { match self.pipe_server.borrow_mut().write(&buffer[..]) {
Ok(len) => { Ok(n) => {
let len0 = buffer.len(); if n < len {
if len < len0 { log::trace!("Wintun TxToken (pipe_server) sent {} less than buffer len {}", n, len);
log::trace!("Wintun TxToken consumed data len {} less than buffer len {}", len, len0); self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[n..]);
self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[len..]);
} }
} }
Err(err) if err.kind() == io::ErrorKind::WouldBlock => { Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
self.pipe_server_cache.borrow_mut().extend_from_slice(&buffer[..]); 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 result
} }