feat(local-tun): changed dependency from tun to tun2

tun (rust-tun) author was lost contact for a long time. Changed to
another actively maintained fork: tun2.

- fixes #1546, removed dependency of ioctl-sys

Author: zonyitoo

Cargo.lock

@@ -93,7 +93,7 @@ local-tunnel = ["local"]
 # Enable socks4 protocol for sslocal
 local-socks4 = ["local"]
 # Enable Tun interface protocol for sslocal
-local-tun = ["local", "etherparse", "tun", "smoltcp"]
+local-tun = ["local", "etherparse", "tun2", "smoltcp"]
 # Enable Fake DNS
 local-fake-dns = ["local", "trust-dns", "sled", "bson"]
 # sslocal support online URL (SIP008 Online Configuration Delivery)
@@ -167,7 +167,7 @@ ipnet = "2.9"
 iprange = "0.6"
 regex = "1.4"
 
-tun = { version = "0.6", optional = true, features = ["async"] }
+tun2 = { version = "1", optional = true, features = ["async"] }
 etherparse = { version = "0.15", optional = true }
 smoltcp = { version = "0.11", optional = true, default-features = false, features = [
     "std",

crates/shadowsocks-service/Cargo.toml

@@ -2,13 +2,13 @@
 
 use std::{
     io::{self, Read, Write},
-    net::Ipv4Addr,
+    net::IpAddr,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tun::{Configuration, Device, Error as TunError};
+use tun2::{AbstractDevice, Configuration, Error as TunError};
 
 pub struct FakeQueue;
 
@@ -30,63 +30,61 @@ impl Write for FakeQueue {
 
 pub struct FakeDevice;
 
-impl Device for FakeDevice {
-    type Queue = FakeQueue;
-
-    fn name(&self) -> tun::Result<String> {
+impl AbstractDevice for FakeDevice {
+    fn tun_name(&self) -> tun2::Result<String> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_name(&mut self, _: &str) -> tun::Result<()> {
+    fn set_tun_name(&mut self, _: &str) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn enabled(&mut self, _: bool) -> tun::Result<()> {
+    fn enabled(&mut self, _: bool) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn address(&self) -> tun::Result<Ipv4Addr> {
+    fn address(&self) -> tun2::Result<IpAddr> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_address(&mut self, _: Ipv4Addr) -> tun::Result<()> {
+    fn set_address(&mut self, _: IpAddr) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn destination(&self) -> tun::Result<Ipv4Addr> {
+    fn destination(&self) -> tun2::Result<IpAddr> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_destination(&mut self, _: Ipv4Addr) -> tun::Result<()> {
+    fn set_destination(&mut self, _: IpAddr) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn broadcast(&self) -> tun::Result<Ipv4Addr> {
+    fn broadcast(&self) -> tun2::Result<IpAddr> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_broadcast(&mut self, _: Ipv4Addr) -> tun::Result<()> {
+    fn set_broadcast(&mut self, _: IpAddr) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn netmask(&self) -> tun::Result<Ipv4Addr> {
+    fn netmask(&self) -> tun2::Result<IpAddr> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_netmask(&mut self, _: Ipv4Addr) -> tun::Result<()> {
+    fn set_netmask(&mut self, _: IpAddr) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn mtu(&self) -> tun::Result<i32> {
+    fn mtu(&self) -> tun2::Result<u16> {
         Err(TunError::NotImplemented)
     }
 
-    fn set_mtu(&mut self, _: i32) -> tun::Result<()> {
+    fn set_mtu(&mut self, _: u16) -> tun2::Result<()> {
         Err(TunError::NotImplemented)
     }
 
-    fn queue(&mut self, _: usize) -> Option<&mut Self::Queue> {
-        None
+    fn packet_information(&self) -> bool {
+        false
     }
 }
 
@@ -108,12 +106,14 @@ impl Write for FakeDevice {
 
 pub struct AsyncDevice(FakeDevice);
 
-impl AsyncDevice {
-    pub fn get_ref(&self) -> &FakeDevice {
+impl AsRef<FakeDevice> for AsyncDevice {
+    fn as_ref(&self) -> &FakeDevice {
         &self.0
     }
+}
 
-    pub fn get_mut(&mut self) -> &mut FakeDevice {
+impl AsMut<FakeDevice> for AsyncDevice {
+    fn as_mut(&mut self) -> &mut FakeDevice {
         &mut self.0
     }
 }

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

@@ -4,14 +4,14 @@
 use std::os::unix::io::RawFd;
 use std::{
     io::{self, ErrorKind},
-    net::{IpAddr, Ipv4Addr, SocketAddr},
+    net::{IpAddr, SocketAddr},
     sync::Arc,
     time::Duration,
 };
 
 use byte_string::ByteStr;
 use cfg_if::cfg_if;
-use ipnet::{IpNet, Ipv4Net};
+use ipnet::IpNet;
 use log::{debug, error, info, trace, warn};
 use shadowsocks::config::Mode;
 use smoltcp::wire::{IpProtocol, TcpPacket, UdpPacket};
@@ -23,11 +23,11 @@ cfg_if! {
                  target_os = "linux",
                  target_os = "android",
                  target_os = "windows"))] {
-        use tun::{
-            create_as_async, AsyncDevice, Configuration as TunConfiguration, Device as TunDevice, Error as TunError, Layer,
+        use tun2::{
+            create_as_async, AsyncDevice, Configuration as TunConfiguration, AbstractDevice, Error as TunError, Layer,
         };
     } else {
-        use tun::{Configuration as TunConfiguration, Device as TunDevice, Error as TunError, Layer};
+        use tun2::{AbstractDevice, Configuration as TunConfiguration, Error as TunError, Layer};
 
         mod fake_tun;
         use self::fake_tun::{create_as_async, AsyncDevice};
@@ -84,7 +84,7 @@ impl TunBuilder {
     }
 
     pub fn name(&mut self, name: &str) {
-        self.tun_config.name(name);
+        self.tun_config.tun_name(name);
     }
 
     #[cfg(unix)]
@@ -130,7 +130,7 @@ impl TunBuilder {
         let tcp = TcpTun::new(
             self.context,
             self.balancer,
-            device.get_ref().mtu().unwrap_or(1500) as u32,
+            device.as_ref().mtu().unwrap_or(1500) as u32,
         );
 
         Ok(Tun {
@@ -157,37 +157,37 @@ pub struct Tun {
 impl Tun {
     /// Start serving
     pub async fn run(mut self) -> io::Result<()> {
-        if let Ok(mtu) = self.device.get_ref().mtu() {
+        if let Ok(mtu) = self.device.as_ref().mtu() {
             assert!(mtu > 0 && mtu as usize > IFF_PI_PREFIX_LEN);
         }
 
         info!(
             "shadowsocks tun device {}, mode {}",
             self.device
-                .get_ref()
-                .name()
+                .as_ref()
+                .tun_name()
                 .or_else(|r| Ok::<_, ()>(r.to_string()))
                 .unwrap(),
             self.mode,
         );
 
-        let address = match self.device.get_ref().address() {
+        let address = match self.device.as_ref().address() {
             Ok(a) => a,
             Err(err) => {
                 error!("[TUN] failed to get device address, error: {}", err);
                 return Err(io::Error::new(io::ErrorKind::Other, err));
             }
         };
 
-        let netmask = match self.device.get_ref().netmask() {
+        let netmask = match self.device.as_ref().netmask() {
             Ok(n) => n,
             Err(err) => {
                 error!("[TUN] failed to get device netmask, error: {}", err);
                 return Err(io::Error::new(io::ErrorKind::Other, err));
             }
         };
 
-        let address_net = match Ipv4Net::with_netmask(address, netmask) {
+        let address_net = match IpNet::with_netmask(address, netmask) {
             Ok(n) => n,
             Err(err) => {
                 error!("[TUN] invalid address {}, netmask {}, error: {}", address, netmask, err);
@@ -203,7 +203,7 @@ impl Tun {
         );
 
         // Set default route
-        if let Err(err) = sys::set_route_configuration(self.device.get_mut()).await {
+        if let Err(err) = sys::set_route_configuration(self.device.as_mut()).await {
             warn!("[TUN] tun device set route failed, error: {}", err);
         }
 
@@ -266,7 +266,7 @@ impl Tun {
         }
     }
 
-    async fn handle_tun_frame(&mut self, device_broadcast_addr: &Ipv4Addr, frame: &[u8]) -> smoltcp::wire::Result<()> {
+    async fn handle_tun_frame(&mut self, device_broadcast_addr: &IpAddr, frame: &[u8]) -> smoltcp::wire::Result<()> {
         let packet = match IpPacket::new_checked(frame)? {
             Some(packet) => packet,
             None => {

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

@@ -4,7 +4,7 @@ use std::{
 };
 
 use tokio::io::{AsyncWrite, AsyncWriteExt};
-use tun::Device;
+use tun2::Device;
 
 /// Packet Information length in bytes
 pub const IFF_PI_PREFIX_LEN: usize = 0;
@@ -15,9 +15,9 @@ pub async fn write_packet_with_pi<W: AsyncWrite + Unpin>(writer: &mut W, packet:
 }
 
 /// Set platform specific route configuration
-pub async fn set_route_configuration<Q>(_: &mut (dyn Device<Queue = Q> + Send)) -> io::Result<()>
+pub async fn set_route_configuration<D>(device: &mut D) -> io::Result<()>
 where
-    Q: Read + Write,
+    D: AbstractDevice,
 {
     Ok(())
 }

crates/shadowsocks-service/src/local/tun/sys/others.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use tokio::io::{AsyncWrite, AsyncWriteExt};
-use tun::Device;
+use tun2::AbstractDevice;
 
 /// Packet Information length in bytes
 ///
@@ -19,9 +19,9 @@ pub async fn write_packet_with_pi<W: AsyncWrite + Unpin>(writer: &mut W, packet:
 }
 
 /// Set platform specific route configuration
-pub async fn set_route_configuration<Q>(_: &mut (dyn Device<Queue = Q> + Send)) -> io::Result<()>
+pub async fn set_route_configuration<D>(device: &mut D) -> io::Result<()>
 where
-    Q: Read + Write,
+    D: AbstractDevice,
 {
     Ok(())
 }