clippy all codes (#1214)

1. clippy code
2. add fmt and clippy check in ci

easytier/src/tunnel/common.rs

@@ -145,8 +145,7 @@ where
                 return Poll::Ready(None);
             }
 
-            while let Some(packet) =
-                Self::extract_one_packet(self_mut.buf, *self_mut.max_packet_size)
+            if let Some(packet) = Self::extract_one_packet(self_mut.buf, *self_mut.max_packet_size)
             {
                 if let Err(TunnelError::InvalidPacket(msg)) = packet.as_ref() {
                     self_mut
@@ -157,7 +156,7 @@ where
             }
 
             reserve_buf(
-                &mut self_mut.buf,
+                self_mut.buf,
                 *self_mut.max_packet_size,
                 *self_mut.max_packet_size * 2,
             );
@@ -186,12 +185,12 @@ where
 }
 
 pub trait ZCPacketToBytes {
-    fn into_bytes(&self, zc_packet: ZCPacket) -> Result<Bytes, TunnelError>;
+    fn zcpacket_into_bytes(&self, zc_packet: ZCPacket) -> Result<Bytes, TunnelError>;
 }
 
 pub struct TcpZCPacketToBytes;
 impl ZCPacketToBytes for TcpZCPacketToBytes {
-    fn into_bytes(&self, item: ZCPacket) -> Result<Bytes, TunnelError> {
+    fn zcpacket_into_bytes(&self, item: ZCPacket) -> Result<Bytes, TunnelError> {
         let mut item = item.convert_type(ZCPacketType::TCP);
 
         let tcp_len = PEER_MANAGER_HEADER_SIZE + item.payload_len();
@@ -280,7 +279,9 @@ where
 
     fn start_send(self: Pin<&mut Self>, item: ZCPacket) -> Result<(), Self::Error> {
         let pinned = self.project();
-        pinned.sending_bufs.push(pinned.converter.into_bytes(item)?);
+        pinned
+            .sending_bufs
+            .push(pinned.converter.zcpacket_into_bytes(item)?);
 
         Ok(())
     }
@@ -461,14 +462,13 @@ pub mod tests {
                     continue;
                 };
                 tracing::debug!(?msg, "recv a msg, try echo back");
-                if let Err(_) = send.send(msg).await {
+                if send.send(msg).await.is_err() {
                     break;
                 }
             }
         } else {
             let Some(ret) = recv.next().await else {
-                assert!(false, "recv error");
-                return;
+                panic!("recv error");
             };
 
             if ret.is_err() {
@@ -597,7 +597,7 @@ pub mod tests {
                 let elapsed_sec = now.elapsed().as_secs();
                 if elapsed_sec > 0 {
                     bps_clone.store(
-                        count as u64 / now.elapsed().as_secs() as u64,
+                        count as u64 / now.elapsed().as_secs(),
                         std::sync::atomic::Ordering::Relaxed,
                     );
                 }
@@ -621,7 +621,7 @@ pub mod tests {
         while now.elapsed().as_secs() < 10 {
             // send.feed(item)
             let item = ZCPacket::new_with_payload(send_buf.as_ref());
-            let _ = send.feed(item).await.unwrap();
+            send.feed(item).await.unwrap();
         }
 
         send.close().await.unwrap();
@@ -649,7 +649,7 @@ pub mod tests {
             .init();
     }
 
-    pub async fn wait_for_condition<F, FRet>(mut condition: F, timeout: std::time::Duration) -> ()
+    pub async fn wait_for_condition<F, FRet>(mut condition: F, timeout: std::time::Duration)
     where
         F: FnMut() -> FRet + Send,
         FRet: Future<Output = bool>,

easytier/src/tunnel/filter.rs

@@ -227,7 +227,7 @@ impl TunnelFilter for PacketRecorderTunnelFilter {
     fn after_received(&self, data: StreamItem) -> Option<StreamItem> {
         match data {
             Ok(v) => {
-                self.sent.lock().unwrap().push(v.clone().into());
+                self.sent.lock().unwrap().push(v.clone());
                 Some(Ok(v))
             }
             Err(e) => Some(Err(e)),
@@ -242,6 +242,12 @@ impl TunnelFilter for PacketRecorderTunnelFilter {
     }
 }
 
+impl Default for PacketRecorderTunnelFilter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl PacketRecorderTunnelFilter {
     pub fn new() -> Self {
         Self {
@@ -278,6 +284,12 @@ impl TunnelFilter for StatsRecorderTunnelFilter {
     }
 }
 
+impl Default for StatsRecorderTunnelFilter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl StatsRecorderTunnelFilter {
     pub fn new() -> Self {
         Self {

easytier/src/tunnel/mod.rs

@@ -90,9 +90,11 @@ impl<T> ZCPacketStream for T where T: Stream<Item = StreamItem> + Send {}
 pub trait ZCPacketSink: Sink<SinkItem, Error = SinkError> + Send {}
 impl<T> ZCPacketSink for T where T: Sink<SinkItem, Error = SinkError> + Send {}
 
+pub type SplitTunnel = (Pin<Box<dyn ZCPacketStream>>, Pin<Box<dyn ZCPacketSink>>);
+
 #[auto_impl::auto_impl(Box, Arc)]
 pub trait Tunnel: Send {
-    fn split(&self) -> (Pin<Box<dyn ZCPacketStream>>, Pin<Box<dyn ZCPacketSink>>);
+    fn split(&self) -> SplitTunnel;
     fn info(&self) -> Option<TunnelInfo>;
 }
 
@@ -189,7 +191,7 @@ where
         return Err(TunnelError::InvalidProtocol(url.scheme().to_string()));
     }
 
-    Ok(T::from_url(url.clone(), ip_version).await?)
+    T::from_url(url.clone(), ip_version).await
 }
 
 fn default_port(scheme: &str) -> Option<u16> {
@@ -269,7 +271,7 @@ impl TunnelUrl {
             if s.is_empty() {
                 None
             } else {
-                Some(String::from_utf8(percent_encoding::percent_decode_str(&s).collect()).unwrap())
+                Some(String::from_utf8(percent_encoding::percent_decode_str(s).collect()).unwrap())
             }
         })
     }

easytier/src/tunnel/mpsc.rs

@@ -86,12 +86,9 @@ impl<T: Tunnel> MpscTunnel<T> {
         sink.feed(initial_item).await?;
 
         while let Ok(item) = rx.try_recv() {
-            match sink.feed(item).await {
-                Err(e) => {
-                    tracing::error!(?e, "feed error");
-                    return Err(e);
-                }
-                Ok(_) => {}
+            if let Err(e) = sink.feed(item).await {
+                tracing::error!(?e, "feed error");
+                return Err(e);
             }
         }
 

easytier/src/tunnel/packet_def.rs

@@ -423,7 +423,7 @@ impl ZCPacket {
         let total_len = payload_off + payload.len();
         ret.inner.reserve(total_len);
         unsafe { ret.inner.set_len(total_len) };
-        ret.mut_payload()[..payload.len()].copy_from_slice(&payload);
+        ret.mut_payload()[..payload.len()].copy_from_slice(payload);
         ret
     }
 
@@ -440,7 +440,7 @@ impl ZCPacket {
         dst_peer_id: u32,
         foreign_zc_packet: &ZCPacket,
     ) -> Self {
-        let foreign_network_hdr = ForeignNetworkPacketHeader::new(dst_peer_id, &network_name);
+        let foreign_network_hdr = ForeignNetworkPacketHeader::new(dst_peer_id, network_name);
         let total_payload_len =
             foreign_network_hdr.get_header_len() + foreign_zc_packet.tunnel_payload().len();
 
@@ -639,7 +639,7 @@ impl ZCPacket {
             return Self::new_from_buf(buf, target_packet_type);
         }
 
-        return Self::new_from_buf(self.inner.split_off(new_offset), target_packet_type);
+        Self::new_from_buf(self.inner.split_off(new_offset), target_packet_type)
     }
 
     pub fn into_bytes(self) -> Bytes {
@@ -656,7 +656,7 @@ impl ZCPacket {
 
     pub fn is_lossy(&self) -> bool {
         self.peer_manager_header()
-            .and_then(|hdr| Some(hdr.packet_type == PacketType::Data as u8))
+            .map(|hdr| hdr.packet_type == PacketType::Data as u8)
             .unwrap_or(false)
     }
 

easytier/src/tunnel/quic.rs

@@ -90,8 +90,8 @@ impl AsyncUdpSocket for NoGroAsyncUdpSocket {
 pub fn make_server_endpoint(bind_addr: SocketAddr) -> Result<(Endpoint, Vec<u8>), Box<dyn Error>> {
     let (server_config, server_cert) = configure_server()?;
     let socket = std::net::UdpSocket::bind(bind_addr)?;
-    let runtime = quinn::default_runtime()
-        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::Other, "no async runtime found"))?;
+    let runtime =
+        quinn::default_runtime().ok_or_else(|| std::io::Error::other("no async runtime found"))?;
     let mut endpoint_config = EndpointConfig::default();
     endpoint_config.max_udp_payload_size(1200)?;
     let socket = NoGroAsyncUdpSocket {
@@ -110,7 +110,7 @@ pub fn make_server_endpoint(bind_addr: SocketAddr) -> Result<(Endpoint, Vec<u8>)
 pub fn configure_server() -> Result<(ServerConfig, Vec<u8>), Box<dyn Error>> {
     let (certs, key) = get_insecure_tls_cert();
 
-    let mut server_config = ServerConfig::with_single_cert(certs.clone(), key.into())?;
+    let mut server_config = ServerConfig::with_single_cert(certs.clone(), key)?;
     let transport_config = Arc::get_mut(&mut server_config.transport).unwrap();
     transport_config.max_concurrent_uni_streams(10_u8.into());
     transport_config.max_concurrent_bidi_streams(10_u8.into());
@@ -123,8 +123,6 @@ pub fn configure_server() -> Result<(ServerConfig, Vec<u8>), Box<dyn Error>> {
 #[allow(unused)]
 pub const ALPN_QUIC_HTTP: &[&[u8]] = &[b"hq-29"];
 
-/// Runs a QUIC server bound to given address.
-
 struct ConnWrapper {
     conn: Connection,
 }

easytier/src/tunnel/ring.rs

@@ -47,7 +47,7 @@ impl RingTunnel {
         let ring_impl = AsyncHeapRb::new(std::cmp::max(RING_TUNNEL_RESERVERD_CAP * 2, cap));
         let (ring_prod_impl, ring_cons_impl) = ring_impl.split();
         Self {
-            id: id.clone(),
+            id,
             ring_cons_impl: AtomicCell::new(Some(ring_cons_impl)),
             ring_prod_impl: AtomicCell::new(Some(ring_prod_impl)),
         }
@@ -74,7 +74,7 @@ pub struct RingStream {
 impl RingStream {
     pub fn new(tunnel: Arc<RingTunnel>) -> Self {
         Self {
-            id: tunnel.id.clone(),
+            id: tunnel.id,
             ring_cons_impl: tunnel.ring_cons_impl.take().unwrap(),
         }
     }
@@ -113,7 +113,7 @@ pub struct RingSink {
 impl RingSink {
     pub fn new(tunnel: Arc<RingTunnel>) -> Self {
         Self {
-            id: tunnel.id.clone(),
+            id: tunnel.id,
             ring_prod_impl: tunnel.ring_prod_impl.take().unwrap(),
         }
     }
@@ -181,9 +181,10 @@ struct Connection {
     server: Arc<RingTunnel>,
 }
 
-static CONNECTION_MAP: Lazy<
-    Arc<std::sync::Mutex<HashMap<uuid::Uuid, UnboundedSender<Arc<Connection>>>>>,
-> = Lazy::new(|| Arc::new(std::sync::Mutex::new(HashMap::new())));
+type ConnectionMap = HashMap<uuid::Uuid, UnboundedSender<Arc<Connection>>>;
+
+static CONNECTION_MAP: Lazy<Arc<std::sync::Mutex<ConnectionMap>>> =
+    Lazy::new(|| Arc::new(std::sync::Mutex::new(HashMap::new())));
 
 #[derive(Debug)]
 pub struct RingTunnelListener {
@@ -315,10 +316,7 @@ impl TunnelConnector for RingTunnelConnector {
         tracing::info!("connecting");
         let conn = Arc::new(Connection {
             client: Arc::new(RingTunnel::new(RING_TUNNEL_CAP)),
-            server: Arc::new(RingTunnel::new_with_id(
-                remote_addr.clone(),
-                RING_TUNNEL_CAP,
-            )),
+            server: Arc::new(RingTunnel::new_with_id(remote_addr, RING_TUNNEL_CAP)),
         });
         entry
             .send(conn.clone())

easytier/src/tunnel/tcp.rs

@@ -155,7 +155,7 @@ impl TcpTunnelConnector {
         tracing::info!(url = ?self.addr, ?addr, "connect tcp start, bind addrs: {:?}", self.bind_addrs);
         let stream = TcpStream::connect(addr).await?;
         tracing::info!(url = ?self.addr, ?addr, "connect tcp succ");
-        return get_tunnel_with_tcp_stream(stream, self.addr.clone().into());
+        get_tunnel_with_tcp_stream(stream, self.addr.clone())
     }
 
     async fn connect_with_custom_bind(
@@ -179,11 +179,11 @@ impl TcpTunnelConnector {
             }
 
             let socket = TcpSocket::from_std_stream(socket2_socket.into());
-            futures.push(socket.connect(addr.clone()));
+            futures.push(socket.connect(addr));
         }
 
         let ret = wait_for_connect_futures(futures).await;
-        return get_tunnel_with_tcp_stream(ret?, self.addr.clone().into());
+        get_tunnel_with_tcp_stream(ret?, self.addr.clone())
     }
 }
 

easytier/src/tunnel/udp.rs

@@ -68,7 +68,7 @@ fn new_syn_packet(conn_id: u32, magic: u64) -> ZCPacket {
             header.conn_id.set(conn_id);
             header.len.set(8);
         },
-        Some(&mut magic.to_le_bytes()),
+        Some(&magic.to_le_bytes()),
     )
 }
 
@@ -79,7 +79,7 @@ fn new_sack_packet(conn_id: u32, magic: u64) -> ZCPacket {
             header.conn_id.set(conn_id);
             header.len.set(8);
         },
-        Some(&mut magic.to_le_bytes()),
+        Some(&magic.to_le_bytes()),
     )
 }
 
@@ -94,7 +94,7 @@ pub fn new_hole_punch_packet(tid: u32, buf_len: u16) -> ZCPacket {
             header.conn_id.set(tid);
             header.len.set(buf_len);
         },
-        Some(&mut buf),
+        Some(&buf),
     )
 }
 
@@ -116,7 +116,7 @@ pub fn new_v6_hole_punch_packet(dst: &SocketAddrV6) -> ZCPacket {
 }
 
 fn extrace_dst_addr_from_hole_punch_packet(buf: &[u8]) -> Option<SocketAddrV6> {
-    let body = V6HolePunchPacket::ref_from_prefix(&buf[..])?;
+    let body = V6HolePunchPacket::ref_from_prefix(buf)?;
     let ip = Ipv6Addr::from(body.dst_ipv6);
     Some(SocketAddrV6::new(ip, body.dst_port.get(), 0, 0))
 }
@@ -173,9 +173,7 @@ async fn respond_stun_packet(
         // we discard the prefix, make sure our implementation is not compatible with other stun client
         u32_to_tid(tid_to_u32(&tid)),
     );
-    resp_msg.add_attribute(Attribute::XorMappedAddress(XorMappedAddress::new(
-        addr.clone(),
-    )));
+    resp_msg.add_attribute(Attribute::XorMappedAddress(XorMappedAddress::new(addr)));
 
     let mut encoder = MessageEncoder::new();
     let rsp_buf = encoder
@@ -189,7 +187,7 @@ async fn respond_stun_packet(
 
     if !change_req {
         socket
-            .send_to(&rsp_buf, addr.clone())
+            .send_to(&rsp_buf, addr)
             .await
             .with_context(|| "send stun response error")?;
     } else {
@@ -199,7 +197,7 @@ async fn respond_stun_packet(
         } else {
             UdpSocket::bind("[::]:0").await?
         };
-        socket.send_to(&rsp_buf, addr.clone()).await?;
+        socket.send_to(&rsp_buf, addr).await?;
     }
 
     tracing::debug!(?addr, ?req_msg, ?change_req, "udp respond stun packet done");
@@ -241,9 +239,7 @@ async fn forward_from_ring_to_udp(
 ) -> Option<TunnelError> {
     tracing::debug!("udp forward from ring to udp");
     loop {
-        let Some(buf) = ring_recv.next().await else {
-            return None;
-        };
+        let buf = ring_recv.next().await?;
         let packet = match buf {
             Ok(v) => v,
             Err(e) => {
@@ -271,7 +267,7 @@ async fn forward_from_ring_to_udp(
 
 async fn udp_recv_from_socket_forward_task<F>(socket: Arc<UdpSocket>, allow_stun: bool, mut f: F)
 where
-    F: FnMut(ZCPacket, SocketAddr) -> (),
+    F: FnMut(ZCPacket, SocketAddr),
 {
     let mut buf = BytesMut::new();
     loop {
@@ -355,10 +351,8 @@ impl UdpConnection {
             if let Err(e) = self.ring_sender.try_send(zc_packet) {
                 tracing::trace!(?e, "ring sender full, drop lossy packet");
             }
-        } else {
-            if let Err(e) = self.ring_sender.force_send(zc_packet) {
-                tracing::trace!(?e, "ring sender full, drop non-lossy packet");
-            }
+        } else if let Err(e) = self.ring_sender.force_send(zc_packet) {
+            tracing::trace!(?e, "ring sender full, drop non-lossy packet");
         }
 
         Ok(())
@@ -389,7 +383,7 @@ impl UdpTunnelListenerData {
         }
     }
 
-    async fn handle_new_connect(self: Self, remote_addr: SocketAddr, zc_packet: ZCPacket) {
+    async fn handle_new_connect(self, remote_addr: SocketAddr, zc_packet: ZCPacket) {
         let udp_payload = zc_packet.udp_payload();
         if udp_payload.len() != 8 {
             tracing::warn!(
@@ -482,7 +476,6 @@ impl UdpTunnelListenerData {
                 tracing::error!(?e, "udp send hole punch packet error");
             }
             tracing::debug!(?dst_addr, "udp forward packet send hole punch packet");
-            return;
         } else if header.msg_type != UdpPacketType::HolePunch as u8 {
             let Some(mut conn) = self.sock_map.get_mut(&addr) else {
                 tracing::trace!(?header, "udp forward packet error, connection not found");
@@ -496,7 +489,7 @@ impl UdpTunnelListenerData {
         }
     }
 
-    async fn do_forward_task(self: Self) {
+    async fn do_forward_task(self) {
         let socket = self.socket.as_ref().unwrap().clone();
         udp_recv_from_socket_forward_task(socket, true, |zc_packet, addr| {
             self.do_forward_one_packet_to_conn(zc_packet, addr);
@@ -587,7 +580,7 @@ impl TunnelListener for UdpTunnelListener {
 
     async fn accept(&mut self) -> Result<Box<dyn super::Tunnel>, super::TunnelError> {
         tracing::info!("start udp accept: {:?}", self.addr);
-        while let Some(conn) = self.conn_recv.recv().await {
+        if let Some(conn) = self.conn_recv.recv().await {
             return Ok(conn);
         }
         return Err(super::TunnelError::InternalError(
@@ -739,7 +732,6 @@ impl UdpTunnelConnector {
                 tokio::select! {
                     _ = close_event_recv.recv() => {
                         tracing::debug!("connector udp close event");
-                        return;
                     }
                     _ = udp_recv_from_socket_forward_task(socket_clone,false, |zc_packet, addr| {
                         tracing::trace!(?addr, "connector udp forward task done");
@@ -748,7 +740,6 @@ impl UdpTunnelConnector {
                         }
                     }) => {
                         tracing::debug!("connector udp forward task done");
-                        return;
                     }
                 }
             }
@@ -1023,9 +1014,9 @@ mod tests {
         let bind_dev = get_interface_name_by_ip(&IpAddr::V4(ips[0].into()));
 
         for ip in ips {
-            println!("bind to ip: {:?}, {:?}", ip, bind_dev);
+            println!("bind to ip: {}, {:?}", ip, bind_dev);
             let addr = check_scheme_and_get_socket_addr::<SocketAddr>(
-                &format!("udp://{}:11111", ip.to_string()).parse().unwrap(),
+                &format!("udp://{}:11111", ip).parse().unwrap(),
                 "udp",
                 IpVersion::Both,
             )

easytier/src/tunnel/websocket.rs

@@ -36,9 +36,9 @@ async fn sink_from_zc_packet<E>(msg: ZCPacket) -> Result<Message, E> {
 async fn map_from_ws_message(
     msg: Result<Message, tokio_websockets::Error>,
 ) -> Option<Result<ZCPacket, TunnelError>> {
-    if msg.is_err() {
-        tracing::error!(?msg, "recv from websocket error");
-        return Some(Err(TunnelError::WebSocketError(msg.unwrap_err())));
+    if let Err(e) = msg {
+        tracing::error!(?e, "recv from websocket error");
+        return Some(Err(TunnelError::WebSocketError(e)));
     }
 
     let msg = msg.unwrap();
@@ -101,15 +101,15 @@ impl WSTunnelListener {
             let (write, read) = server_bulder.accept(stream).await?.split();
 
             Box::new(TunnelWrapper::new(
-                read.filter_map(move |msg| map_from_ws_message(msg)),
-                write.with(move |msg| sink_from_zc_packet(msg)),
+                read.filter_map(map_from_ws_message),
+                write.with(sink_from_zc_packet),
                 Some(info),
             ))
         } else {
             let (write, read) = server_bulder.accept(stream).await?.split();
             Box::new(TunnelWrapper::new(
-                read.filter_map(move |msg| map_from_ws_message(msg)),
-                write.with(move |msg| sink_from_zc_packet(msg)),
+                read.filter_map(map_from_ws_message),
+                write.with(sink_from_zc_packet),
                 Some(info),
             ))
         };
@@ -217,8 +217,8 @@ impl WSTunnelConnector {
 
         let (client, _) = c.connect_on(stream).await?;
         let (write, read) = client.split();
-        let read = read.filter_map(move |msg| map_from_ws_message(msg));
-        let write = write.with(move |msg| sink_from_zc_packet(msg));
+        let read = read.filter_map(map_from_ws_message);
+        let write = write.with(sink_from_zc_packet);
         Ok(Box::new(TunnelWrapper::new(read, write, Some(info))))
     }
 

easytier/src/tunnel/wireguard.rs

@@ -65,7 +65,7 @@ impl WgConfig {
         let my_secret_key = StaticSecret::from(my_sec);
         let my_public_key = PublicKey::from(&my_secret_key);
         let peer_secret_key = StaticSecret::from(my_sec);
-        let peer_public_key = my_public_key.clone();
+        let peer_public_key = my_public_key;
 
         WgConfig {
             my_secret_key,
@@ -186,7 +186,7 @@ impl WgPeerData {
         recv_buf: &[u8],
     ) {
         let mut send_buf = vec![0u8; MAX_PACKET];
-        let data = &recv_buf[..];
+        let data = recv_buf;
         let decapsulate_result = {
             let mut peer = self.tunn.lock().await;
             peer.decapsulate(None, data, &mut send_buf)
@@ -325,9 +325,9 @@ impl WgPeerData {
 
     fn remove_ip_header<'a>(&self, packet: &'a [u8], is_v4: bool) -> &'a [u8] {
         if is_v4 {
-            return &packet[20..];
+            &packet[20..]
         } else {
-            return &packet[40..];
+            &packet[40..]
         }
     }
 }
@@ -351,7 +351,7 @@ impl WgPeer {
         WgPeer {
             tunn: Some(Mutex::new(Tunn::new(
                 config.my_secret_key.clone(),
-                config.peer_public_key.clone(),
+                config.peer_public_key,
                 None,
                 None,
                 rand::thread_rng().next_u32(),
@@ -513,7 +513,7 @@ impl WgTunnelListener {
 
             if !peer_map.contains_key(&addr) {
                 tracing::info!("New peer: {}", addr);
-                let mut wg = WgPeer::new(socket.clone(), config.clone(), addr.clone());
+                let mut wg = WgPeer::new(socket.clone(), config.clone(), addr);
                 let (stream, sink) = wg.start_and_get_tunnel().split();
                 let tunnel = Box::new(TunnelWrapper::new(
                     stream,
@@ -579,7 +579,7 @@ impl TunnelListener for WgTunnelListener {
     }
 
     async fn accept(&mut self) -> Result<Box<dyn Tunnel>, super::TunnelError> {
-        while let Some(tunnel) = self.conn_recv.recv().await {
+        if let Some(tunnel) = self.conn_recv.recv().await {
             tracing::info!(?tunnel, "Accepted tunnel");
             return Ok(tunnel);
         }
@@ -781,7 +781,7 @@ pub mod tests {
             my_secret_key: my_secret_key.clone(),
             my_public_key,
             peer_secret_key: their_secret_key.clone(),
-            peer_public_key: their_public_key.clone(),
+            peer_public_key: their_public_key,
             wg_type: WgType::InternalUse,
         };