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

fix clippy and fmt and semver

Browse source
This commit is contained in:
suchao 2024-10-20 10:16:40 +08:00
parent c27af98585
commit 718a623dff
4 changed files with 39 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "tun2proxy"
version = "0.5.4"
version = "0.6.0"
edition = "2021"
license = "MIT"
repository = "https://github.com/tun2proxy/tun2proxy"

17
src/bin/udpgw_server.rs
View file

@ -126,14 +126,12 @@ pub fn parse_udp(udp_mtu: u16, data_len: usize, data: &[u8]) -> Result<(&[u8], u
return Err("too much data".into());
}
let udpdata = &ip_data[(2 + domain.len() + 1)..];
return Ok((udpdata, flags, conid, target));
}
Err(_) => {
return Err("Invalid UTF-8 sequence in domain".into());
Ok((udpdata, flags, conid, target))
}
Err(_) => Err("Invalid UTF-8 sequence in domain".into()),
}
} else {
return Err("missing domain name".into());
Err("missing domain name".into())
}
} else if flags & UDPGW_FLAG_IPV6 != 0 {
if data_len < mem::size_of::<UdpgwAddrIpv6>() {
@ -230,11 +228,8 @@ async fn process_client_udp_req<'a>(args: &UdpGwArgs, tx: Sender<Vec<u8>>, mut c
let udp_timeout = args.udp_timeout;
'out: loop {
let result;
match tokio::time::timeout(tokio::time::Duration::from_secs(2), tcp_read_stream.read(&mut len_buf)).await {
Ok(ret) => {
result = ret;
}
let result = match tokio::time::timeout(tokio::time::Duration::from_secs(2), tcp_read_stream.read(&mut len_buf)).await {
Ok(ret) => ret,
Err(_e) => {
if client.last_activity.elapsed() >= CLIENT_DISCONNECT_TIMEOUT {
log::debug!("client {} last_activity elapsed", client.addr);
@ -263,7 +258,7 @@ async fn process_client_udp_req<'a>(args: &UdpGwArgs, tx: Sender<Vec<u8>>, mut c
if len == 0 {
break 'out;
}
client.buf.extend_from_slice(&mut buf[..len]);
client.buf.extend_from_slice(&buf[..len]);
left_len -= len;
} else {
break 'out;

20
src/lib.rs
View file

@ -238,7 +238,13 @@ where
None => None,
Some(addr) => {
log::info!("UDPGW enabled");
let client = Arc::new(UdpGwClient::new(mtu, args.max_udpgw_connections, UDPGW_KEEPALIVE_TIME, args.udp_timeout, addr));
let client = Arc::new(UdpGwClient::new(
mtu,
args.max_udpgw_connections,
UDPGW_KEEPALIVE_TIME,
args.udp_timeout,
addr,
));
let client_keepalive = client.clone();
tokio::spawn(async move {
client_keepalive.heartbeat_task().await;
@ -485,7 +491,7 @@ async fn handle_udp_gateway_session(
};
let udpinfo = SessionInfo::new(udp_stack.local_addr(), udp_stack.peer_addr(), IpProtocol::Udp);
let udp_mtu = udpgw_client.get_udp_mtu();
let udp_timeout = udpgw_client.get_udp_timeout();
let udp_timeout = udpgw_client.get_udp_timeout();
let mut server_stream: UdpGwClientStream;
let server = udpgw_client.get_server_connection().await;
match server {
@ -498,7 +504,7 @@ async fn handle_udp_gateway_session(
}
let mut tcp_server_stream = create_tcp_stream(&socket_queue, server_addr).await?;
if let Err(e) = handle_proxy_session(&mut tcp_server_stream, proxy_handler).await {
return Err(format!("udpgw connection error: {}",e).into());
return Err(format!("udpgw connection error: {}", e).into());
}
server_stream = UdpGwClientStream::new(udp_mtu, tcp_server_stream);
}
@ -549,7 +555,7 @@ async fn handle_udp_gateway_session(
{
log::info!(
"Ending {} <- {} with send_udpgw_packet {}",
udpinfo,
udpinfo,
&tcp_local_addr,
e
);
@ -593,8 +599,10 @@ async fn handle_udp_gateway_session(
}
}
if !server_stream.is_closed() {
udpgw_client.release_server_connection_with_stream(server_stream,stream_reader,stream_writer).await;
if !server_stream.is_closed() {
udpgw_client
.release_server_connection_with_stream(server_stream, stream_reader, stream_writer)
.await;
}
Ok(())

38
src/udpgw.rs
View file

@ -95,7 +95,7 @@ pub(crate) struct UdpGwData<'a> {
impl<'a> UdpGwData<'a> {
pub fn len(&self) -> usize {
return self.udpdata.len();
self.udpdata.len()
}
}
@ -212,7 +212,7 @@ impl UdpGwClient {
keepalive_packet.extend_from_slice(&(std::mem::size_of::<UdpgwHeader>() as u16).to_le_bytes());
keepalive_packet.extend_from_slice(&[UDPGW_FLAG_KEEPALIVE, 0, 0]);
let server_connections = Mutex::new(VecDeque::with_capacity(max_connections as usize));
return UdpGwClient {
UdpGwClient {
udp_mtu,
max_connections,
udp_timeout,
@ -220,7 +220,7 @@ impl UdpGwClient {
keepalive_time,
keepalive_packet,
server_connections,
};
}
}
pub(crate) fn get_udp_mtu(&self) -> u16 {
@ -259,7 +259,7 @@ impl UdpGwClient {
}
pub(crate) fn get_udpgw_bind_addr(&self) -> SocketAddr {
return self.udpgw_bind_addr;
self.udpgw_bind_addr
}
/// Heartbeat task asynchronous function to periodically check and maintain the active state of the server connection.
@ -281,7 +281,12 @@ impl UdpGwClient {
};
log::debug!("{:?}:{} send keepalive", stream_writer.inner.local_addr(), stream.id());
if let Err(e) = stream_writer.inner.write_all(&self.keepalive_packet).await {
log::warn!("{:?}:{} send keepalive failed: {}", stream_writer.inner.local_addr(), stream.id(), e);
log::warn!(
"{:?}:{} send keepalive failed: {}",
stream_writer.inner.local_addr(),
stream.id(),
e
);
} else {
match UdpGwClient::recv_udpgw_packet(self.udp_mtu, 10, &mut stream_reader).await {
Ok(UdpGwResponse::KeepAlive) => {
@ -372,14 +377,14 @@ impl UdpGwClient {
udp_stack: &mut IpStackUdpStream,
stream: &mut UdpGwClientStreamWriter,
) -> std::result::Result<usize, std::io::Error> {
return udp_stack.read(&mut stream.tmp_buf).await;
udp_stack.read(&mut stream.tmp_buf).await
}
pub(crate) async fn send_udp_packet<'a>(
packet: UdpGwData<'a>,
udp_stack: &mut IpStackUdpStream,
) -> std::result::Result<(), std::io::Error> {
return udp_stack.write_all(&packet.udpdata).await;
udp_stack.write_all(packet.udpdata).await
}
/// Receives a UDP gateway packet.
@ -394,24 +399,19 @@ impl UdpGwClient {
/// # Returns
/// - `Result<UdpGwResponse>`: Returns a result type containing the parsed UDP gateway response, or an error if one occurs.
pub(crate) async fn recv_udpgw_packet(udp_mtu: u16, udp_timeout: u64, stream: &mut UdpGwClientStreamReader) -> Result<UdpGwResponse> {
let result;
match tokio::time::timeout(
let result = match tokio::time::timeout(
tokio::time::Duration::from_secs(udp_timeout + 2),
stream.inner.read(&mut stream.recv_buf[..2]),
)
.await
{
Ok(ret) => {
result = ret;
}
Ok(ret) => ret,
Err(_e) => {
return Err(format!("wait tcp data timeout").into());
return Err(("wait tcp data timeout").into());
}
};
match result {
Ok(0) => {
return Err(format!("tcp connection closed").into());
}
Ok(0) => Err(("tcp connection closed").into()),
Ok(n) => {
if n < std::mem::size_of::<PackLenHeader>() {
return Err("received PackLenHeader error".into());
@ -435,9 +435,7 @@ impl UdpGwClient {
}
return UdpGwClient::parse_udp_response(udp_mtu, packet_len as usize, stream);
}
Err(_) => {
return Err("tcp read error".into());
}
Err(_) => Err("tcp read error".into()),
}
}
@ -518,7 +516,7 @@ impl UdpGwClient {
},
}
stream.inner.write_all(&packet).await?;
stream.inner.write_all(packet).await?;
Ok(())
}