Merge branch 'linux-add-extra-metadata-to-problem-reports'

14 files changed, 217 insertions, 144 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cda39a08d0..a453317df3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,6 +35,8 @@ Line wrap the file at 100 chars.                                              Th
 
 #### Linux
 - Improved compatiblitiy with newer versions of systemd-resolved.
+- Add version data to problem reports for the following software: the kernel, NetworkManager,
+  WireGuard kernel module, SystemD.
 
 ### Fixed
 #### Linux
diff --git a/Cargo.lock b/Cargo.lock
index cc29caeba4..66de6efc0b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1327,6 +1327,7 @@ name = "mullvad-platform-metadata"
 version = "0.1.0"
 dependencies = [
  "rs-release",
+ "talpid-dbus",
 ]
 
 [[package]]
@@ -2529,7 +2530,6 @@ dependencies = [
  "byteorder",
  "cfg-if 1.0.0",
  "chrono",
- "dbus",
  "duct",
  "err-derive",
  "failure",
@@ -2565,6 +2565,7 @@ dependencies = [
  "shell-escape",
  "socket2",
  "system-configuration",
+ "talpid-dbus",
  "talpid-types",
  "tempfile",
  "tokio",
@@ -2581,6 +2582,16 @@ dependencies = [
 ]
 
 [[package]]
+name = "talpid-dbus"
+version = "0.1.0"
+dependencies = [
+ "dbus",
+ "err-derive",
+ "lazy_static",
+ "log 0.4.11",
+]
+
+[[package]]
 name = "talpid-openvpn-plugin"
 version = "2020.8.0-beta2"
 dependencies = [
diff --git a/Cargo.toml b/Cargo.toml
index 4d155d203a..cd57754721 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@ members = [
     "mullvad-exclude",
     "talpid-openvpn-plugin",
     "talpid-core",
+    "talpid-dbus",
     "mullvad-management-interface",
 ]
 exclude = ["dist-assets/binaries/shadowsocks-rust"]
diff --git a/mullvad-platform-metadata/Cargo.toml b/mullvad-platform-metadata/Cargo.toml
index d1ba2f6a14..fa33efb362 100644
--- a/mullvad-platform-metadata/Cargo.toml
+++ b/mullvad-platform-metadata/Cargo.toml
@@ -10,3 +10,4 @@ publish = false
 
 [target.'cfg(target_os = "linux")'.dependencies]
 rs-release = "0.1.7"
+talpid-dbus = { path = "../talpid-dbus" }
diff --git a/mullvad-platform-metadata/src/linux.rs b/mullvad-platform-metadata/src/linux.rs
index 484d2eaaf8..25c29b6a54 100644
--- a/mullvad-platform-metadata/src/linux.rs
+++ b/mullvad-platform-metadata/src/linux.rs
@@ -58,5 +58,41 @@ fn parse_lsb_release() -> Option<String> {
 }
 
 pub fn extra_metadata() -> impl Iterator<Item = (String, String)> {
-    std::iter::empty()
+    [kernel_version, nm_version, wg_version, systemd_version]
+        .iter()
+        .filter_map(|f| f())
+}
+
+/// `uname -r` outputs a single line containing only the kernel version:
+/// > 5.9.15
+fn kernel_version() -> Option<(String, String)> {
+    let kernel = command_stdout_lossy("uname", &["-r"])?;
+    Some(("kernel".to_string(), kernel))
+}
+
+/// NetworkManager's version is returned as a numeric version string
+/// > 1.26.0
+fn nm_version() -> Option<(String, String)> {
+    let nm = talpid_dbus::network_manager::NetworkManager::new().ok()?;
+    Some(("nm".to_string(), nm.version().ok()?))
+}
+
+/// `/sys/module/wireguard/version` contains only a numeric version string
+/// > 1.0.0
+fn wg_version() -> Option<(String, String)> {
+    let wireguard_version = std::fs::read_to_string("/sys/module/wireguard/version")
+        .ok()?
+        .trim()
+        .to_string();
+    Some(("wireguard".to_string(), wireguard_version))
+}
+
+/// `systemctl --version` usually outpus two lines - one with the version, and another listing
+/// features:
+/// > systemd 246 (246)
+/// > +PAM +AUDIT -SELINUX +IMA +APPARMOR +SMACK -SYSVINIT +UTMP +LIBCRYPTSETUP +GCRYPT -GNUTLS +ACL
+fn systemd_version() -> Option<(String, String)> {
+    let systemd_version_output = command_stdout_lossy("systemctl", &["--version"])?;
+    let version = systemd_version_output.lines().next()?.to_string();
+    Some(("systemd".to_string(), version))
 }
diff --git a/talpid-core/Cargo.toml b/talpid-core/Cargo.toml
index 6c796f5049..6c03f1af90 100644
--- a/talpid-core/Cargo.toml
+++ b/talpid-core/Cargo.toml
@@ -46,7 +46,6 @@ jnix = { version = "0.3", features = ["derive"] }
 
 
 [target.'cfg(target_os = "linux")'.dependencies]
-dbus = "0.9"
 failure = "0.1"
 notify = "4.0"
 resolv-conf = "0.7"
@@ -61,6 +60,7 @@ nftnl = { version = "0.6", features = ["nftnl-1-1-0"] }
 mnl = { version = "0.2.0", features = ["mnl-1-0-4"] }
 which = { version = "4.0", default-features = false }
 tun = "0.5"
+talpid-dbus = { path = "../talpid-dbus" }
 
 
 [target.'cfg(target_os = "macos")'.dependencies]
diff --git a/talpid-core/src/dns/linux/network_manager.rs b/talpid-core/src/dns/linux/network_manager.rs
index 1112305468..b51308368b 100644
--- a/talpid-core/src/dns/linux/network_manager.rs
+++ b/talpid-core/src/dns/linux/network_manager.rs
@@ -1,6 +1,6 @@
-pub use crate::linux::network_manager::Error;
-use crate::linux::network_manager::{self, DeviceConfig, NetworkManager as DBus};
 use std::net::IpAddr;
+pub use talpid_dbus::network_manager::Error;
+use talpid_dbus::network_manager::{self, DeviceConfig, NetworkManager as DBus};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
diff --git a/talpid-core/src/dns/linux/systemd_resolved.rs b/talpid-core/src/dns/linux/systemd_resolved.rs
index 8cc7b0b02a..73b8756a37 100644
--- a/talpid-core/src/dns/linux/systemd_resolved.rs
+++ b/talpid-core/src/dns/linux/systemd_resolved.rs
@@ -1,12 +1,13 @@
 use super::RESOLV_CONF_PATH;
 use crate::linux::iface_index;
-use dbus::{
-    arg::RefArg,
-    blocking::{stdintf::org_freedesktop_dbus::Properties, Proxy, SyncConnection},
-};
 use lazy_static::lazy_static;
 use libc::{AF_INET, AF_INET6};
 use std::{fs, io, net::IpAddr, path::Path, sync::Arc, time::Duration};
+use talpid_dbus::dbus::{
+    self,
+    arg::RefArg,
+    blocking::{stdintf::org_freedesktop_dbus::Properties, Proxy, SyncConnection},
+};
 use talpid_types::ErrorExt as _;
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -76,7 +77,7 @@ pub struct SystemdResolved {
 
 impl SystemdResolved {
     pub fn new() -> Result<Self> {
-        let dbus_connection = crate::linux::dbus::get_connection().map_err(Error::ConnectDBus)?;
+        let dbus_connection = talpid_dbus::get_connection().map_err(Error::ConnectDBus)?;
 
         let systemd_resolved = SystemdResolved {
             dbus_connection,
diff --git a/talpid-core/src/linux/mod.rs b/talpid-core/src/linux/mod.rs
index 0441e1f7bd..69328ff28a 100644
--- a/talpid-core/src/linux/mod.rs
+++ b/talpid-core/src/linux/mod.rs
@@ -3,9 +3,6 @@ use std::{
     io,
 };
 
-pub mod dbus;
-pub mod network_manager;
-
 /// Converts an interface name into the corresponding index.
 pub fn iface_index(name: &str) -> Result<libc::c_uint, IfaceIndexLookupError> {
     let c_name = CString::new(name)
diff --git a/talpid-core/src/tunnel/wireguard/wireguard_kernel/nm_tunnel.rs b/talpid-core/src/tunnel/wireguard/wireguard_kernel/nm_tunnel.rs
index adaa8977dd..21f5f283cc 100644
--- a/talpid-core/src/tunnel/wireguard/wireguard_kernel/nm_tunnel.rs
+++ b/talpid-core/src/tunnel/wireguard/wireguard_kernel/nm_tunnel.rs
@@ -2,8 +2,13 @@ use super::{
     super::stats::{Error as StatsError, Stats},
     Config, Error as WgKernelError, Tunnel, TunnelError, MULLVAD_INTERFACE_NAME,
 };
-use crate::linux::network_manager::{
-    Error as NetworkManagerError, NetworkManager, WireguardTunnel,
+use std::collections::HashMap;
+use talpid_dbus::{
+    dbus,
+    network_manager::{
+        DeviceConfig, Error as NetworkManagerError, NetworkManager, Variant, VariantMap,
+        WireguardTunnel,
+    },
 };
 use talpid_types::ErrorExt;
 
@@ -31,8 +36,9 @@ impl NetworkManagerTunnel {
         let network_manager = NetworkManager::new()
             .map_err(Error::NetworkManager)
             .map_err(WgKernelError::NetworkManager)?;
+        let config_map = convert_config_to_dbus(config);
         let tunnel = network_manager
-            .create_wg_tunnel(config)
+            .create_wg_tunnel(&config_map)
             .map_err(|err| WgKernelError::NetworkManager(err.into()))?;
 
         network_manager
@@ -100,3 +106,97 @@ impl Tunnel for NetworkManagerTunnel {
         }
     }
 }
+
+fn convert_config_to_dbus(config: &Config) -> DeviceConfig {
+    let mut ipv6_config: VariantMap = HashMap::new();
+    let mut ipv4_config: VariantMap = HashMap::new();
+    let mut wireguard_config: VariantMap = HashMap::new();
+    let mut connection_config: VariantMap = HashMap::new();
+    let mut peer_configs = vec![];
+
+    wireguard_config.insert("mtu".into(), Variant(Box::new(config.mtu as u32)));
+    wireguard_config.insert("fwmark".into(), Variant(Box::new(config.fwmark as u32)));
+    wireguard_config.insert("peer-routes".into(), Variant(Box::new(false)));
+    wireguard_config.insert(
+        "private-key".into(),
+        Variant(Box::new(config.tunnel.private_key.to_base64())),
+    );
+    wireguard_config.insert("private-key-flags".into(), Variant(Box::new(0x0u32)));
+
+    for peer in config.peers.iter() {
+        let mut peer_config: VariantMap = HashMap::new();
+        let allowed_ips = peer
+            .allowed_ips
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>();
+
+
+        peer_config.insert("allowed-ips".into(), Variant(Box::new(allowed_ips)));
+        peer_config.insert(
+            "endpoint".into(),
+            Variant(Box::new(peer.endpoint.to_string())),
+        );
+        peer_config.insert(
+            "public-key".into(),
+            Variant(Box::new(peer.public_key.to_base64())),
+        );
+
+        peer_configs.push(peer_config);
+    }
+    wireguard_config.insert("peers".into(), Variant(Box::new(peer_configs)));
+
+    connection_config.insert("type".into(), Variant(Box::new("wireguard".to_string())));
+    connection_config.insert(
+        "id".into(),
+        Variant(Box::new(MULLVAD_INTERFACE_NAME.to_string())),
+    );
+    connection_config.insert(
+        "interface-name".into(),
+        Variant(Box::new(MULLVAD_INTERFACE_NAME.to_string())),
+    );
+    connection_config.insert("autoconnect".into(), Variant(Box::new(true)));
+
+
+    let ipv4_addrs: Vec<_> = config
+        .tunnel
+        .addresses
+        .iter()
+        .filter(|ip| ip.is_ipv4())
+        .map(NetworkManager::convert_address_to_dbus)
+        .collect();
+
+    let ipv6_addrs: Vec<_> = config
+        .tunnel
+        .addresses
+        .iter()
+        .filter(|ip| ip.is_ipv6())
+        .map(NetworkManager::convert_address_to_dbus)
+        .collect();
+
+    ipv4_config.insert("address-data".into(), Variant(Box::new(ipv4_addrs)));
+    ipv4_config.insert("ignore-auto-routes".into(), Variant(Box::new(true)));
+    ipv4_config.insert("ignore-auto-dns".into(), Variant(Box::new(true)));
+    ipv4_config.insert("may-fail".into(), Variant(Box::new(true)));
+    ipv4_config.insert("method".into(), Variant(Box::new("manual".to_string())));
+    ipv4_config.insert("never-default".into(), Variant(Box::new(true)));
+
+    if !ipv6_addrs.is_empty() {
+        ipv6_config.insert("method".into(), Variant(Box::new("manual".to_string())));
+        ipv6_config.insert("address-data".into(), Variant(Box::new(ipv6_addrs)));
+        ipv6_config.insert("ignore-auto-routes".into(), Variant(Box::new(true)));
+        ipv6_config.insert("ignore-auto-dns".into(), Variant(Box::new(true)));
+        ipv6_config.insert("may-fail".into(), Variant(Box::new(true)));
+    }
+
+
+    let mut settings = HashMap::new();
+    settings.insert("ipv4".into(), ipv4_config);
+    if !ipv6_config.is_empty() {
+        settings.insert("ipv6".into(), ipv6_config);
+    }
+    settings.insert("wireguard".into(), wireguard_config);
+    settings.insert("connection".into(), connection_config);
+
+    settings
+}
diff --git a/talpid-core/src/tunnel_state_machine/mod.rs b/talpid-core/src/tunnel_state_machine/mod.rs
index b657ec5e36..5a86722c01 100644
--- a/talpid-core/src/tunnel_state_machine/mod.rs
+++ b/talpid-core/src/tunnel_state_machine/mod.rs
@@ -386,7 +386,7 @@ impl SharedTunnelStateValues {
     #[cfg(target_os = "linux")]
     pub fn disable_connectivity_check(&mut self) {
         if self.connectivity_check_was_enabled.is_none() {
-            if let Ok(nm) = crate::linux::network_manager::NetworkManager::new() {
+            if let Ok(nm) = talpid_dbus::network_manager::NetworkManager::new() {
                 self.connectivity_check_was_enabled = nm.disable_connectivity_check();
             }
         } else {
@@ -398,7 +398,7 @@ impl SharedTunnelStateValues {
     #[cfg(target_os = "linux")]
     pub fn reset_connectivity_check(&mut self) {
         if self.connectivity_check_was_enabled.take() == Some(true) {
-            if let Ok(nm) = crate::linux::network_manager::NetworkManager::new() {
+            if let Ok(nm) = talpid_dbus::network_manager::NetworkManager::new() {
                 nm.enable_connectivity_check();
             }
         } else {
diff --git a/talpid-dbus/Cargo.toml b/talpid-dbus/Cargo.toml
new file mode 100644
index 0000000000..57ffda5eb9
--- /dev/null
+++ b/talpid-dbus/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "talpid-dbus"
+version = "0.1.0"
+authors = ["Mullvad VPN"]
+edition = "2018"
+publish = false
+
+[target.'cfg(target_os = "linux")'.dependencies]
+dbus = "0.9"
+err-derive = "0.2.1"
+lazy_static = "1.0"
+log = "0.4"
diff --git a/talpid-core/src/linux/dbus.rs b/talpid-dbus/src/lib.rs
index 147574895d..d8515ce305 100644
--- a/talpid-core/src/linux/dbus.rs
+++ b/talpid-dbus/src/lib.rs
@@ -1,10 +1,15 @@
+#![cfg(target_os = "linux")]
 //! DBus system connection
+pub use dbus;
 use dbus::blocking::SyncConnection;
 use std::sync::{Arc, Mutex};
+pub mod network_manager;
+
 lazy_static::lazy_static! {
     static ref DBUS_CONNECTION: Mutex<Option<Arc<SyncConnection>>> = Mutex::new(None);
 }
 
+
 /// Reuse or create a system DBus connection.
 pub fn get_connection() -> Result<Arc<SyncConnection>, dbus::Error> {
     let mut connection = DBUS_CONNECTION.lock().expect("DBus lock poisoned");
diff --git a/talpid-core/src/linux/network_manager.rs b/talpid-dbus/src/network_manager.rs
index a09acb7e11..9253a68ac8 100644
--- a/talpid-core/src/linux/network_manager.rs
+++ b/talpid-dbus/src/network_manager.rs
@@ -1,9 +1,7 @@
 //! NetworkManager is the one-stop-shop of network configuration on Linux.
-use crate::tunnel::wireguard::{
-    config::Config as WireguardConfig, wireguard_kernel::MULLVAD_INTERFACE_NAME,
-};
+pub use dbus::arg::{RefArg, Variant};
 use dbus::{
-    arg::{self, RefArg, Variant},
+    arg,
     blocking::{stdintf::org_freedesktop_dbus::Properties, Proxy, SyncConnection},
     message::MatchRule,
 };
@@ -110,11 +108,11 @@ pub struct NetworkManager {
 impl NetworkManager {
     pub fn new() -> Result<Self> {
         Ok(Self {
-            connection: crate::linux::dbus::get_connection()?,
+            connection: crate::get_connection()?,
         })
     }
 
-    pub fn create_wg_tunnel(&self, config: &WireguardConfig) -> Result<WireguardTunnel> {
+    pub fn create_wg_tunnel(&self, config: &DeviceConfig) -> Result<WireguardTunnel> {
         self.ensure_nm_is_new_enough_for_wireguard()?;
         let tunnel = self.create_wg_tunnel_inner(config)?;
         if let Err(err) = self.wait_until_device_is_ready(&tunnel.device_path) {
@@ -143,13 +141,11 @@ impl NetworkManager {
             .map_err(Error::Dbus)
     }
 
-    fn create_wg_tunnel_inner(&self, config: &WireguardConfig) -> Result<WireguardTunnel> {
-        let settings_map = Self::convert_config_to_dbus(config);
-
-        let config_path: dbus::Path<'static> = match self.add_connection_2(&settings_map) {
+    fn create_wg_tunnel_inner(&self, config: &DeviceConfig) -> Result<WireguardTunnel> {
+        let config_path: dbus::Path<'static> = match self.add_connection_2(&config) {
             Ok((path, _result)) => path,
             Err(Error::Dbus(dbus_error)) if dbus_error.name() == Some(DBUS_UNKNOWN_METHOD) => {
-                self.add_connection_unsaved(&settings_map)?.0
+                self.add_connection_unsaved(&config)?.0
             }
             Err(err) => {
                 log::error!(
@@ -188,10 +184,9 @@ impl NetworkManager {
     }
 
     fn ensure_nm_is_new_enough_for_wireguard(&self) -> Result<()> {
-        let manager = self.nm_manager();
-        let version_string: String = manager.get(NM_MANAGER, "Version").map_err(Error::Dbus)?;
-        let version_too_old = || Error::NMTooOld(version_string.clone());
-        let mut parts = version_string
+        let version: String = self.version()?;
+        let version_too_old = || Error::NMTooOld(version.clone());
+        let mut parts = version
             .split(".")
             .map(|part| part.parse().map_err(|_| version_too_old()));
 
@@ -199,7 +194,8 @@ impl NetworkManager {
         let minor_version: u32 = parts.next().ok_or_else(|| version_too_old())??;
 
         if major_version < MINIMUM_SUPPORTED_MAJOR_VERSION
-            || minor_version < MINIMUM_SUPPORTED_MINOR_VERSION
+            || (minor_version < MINIMUM_SUPPORTED_MINOR_VERSION
+                && major_version == MINIMUM_SUPPORTED_MAJOR_VERSION)
         {
             Err(version_too_old())
         } else {
@@ -207,6 +203,11 @@ impl NetworkManager {
         }
     }
 
+    pub fn version(&self) -> Result<String> {
+        let manager = self.nm_manager();
+        manager.get(NM_MANAGER, "Version").map_err(Error::Dbus)
+    }
+
     fn add_connection_2(
         &self,
         settings_map: &DeviceConfig,
@@ -360,112 +361,6 @@ impl NetworkManager {
         Proxy::new(NM_BUS, NM_MANAGER_PATH, RPC_TIMEOUT, &*self.connection)
     }
 
-    fn convert_config_to_dbus(config: &WireguardConfig) -> DeviceConfig {
-        let mut ipv6_config: VariantMap = HashMap::new();
-        let mut ipv4_config: VariantMap = HashMap::new();
-        let mut wireguard_config: VariantMap = HashMap::new();
-        let mut connection_config: VariantMap = HashMap::new();
-        let mut peer_configs = vec![];
-
-        wireguard_config.insert("mtu".into(), Variant(Box::new(config.mtu as u32)));
-        wireguard_config.insert("fwmark".into(), Variant(Box::new(config.fwmark as u32)));
-        wireguard_config.insert("peer-routes".into(), Variant(Box::new(false)));
-        wireguard_config.insert(
-            "private-key".into(),
-            Variant(Box::new(config.tunnel.private_key.to_base64())),
-        );
-        wireguard_config.insert("private-key-flags".into(), Variant(Box::new(0x0u32)));
-
-        for peer in config.peers.iter() {
-            let mut peer_config: VariantMap = HashMap::new();
-            let allowed_ips = peer
-                .allowed_ips
-                .iter()
-                .map(ToString::to_string)
-                .collect::<Vec<_>>();
-
-
-            peer_config.insert("allowed-ips".into(), Variant(Box::new(allowed_ips)));
-            peer_config.insert(
-                "endpoint".into(),
-                Variant(Box::new(peer.endpoint.to_string())),
-            );
-            peer_config.insert(
-                "public-key".into(),
-                Variant(Box::new(peer.public_key.to_base64())),
-            );
-
-            peer_configs.push(peer_config);
-        }
-        wireguard_config.insert("peers".into(), Variant(Box::new(peer_configs)));
-
-        connection_config.insert("type".into(), Variant(Box::new("wireguard".to_string())));
-        connection_config.insert(
-            "id".into(),
-            Variant(Box::new(MULLVAD_INTERFACE_NAME.to_string())),
-        );
-        connection_config.insert(
-            "interface-name".into(),
-            Variant(Box::new(MULLVAD_INTERFACE_NAME.to_string())),
-        );
-        connection_config.insert("autoconnect".into(), Variant(Box::new(true)));
-
-
-        let ipv4_addrs: Vec<_> = config
-            .tunnel
-            .addresses
-            .iter()
-            .filter(|ip| ip.is_ipv4())
-            .map(Self::convert_address_to_dbus)
-            .collect();
-
-        let ipv6_addrs: Vec<_> = config
-            .tunnel
-            .addresses
-            .iter()
-            .filter(|ip| ip.is_ipv6())
-            .map(Self::convert_address_to_dbus)
-            .collect();
-
-        ipv4_config.insert("address-data".into(), Variant(Box::new(ipv4_addrs)));
-        ipv4_config.insert("ignore-auto-routes".into(), Variant(Box::new(true)));
-        ipv4_config.insert("ignore-auto-dns".into(), Variant(Box::new(true)));
-        ipv4_config.insert("may-fail".into(), Variant(Box::new(true)));
-        ipv4_config.insert("method".into(), Variant(Box::new("manual".to_string())));
-        ipv4_config.insert("never-default".into(), Variant(Box::new(true)));
-
-        if !ipv6_addrs.is_empty() {
-            ipv6_config.insert("method".into(), Variant(Box::new("manual".to_string())));
-            ipv6_config.insert("address-data".into(), Variant(Box::new(ipv6_addrs)));
-            ipv6_config.insert("ignore-auto-routes".into(), Variant(Box::new(true)));
-            ipv6_config.insert("ignore-auto-dns".into(), Variant(Box::new(true)));
-            ipv6_config.insert("may-fail".into(), Variant(Box::new(true)));
-        }
-
-
-        let mut settings = HashMap::new();
-        settings.insert("ipv4".into(), ipv4_config);
-        if !ipv6_config.is_empty() {
-            settings.insert("ipv6".into(), ipv6_config);
-        }
-        settings.insert("wireguard".into(), wireguard_config);
-        settings.insert("connection".into(), connection_config);
-
-        settings
-    }
-
-    fn convert_address_to_dbus(address: &IpAddr) -> VariantMap {
-        let mut map: VariantMap = HashMap::new();
-        map.insert(
-            "address".to_string(),
-            Variant(Box::new(address.to_string())),
-        );
-        let prefix: u32 = if address.is_ipv4() { 32 } else { 128 };
-        map.insert("prefix".to_string(), Variant(Box::new(prefix)));
-
-        map
-    }
-
     pub fn ensure_network_manager_exists(&self) -> Result<()> {
         match self
             .as_manager()
@@ -636,10 +531,9 @@ impl NetworkManager {
         }
 
         if let Some(wg_config) = settings.get_mut("wireguard") {
-            wg_config.insert(
-                "fwmark".to_string(),
-                Variant(Box::new(crate::linux::TUNNEL_FW_MARK) as Box<dyn RefArg>),
-            );
+            if !wg_config.contains_key("fwmark") {
+                log::error!("WireGuard config doesn't contain the firewall mark");
+            }
         }
 
         self.reapply_settings(&device_path, settings, version_id)?;
@@ -717,6 +611,19 @@ impl NetworkManager {
         }
         Err(Error::DeviceNotFound)
     }
+
+
+    pub fn convert_address_to_dbus(address: &IpAddr) -> VariantMap {
+        let mut map: VariantMap = HashMap::new();
+        map.insert(
+            "address".to_string(),
+            Variant(Box::new(address.to_string())),
+        );
+        let prefix: u32 = if address.is_ipv4() { 32 } else { 128 };
+        map.insert("prefix".to_string(), Variant(Box::new(prefix)));
+
+        map
+    }
 }
 
 #[derive(Debug)]