fixup! Add daita as a cargo feature

Author: MarkusPettersson98

mullvad-types/src/wireguard.rs

@@ -57,6 +57,8 @@ pub struct QuantumResistantStateParseError;
 
 #[cfg(feature = "daita")]
 #[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(target_os = "android", derive(IntoJava, FromJava))]
+#[cfg_attr(target_os = "android", jnix(package = "net.mullvad.mullvadvpn.model"))]
 pub struct DaitaSettings {
     pub enabled: bool,
 }

talpid-wireguard/src/lib.rs

@@ -6,11 +6,11 @@ use self::config::Config;
 #[cfg(windows)]
 use futures::channel::mpsc;
 use futures::future::{abortable, AbortHandle as FutureAbortHandle, BoxFuture, Future};
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", not(feature = "daita")))]
 use once_cell::sync::Lazy;
 #[cfg(target_os = "android")]
 use std::borrow::Cow;
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", not(feature = "daita")))]
 use std::env;
 #[cfg(windows)]
 use std::io;
@@ -199,7 +199,7 @@ impl Drop for ObfuscatorHandle {
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", not(feature = "daita")))]
 /// Overrides the preference for the kernel module for WireGuard.
 static FORCE_USERSPACE_WIREGUARD: Lazy<bool> = Lazy::new(|| {
     env::var("TALPID_FORCE_USERSPACE_WIREGUARD")
@@ -753,21 +753,20 @@ impl WireguardMonitor {
         Ok(ephemeral.psk)
     }
 
-    #[cfg(all(not(target_os = "windows"), not(feature = "daita")))]
-    #[allow(unused_variables)]
+    // TODO(markus): De-duplicate parts of different `open_tunnel`implementations.
+
+    /// Linux can use the kernel implementation of Wireguard and fall back to WireguardGo.
+    /// Note that when DAITA is enabled, only WireguardGo may be used.
+    #[cfg(all(target_os = "linux", not(feature = "daita")))]
     fn open_tunnel(
         runtime: tokio::runtime::Handle,
         config: &Config,
         log_path: Option<&Path>,
-        resource_dir: &Path,
+        _resource_dir: &Path,
         tun_provider: Arc<Mutex<TunProvider>>,
-        #[cfg(target_os = "android")] gateway_only: bool,
     ) -> Result<TunnelT> {
         log::debug!("Tunnel MTU: {}", config.mtu);
-
-        let daita = true;
-        #[cfg(target_os = "linux")]
-        if !daita && !*FORCE_USERSPACE_WIREGUARD {
+        if !*FORCE_USERSPACE_WIREGUARD {
             if will_nm_manage_dns() {
                 match wireguard_kernel::NetworkManagerTunnel::new(runtime, config) {
                     Ok(tunnel) => {
@@ -801,15 +800,14 @@ impl WireguardMonitor {
             }
         }
 
+        // TODO: `wireguard_go` is *currently* implied when building for Linux, but that might not
+        // always be true. When that assumptions is not uphold anymore, the kernel-only version of
+        // this function will have to return any errors instead of falling back to WireguardGo.
         #[cfg(wireguard_go)]
         {
             let routes =
                 Self::get_tunnel_destinations(config).flat_map(Self::replace_default_prefixes);
 
-            #[cfg(target_os = "android")]
-            let config = Self::patch_allowed_ips(config, gateway_only);
-
-            #[cfg(target_os = "linux")]
             log::debug!("Using userspace WireGuard implementation");
             Ok(Box::new(
                 WgGoTunnel::start_tunnel(
@@ -826,7 +824,34 @@ impl WireguardMonitor {
         }
     }
 
-    #[cfg(all(not(target_os = "windows"), feature = "daita", wireguard_go))]
+    #[cfg(all(target_os = "linux", feature = "daita"))]
+    fn open_tunnel(
+        _runtime: tokio::runtime::Handle,
+        config: &Config,
+        log_path: Option<&Path>,
+        resource_dir: &Path,
+        tun_provider: Arc<Mutex<TunProvider>>,
+    ) -> Result<TunnelT> {
+        log::debug!("Tunnel MTU: {}", config.mtu);
+
+        let routes = Self::get_tunnel_destinations(config).flat_map(Self::replace_default_prefixes);
+
+        Ok(Box::new(
+            WgGoTunnel::start_tunnel(
+                #[allow(clippy::needless_borrow)]
+                &config,
+                log_path,
+                tun_provider,
+                routes,
+                #[cfg(feature = "daita")]
+                resource_dir,
+            )
+            .map_err(Error::TunnelError)?,
+        ))
+    }
+
+    /// Both Android and macOS uses WireguardGo.
+    #[cfg(any(target_os = "macos", target_os = "android"))]
     #[allow(unused_variables)]
     fn open_tunnel(
         runtime: tokio::runtime::Handle,
@@ -838,14 +863,11 @@ impl WireguardMonitor {
     ) -> Result<TunnelT> {
         log::debug!("Tunnel MTU: {}", config.mtu);
 
-        let daita = true;
         let routes = Self::get_tunnel_destinations(config).flat_map(Self::replace_default_prefixes);
 
         #[cfg(target_os = "android")]
         let config = Self::patch_allowed_ips(config, gateway_only);
 
-        #[cfg(target_os = "linux")]
-        log::debug!("Using userspace WireGuard implementation");
         Ok(Box::new(
             WgGoTunnel::start_tunnel(
                 #[allow(clippy::needless_borrow)]
@@ -860,6 +882,7 @@ impl WireguardMonitor {
         ))
     }
 
+    /// Windows uses it's own version of `open_tunnel`.
     #[cfg(target_os = "windows")]
     #[allow(unused_variables)]
     fn open_tunnel(
@@ -1171,6 +1194,7 @@ pub enum TunnelError {
 }
 
 #[cfg(target_os = "linux")]
+#[allow(dead_code)]
 fn will_nm_manage_dns() -> bool {
     use talpid_dbus::network_manager::NetworkManager;
 

talpid-wireguard/src/wireguard_kernel/mod.rs

@@ -1,3 +1,4 @@
+#![cfg(not(feature = "daita"))]
 use super::{Config, Tunnel, TunnelError};
 use futures::future::{abortable, AbortHandle};
 use netlink_packet_core::{constants::*, NetlinkDeserializable};