Merge branch 'cleanup-talpid-tunnel-unix-mod'

Cargo.toml

@@ -137,6 +137,7 @@ serde = "1.0.204"
 serde_json = "1.0.122"
 
 ipnetwork = "0.20"
+tun = { version = "0.7", features = ["async"] }
 
 # Test dependencies
 proptest = "1.4"

talpid-tunnel/Cargo.toml

@@ -24,8 +24,7 @@ jnix = { version = "0.5.1", features = ["derive"] }
 log = { workspace = true }
 
 [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
-tun = "0.7"
-nix = "0.23"
+tun = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
 talpid-windows = { path = "../talpid-windows" }

talpid-tunnel/src/tun_provider/mod.rs

@@ -35,6 +35,7 @@ cfg_if! {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct TunConfig {
     /// Interface name to use.
+    #[cfg(target_os = "linux")]
     pub name: Option<String>,
 
     /// IP addresses for the tunnel interface.
@@ -80,6 +81,7 @@ impl TunConfig {
 /// Android to route all traffic inside the tunnel.
 pub fn blocking_config() -> TunConfig {
     TunConfig {
+        #[cfg(target_os = "linux")]
         name: None,
         addresses: vec![IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1))],
         mtu: 1380,

talpid-tunnel/src/tun_provider/unix.rs

@@ -1,11 +1,10 @@
 use super::TunConfig;
-use nix::fcntl;
 #[cfg(target_os = "macos")]
 use std::io;
 use std::{
     net::IpAddr,
     ops::Deref,
-    os::unix::io::{AsRawFd, IntoRawFd, RawFd},
+    os::unix::io::{AsRawFd, RawFd},
 };
 use tun::{AbstractDevice, Configuration};
 
@@ -31,10 +30,6 @@ pub enum Error {
     #[error("Unable to open a tunnel device")]
     CreateDevice(#[source] tun::Error),
 
-    /// Failed to apply async flags to tunnel device
-    #[error("Failed to apply async flags to tunnel device")]
-    SetDeviceAsync(#[source] nix::Error),
-
     /// Failed to enable/disable link device
     #[error("Failed to enable/disable link device")]
     ToggleDevice(#[source] tun::Error),
@@ -66,10 +61,11 @@ impl UnixTunProvider {
             #[allow(unused_mut)]
             let mut builder = TunnelDeviceBuilder::default();
             #[cfg(target_os = "linux")]
-            builder.enable_packet_information();
-            #[cfg(target_os = "linux")]
-            if let Some(ref name) = self.config.name {
-                builder.name(name);
+            {
+                builder.enable_packet_information();
+                if let Some(ref name) = self.config.name {
+                    builder.name(name);
+                }
             }
             builder.create()?
         };
@@ -106,28 +102,21 @@ impl Deref for UnixTun {
 
 /// A tunnel device
 pub struct TunnelDevice {
-    dev: tun::Device,
+    dev: tun::AsyncDevice,
 }
 
 /// A tunnel device builder.
 ///
 /// Call [`Self::create`] to create [`TunnelDevice`] from the config.
+#[derive(Default)]
 pub struct TunnelDeviceBuilder {
     config: Configuration,
 }
 
 impl TunnelDeviceBuilder {
     /// Create a [`TunnelDevice`] from this builder.
     pub fn create(self) -> Result<TunnelDevice, Error> {
-        fn apply_async_flags(fd: RawFd) -> Result<(), nix::Error> {
-            fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFL)?;
-            let arg = fcntl::FcntlArg::F_SETFL(fcntl::OFlag::O_RDWR | fcntl::OFlag::O_NONBLOCK);
-            fcntl::fcntl(fd, arg)?;
-            Ok(())
-        }
-
-        let dev = tun::create(&self.config).map_err(Error::CreateDevice)?;
-        apply_async_flags(dev.as_raw_fd()).map_err(Error::SetDeviceAsync)?;
+        let dev = tun::create_as_async(&self.config).map_err(Error::CreateDevice)?;
         Ok(TunnelDevice { dev })
     }
 
@@ -152,25 +141,12 @@ impl TunnelDeviceBuilder {
     }
 }
 
-impl Default for TunnelDeviceBuilder {
-    fn default() -> Self {
-        let config = Configuration::default();
-        Self { config }
-    }
-}
-
 impl AsRawFd for TunnelDevice {
     fn as_raw_fd(&self) -> RawFd {
         self.dev.as_raw_fd()
     }
 }
 
-impl IntoRawFd for TunnelDevice {
-    fn into_raw_fd(self) -> RawFd {
-        self.dev.into_raw_fd()
-    }
-}
-
 impl TunnelDevice {
     #[cfg(target_os = "linux")]
     fn set_ip(&mut self, ip: IpAddr) -> Result<(), Error> {