From 718a623dff405a6f894349802a31998133cf01dc Mon Sep 17 00:00:00 2001 From: suchao Date: Sun, 20 Oct 2024 10:16:40 +0800 Subject: [PATCH] fix clippy and fmt and semver --- Cargo.toml | 2 +- src/bin/udpgw_server.rs | 17 ++++++----------- src/lib.rs | 20 ++++++++++++++------ src/udpgw.rs | 38 ++++++++++++++++++-------------------- 4 files changed, 39 insertions(+), 38 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 266d8f1..24ebc64 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/src/bin/udpgw_server.rs b/src/bin/udpgw_server.rs index 5d82229..9e1a728 100644 --- a/src/bin/udpgw_server.rs +++ b/src/bin/udpgw_server.rs @@ -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::() { @@ -230,11 +228,8 @@ async fn process_client_udp_req<'a>(args: &UdpGwArgs, tx: Sender>, 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>, 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; diff --git a/src/lib.rs b/src/lib.rs index fa506d7..7ee936d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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(()) diff --git a/src/udpgw.rs b/src/udpgw.rs index 3649043..26d47a5 100644 --- a/src/udpgw.rs +++ b/src/udpgw.rs @@ -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::() 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 { - 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`: 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 { - 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::() { 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(()) }