Remove userspace wg module on Windows

4 files changed, 42 insertions, 221 deletions

diff --git a/talpid-wireguard/src/lib.rs b/talpid-wireguard/src/lib.rs
index 784cafa75b..2a98ad3fb0 100644
--- a/talpid-wireguard/src/lib.rs
+++ b/talpid-wireguard/src/lib.rs
@@ -50,12 +50,14 @@ mod connectivity_check;
 mod logging;
 mod ping_monitor;
 mod stats;
+#[cfg(unix)]
 mod wireguard_go;
 #[cfg(target_os = "linux")]
 pub(crate) mod wireguard_kernel;
 #[cfg(windows)]
 mod wireguard_nt;
 
+#[cfg(unix)]
 use self::wireguard_go::WgGoTunnel;
 
 type Result<T> = std::result::Result<T, Error>;
@@ -764,44 +766,33 @@ impl WireguardMonitor {
         }
 
         #[cfg(target_os = "windows")]
-        if config.use_wireguard_nt {
-            log::debug!("Using WireGuardNT");
-            return wireguard_nt::WgNtTunnel::start_tunnel(
-                config,
-                log_path,
-                resource_dir,
-                setup_done_tx,
-            )
-            .map(|tun| Box::new(tun) as Box<dyn Tunnel + 'static>)
-            .map_err(Error::TunnelError);
+        {
+            wireguard_nt::WgNtTunnel::start_tunnel(config, log_path, resource_dir, setup_done_tx)
+                .map(|tun| Box::new(tun) as Box<dyn Tunnel + 'static>)
+                .map_err(Error::TunnelError)
         }
 
-        #[cfg(not(windows))]
-        let routes = Self::get_tunnel_destinations(config).flat_map(Self::replace_default_prefixes);
+        #[cfg(not(target_os = "windows"))]
+        {
+            let routes =
+                Self::get_tunnel_destinations(config).flat_map(Self::replace_default_prefixes);
 
-        #[cfg(target_os = "android")]
-        let config = Self::patch_allowed_ips(config, psk_negotiation);
+            #[cfg(target_os = "android")]
+            let config = Self::patch_allowed_ips(config, psk_negotiation);
 
-        #[cfg(any(target_os = "linux", windows))]
-        log::debug!("Using userspace WireGuard implementation");
-        Ok(Box::new(
-            WgGoTunnel::start_tunnel(
-                #[allow(clippy::needless_borrow)]
-                &config,
-                log_path,
-                #[cfg(not(windows))]
-                tun_provider,
-                #[cfg(not(windows))]
-                routes,
-                #[cfg(windows)]
-                route_manager_handle,
-                #[cfg(windows)]
-                setup_done_tx,
-                #[cfg(windows)]
-                &runtime,
-            )
-            .map_err(Error::TunnelError)?,
-        ))
+            #[cfg(target_os = "linux")]
+            log::debug!("Using userspace WireGuard implementation");
+            Ok(Box::new(
+                WgGoTunnel::start_tunnel(
+                    #[allow(clippy::needless_borrow)]
+                    &config,
+                    log_path,
+                    tun_provider,
+                    routes,
+                )
+                .map_err(Error::TunnelError)?,
+            ))
+        }
     }
 
     /// Blocks the current thread until tunnel disconnects
diff --git a/talpid-wireguard/src/logging.rs b/talpid-wireguard/src/logging.rs
index 5f006d418c..99cf405d23 100644
--- a/talpid-wireguard/src/logging.rs
+++ b/talpid-wireguard/src/logging.rs
@@ -1,5 +1,6 @@
 use once_cell::sync::Lazy;
 use parking_lot::Mutex;
+#[cfg(unix)]
 use std::ffi::{c_char, c_void};
 use std::{collections::HashMap, fmt, fs, io::Write, path::Path};
 
@@ -90,6 +91,7 @@ fn log_inner(logfile: &mut fs::File, level: LogLevel, tag: &str, msg: &str) {
 }
 
 // Callback that receives messages from WireGuard
+#[cfg(unix)]
 pub unsafe extern "system" fn wg_go_logging_callback(
     level: WgLogLevel,
     msg: *const c_char,
@@ -98,14 +100,7 @@ pub unsafe extern "system" fn wg_go_logging_callback(
     let mut map = LOG_MUTEX.lock();
     if let Some(logfile) = map.get_mut(&(context as u32)) {
         let managed_msg = if !msg.is_null() {
-            #[cfg(not(target_os = "windows"))]
-            let m = std::ffi::CStr::from_ptr(msg).to_string_lossy().to_string();
-            #[cfg(target_os = "windows")]
-            let m = std::ffi::CStr::from_ptr(msg)
-                .to_string_lossy()
-                .to_string()
-                .replace('\n', "\r\n");
-            m
+            std::ffi::CStr::from_ptr(msg).to_string_lossy().to_string()
         } else {
             "Logging message from WireGuard is NULL".to_string()
         };
@@ -118,8 +113,11 @@ pub unsafe extern "system" fn wg_go_logging_callback(
     }
 }
 
-pub type WgLogLevel = u32;
 // wireguard-go supports log levels 0 through 3 with 3 being the most verbose
 // const WG_GO_LOG_SILENT: WgLogLevel = 0;
 // const WG_GO_LOG_ERROR: WgLogLevel = 1;
+#[cfg(unix)]
 const WG_GO_LOG_VERBOSE: WgLogLevel = 2;
+
+#[cfg(unix)]
+pub type WgLogLevel = u32;
diff --git a/talpid-wireguard/src/stats.rs b/talpid-wireguard/src/stats.rs
index bd7b578545..79db5937a0 100644
--- a/talpid-wireguard/src/stats.rs
+++ b/talpid-wireguard/src/stats.rs
@@ -27,6 +27,7 @@ pub struct Stats {
 pub type StatsMap = std::collections::HashMap<[u8; 32], Stats>;
 
 impl Stats {
+    #[cfg(unix)]
     pub fn parse_config_str(config: &str) -> Result<StatsMap, Error> {
         let mut map = StatsMap::new();
 
@@ -124,6 +125,7 @@ impl Stats {
 mod test {
     use super::{Error, Stats};
 
+    #[cfg(unix)]
     #[test]
     fn test_parsing() {
         let valid_input = "private_key=0000000000000000000000000000000000000000000000000000000000000000\npublic_key=0000000000000000000000000000000000000000000000000000000000000000\npreshared_key=0000000000000000000000000000000000000000000000000000000000000000\nprotocol_version=1\nendpoint=000.000.000.000:00000\nlast_handshake_time_sec=1578420649\nlast_handshake_time_nsec=369416131\ntx_bytes=2740\nrx_bytes=2396\npersistent_keepalive_interval=0\nallowed_ip=0.0.0.0/0\n";
@@ -137,6 +139,7 @@ mod test {
         assert_eq!(stats[&pubkey].tx_bytes, 2740);
     }
 
+    #[cfg(unix)]
     #[test]
     fn test_parsing_invalid_input() {
         let invalid_input = "private_key=0000000000000000000000000000000000000000000000000000000000000000\npublic_key=0000000000000000000000000000000000000000000000000000000000000000\npreshared_key=0000000000000000000000000000000000000000000000000000000000000000\nprotocol_version=1\nendpoint=000.000.000.000:00000\nlast_handshake_time_sec=1578420649\nlast_handshake_time_nsec=369416131\ntx_bytes=27error40\npersistent_keepalive_interval=0\nallowed_ip=0.0.0.0/0\n";
diff --git a/talpid-wireguard/src/wireguard_go.rs b/talpid-wireguard/src/wireguard_go.rs
index e848e32679..24ad613659 100644
--- a/talpid-wireguard/src/wireguard_go.rs
+++ b/talpid-wireguard/src/wireguard_go.rs
@@ -3,41 +3,29 @@ use super::{
     Config, Tunnel, TunnelError,
 };
 use crate::logging::{clean_up_logging, initialize_logging, wg_go_logging_callback, WgLogLevel};
-#[cfg(windows)]
-use futures::SinkExt;
+use ipnetwork::IpNetwork;
 use std::{
     ffi::{c_char, c_void, CStr},
     future::Future,
     path::Path,
     pin::Pin,
 };
-#[cfg(windows)]
-use talpid_types::BoxedError;
+use talpid_tunnel::tun_provider::TunProvider;
 use zeroize::Zeroize;
-#[cfg(not(windows))]
-use {ipnetwork::IpNetwork, talpid_tunnel::tun_provider::TunProvider};
-
-#[cfg(target_os = "windows")]
-use std::ffi::CString;
 
 #[cfg(target_os = "android")]
 use talpid_tunnel::tun_provider;
 
-#[cfg(not(target_os = "windows"))]
-use {
-    std::{
-        net::IpAddr,
-        os::unix::io::{AsRawFd, RawFd},
-    },
-    talpid_tunnel::tun_provider::{Tun, TunConfig},
+use std::{
+    net::IpAddr,
+    os::unix::io::{AsRawFd, RawFd},
 };
+use talpid_tunnel::tun_provider::{Tun, TunConfig};
 
 type Result<T> = std::result::Result<T, TunnelError>;
 
-#[cfg(not(target_os = "windows"))]
 use std::sync::{Arc, Mutex};
 
-#[cfg(not(target_os = "windows"))]
 const MAX_PREPARE_TUN_ATTEMPTS: usize = 4;
 
 struct LoggingContext(u32);
@@ -53,20 +41,14 @@ pub struct WgGoTunnel {
     handle: Option<i32>,
     // holding on to the tunnel device and the log file ensures that the associated file handles
     // live long enough and get closed when the tunnel is stopped
-    #[cfg(not(target_os = "windows"))]
     _tunnel_device: Tun,
     // context that maps to fs::File instance, used with logging callback
     _logging_context: LoggingContext,
-    #[cfg(target_os = "windows")]
-    _route_callback_handle: Option<talpid_routing::CallbackHandle>,
-    #[cfg(target_os = "windows")]
-    setup_handle: tokio::task::JoinHandle<()>,
     #[cfg(target_os = "android")]
     tun_provider: Arc<Mutex<TunProvider>>,
 }
 
 impl WgGoTunnel {
-    #[cfg(not(target_os = "windows"))]
     pub fn start_tunnel(
         config: &Config,
         log_path: Option<&Path>,
@@ -113,139 +95,6 @@ impl WgGoTunnel {
         })
     }
 
-    #[cfg(target_os = "windows")]
-    pub fn start_tunnel(
-        config: &Config,
-        log_path: Option<&Path>,
-        route_manager_handle: talpid_routing::RouteManagerHandle,
-        mut done_tx: futures::channel::mpsc::Sender<std::result::Result<(), BoxedError>>,
-        runtime: &tokio::runtime::Handle,
-    ) -> Result<Self> {
-        use talpid_types::ErrorExt;
-
-        let route_callback_handle = runtime
-            .block_on(
-                route_manager_handle.add_default_route_change_callback(Box::new(
-                    WgGoTunnel::default_route_changed_callback,
-                )),
-            )
-            .ok();
-        if route_callback_handle.is_none() {
-            log::warn!("Failed to register default route callback");
-        }
-
-        let wg_config_str = config.to_userspace_format();
-        let iface_name: String = "Mullvad".to_string();
-        let cstr_iface_name =
-            CString::new(iface_name.as_bytes()).map_err(TunnelError::InterfaceNameError)?;
-        let logging_context = initialize_logging(log_path)
-            .map(LoggingContext)
-            .map_err(TunnelError::LoggingError)?;
-
-        let mut alias_ptr = std::ptr::null_mut();
-        let mut interface_luid = 0u64;
-
-        let handle = unsafe {
-            wgTurnOn(
-                cstr_iface_name.as_ptr(),
-                config.mtu as i64,
-                wg_config_str.as_ptr(),
-                &mut alias_ptr,
-                &mut interface_luid,
-                Some(wg_go_logging_callback),
-                logging_context.0 as *mut c_void,
-            )
-        };
-        check_wg_status(handle)?;
-
-        let actual_iface_name = {
-            let actual_iface_name_c = unsafe { CStr::from_ptr(alias_ptr) };
-            let actual_iface_name = actual_iface_name_c
-                .to_str()
-                .map_err(|_| TunnelError::InvalidAlias)?
-                .to_string();
-            unsafe { wgFreePtr(alias_ptr as *mut c_void) };
-            actual_iface_name
-        };
-
-        log::debug!("Adapter alias: {}", actual_iface_name);
-
-        let has_ipv6 = config.tunnel.addresses.iter().any(|addr| addr.is_ipv6());
-        let setup_handle = tokio::spawn(async move {
-            use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
-            let luid = NET_LUID_LH {
-                Value: interface_luid,
-            };
-            log::debug!("Waiting for tunnel IP interfaces to arrive");
-
-            let prepare_interfaces = async move {
-                talpid_windows_net::wait_for_interfaces(luid, true, has_ipv6).await?;
-
-                if let Err(error) =
-                    talpid_tunnel::network_interface::initialize_interfaces(luid, None)
-                {
-                    log::error!(
-                        "{}",
-                        error.display_chain_with_msg("Failed to set tunnel interface metric"),
-                    );
-                }
-
-                Ok(())
-            };
-
-            let _ = done_tx
-                .send(
-                    prepare_interfaces
-                        .await
-                        .map_err(|error| BoxedError::new(TunnelError::SetupIpInterfaces(error))),
-                )
-                .await;
-            log::debug!("Waiting for tunnel IP interfaces: Done");
-        });
-
-        Ok(WgGoTunnel {
-            interface_name: actual_iface_name,
-            handle: Some(handle),
-            setup_handle,
-            _logging_context: logging_context,
-            _route_callback_handle: route_callback_handle,
-        })
-    }
-
-    // Callback to be used to rebind the tunnel sockets when the default route changes
-    #[cfg(target_os = "windows")]
-    pub fn default_route_changed_callback(
-        event_type: crate::routing::EventType<'_>,
-        address_family: talpid_windows_net::AddressFamily,
-    ) {
-        use crate::routing::EventType::*;
-        use windows_sys::Win32::NetworkManagement::IpHelper::ConvertInterfaceLuidToIndex;
-
-        let iface_idx: u32 = match event_type {
-            Updated(default_route) => {
-                let mut iface_idx = 0u32;
-                let iface_luid = default_route.iface;
-                let status = unsafe { ConvertInterfaceLuidToIndex(&iface_luid, &mut iface_idx) };
-                if status != 0 {
-                    log::error!(
-                        "Failed to convert interface LUID to interface index: {}: {}",
-                        status,
-                        std::io::Error::last_os_error()
-                    );
-                    return;
-                }
-                iface_idx
-            }
-            // if there is no new default route, specify 0 as the interface index
-            Removed => 0,
-            // ignore interface updates that don't affect the interface to use
-            UpdatedDetails(_) => return,
-        };
-
-        unsafe { wgRebindTunnelSocket(address_family.to_af_family(), iface_idx) };
-    }
-
-    #[cfg(not(target_os = "windows"))]
     fn create_tunnel_config(config: &Config, routes: impl Iterator<Item = IpNetwork>) -> TunConfig {
         let mut dns_servers = vec![IpAddr::V4(config.ipv4_gateway)];
         dns_servers.extend(config.ipv6_gateway.map(IpAddr::V6));
@@ -287,8 +136,6 @@ impl WgGoTunnel {
     }
 
     fn stop_tunnel(&mut self) -> Result<()> {
-        #[cfg(windows)]
-        self.setup_handle.abort();
         if let Some(handle) = self.handle.take() {
             let status = unsafe { wgTurnOff(handle) };
             if status < 0 {
@@ -298,7 +145,6 @@ impl WgGoTunnel {
         Ok(())
     }
 
-    #[cfg(not(target_os = "windows"))]
     fn get_tunnel(
         tun_provider: Arc<Mutex<TunProvider>>,
         config: &Config,
@@ -420,7 +266,6 @@ fn check_wg_status(wg_code: i32) -> Result<()> {
     }
 }
 
-#[cfg(unix)]
 pub type Fd = std::os::unix::io::RawFd;
 
 pub type LoggingCallback =
@@ -435,7 +280,7 @@ extern "C" {
     ///
     /// Positive return values are tunnel handles for this specific wireguard tunnel instance.
     /// Negative return values signify errors. All error codes are opaque.
-    #[cfg(not(any(target_os = "android", target_os = "windows")))]
+    #[cfg(not(target_os = "android"))]
     fn wgTurnOn(
         mtu: isize,
         settings: *const i8,
@@ -453,18 +298,6 @@ extern "C" {
         logging_context: *mut c_void,
     ) -> i32;
 
-    // Windows
-    #[cfg(target_os = "windows")]
-    fn wgTurnOn(
-        iface_name: *const i8,
-        mtu: i64,
-        settings: *const i8,
-        iface_name_out: *mut *mut c_char,
-        iface_luid_out: *mut u64,
-        logging_callback: Option<LoggingCallback>,
-        logging_context: *mut c_void,
-    ) -> i32;
-
     // Pass a handle that was created by wgTurnOn to stop a wireguard tunnel.
     fn wgTurnOff(handle: i32) -> i32;
 
@@ -484,8 +317,4 @@ extern "C" {
     // Returns the file descriptor of the tunnel IPv6 socket.
     #[cfg(target_os = "android")]
     fn wgGetSocketV6(handle: i32) -> Fd;
-
-    // Rebind tunnel socket when network interfaces change
-    #[cfg(target_os = "windows")]
-    fn wgRebindTunnelSocket(family: u16, interfaceIndex: u32);
 }