make tun dependency optional (#142)

* remove log crates
* remove udp/raw of smoltcp
* make tun as optional dependancy, compile for freebsd works

easytier/Cargo.toml

@@ -36,7 +36,6 @@ tracing-subscriber = { version = "0.3", features = [
     "time",
 ] }
 tracing-appender = "0.2.3"
-log = "0.4"
 thiserror = "1.0"
 auto_impl = "1.1.0"
 crossbeam = "0.8.4"
@@ -85,7 +84,9 @@ http = { version = "1", default-features = false, features = [
 tokio-rustls = { version = "0.26", default-features = false, optional = true }
 
 # for tap device
-tun = { package = "tun-easytier", version = "0.6.1", features = ["async"] }
+tun = { package = "tun-easytier", version = "0.6.1", features = [
+    "async",
+], optional = true }
 # for net ns
 nix = { version = "0.27", features = ["sched", "socket", "ioctl"] }
 
@@ -155,7 +156,14 @@ indexmap = { version = "~1.9.3", optional = false, features = ["std"] }
 
 atomic-shim = "0.2.0"
 
-smoltcp = { version = "0.11.0", optional = true }
+smoltcp = { version = "0.11.0", optional = true, default-features = false, features = [
+    "std",
+    "medium-ip",
+    "proto-ipv4",
+    "proto-ipv6",
+    "socket-tcp",
+    "async",
+] }
 parking_lot = { version = "0.12.0", optional = true }
 
 [target.'cfg(windows)'.dependencies]
@@ -182,13 +190,23 @@ defguard_wireguard_rs = "0.4.2"
 
 
 [features]
-default = ["wireguard", "mimalloc", "websocket", "smoltcp"]
-full = ["quic", "websocket", "wireguard", "mimalloc", "aes-gcm", "smoltcp"]
+default = ["wireguard", "mimalloc", "websocket", "smoltcp", "tun"]
+full = [
+    "quic",
+    "websocket",
+    "wireguard",
+    "mimalloc",
+    "aes-gcm",
+    "smoltcp",
+    "tun",
+]
 mips = ["aes-gcm", "mimalloc", "wireguard"]
+bsd = ["aes-gcm", "mimalloc", "smoltcp"]
 wireguard = ["dep:boringtun", "dep:ring"]
 quic = ["dep:quinn", "dep:rustls", "dep:rcgen"]
 mimalloc = ["dep:mimalloc-rust"]
 aes-gcm = ["dep:aes-gcm"]
+tun = ["dep:tun"]
 websocket = [
     "dep:tokio-websockets",
     "dep:http",

easytier/src/common/error.rs

@@ -10,8 +10,11 @@ use super::PeerId;
 pub enum Error {
     #[error("io error")]
     IOError(#[from] io::Error),
+
+    #[cfg(feature = "tun")]
     #[error("rust tun error {0}")]
     TunError(#[from] tun::Error),
+
     #[error("tunnel error {0}")]
     TunnelError(#[from] tunnel::TunnelError),
     #[error("Peer has no conn, PeerId: {0}")]

easytier/src/common/global_ctx.rs

@@ -128,7 +128,7 @@ impl GlobalCtx {
         if self.event_bus.receiver_count() != 0 {
             self.event_bus.send(event).unwrap();
         } else {
-            log::warn!("No subscriber for event: {:?}", event);
+            tracing::warn!("No subscriber for event: {:?}", event);
         }
     }
 

easytier/src/common/netns.rs

@@ -43,7 +43,7 @@ impl NetNSGuard {
         }
 
         let ns = std::fs::File::open(ns_path).unwrap();
-        log::info!(
+        tracing::info!(
             "[INIT NS] switching to new ns_name: {:?}, ns_file: {:?}",
             name,
             ns
@@ -59,7 +59,7 @@ impl Drop for NetNSGuard {
         if self.old_ns.is_none() {
             return;
         }
-        log::info!("[INIT NS] switching back to old ns, ns: {:?}", self.old_ns);
+        tracing::info!("[INIT NS] switching back to old ns, ns: {:?}", self.old_ns);
         setns(
             self.old_ns.as_ref().unwrap().as_fd(),
             CloneFlags::CLONE_NEWNET,

easytier/src/common/network.rs

@@ -51,7 +51,7 @@ impl InterfaceFilter {
     }
 }
 
-#[cfg(target_os = "macos")]
+#[cfg(any(target_os = "macos", target_os = "freebsd"))]
 impl InterfaceFilter {
     async fn is_interface_physical(interface_name: &str) -> bool {
         let output = tokio::process::Command::new("networksetup")

easytier/src/connector/direct.rs

@@ -220,7 +220,7 @@ impl DirectConnectorManager {
             }
             return Err(e);
         } else {
-            log::info!("try_connect_to_ip success, peer_id: {}", dst_peer_id);
+            tracing::info!("try_connect_to_ip success, peer_id: {}", dst_peer_id);
             return Ok(());
         }
     }
@@ -314,7 +314,7 @@ impl DirectConnectorManager {
         let mut has_succ = false;
         while let Some(ret) = tasks.join_next().await {
             if let Err(e) = ret {
-                log::error!("join direct connect task failed: {:?}", e);
+                tracing::error!("join direct connect task failed: {:?}", e);
             } else if let Ok(Ok(_)) = ret {
                 has_succ = true;
             }
@@ -345,7 +345,7 @@ impl DirectConnectorManager {
             }
         }
 
-        log::trace!("try direct connect to peer: {}", dst_peer_id);
+        tracing::trace!("try direct connect to peer: {}", dst_peer_id);
 
         let ip_list = peer_manager
             .get_peer_rpc_mgr()

easytier/src/connector/manual.rs

@@ -89,7 +89,7 @@ impl ManualConnectorManager {
     where
         T: TunnelConnector + 'static,
     {
-        log::info!("add_connector: {}", connector.remote_url());
+        tracing::info!("add_connector: {}", connector.remote_url());
         self.data.connectors.insert(
             connector.remote_url().into(),
             Arc::new(Mutex::new(Box::new(connector))),
@@ -102,7 +102,7 @@ impl ManualConnectorManager {
     }
 
     pub async fn remove_connector(&self, url: &str) -> Result<(), Error> {
-        log::info!("remove_connector: {}", url);
+        tracing::info!("remove_connector: {}", url);
         if !self.list_connectors().await.iter().any(|x| x.url == url) {
             return Err(Error::NotFound);
         }
@@ -163,7 +163,7 @@ impl ManualConnectorManager {
         data: Arc<ConnectorManagerData>,
         mut event_recv: Receiver<GlobalCtxEvent>,
     ) {
-        log::warn!("conn_mgr_routine started");
+        tracing::warn!("conn_mgr_routine started");
         let mut reconn_interval = tokio::time::interval(std::time::Duration::from_millis(
             use_global_var!(MANUAL_CONNECTOR_RECONNECT_INTERVAL_MS),
         ));
@@ -200,11 +200,11 @@ impl ManualConnectorManager {
                             data_clone.connectors.insert(dead_url.clone(), connector);
                         });
                     }
-                    log::info!("reconn_interval tick, done");
+                    tracing::info!("reconn_interval tick, done");
                 }
 
                 ret = reconn_result_recv.recv() => {
-                    log::warn!("reconn_tasks done, reconn result: {:?}", ret);
+                    tracing::warn!("reconn_tasks done, reconn result: {:?}", ret);
                 }
             }
         }
@@ -215,13 +215,13 @@ impl ManualConnectorManager {
             GlobalCtxEvent::PeerConnAdded(conn_info) => {
                 let addr = conn_info.tunnel.as_ref().unwrap().remote_addr.clone();
                 data.alive_conn_urls.lock().await.insert(addr);
-                log::warn!("peer conn added: {:?}", conn_info);
+                tracing::warn!("peer conn added: {:?}", conn_info);
             }
 
             GlobalCtxEvent::PeerConnRemoved(conn_info) => {
                 let addr = conn_info.tunnel.as_ref().unwrap().remote_addr.clone();
                 data.alive_conn_urls.lock().await.remove(&addr);
-                log::warn!("peer conn removed: {:?}", conn_info);
+                tracing::warn!("peer conn removed: {:?}", conn_info);
             }
 
             _ => {}
@@ -233,14 +233,14 @@ impl ManualConnectorManager {
         for it in data.removed_conn_urls.iter() {
             let url = it.key();
             if let Some(_) = data.connectors.remove(url) {
-                log::warn!("connector: {}, removed", url);
+                tracing::warn!("connector: {}, removed", url);
                 continue;
             } else if data.reconnecting.contains(url) {
-                log::warn!("connector: {}, reconnecting, remove later.", url);
+                tracing::warn!("connector: {}, reconnecting, remove later.", url);
                 remove_later.insert(url.clone());
                 continue;
             } else {
-                log::warn!("connector: {}, not found", url);
+                tracing::warn!("connector: {}, not found", url);
             }
         }
         data.removed_conn_urls.clear();
@@ -284,17 +284,17 @@ impl ManualConnectorManager {
         ));
 
         let _g = net_ns.guard();
-        log::info!("reconnect try connect... conn: {:?}", connector);
+        tracing::info!("reconnect try connect... conn: {:?}", connector);
         let tunnel = connector.lock().await.connect().await?;
-        log::info!("reconnect get tunnel succ: {:?}", tunnel);
+        tracing::info!("reconnect get tunnel succ: {:?}", tunnel);
         assert_eq!(
             dead_url,
             tunnel.info().unwrap().remote_addr,
             "info: {:?}",
             tunnel.info()
         );
         let (peer_id, conn_id) = data.peer_manager.add_client_tunnel(tunnel).await?;
-        log::info!("reconnect succ: {} {} {}", peer_id, conn_id, dead_url);
+        tracing::info!("reconnect succ: {} {} {}", peer_id, conn_id, dead_url);
         Ok(ReconnResult {
             dead_url,
             peer_id,
@@ -307,7 +307,7 @@ impl ManualConnectorManager {
         dead_url: String,
         connector: MutexConnector,
     ) -> Result<ReconnResult, Error> {
-        log::info!("reconnect: {}", dead_url);
+        tracing::info!("reconnect: {}", dead_url);
 
         let mut ip_versions = vec![];
         let u = url::Url::parse(&dead_url)
@@ -347,7 +347,7 @@ impl ManualConnectorManager {
                 ),
             )
             .await;
-            log::info!("reconnect: {} done, ret: {:?}", dead_url, ret);
+            tracing::info!("reconnect: {} done, ret: {:?}", dead_url, ret);
 
             if ret.is_ok() && ret.as_ref().unwrap().is_ok() {
                 reconn_ret = ret.unwrap();

easytier/src/easytier-core.rs

@@ -428,7 +428,7 @@ impl From<Cli> for TomlConfigLoader {
             f.mtu = mtu;
         }
         f.enable_exit_node = cli.enable_exit_node;
-        f.no_tun = cli.no_tun;
+        f.no_tun = cli.no_tun || cfg!(not(feature = "tun"));
         f.use_smoltcp = cli.use_smoltcp;
         cfg.set_flags(f);
 

easytier/src/gateway/tokio_smoltcp/mod.rs

@@ -18,9 +18,9 @@ pub use smoltcp;
 use smoltcp::{
     iface::{Config, Interface, Routes},
     time::{Duration, Instant},
-    wire::{HardwareAddress, IpAddress, IpCidr, IpProtocol, IpVersion},
+    wire::{HardwareAddress, IpAddress, IpCidr},
 };
-pub use socket::{RawSocket, TcpListener, TcpStream, UdpSocket};
+pub use socket::{TcpListener, TcpStream};
 pub use socket_allocator::BufferSize;
 use tokio::sync::Notify;
 
@@ -155,19 +155,6 @@ impl Net {
         )
         .await
     }
-    /// This function will create a new UDP socket and attempt to bind it to the `addr` provided.
-    pub async fn udp_bind(&self, addr: SocketAddr) -> io::Result<UdpSocket> {
-        let addr = self.set_address(addr);
-        UdpSocket::new(self.reactor.clone(), addr.into()).await
-    }
-    /// Creates a new raw socket.
-    pub async fn raw_socket(
-        &self,
-        ip_version: IpVersion,
-        ip_protocol: IpProtocol,
-    ) -> io::Result<RawSocket> {
-        RawSocket::new(self.reactor.clone(), ip_version, ip_protocol).await
-    }
     fn set_address(&self, mut addr: SocketAddr) -> SocketAddr {
         if addr.ip().is_unspecified() {
             addr.set_ip(match self.ip_addr.address() {

easytier/src/gateway/tokio_smoltcp/reactor.rs

@@ -153,8 +153,6 @@ impl Drop for Reactor {
         for (_, socket) in self.socket_allocator.sockets().lock().iter_mut() {
             match socket {
                 Socket::Tcp(tcp) => tcp.close(),
-                Socket::Raw(_) => {}
-                Socket::Udp(udp) => udp.close(),
                 #[allow(unreachable_patterns)]
                 _ => {}
             }