chore: update Rust to 2024 edition (#2066)

easytier/src/tunnel/common.rs

@@ -3,10 +3,10 @@ use std::{
     net::{IpAddr, SocketAddr},
     pin::Pin,
     sync::{Arc, Mutex},
-    task::{ready, Poll},
+    task::{Poll, ready},
 };
 
-use futures::{stream::FuturesUnordered, Future, Sink, Stream};
+use futures::{Future, Sink, Stream, stream::FuturesUnordered};
 use network_interface::NetworkInterfaceConfig as _;
 use pin_project_lite::pin_project;
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
@@ -18,12 +18,12 @@ use zerocopy::FromBytes as _;
 
 use super::TunnelInfo;
 
-use crate::tunnel::packet_def::{ZCPacket, PEER_MANAGER_HEADER_SIZE};
+use crate::tunnel::packet_def::{PEER_MANAGER_HEADER_SIZE, ZCPacket};
 
 use super::{
-    buf::BufList,
-    packet_def::{TCPTunnelHeader, ZCPacketType, TCP_TUNNEL_HEADER_SIZE},
     SinkItem, StreamItem, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream,
+    buf::BufList,
+    packet_def::{TCP_TUNNEL_HEADER_SIZE, TCPTunnelHeader, ZCPacketType},
 };
 
 pub struct TunnelWrapper<R, W> {
@@ -454,7 +454,7 @@ pub mod tests {
 
     use crate::{
         common::netns::NetNS,
-        tunnel::{packet_def::ZCPacket, TunnelConnector, TunnelListener},
+        tunnel::{TunnelConnector, TunnelListener, packet_def::ZCPacket},
     };
 
     pub async fn _tunnel_echo_server(tunnel: Box<dyn super::Tunnel>, once: bool) {

easytier/src/tunnel/fake_tcp/mod.rs

@@ -17,11 +17,11 @@ use tokio::{io::AsyncReadExt, net::TcpStream, sync::Mutex};
 use crate::{
     common::scoped_task::ScopedTask,
     tunnel::{
-        common::TunnelWrapper,
-        fake_tcp::netfilter::create_tun,
-        packet_def::{ZCPacket, ZCPacketType, PEER_MANAGER_HEADER_SIZE, TCP_TUNNEL_HEADER_SIZE},
         FromUrl, IpVersion, SinkError, SinkItem, StreamItem, Tunnel, TunnelConnector, TunnelError,
         TunnelInfo, TunnelListener,
+        common::TunnelWrapper,
+        fake_tcp::netfilter::create_tun,
+        packet_def::{PEER_MANAGER_HEADER_SIZE, TCP_TUNNEL_HEADER_SIZE, ZCPacket, ZCPacketType},
     },
 };
 

easytier/src/tunnel/fake_tcp/netfilter/linux_bpf.rs

@@ -7,8 +7,8 @@ use std::mem;
 use std::net::IpAddr;
 use std::net::SocketAddr;
 use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::time::{Duration, Instant};
 use tokio::sync::Mutex;
 
@@ -182,13 +182,13 @@ fn build_tcp_filter(
     src_addr: Option<SocketAddr>,
     dst_addr: SocketAddr,
 ) -> io::Result<Vec<libc::sock_filter>> {
-    if let Some(src) = src_addr {
-        if src.is_ipv4() != dst_addr.is_ipv4() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "src/dst addr family mismatch",
-            ));
-        }
+    if let Some(src) = src_addr
+        && src.is_ipv4() != dst_addr.is_ipv4()
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "src/dst addr family mismatch",
+        ));
     }
 
     let mut b = BpfBuilder::new();
@@ -637,7 +637,7 @@ mod tests {
     use pnet::util::MacAddr;
     use rand::Rng;
     use std::net::{IpAddr, Ipv4Addr};
-    use tokio::time::{timeout, Duration};
+    use tokio::time::{Duration, timeout};
 
     fn is_root() -> bool {
         unsafe { libc::geteuid() == 0 }

easytier/src/tunnel/fake_tcp/netfilter/macos_bpf.rs

@@ -7,8 +7,8 @@ use std::mem;
 use std::net::IpAddr;
 use std::net::SocketAddr;
 use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use tokio::sync::Mutex;
 use tracing::{debug, info, warn};
 

easytier/src/tunnel/fake_tcp/netfilter/pnet.rs

@@ -2,8 +2,8 @@ use std::{
     io,
     net::{IpAddr, SocketAddr},
     sync::{
-        atomic::{AtomicU32, Ordering},
         Arc, Weak,
+        atomic::{AtomicU32, Ordering},
     },
 };
 
@@ -25,10 +25,10 @@ fn filter_tcp_packet(
     src_addr: Option<&SocketAddr>,
     dst_addr: Option<&SocketAddr>,
 ) -> bool {
+    use pnet::packet::Packet;
     use pnet::packet::ethernet::EthernetPacket;
     use pnet::packet::ipv4::Ipv4Packet;
     use pnet::packet::tcp::TcpPacket;
-    use pnet::packet::Packet;
 
     let ethernet = if let Some(ethernet) = EthernetPacket::new(packet) {
         ethernet

easytier/src/tunnel/fake_tcp/netfilter/windivert.rs

@@ -9,7 +9,7 @@ use tokio::sync::Mutex;
 use windivert::error::WinDivertError;
 use windivert::packet::WinDivertPacket;
 use windivert::prelude::{WinDivertFlags, WinDivertShutdownMode};
-use windivert::{layer, WinDivert};
+use windivert::{WinDivert, layer};
 
 use crate::tunnel::fake_tcp::stack;
 

easytier/src/tunnel/fake_tcp/stack.rs

@@ -44,14 +44,14 @@ use super::packet::*;
 use bytes::{Bytes, BytesMut};
 use crossbeam::atomic::AtomicCell;
 use pnet::packet::tcp::TcpOptionNumbers;
-use pnet::packet::{tcp, Packet};
+use pnet::packet::{Packet, tcp};
 use pnet::util::MacAddr;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::sync::{
-    atomic::{AtomicU32, Ordering},
     Arc, RwLock,
+    atomic::{AtomicU32, Ordering},
 };
 use tokio::sync::broadcast;
 use tokio::time;

easytier/src/tunnel/filter.rs

@@ -98,7 +98,7 @@ where
         }
     }
 
-    fn wrap_sink<S: ZCPacketSink + Unpin + 'static>(&self, sink: S) -> impl ZCPacketSink {
+    fn wrap_sink<S: ZCPacketSink + Unpin + 'static>(filter: Arc<F>, sink: S) -> impl ZCPacketSink {
         struct SinkWrapper<F, S> {
             sink: S,
             filter: Arc<F>,
@@ -143,13 +143,13 @@ where
             }
         }
 
-        SinkWrapper {
-            sink,
-            filter: self.filter.clone(),
-        }
+        SinkWrapper { sink, filter }
     }
 
-    fn wrap_stream<S: ZCPacketStream + Unpin + 'static>(&self, stream: S) -> impl ZCPacketStream {
+    fn wrap_stream<S: ZCPacketStream + Unpin + 'static>(
+        filter: Arc<F>,
+        stream: S,
+    ) -> impl ZCPacketStream {
         struct StreamWrapper<F, S> {
             stream: S,
             filter: Arc<F>,
@@ -186,10 +186,7 @@ where
             }
         }
 
-        StreamWrapper {
-            stream,
-            filter: self.filter.clone(),
-        }
+        StreamWrapper { stream, filter }
     }
 }
 
@@ -204,9 +201,10 @@ where
 
     fn split(&self) -> (Pin<Box<dyn ZCPacketStream>>, Pin<Box<dyn ZCPacketSink>>) {
         let (stream, sink) = self.inner.split();
+        let filter = self.filter.clone();
         (
-            Box::pin(self.wrap_stream(stream)),
-            Box::pin(self.wrap_sink(sink)),
+            Box::pin(Self::wrap_stream(filter.clone(), stream)),
+            Box::pin(Self::wrap_sink(filter, sink)),
         )
     }
 }
@@ -363,9 +361,9 @@ pub mod tests {
 
         let out = filter.filter_output();
 
-        let a = out.0 .0 .0 .1;
-        let b = out.0 .0 .1;
-        let c = out.0 .1;
+        let a = out.0.0.0.1;
+        let b = out.0.0.1;
+        let c = out.0.1;
         let _d = out.1;
 
         assert_eq!(1, a.0.len());

easytier/src/tunnel/mpsc.rs

@@ -7,9 +7,9 @@ use tokio::time::timeout;
 
 use crate::{common::scoped_task::ScopedTask, proto::common::TunnelInfo};
 
-use super::{packet_def::ZCPacket, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream};
+use super::{Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, packet_def::ZCPacket};
 
-use tokio::sync::mpsc::{channel, error::TrySendError, Receiver, Sender};
+use tokio::sync::mpsc::{Receiver, Sender, channel, error::TrySendError};
 // use tachyonix::{channel, Receiver, Sender, TrySendError};
 
 use futures::SinkExt;
@@ -141,9 +141,9 @@ mod tests {
     use futures::StreamExt;
 
     use crate::tunnel::{
-        ring::{create_ring_tunnel_pair, RING_TUNNEL_CAP},
-        tcp::{TcpTunnelConnector, TcpTunnelListener},
         TunnelConnector, TunnelListener,
+        ring::{RING_TUNNEL_CAP, create_ring_tunnel_pair},
+        tcp::{TcpTunnelConnector, TcpTunnelListener},
     };
 
     use super::*;

easytier/src/tunnel/packet_def.rs

@@ -1,9 +1,9 @@
 use bytes::Bytes;
 use bytes::BytesMut;
-use zerocopy::byteorder::*;
 use zerocopy::AsBytes;
 use zerocopy::FromBytes;
 use zerocopy::FromZeroes;
+use zerocopy::byteorder::*;
 
 type DefaultEndian = LittleEndian;
 

easytier/src/tunnel/quic.rs

@@ -7,15 +7,15 @@ use std::{
 };
 
 use crate::tunnel::{
-    common::{setup_sokcet2, FramedReader, FramedWriter, TunnelWrapper},
     FromUrl, TunnelInfo,
+    common::{FramedReader, FramedWriter, TunnelWrapper, setup_sokcet2},
 };
 use anyhow::Context;
 
 use super::{IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener};
 use quinn::{
-    congestion::BbrConfig, udp::RecvMeta, AsyncUdpSocket, ClientConfig, Connection, Endpoint,
-    EndpointConfig, ServerConfig, TransportConfig, UdpPoller,
+    AsyncUdpSocket, ClientConfig, Connection, Endpoint, EndpointConfig, ServerConfig,
+    TransportConfig, UdpPoller, congestion::BbrConfig, udp::RecvMeta,
 };
 
 pub fn transport_config() -> Arc<TransportConfig> {
@@ -309,8 +309,8 @@ impl TunnelConnector for QuicTunnelConnector {
 #[cfg(test)]
 mod tests {
     use crate::tunnel::{
-        common::tests::{_tunnel_bench, _tunnel_pingpong},
         IpVersion, TunnelConnector,
+        common::tests::{_tunnel_bench, _tunnel_pingpong},
     };
 
     use super::*;

easytier/src/tunnel/ring.rs

@@ -1,10 +1,10 @@
-use async_ringbuf::{traits::*, AsyncHeapCons, AsyncHeapProd, AsyncHeapRb};
+use async_ringbuf::{AsyncHeapCons, AsyncHeapProd, AsyncHeapRb, traits::*};
 use crossbeam::atomic::AtomicCell;
 use std::{
     collections::HashMap,
     fmt::Debug,
     sync::Arc,
-    task::{ready, Poll},
+    task::{Poll, ready},
 };
 
 use async_trait::async_trait;
@@ -18,8 +18,8 @@ use uuid::Uuid;
 use crate::tunnel::{FromUrl, IpVersion, SinkError, SinkItem};
 
 use super::{
-    build_url_from_socket_addr, common::TunnelWrapper, StreamItem, Tunnel, TunnelConnector,
-    TunnelError, TunnelInfo, TunnelListener,
+    StreamItem, Tunnel, TunnelConnector, TunnelError, TunnelInfo, TunnelListener,
+    build_url_from_socket_addr, common::TunnelWrapper,
 };
 
 pub static RING_TUNNEL_CAP: usize = 128;

easytier/src/tunnel/tcp.rs

@@ -7,8 +7,8 @@ use futures::stream::FuturesUnordered;
 use tokio::net::{TcpListener, TcpSocket, TcpStream};
 
 use super::{
-    common::{wait_for_connect_futures, FramedReader, FramedWriter, TunnelWrapper},
     IpVersion, Tunnel, TunnelError, TunnelListener,
+    common::{FramedReader, FramedWriter, TunnelWrapper, wait_for_connect_futures},
 };
 
 const TCP_MTU_BYTES: usize = 2000;
@@ -216,8 +216,8 @@ impl super::TunnelConnector for TcpTunnelConnector {
 #[cfg(test)]
 mod tests {
     use crate::tunnel::{
-        common::tests::{_tunnel_bench, _tunnel_pingpong},
         TunnelConnector,
+        common::tests::{_tunnel_bench, _tunnel_pingpong},
     };
 
     use super::*;

easytier/src/tunnel/udp.rs

@@ -8,7 +8,7 @@ use anyhow::Context;
 use async_trait::async_trait;
 use bytes::BytesMut;
 use dashmap::DashMap;
-use futures::{stream::FuturesUnordered, SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt, stream::FuturesUnordered};
 use rand::{Rng, SeedableRng};
 use zerocopy::{AsBytes, FromBytes};
 
@@ -19,20 +19,20 @@ use tokio::{
     task::JoinSet,
 };
 
-use tracing::{instrument, Instrument};
+use tracing::{Instrument, instrument};
 
 use super::{
-    common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures},
-    packet_def::{UDPTunnelHeader, V6HolePunchPacket, UDP_TUNNEL_HEADER_SIZE},
-    ring::{RingSink, RingStream},
     FromUrl, IpVersion, Tunnel, TunnelConnCounter, TunnelError, TunnelInfo, TunnelListener,
     TunnelUrl,
+    common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures},
+    packet_def::{UDP_TUNNEL_HEADER_SIZE, UDPTunnelHeader, V6HolePunchPacket},
+    ring::{RingSink, RingStream},
 };
 use crate::{
     common::{join_joinset_background, scoped_task::ScopedTask, shrink_dashmap},
     tunnel::{
         build_url_from_socket_addr,
-        common::{reserve_buf, TunnelWrapper},
+        common::{TunnelWrapper, reserve_buf},
         packet_def::{UdpPacketType, ZCPacket, ZCPacketType},
         ring::RingTunnel,
     },
@@ -150,8 +150,8 @@ async fn respond_stun_packet(
     use crate::common::stun_codec_ext::*;
     use bytecodec::{DecodeExt as _, EncodeExt as _};
     use stun_codec::{
-        rfc5389::{attributes::XorMappedAddress, methods::BINDING},
         Message, MessageClass, MessageDecoder, MessageEncoder,
+        rfc5389::{attributes::XorMappedAddress, methods::BINDING},
     };
 
     let mut decoder = MessageDecoder::<Attribute>::new();
@@ -884,11 +884,11 @@ mod tests {
     use crate::{
         common::global_ctx::tests::get_mock_global_ctx,
         tunnel::{
+            TunnelConnector,
             common::{
                 get_interface_name_by_ip,
                 tests::{_tunnel_bench, _tunnel_echo_server, _tunnel_pingpong, wait_for_condition},
             },
-            TunnelConnector,
         },
     };
 

easytier/src/tunnel/unix.rs

@@ -1,13 +1,13 @@
 use std::path::Path;
 
 use async_trait::async_trait;
-use tokio::net::{unix::SocketAddr, UnixListener, UnixStream};
+use tokio::net::{UnixListener, UnixStream, unix::SocketAddr};
 
 use super::TunnelInfo;
 
 use super::{
-    common::{FramedReader, FramedWriter, TunnelWrapper},
     IpVersion, Tunnel, TunnelError, TunnelListener,
+    common::{FramedReader, FramedWriter, TunnelWrapper},
 };
 
 const MAX_PACKET_SIZE: usize = 4096;

easytier/src/tunnel/websocket.rs

@@ -1,14 +1,14 @@
 use super::{
-    common::{setup_sokcet2, wait_for_connect_futures, TunnelWrapper},
+    FromUrl, IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener,
+    common::{TunnelWrapper, setup_sokcet2, wait_for_connect_futures},
     insecure_tls::{get_insecure_tls_cert, init_crypto_provider},
     packet_def::{ZCPacket, ZCPacketType},
-    FromUrl, IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener,
 };
 use crate::{proto::common::TunnelInfo, tunnel::insecure_tls::get_insecure_tls_client_config};
 use anyhow::Context;
 use bytes::BytesMut;
 use forwarded_header_value::ForwardedHeaderValue;
-use futures::{stream::FuturesUnordered, SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt, stream::FuturesUnordered};
 use pnet::ipnetwork::IpNetwork;
 use std::{
     net::SocketAddr,
@@ -117,8 +117,7 @@ impl WsTunnelListener {
         if TRUSTED_PROXIES
             .iter()
             .any(|net| net.contains(peer_addr.ip()))
-        {
-            if let Some(forwarded) = request
+            && let Some(forwarded) = request
                 .headers()
                 .get("Forwarded")
                 .and_then(|f| f.to_str().ok())
@@ -130,16 +129,14 @@ impl WsTunnelListener {
                         .and_then(|f| f.to_str().ok())
                         .and_then(|f| ForwardedHeaderValue::from_x_forwarded_for(f).ok())
                 })
-            {
-                if let Some(ip) = forwarded.remotest_forwarded_for_ip() {
-                    remote_addr.set_host(Some(&ip.to_string())).map_err(|_| {
-                        TunnelError::InvalidAddr(format!("invalid forwarded ip {}", ip))
-                    })?;
-                    remote_addr
-                        .query_pairs_mut()
-                        .append_pair("proxy", &peer_addr.to_string());
-                }
-            }
+            && let Some(ip) = forwarded.remotest_forwarded_for_ip()
+        {
+            remote_addr
+                .set_host(Some(&ip.to_string()))
+                .map_err(|_| TunnelError::InvalidAddr(format!("invalid forwarded ip {}", ip)))?;
+            remote_addr
+                .query_pairs_mut()
+                .append_pair("proxy", &peer_addr.to_string());
         }
 
         let (write, read) = stream.split();

easytier/src/tunnel/wireguard.rs

@@ -2,7 +2,7 @@ use std::{
     fmt::{Debug, Formatter},
     net::SocketAddr,
     pin::Pin,
-    sync::{atomic::AtomicBool, Arc},
+    sync::{Arc, atomic::AtomicBool},
     time::Duration,
 };
 
@@ -10,30 +10,30 @@ use anyhow::Context;
 use async_recursion::async_recursion;
 use async_trait::async_trait;
 use boringtun::{
-    noise::{errors::WireGuardError, Tunn, TunnResult},
+    noise::{Tunn, TunnResult, errors::WireGuardError},
     x25519::{PublicKey, StaticSecret},
 };
 use bytes::BytesMut;
 use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
-use futures::{stream::FuturesUnordered, SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt, stream::FuturesUnordered};
 use rand::RngCore;
 use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet};
 
 use super::{
-    common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures},
-    generate_digest_from_str,
-    packet_def::{ZCPacketType, PEER_MANAGER_HEADER_SIZE},
-    ring::create_ring_tunnel_pair,
     FromUrl, IpVersion, Tunnel, TunnelError, TunnelInfo, TunnelListener, TunnelUrl, ZCPacketSink,
     ZCPacketStream,
+    common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures},
+    generate_digest_from_str,
+    packet_def::{PEER_MANAGER_HEADER_SIZE, ZCPacketType},
+    ring::create_ring_tunnel_pair,
 };
 use crate::{
     common::shrink_dashmap,
     tunnel::{
         build_url_from_socket_addr,
         common::TunnelWrapper,
-        packet_def::{ZCPacket, WG_TUNNEL_HEADER_SIZE},
+        packet_def::{WG_TUNNEL_HEADER_SIZE, ZCPacket},
     },
 };
 
@@ -331,11 +331,7 @@ impl WgPeerData {
     }
 
     fn remove_ip_header<'a>(&self, packet: &'a [u8], is_v4: bool) -> &'a [u8] {
-        if is_v4 {
-            &packet[20..]
-        } else {
-            &packet[40..]
-        }
+        if is_v4 { &packet[20..] } else { &packet[40..] }
     }
 }
 
@@ -772,8 +768,8 @@ impl super::TunnelConnector for WgTunnelConnector {
 pub mod tests {
     use super::*;
     use crate::tunnel::{
-        common::tests::{_tunnel_bench, _tunnel_pingpong},
         TunnelConnector,
+        common::tests::{_tunnel_bench, _tunnel_pingpong},
     };
     use boringtun::*;