Perf improve (#59)

* improve perf

* fix forward

easytier/src/instance/listeners.rs

@@ -12,6 +12,7 @@ use crate::{
     },
     peers::peer_manager::PeerManager,
     tunnel::{
+        quic::QUICTunnelListener,
         ring::RingTunnelListener,
         tcp::TcpTunnelListener,
         udp::UdpTunnelListener,
@@ -20,6 +21,26 @@ use crate::{
     },
 };
 
+pub fn get_listener_by_url(
+    l: &url::Url,
+    ctx: ArcGlobalCtx,
+) -> Result<Box<dyn TunnelListener>, Error> {
+    Ok(match l.scheme() {
+        "tcp" => Box::new(TcpTunnelListener::new(l.clone())),
+        "udp" => Box::new(UdpTunnelListener::new(l.clone())),
+        "wg" => {
+            let nid = ctx.get_network_identity();
+            let wg_config =
+                WgConfig::new_from_network_identity(&nid.network_name, &nid.network_secret);
+            Box::new(WgTunnelListener::new(l.clone(), wg_config))
+        }
+        "quic" => Box::new(QUICTunnelListener::new(l.clone())),
+        _ => {
+            unreachable!("unsupported listener uri");
+        }
+    })
+}
+
 #[async_trait]
 pub trait TunnelHandlerForListener {
     async fn handle_tunnel(&self, tunnel: Box<dyn Tunnel>) -> Result<(), Error>;
@@ -62,24 +83,8 @@ impl<H: TunnelHandlerForListener + Send + Sync + 'static + Debug> ListenerManage
         .await?;
 
         for l in self.global_ctx.config.get_listener_uris().iter() {
-            match l.scheme() {
-                "tcp" => {
-                    self.add_listener(TcpTunnelListener::new(l.clone())).await?;
-                }
-                "udp" => {
-                    self.add_listener(UdpTunnelListener::new(l.clone())).await?;
-                }
-                "wg" => {
-                    let nid = self.global_ctx.get_network_identity();
-                    let wg_config =
-                        WgConfig::new_from_network_identity(&nid.network_name, &nid.network_secret);
-                    self.add_listener(WgTunnelListener::new(l.clone(), wg_config))
-                        .await?;
-                }
-                _ => {
-                    log::warn!("unsupported listener uri: {}", l);
-                }
-            }
+            let lis = get_listener_by_url(l, self.global_ctx.clone())?;
+            self.add_listener(lis).await?;
         }
 
         Ok(())

easytier/src/instance/virtual_nic.rs

@@ -19,11 +19,11 @@ use crate::{
 };
 
 use byteorder::WriteBytesExt as _;
-use bytes::BytesMut;
+use bytes::{BufMut, BytesMut};
 use futures::{lock::BiLock, ready, Stream};
 use pin_project_lite::pin_project;
-use tokio::io::AsyncWrite;
-use tokio_util::{bytes::Bytes, io::poll_read_buf};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_util::bytes::Bytes;
 use tun::{create_as_async, AsyncDevice, Configuration, Device as _, Layer};
 use zerocopy::{NativeEndian, NetworkEndian};
 
@@ -64,12 +64,24 @@ impl Stream for TunStream {
                 self_mut.cur_buf.set_len(*self_mut.payload_offset);
             }
         }
-        match ready!(poll_read_buf(g.as_pin_mut(), cx, &mut self_mut.cur_buf)) {
-            Ok(0) => Poll::Ready(None),
-            Ok(_n) => Poll::Ready(Some(Ok(ZCPacket::new_from_buf(
-                self_mut.cur_buf.split(),
-                ZCPacketType::NIC,
-            )))),
+        let buf = self_mut.cur_buf.chunk_mut().as_mut_ptr();
+        let buf = unsafe { std::slice::from_raw_parts_mut(buf, 2500) };
+        let mut buf = ReadBuf::new(buf);
+
+        let ret = ready!(g.as_pin_mut().poll_read(cx, &mut buf));
+        let len = buf.filled().len();
+        unsafe { self_mut.cur_buf.advance_mut(len) };
+
+        match ret {
+            Ok(_) => {
+                if len == 0 {
+                    return Poll::Ready(None);
+                }
+                Poll::Ready(Some(Ok(ZCPacket::new_from_buf(
+                    self_mut.cur_buf.split(),
+                    ZCPacketType::NIC,
+                ))))
+            }
             Err(err) => {
                 println!("tun stream error: {:?}", err);
                 Poll::Ready(None)