feat(shadowsocks-service): local-tun removed dependency of tun on not supported platforms

Making non-supported platforms to be able to build with the default
"full" feature set.

Author: zonyitoo

crates/shadowsocks-service/Cargo.toml

@@ -178,7 +178,6 @@ flate2 = { version = "1.0", optional = true }
 brotli = { version = "8.0", optional = true }
 zstd = { version = "0.13", optional = true }
 
-tun = { version = "0.7", optional = true, features = ["async"] }
 etherparse = { version = "0.18", optional = true }
 smoltcp = { version = "0.12", optional = true, default-features = false, features = [
     "std",
@@ -206,6 +205,9 @@ nix = { version = "0.29", features = ["ioctl"] }
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.59", features = ["Win32_Networking_WinSock"] }
 
+[target.'cfg(any(target_os = "ios", target_os = "macos", target_os = "linux", target_os = "android", target_os = "windows", target_os = "freebsd"))'.dependencies]
+tun = { version = "0.7", optional = true, features = ["async"] }
+
 [dev-dependencies]
 byteorder = "1.5"
 env_logger = "0.11"

crates/shadowsocks-service/src/local/redir/sys/mod.rs

@@ -12,6 +12,7 @@ cfg_if! {
 }
 
 #[cfg(unix)]
+#[allow(dead_code)]
 pub fn set_ipv6_only<S>(socket: &S, ipv6_only: bool) -> io::Result<()>
 where
     S: std::os::unix::io::AsRawFd,

crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/mod.rs

@@ -10,5 +10,8 @@ cfg_if! {
                         target_os = "openbsd"))] {
         mod bsd;
         pub use self::bsd::*;
+    } else {
+        mod not_supported;
+        pub use self::not_supported::*;
     }
 }

crates/shadowsocks-service/src/local/redir/tcprelay/sys/unix/not_supported.rs

@@ -0,0 +1,21 @@
+use std::{io, net::SocketAddr};
+
+use shadowsocks::net::AcceptOpts;
+use tokio::net::{TcpListener, TcpStream};
+
+use crate::{
+    config::RedirType,
+    local::redir::redir_ext::{TcpListenerRedirExt, TcpStreamRedirExt},
+};
+
+impl TcpListenerRedirExt for TcpListener {
+    async fn bind_redir(_ty: RedirType, _addr: SocketAddr, _accept_opts: AcceptOpts) -> io::Result<TcpListener> {
+        unimplemented!("TCP transparent proxy is not supported on this platform")
+    }
+}
+
+impl TcpStreamRedirExt for TcpStream {
+    fn destination_addr(&self, _ty: RedirType) -> io::Result<SocketAddr> {
+        unimplemented!("TCP transparent proxy is not supported on this platform")
+    }
+}

crates/shadowsocks-service/src/local/redir/udprelay/sys/unix/not_supported.rs

@@ -1,4 +1,8 @@
-use std::{io, net::SocketAddr};
+use std::{
+    io,
+    net::SocketAddr,
+    task::{Context, Poll},
+};
 
 use crate::{
     config::RedirType,

crates/shadowsocks-service/src/local/tun/fake_tun.rs

@@ -1,5 +1,7 @@
 //! Fake `tun` for those platforms that doesn't support `tun`
 
+#![allow(dead_code)]
+
 use std::{
     io::{self, Read, Write},
     net::IpAddr,
@@ -9,7 +11,142 @@ use std::{
 };
 
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tun::{AbstractDevice, Configuration, Error as TunError};
+
+/// TUN interface OSI layer of operation.
+#[derive(Clone, Copy, Default, Debug, Eq, PartialEq)]
+pub enum Layer {
+    L2,
+    #[default]
+    L3,
+}
+
+/// Configuration builder for a TUN interface.
+#[derive(Clone, Default, Debug)]
+pub struct Configuration;
+
+impl Configuration {
+    /// Set the tun name.
+    ///
+    /// [Note: on macOS, the tun name must be the form `utunx` where `x` is a number, such as `utun3`. -- end note]
+    pub fn tun_name<S: AsRef<str>>(&mut self, _tun_name: S) -> &mut Self {
+        self
+    }
+
+    /// Set the address.
+    pub fn address(&mut self, _value: IpAddr) -> &mut Self {
+        self
+    }
+
+    /// Set the destination address.
+    pub fn destination(&mut self, _value: IpAddr) -> &mut Self {
+        self
+    }
+
+    /// Set the broadcast address.
+    pub fn broadcast(&mut self, _value: IpAddr) -> &mut Self {
+        self
+    }
+
+    /// Set the netmask.
+    pub fn netmask(&mut self, _value: IpAddr) -> &mut Self {
+        self
+    }
+
+    /// Set the MTU.
+    pub fn mtu(&mut self, _value: u16) -> &mut Self {
+        self
+    }
+
+    /// Set the interface to be enabled once created.
+    pub fn up(&mut self) -> &mut Self {
+        self
+    }
+
+    /// Set the interface to be disabled once created.
+    pub fn down(&mut self) -> &mut Self {
+        self
+    }
+
+    /// Set the OSI layer of operation.
+    pub fn layer(&mut self, _value: Layer) -> &mut Self {
+        self
+    }
+
+    /// Set the raw fd.
+    #[cfg(unix)]
+    pub fn raw_fd(&mut self, _fd: ::std::os::fd::RawFd) -> &mut Self {
+        self
+    }
+}
+
+/// tun Error type
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("not implementated")]
+    NotImplemented,
+
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+}
+
+pub type Result<T, E = Error> = ::std::result::Result<T, E>;
+
+/// A TUN abstract device interface.
+pub trait AbstractDevice: Read + Write {
+    /// Reconfigure the device.
+    fn configure(&mut self, _config: &Configuration) -> Result<()> {
+        Ok(())
+    }
+
+    /// Get the device index.
+    fn tun_index(&self) -> Result<i32>;
+
+    /// Get the device tun name.
+    fn tun_name(&self) -> Result<String>;
+
+    /// Set the device tun name.
+    fn set_tun_name(&mut self, tun_name: &str) -> Result<()>;
+
+    /// Turn on or off the interface.
+    fn enabled(&mut self, value: bool) -> Result<()>;
+
+    /// Get the address.
+    fn address(&self) -> Result<IpAddr>;
+
+    /// Set the address.
+    fn set_address(&mut self, value: IpAddr) -> Result<()>;
+
+    /// Get the destination address.
+    fn destination(&self) -> Result<IpAddr>;
+
+    /// Set the destination address.
+    fn set_destination(&mut self, value: IpAddr) -> Result<()>;
+
+    /// Get the broadcast address.
+    fn broadcast(&self) -> Result<IpAddr>;
+
+    /// Set the broadcast address.
+    fn set_broadcast(&mut self, value: IpAddr) -> Result<()>;
+
+    /// Get the netmask.
+    fn netmask(&self) -> Result<IpAddr>;
+
+    /// Set the netmask.
+    fn set_netmask(&mut self, value: IpAddr) -> Result<()>;
+
+    /// Get the MTU.
+    fn mtu(&self) -> Result<u16>;
+
+    /// Set the MTU.
+    ///
+    /// [Note: This setting has no effect on the Windows platform due to the mtu of wintun is always 65535. --end note]
+    fn set_mtu(&mut self, value: u16) -> Result<()>;
+
+    /// Return whether the underlying tun device on the platform has packet information
+    ///
+    /// [Note: This value is not used to specify whether the packets delivered from/to tun have packet information. -- end note]
+    fn packet_information(&self) -> bool;
+}
 
 pub struct FakeQueue;
 
@@ -32,60 +169,60 @@ impl Write for FakeQueue {
 pub struct FakeDevice;
 
 impl AbstractDevice for FakeDevice {
-    fn tun_name(&self) -> tun::Result<String> {
-        Err(TunError::NotImplemented)
+    fn tun_name(&self) -> Result<String> {
+        Err(Error::NotImplemented)
     }
 
-    fn tun_index(&self) -> tun::Result<i32> {
-        Err(TunError::NotImplemented)
+    fn tun_index(&self) -> Result<i32> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_tun_name(&mut self, _: &str) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_tun_name(&mut self, _: &str) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn enabled(&mut self, _: bool) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn enabled(&mut self, _: bool) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn address(&self) -> tun::Result<IpAddr> {
-        Err(TunError::NotImplemented)
+    fn address(&self) -> Result<IpAddr> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_address(&mut self, _: IpAddr) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_address(&mut self, _: IpAddr) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn destination(&self) -> tun::Result<IpAddr> {
-        Err(TunError::NotImplemented)
+    fn destination(&self) -> Result<IpAddr> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_destination(&mut self, _: IpAddr) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_destination(&mut self, _: IpAddr) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn broadcast(&self) -> tun::Result<IpAddr> {
-        Err(TunError::NotImplemented)
+    fn broadcast(&self) -> Result<IpAddr> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_broadcast(&mut self, _: IpAddr) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_broadcast(&mut self, _: IpAddr) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn netmask(&self) -> tun::Result<IpAddr> {
-        Err(TunError::NotImplemented)
+    fn netmask(&self) -> Result<IpAddr> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_netmask(&mut self, _: IpAddr) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_netmask(&mut self, _: IpAddr) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
-    fn mtu(&self) -> tun::Result<u16> {
-        Err(TunError::NotImplemented)
+    fn mtu(&self) -> Result<u16> {
+        Err(Error::NotImplemented)
     }
 
-    fn set_mtu(&mut self, _: u16) -> tun::Result<()> {
-        Err(TunError::NotImplemented)
+    fn set_mtu(&mut self, _: u16) -> Result<()> {
+        Err(Error::NotImplemented)
     }
 
     fn packet_information(&self) -> bool {
@@ -158,6 +295,6 @@ impl AsyncWrite for AsyncDevice {
 }
 
 /// Create a TUN device with the given name.
-pub fn create_as_async(_: &Configuration) -> Result<AsyncDevice, TunError> {
-    Err(TunError::NotImplemented)
+pub fn create_as_async(_: &Configuration) -> Result<AsyncDevice, Error> {
+    Err(Error::NotImplemented)
 }

crates/shadowsocks-service/src/local/tun/mod.rs

@@ -33,10 +33,10 @@ cfg_if! {
             create_as_async, AsyncDevice, Configuration as TunConfiguration, AbstractDevice, Error as TunError, Layer,
         };
     } else {
-        use tun::{AbstractDevice, Configuration as TunConfiguration, Error as TunError, Layer};
-
         mod fake_tun;
-        use self::fake_tun::{create_as_async, AsyncDevice};
+        use self::fake_tun::{
+            AbstractDevice, AsyncDevice, Configuration as TunConfiguration, Error as TunError, Layer, create_as_async,
+        };
     }
 }