From f11a902b3d1876b2f94886cd683af39a425efd11 Mon Sep 17 00:00:00 2001 From: Thomas Eizinger Date: Tue, 6 May 2025 11:29:09 +1000 Subject: [PATCH] refactor(rust): move `dns-control` to `bin-shared` (#9023) Currently, the platform-specific code for controlling DNS resolution on a system sits in `firezone-headless-client`. This code is also used by the GUI client. This creates a weird compile-time dependency from the GUI client to the headless client. For other components that have platform-specific implementations, we use the `firezone-bin-shared` crate. As a first step of resolving the compile-time dependency, we move the `dns_control` module to `firezone-bin-shared`. --- rust/Cargo.lock | 8 +- rust/bin-shared/Cargo.toml | 11 ++- .../src/dns_control.rs | 3 +- .../src/dns_control/linux.rs | 27 +++++- .../src/dns_control/linux/etc_resolv_conf.rs | 0 .../src/dns_control/macos.rs | 7 +- .../src/dns_control/windows.rs | 85 +++++-------------- rust/bin-shared/src/lib.rs | 2 + rust/bin-shared/src/linux.rs | 24 ------ rust/bin-shared/src/macos.rs | 6 -- rust/bin-shared/src/network_changes/linux.rs | 2 +- rust/bin-shared/src/network_changes/macos.rs | 2 +- .../bin-shared/src/network_changes/windows.rs | 2 +- rust/bin-shared/src/windows.rs | 17 ---- rust/bin-shared/tests/dns_control_windows.rs | 62 ++++++++++++++ rust/bin-shared/tests/network_notifiers.rs | 2 +- rust/gui-client/src-common/src/controller.rs | 5 +- rust/headless-client/Cargo.toml | 3 - rust/headless-client/src/ipc_service.rs | 6 +- rust/headless-client/src/ipc_service/ipc.rs | 2 - .../src/ipc_service/windows.rs | 2 +- rust/headless-client/src/lib.rs | 5 +- rust/headless-client/src/main.rs | 4 +- 23 files changed, 147 insertions(+), 140 deletions(-) rename rust/{headless-client => bin-shared}/src/dns_control.rs (96%) rename rust/{headless-client => bin-shared}/src/dns_control/linux.rs (89%) rename rust/{headless-client => bin-shared}/src/dns_control/linux/etc_resolv_conf.rs (100%) rename rust/{headless-client => bin-shared}/src/dns_control/macos.rs (86%) rename rust/{headless-client => bin-shared}/src/dns_control/windows.rs (83%) create mode 100644 rust/bin-shared/tests/dns_control_windows.rs diff --git a/rust/Cargo.lock b/rust/Cargo.lock index e06de021c..545800971 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -2093,11 +2093,13 @@ name = "firezone-bin-shared" version = "0.1.0" dependencies = [ "anyhow", + "atomicwrites", "axum", "bufferpool", "bytes", "clap", "dirs 5.0.1", + "dns-types", "firezone-logging", "flume", "futures", @@ -2105,14 +2107,19 @@ dependencies = [ "hex-literal", "ip-packet", "ip_network", + "ipconfig", + "itertools 0.13.0", "known-folders", "libc", + "mutants", "netlink-packet-core", "netlink-packet-route", "nix 0.29.0", + "resolv-conf", "ring", "rtnetlink", "socket-factory", + "tempfile", "thiserror 1.0.69", "tokio", "tokio-util", @@ -2285,7 +2292,6 @@ dependencies = [ "itertools 0.13.0", "known-folders", "libc", - "mutants", "nix 0.29.0", "opentelemetry", "opentelemetry-stdout", diff --git a/rust/bin-shared/Cargo.toml b/rust/bin-shared/Cargo.toml index 8355fe603..2907adf5a 100644 --- a/rust/bin-shared/Cargo.toml +++ b/rust/bin-shared/Cargo.toml @@ -10,6 +10,7 @@ license = { workspace = true } anyhow = { workspace = true } axum = { workspace = true, features = ["http1", "tokio"] } clap = { workspace = true, features = ["derive", "env"] } +dns-types = { workspace = true } firezone-logging = { workspace = true } futures = { workspace = true, features = ["std", "async-await"] } gat-lending-iterator = { workspace = true } @@ -18,7 +19,7 @@ ip-packet = { workspace = true } ip_network = { workspace = true, features = ["serde"] } socket-factory = { workspace = true } thiserror = { workspace = true } -tokio = { workspace = true, features = ["io-util", "net", "rt", "sync"] } +tokio = { workspace = true, features = ["io-util", "net", "rt", "sync", "process"] } tracing = { workspace = true } tun = { workspace = true } @@ -29,11 +30,13 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } [target.'cfg(target_os = "linux")'.dependencies] dirs = { workspace = true } +atomicwrites = { workspace = true } flume = { workspace = true } libc = { workspace = true } netlink-packet-core = { version = "0.7" } netlink-packet-route = { version = "0.19" } nix = { workspace = true, features = ["socket"] } +resolv-conf = { workspace = true } rtnetlink = { workspace = true } zbus = { workspace = true } # Can't use `zbus`'s `tokio` feature here, or it will break toast popups all the way over in `gui-client`. @@ -46,6 +49,8 @@ windows-implement = { workspace = true } wintun = "0.5.1" winreg = { workspace = true } tokio-util = { workspace = true } +ipconfig = "0.3.2" +itertools = { workspace = true } [target.'cfg(windows)'.dependencies.windows] workspace = true @@ -69,5 +74,9 @@ features = [ ip-packet = { workspace = true } tokio = { workspace = true, features = ["net", "time"] } +[target.'cfg(target_os = "linux")'.dev-dependencies] +mutants = "0.0.3" # Needed to mark functions as exempt from `cargo-mutants` testing +tempfile = { workspace = true } + [lints] workspace = true diff --git a/rust/headless-client/src/dns_control.rs b/rust/bin-shared/src/dns_control.rs similarity index 96% rename from rust/headless-client/src/dns_control.rs rename to rust/bin-shared/src/dns_control.rs index 1aa0b3fdd..9e2be422f 100644 --- a/rust/headless-client/src/dns_control.rs +++ b/rust/bin-shared/src/dns_control.rs @@ -6,7 +6,6 @@ //! On Windows, we use NRPT by default. We can also explicitly not control DNS. use anyhow::Result; -use firezone_bin_shared::platform::DnsControlMethod; use std::net::IpAddr; #[cfg(target_os = "linux")] @@ -26,6 +25,8 @@ use macos as platform; use platform::system_resolvers; +pub use platform::DnsControlMethod; + /// Controls system-wide DNS. /// /// Always call `deactivate` when Firezone starts. diff --git a/rust/headless-client/src/dns_control/linux.rs b/rust/bin-shared/src/dns_control/linux.rs similarity index 89% rename from rust/headless-client/src/dns_control/linux.rs rename to rust/bin-shared/src/dns_control/linux.rs index 26e17ef71..b1929ed77 100644 --- a/rust/headless-client/src/dns_control/linux.rs +++ b/rust/bin-shared/src/dns_control/linux.rs @@ -1,11 +1,36 @@ +use crate::TunDeviceManager; + use super::DnsController; use anyhow::{Context as _, Result, bail}; use dns_types::DomainName; -use firezone_bin_shared::{TunDeviceManager, platform::DnsControlMethod}; use std::{net::IpAddr, process::Command, str::FromStr}; mod etc_resolv_conf; +#[derive(clap::ValueEnum, Clone, Copy, Debug)] +pub enum DnsControlMethod { + /// Explicitly disable DNS control. + /// + /// We don't use an `Option` because leaving out the CLI arg should + /// use Systemd, not disable DNS control. + Disabled, + /// Back up `/etc/resolv.conf` and replace it with our own + /// + /// Only suitable for the Alpine CI containers and maybe something like an + /// embedded system + EtcResolvConf, + /// Cooperate with `systemd-resolved` + /// + /// Suitable for most Ubuntu systems, probably + SystemdResolved, +} + +impl Default for DnsControlMethod { + fn default() -> Self { + Self::SystemdResolved + } +} + impl DnsController { pub fn deactivate(&mut self) -> Result<()> { tracing::debug!("Deactivating DNS control..."); diff --git a/rust/headless-client/src/dns_control/linux/etc_resolv_conf.rs b/rust/bin-shared/src/dns_control/linux/etc_resolv_conf.rs similarity index 100% rename from rust/headless-client/src/dns_control/linux/etc_resolv_conf.rs rename to rust/bin-shared/src/dns_control/linux/etc_resolv_conf.rs diff --git a/rust/headless-client/src/dns_control/macos.rs b/rust/bin-shared/src/dns_control/macos.rs similarity index 86% rename from rust/headless-client/src/dns_control/macos.rs rename to rust/bin-shared/src/dns_control/macos.rs index a9de71d24..1f869a847 100644 --- a/rust/headless-client/src/dns_control/macos.rs +++ b/rust/bin-shared/src/dns_control/macos.rs @@ -3,7 +3,12 @@ use std::net::IpAddr; use super::DnsController; use anyhow::{Result, bail}; use dns_types::DomainName; -use firezone_bin_shared::macos::DnsControlMethod; + +#[derive(clap::ValueEnum, Clone, Copy, Debug, Default)] +pub enum DnsControlMethod { + #[default] + None, +} impl DnsController { pub fn deactivate(&mut self) -> Result<()> { diff --git a/rust/headless-client/src/dns_control/windows.rs b/rust/bin-shared/src/dns_control/windows.rs similarity index 83% rename from rust/headless-client/src/dns_control/windows.rs rename to rust/bin-shared/src/dns_control/windows.rs index e6ba1e9b8..67ccccfeb 100644 --- a/rust/headless-client/src/dns_control/windows.rs +++ b/rust/bin-shared/src/dns_control/windows.rs @@ -13,11 +13,10 @@ //! //! -use super::DnsController; +use crate::DnsController; +use crate::windows::{CREATE_NO_WINDOW, TUNNEL_UUID, error::EPT_S_NOT_REGISTERED}; use anyhow::{Context as _, Result}; use dns_types::DomainName; -use firezone_bin_shared::platform::{CREATE_NO_WINDOW, DnsControlMethod, TUNNEL_UUID}; -use firezone_bin_shared::windows::error::EPT_S_NOT_REGISTERED; use std::{io, net::IpAddr, os::windows::process::CommandExt, path::Path, process::Command}; use windows::Win32::System::GroupPolicy::{RP_FORCE, RefreshPolicyEx}; @@ -25,6 +24,23 @@ use windows::Win32::System::GroupPolicy::{RP_FORCE, RefreshPolicyEx}; // Copied from the deep link schema const FZ_MAGIC: &str = "firezone-fd0020211111"; +#[derive(clap::ValueEnum, Clone, Copy, Debug)] +pub enum DnsControlMethod { + /// Explicitly disable DNS control. + /// + /// We don't use an `Option` because leaving out the CLI arg should + /// use NRPT, not disable DNS control. + Disabled, + /// NRPT, the only DNS control method we use on Windows. + Nrpt, +} + +impl Default for DnsControlMethod { + fn default() -> Self { + Self::Nrpt + } +} + impl DnsController { /// Deactivate any control Firezone has over the computer's DNS /// @@ -280,66 +296,3 @@ fn set_nrpt_rule(key: &winreg::RegKey, dns_config_string: &str) -> Result<()> { key.set_value("Version", &0x2u32)?; Ok(()) } - -#[cfg(test)] -mod tests { - use super::*; - use std::collections::BTreeSet; - - // Passes in CI but not locally. Maybe ReactorScram's dev system has IPv6 misconfigured. There it fails to pick up the IPv6 DNS servers. - #[ignore = "Needs admin, changes system state"] - #[test] - fn dns_control() { - let _guard = firezone_logging::test("debug"); - - let rt = tokio::runtime::Builder::new_current_thread() - .build() - .unwrap(); - - let mut tun_dev_manager = firezone_bin_shared::TunDeviceManager::new(1280, 1).unwrap(); // Note: num_threads (`1`) is unused on windows. - let _tun = tun_dev_manager.make_tun().unwrap(); - - rt.block_on(async { - tun_dev_manager - .set_ips( - [100, 92, 193, 137].into(), - [0xfd00, 0x2021, 0x1111, 0x0, 0x0, 0x0, 0xa, 0x9db5].into(), - ) - .await - }) - .unwrap(); - - let mut dns_controller = DnsController { - dns_control_method: DnsControlMethod::Nrpt, - }; - - let fz_dns_servers = vec![ - IpAddr::from([100, 100, 111, 1]), - IpAddr::from([100, 100, 111, 2]), - IpAddr::from([ - 0xfd00, 0x2021, 0x1111, 0x8000, 0x0100, 0x0100, 0x0111, 0x0003, - ]), - IpAddr::from([ - 0xfd00, 0x2021, 0x1111, 0x8000, 0x0100, 0x0100, 0x0111, 0x0004, - ]), - ]; - rt.block_on(async { - dns_controller - .set_dns(fz_dns_servers.clone(), None) - .await - .unwrap(); - }); - - let adapter = ipconfig::get_adapters() - .unwrap() - .into_iter() - .find(|a| a.friendly_name() == "Firezone") - .unwrap(); - assert_eq!( - BTreeSet::from_iter(adapter.dns_servers().iter().cloned()), - BTreeSet::from_iter(fz_dns_servers.into_iter()) - ); - - dns_controller.deactivate().unwrap(); - } -} diff --git a/rust/bin-shared/src/lib.rs b/rust/bin-shared/src/lib.rs index ded500faa..a63d0b385 100644 --- a/rust/bin-shared/src/lib.rs +++ b/rust/bin-shared/src/lib.rs @@ -2,6 +2,7 @@ pub mod http_health_check; +mod dns_control; mod network_changes; mod tun_device_manager; @@ -51,5 +52,6 @@ pub const BUNDLE_ID: &str = "dev.firezone.client"; /// Mark for Firezone sockets to prevent routing loops on Linux. pub const FIREZONE_MARK: u32 = 0xfd002021; +pub use dns_control::{DnsControlMethod, DnsController, system_resolvers_for_gui}; pub use network_changes::{new_dns_notifier, new_network_notifier}; pub use tun_device_manager::TunDeviceManager; diff --git a/rust/bin-shared/src/linux.rs b/rust/bin-shared/src/linux.rs index 15ef42944..2cfe29b1f 100644 --- a/rust/bin-shared/src/linux.rs +++ b/rust/bin-shared/src/linux.rs @@ -4,30 +4,6 @@ use crate::FIREZONE_MARK; use nix::sys::socket::{setsockopt, sockopt}; use socket_factory::{TcpSocket, UdpSocket}; -#[derive(clap::ValueEnum, Clone, Copy, Debug)] -pub enum DnsControlMethod { - /// Explicitly disable DNS control. - /// - /// We don't use an `Option` because leaving out the CLI arg should - /// use Systemd, not disable DNS control. - Disabled, - /// Back up `/etc/resolv.conf` and replace it with our own - /// - /// Only suitable for the Alpine CI containers and maybe something like an - /// embedded system - EtcResolvConf, - /// Cooperate with `systemd-resolved` - /// - /// Suitable for most Ubuntu systems, probably - SystemdResolved, -} - -impl Default for DnsControlMethod { - fn default() -> Self { - Self::SystemdResolved - } -} - pub fn tcp_socket_factory(socket_addr: &SocketAddr) -> io::Result { let socket = socket_factory::tcp(socket_addr)?; setsockopt(&socket, sockopt::Mark, &FIREZONE_MARK)?; diff --git a/rust/bin-shared/src/macos.rs b/rust/bin-shared/src/macos.rs index eb6561a61..43b7b4a9f 100644 --- a/rust/bin-shared/src/macos.rs +++ b/rust/bin-shared/src/macos.rs @@ -1,8 +1,2 @@ -#[derive(clap::ValueEnum, Clone, Copy, Debug, Default)] -pub enum DnsControlMethod { - #[default] - None, -} - pub use socket_factory::tcp as tcp_socket_factory; pub use socket_factory::udp as udp_socket_factory; diff --git a/rust/bin-shared/src/network_changes/linux.rs b/rust/bin-shared/src/network_changes/linux.rs index d5f5f729a..05fd9c84b 100644 --- a/rust/bin-shared/src/network_changes/linux.rs +++ b/rust/bin-shared/src/network_changes/linux.rs @@ -1,6 +1,6 @@ //! Not implemented for Linux yet -use crate::platform::DnsControlMethod; +use crate::DnsControlMethod; use anyhow::Result; use futures::StreamExt as _; use std::time::Duration; diff --git a/rust/bin-shared/src/network_changes/macos.rs b/rust/bin-shared/src/network_changes/macos.rs index 97fc2eff3..7db4919a0 100644 --- a/rust/bin-shared/src/network_changes/macos.rs +++ b/rust/bin-shared/src/network_changes/macos.rs @@ -1,4 +1,4 @@ -use crate::platform::DnsControlMethod; +use crate::DnsControlMethod; use anyhow::{Result, bail}; pub async fn new_dns_notifier( diff --git a/rust/bin-shared/src/network_changes/windows.rs b/rust/bin-shared/src/network_changes/windows.rs index 5bfe8b0c7..eb1efb371 100644 --- a/rust/bin-shared/src/network_changes/windows.rs +++ b/rust/bin-shared/src/network_changes/windows.rs @@ -62,7 +62,7 @@ //! //! Raymond Chen also explains it on his blog: -use crate::platform::DnsControlMethod; +use crate::DnsControlMethod; use anyhow::{Context as _, Result, anyhow}; use std::collections::HashMap; use std::sync::Mutex; diff --git a/rust/bin-shared/src/windows.rs b/rust/bin-shared/src/windows.rs index c520b6c88..6aa128a0e 100644 --- a/rust/bin-shared/src/windows.rs +++ b/rust/bin-shared/src/windows.rs @@ -87,23 +87,6 @@ pub mod error { pub const EPT_S_NOT_REGISTERED: HRESULT = HRESULT::from_win32(0x06D9); } -#[derive(clap::ValueEnum, Clone, Copy, Debug)] -pub enum DnsControlMethod { - /// Explicitly disable DNS control. - /// - /// We don't use an `Option` because leaving out the CLI arg should - /// use NRPT, not disable DNS control. - Disabled, - /// NRPT, the only DNS control method we use on Windows. - Nrpt, -} - -impl Default for DnsControlMethod { - fn default() -> Self { - Self::Nrpt - } -} - pub fn tcp_socket_factory(addr: &SocketAddr) -> io::Result { delete_all_routing_entries_matching(addr.ip())?; diff --git a/rust/bin-shared/tests/dns_control_windows.rs b/rust/bin-shared/tests/dns_control_windows.rs new file mode 100644 index 000000000..dfed79147 --- /dev/null +++ b/rust/bin-shared/tests/dns_control_windows.rs @@ -0,0 +1,62 @@ +#![cfg(target_os = "windows")] +#![allow(clippy::unwrap_used)] + +use firezone_bin_shared::{DnsControlMethod, DnsController}; +use std::{collections::BTreeSet, net::IpAddr}; + +// Passes in CI but not locally. Maybe ReactorScram's dev system has IPv6 misconfigured. There it fails to pick up the IPv6 DNS servers. +#[ignore = "Needs admin, changes system state"] +#[test] +fn dns_control() { + let _guard = firezone_logging::test("debug"); + + let rt = tokio::runtime::Builder::new_current_thread() + .build() + .unwrap(); + + let mut tun_dev_manager = firezone_bin_shared::TunDeviceManager::new(1280, 1).unwrap(); // Note: num_threads (`1`) is unused on windows. + let _tun = tun_dev_manager.make_tun().unwrap(); + + rt.block_on(async { + tun_dev_manager + .set_ips( + [100, 92, 193, 137].into(), + [0xfd00, 0x2021, 0x1111, 0x0, 0x0, 0x0, 0xa, 0x9db5].into(), + ) + .await + }) + .unwrap(); + + let mut dns_controller = DnsController { + dns_control_method: DnsControlMethod::Nrpt, + }; + + let fz_dns_servers = vec![ + IpAddr::from([100, 100, 111, 1]), + IpAddr::from([100, 100, 111, 2]), + IpAddr::from([ + 0xfd00, 0x2021, 0x1111, 0x8000, 0x0100, 0x0100, 0x0111, 0x0003, + ]), + IpAddr::from([ + 0xfd00, 0x2021, 0x1111, 0x8000, 0x0100, 0x0100, 0x0111, 0x0004, + ]), + ]; + rt.block_on(async { + dns_controller + .set_dns(fz_dns_servers.clone(), None) + .await + .unwrap(); + }); + + let adapter = ipconfig::get_adapters() + .unwrap() + .into_iter() + .find(|a| a.friendly_name() == "Firezone") + .unwrap(); + assert_eq!( + BTreeSet::from_iter(adapter.dns_servers().iter().cloned()), + BTreeSet::from_iter(fz_dns_servers.into_iter()) + ); + + dns_controller.deactivate().unwrap(); +} diff --git a/rust/bin-shared/tests/network_notifiers.rs b/rust/bin-shared/tests/network_notifiers.rs index 236c09a07..832c6dcbe 100644 --- a/rust/bin-shared/tests/network_notifiers.rs +++ b/rust/bin-shared/tests/network_notifiers.rs @@ -1,6 +1,6 @@ #![allow(clippy::unwrap_used)] -use firezone_bin_shared::{new_dns_notifier, new_network_notifier, platform::DnsControlMethod}; +use firezone_bin_shared::{DnsControlMethod, new_dns_notifier, new_network_notifier}; use futures::future::FutureExt as _; use std::time::Duration; use tokio::time::timeout; diff --git a/rust/gui-client/src-common/src/controller.rs b/rust/gui-client/src-common/src/controller.rs index f62b5f370..3f0eddb49 100644 --- a/rust/gui-client/src-common/src/controller.rs +++ b/rust/gui-client/src-common/src/controller.rs @@ -6,7 +6,7 @@ use crate::{ }; use anyhow::{Context, Result, anyhow}; use connlib_model::ResourceView; -use firezone_bin_shared::platform::DnsControlMethod; +use firezone_bin_shared::DnsControlMethod; use firezone_headless_client::{ IpcClientMsg::{self, SetDisabledResources}, IpcServerMsg, IpcServiceError, @@ -246,8 +246,7 @@ impl Controller { } EventloopTick::DnsChanged(Ok(())) => { if self.status.needs_network_changes() { - let resolvers = - firezone_headless_client::dns_control::system_resolvers_for_gui()?; + let resolvers = firezone_bin_shared::system_resolvers_for_gui()?; tracing::debug!( ?resolvers, "New DNS resolvers, calling `Session::set_dns`" diff --git a/rust/headless-client/Cargo.toml b/rust/headless-client/Cargo.toml index 4457186b0..0b8c429e7 100644 --- a/rust/headless-client/Cargo.toml +++ b/rust/headless-client/Cargo.toml @@ -47,9 +47,6 @@ uuid = { workspace = true, features = ["std", "v4", "serde"] } [dev-dependencies] tempfile = { workspace = true } -[target.'cfg(target_os = "linux")'.dev-dependencies] -mutants = "0.0.3" # Needed to mark functions as exempt from `cargo-mutants` testing - [target.'cfg(target_os = "linux")'.dependencies] libc = { workspace = true } nix = { workspace = true, features = ["fs", "user", "socket"] } diff --git a/rust/headless-client/src/ipc_service.rs b/rust/headless-client/src/ipc_service.rs index 45221a9ab..d61b43880 100644 --- a/rust/headless-client/src/ipc_service.rs +++ b/rust/headless-client/src/ipc_service.rs @@ -1,11 +1,11 @@ -use crate::{CallbackHandler, CliCommon, ConnlibMsg, device_id, dns_control::DnsController}; +use crate::{CallbackHandler, CliCommon, ConnlibMsg, device_id}; use anyhow::{Context as _, Result, bail}; use atomicwrites::{AtomicFile, OverwriteBehavior}; use clap::Parser; use connlib_model::ResourceView; use firezone_bin_shared::{ - TOKEN_ENV_KEY, TunDeviceManager, known_dirs, - platform::{DnsControlMethod, tcp_socket_factory, udp_socket_factory}, + DnsControlMethod, DnsController, TOKEN_ENV_KEY, TunDeviceManager, known_dirs, + platform::{tcp_socket_factory, udp_socket_factory}, signals, }; use firezone_logging::{FilterReloadHandle, err_with_src, sentry_layer, telemetry_span}; diff --git a/rust/headless-client/src/ipc_service/ipc.rs b/rust/headless-client/src/ipc_service/ipc.rs index 5123d4bb7..e87808719 100644 --- a/rust/headless-client/src/ipc_service/ipc.rs +++ b/rust/headless-client/src/ipc_service/ipc.rs @@ -6,8 +6,6 @@ use tokio_util::{ codec::{FramedRead, FramedWrite, LengthDelimitedCodec}, }; -// There is no special way to prevent `cargo-mutants` from throwing false -// positives on code for other platforms. #[cfg(target_os = "linux")] #[path = "ipc/linux.rs"] mod platform; diff --git a/rust/headless-client/src/ipc_service/windows.rs b/rust/headless-client/src/ipc_service/windows.rs index 4c1354239..c9343143f 100644 --- a/rust/headless-client/src/ipc_service/windows.rs +++ b/rust/headless-client/src/ipc_service/windows.rs @@ -1,6 +1,6 @@ use crate::CliCommon; use anyhow::{Context as _, Result, bail}; -use firezone_bin_shared::platform::DnsControlMethod; +use firezone_bin_shared::DnsControlMethod; use firezone_logging::FilterReloadHandle; use firezone_telemetry::Telemetry; use futures::channel::mpsc; diff --git a/rust/headless-client/src/lib.rs b/rust/headless-client/src/lib.rs index e3aabffd0..ed9c1c2f4 100644 --- a/rust/headless-client/src/lib.rs +++ b/rust/headless-client/src/lib.rs @@ -14,7 +14,7 @@ use anyhow::{Context as _, Result}; use connlib_client_shared::Callbacks; use connlib_model::ResourceView; use dns_types::DomainName; -use firezone_bin_shared::platform::DnsControlMethod; +use firezone_bin_shared::DnsControlMethod; use firezone_logging::FilterReloadHandle; use std::{ net::{IpAddr, Ipv4Addr, Ipv6Addr}, @@ -26,12 +26,9 @@ use tracing_subscriber::{EnvFilter, Layer as _, Registry, fmt, layer::Subscriber mod clear_logs; /// Generate a persistent device ID, stores it to disk, and reads it back. pub mod device_id; -// Pub because the GUI reads the system resolvers -pub mod dns_control; mod ipc_service; pub use clear_logs::clear_logs; -pub use dns_control::DnsController; pub use ipc_service::{ ClientMsg as IpcClientMsg, Error as IpcServiceError, ServerMsg as IpcServerMsg, ipc, run_only_ipc_service, diff --git a/rust/headless-client/src/main.rs b/rust/headless-client/src/main.rs index f2740f4d9..30dfaf50b 100644 --- a/rust/headless-client/src/main.rs +++ b/rust/headless-client/src/main.rs @@ -7,11 +7,11 @@ use backoff::ExponentialBackoffBuilder; use clap::Parser; use connlib_client_shared::Session; use firezone_bin_shared::{ - TOKEN_ENV_KEY, TunDeviceManager, new_dns_notifier, new_network_notifier, + DnsController, TOKEN_ENV_KEY, TunDeviceManager, new_dns_notifier, new_network_notifier, platform::{tcp_socket_factory, udp_socket_factory}, signals, }; -use firezone_headless_client::{CallbackHandler, CliCommon, ConnlibMsg, DnsController, device_id}; +use firezone_headless_client::{CallbackHandler, CliCommon, ConnlibMsg, device_id}; use firezone_logging::telemetry_span; use firezone_telemetry::Telemetry; use firezone_telemetry::otel;