Rename api to access_mode in mullvad-api

buggmagnet · buggmagnet · commit 64433003a5fa · 2025-03-13T14:20:22.000+01:00
diff --git a/mullvad-api/src/access_mode.rs b/mullvad-api/src/access_mode.rs
@@ -7,20 +7,17 @@
 #[cfg(feature = "api-override")]
 use crate::ApiEndpoint;
 use crate::{
-    proxy::{AllowedClientsProvider, ApiConnectionMode, ConnectionModeProvider, ProxyConfig},
+    proxy::{AllowedClientsProvider, ApiConnectionMode, ConnectionModeProvider},
     AddressCache,
 };
+use async_trait::async_trait;
 use futures::{
     channel::{mpsc, oneshot},
     StreamExt,
 };
-use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
-use mullvad_relay_selector::RelaySelector;
-use mullvad_types::access_method::{
-    AccessMethod, AccessMethodSetting, BuiltInAccessMethod, Id, Settings,
-};
+use mullvad_types::access_method::{AccessMethod, AccessMethodSetting, Id, Settings};
 use std::{marker::PhantomData, net::SocketAddr, path::PathBuf};
-use talpid_types::net::{proxy::CustomProxy, AllowedEndpoint, Endpoint, TransportProtocol};
+use talpid_types::net::{AllowedEndpoint, Endpoint, TransportProtocol};
 
 pub enum Message {
     Get(ResponseTx<ResolvedConnectionMode>),
@@ -250,10 +247,7 @@ pub struct AccessModeSelector<P> {
     api_endpoint: ApiEndpoint,
     cmd_rx: mpsc::UnboundedReceiver<Message>,
     cache_dir: PathBuf,
-    /// Used for selecting a Bridge when the `Mullvad Bridges` access method is used.
-    relay_selector: RelaySelector,
-    /// Used for selecting a config for the 'Encrypted DNS proxy' access method.
-    encrypted_dns_proxy_cache: EncryptedDnsProxyState,
+    bridge_dns_proxy_provider: Box<dyn BridgeAndDNSProxy>,
     access_method_settings: Settings,
     address_cache: AddressCache,
     access_method_event_sender: mpsc::UnboundedSender<(AccessMethodEvent, oneshot::Sender<()>)>,
@@ -270,7 +264,7 @@ where
 {
     pub async fn spawn(
         cache_dir: PathBuf,
-        relay_selector: RelaySelector,
+        mut bridge_dns_proxy_provider: Box<dyn BridgeAndDNSProxy>,
         #[cfg_attr(not(feature = "api-override"), allow(unused_mut))]
         mut access_method_settings: Settings,
         #[cfg(feature = "api-override")] api_endpoint: ApiEndpoint,
@@ -287,16 +281,12 @@ where
             }
         }
 
-        // Initialize the Encrypted DNS cache
-        let mut encrypted_dns_proxy_cache = EncryptedDnsProxyState::default();
-
         // Always start looking from the position of `Direct`.
         let (index, next) = Self::find_next_active(0, &access_method_settings);
         let initial_connection_mode = Self::resolve_inner_with_default(
             &next,
-            &relay_selector,
-            &mut encrypted_dns_proxy_cache,
             &address_cache,
+            &mut *bridge_dns_proxy_provider,
         )
         .await;
 
@@ -309,8 +299,7 @@ where
             api_endpoint,
             cmd_rx,
             cache_dir,
-            relay_selector,
-            encrypted_dns_proxy_cache,
+            bridge_dns_proxy_provider,
             access_method_settings,
             address_cache,
             access_method_event_sender,
@@ -537,22 +526,20 @@ where
     ) -> Option<ResolvedConnectionMode> {
         Self::resolve_inner(
             &access_method,
-            &self.relay_selector,
-            &mut self.encrypted_dns_proxy_cache,
             &self.address_cache,
+            &mut *self.bridge_dns_proxy_provider,
         )
         .await
     }
 
     async fn resolve_inner(
         access_method: &AccessMethodSetting,
-        relay_selector: &RelaySelector,
-        encrypted_dns_proxy_cache: &mut EncryptedDnsProxyState,
         address_cache: &AddressCache,
+        bridge_dns_proxy_provider: &mut dyn BridgeAndDNSProxy,
     ) -> Option<ResolvedConnectionMode> {
-        let connection_mode =
-            Self::resolve_connection_mode(access_method, relay_selector, encrypted_dns_proxy_cache)
-                .await?;
+        let connection_mode = bridge_dns_proxy_provider
+            .match_access_method(access_method)
+            .await?;
         let endpoint =
             resolve_allowed_endpoint::<P>(&connection_mode, address_cache.get_address().await);
         Some(ResolvedConnectionMode {
@@ -570,27 +557,18 @@ where
     ) -> ResolvedConnectionMode {
         Self::resolve_inner_with_default(
             &access_method,
-            &self.relay_selector,
-            &mut self.encrypted_dns_proxy_cache,
             &self.address_cache,
+            &mut *self.bridge_dns_proxy_provider,
         )
         .await
     }
 
     async fn resolve_inner_with_default(
         access_method: &AccessMethodSetting,
-        relay_selector: &RelaySelector,
-        encrypted_dns_proxy_cache: &mut EncryptedDnsProxyState,
         address_cache: &AddressCache,
+        bridge_dns_proxy_provider: &mut dyn BridgeAndDNSProxy,
     ) -> ResolvedConnectionMode {
-        match Self::resolve_inner(
-            access_method,
-            relay_selector,
-            encrypted_dns_proxy_cache,
-            address_cache,
-        )
-        .await
-        {
+        match Self::resolve_inner(access_method, address_cache, bridge_dns_proxy_provider).await {
             Some(resolved) => resolved,
             None => {
                 log::trace!("Defaulting to direct API connection");
@@ -606,42 +584,14 @@ where
             }
         }
     }
+}
 
-    async fn resolve_connection_mode(
+#[async_trait]
+pub trait BridgeAndDNSProxy: Send + Sync {
+    async fn match_access_method(
+        &mut self,
         access_method: &AccessMethodSetting,
-        relay_selector: &RelaySelector,
-        encrypted_dns_proxy_cache: &mut EncryptedDnsProxyState,
-    ) -> Option<ApiConnectionMode> {
-        let connection_mode = {
-            match &access_method.access_method {
-                AccessMethod::BuiltIn(BuiltInAccessMethod::Direct) => ApiConnectionMode::Direct,
-                AccessMethod::BuiltIn(BuiltInAccessMethod::Bridge) => {
-                    let Some(bridge) = relay_selector.get_bridge_forced() else {
-                        log::warn!("Could not select a Mullvad bridge");
-                        log::debug!("The relay list might be empty");
-                        return None;
-                    };
-                    let proxy = CustomProxy::Shadowsocks(bridge);
-                    ApiConnectionMode::Proxied(ProxyConfig::from(proxy))
-                }
-                AccessMethod::BuiltIn(BuiltInAccessMethod::EncryptedDnsProxy) => {
-                    if let Err(error) = encrypted_dns_proxy_cache.fetch_configs("frakta.eu").await {
-                        log::warn!("Failed to fetch new Encrypted DNS Proxy configurations");
-                        log::debug!("{error:#?}");
-                    }
-                    let Some(edp) = encrypted_dns_proxy_cache.next_configuration() else {
-                        log::warn!("Could not select next Encrypted DNS proxy config");
-                        return None;
-                    };
-                    ApiConnectionMode::Proxied(ProxyConfig::from(edp))
-                }
-                AccessMethod::Custom(config) => {
-                    ApiConnectionMode::Proxied(ProxyConfig::from(config.clone()))
-                }
-            }
-        };
-        Some(connection_mode)
-    }
+    ) -> Option<ApiConnectionMode>;
 }
 
 pub fn resolve_allowed_endpoint<P>(
diff --git a/mullvad-api/src/lib.rs b/mullvad-api/src/lib.rs
@@ -25,7 +25,7 @@ use availability::ApiAvailability;
 pub mod rest;
 
 mod abortable_stream;
-pub mod api;
+pub mod access_mode;
 mod https_client_with_sni;
 pub mod proxy;
 mod tls_stream;
diff --git a/mullvad-daemon/src/access_method.rs b/mullvad-daemon/src/access_method.rs
@@ -1,5 +1,5 @@
 use crate::{settings, Daemon};
-use mullvad_api::{api, proxy::ApiConnectionMode, rest, ApiProxy};
+use mullvad_api::{access_mode, proxy::ApiConnectionMode, rest, ApiProxy};
 use mullvad_types::{
     access_method::{self, AccessMethod, AccessMethodSetting},
     settings::Settings,
@@ -16,7 +16,7 @@ pub enum Error {
     /// Some error occured in the daemon's state of handling
     /// [`AccessMethodSetting`]s & [`ApiConnectionMode`]s
     #[error("Error occured when handling connection settings & details")]
-    ApiService(#[from] api::Error),
+    ApiService(#[from] access_mode::Error),
     /// A REST request failed
     #[error("Reset request failed")]
     Rest(#[from] rest::Error),
@@ -153,9 +153,9 @@ impl Daemon {
     #[cfg(not(target_os = "android"))]
     pub(crate) async fn test_access_method(
         proxy: talpid_types::net::AllowedEndpoint,
-        access_method_selector: api::AccessModeSelectorHandle,
+        access_method_selector: access_mode::AccessModeSelectorHandle,
         daemon_event_sender: crate::DaemonEventSender<(
-            api::AccessMethodEvent,
+            access_mode::AccessMethodEvent,
             futures::channel::oneshot::Sender<()>,
         )>,
         api_proxy: ApiProxy,
@@ -165,13 +165,13 @@ impl Daemon {
             .await
             .map(|connection_mode| connection_mode.endpoint)?;
 
-        api::AccessMethodEvent::Allow { endpoint: proxy }
+        access_mode::AccessMethodEvent::Allow { endpoint: proxy }
             .send(daemon_event_sender.to_unbounded_sender())
             .await?;
 
         let result = Self::perform_api_request(api_proxy).await;
 
-        api::AccessMethodEvent::Allow { endpoint: reset }
+        access_mode::AccessMethodEvent::Allow { endpoint: reset }
             .send(daemon_event_sender.to_unbounded_sender())
             .await?;
 
@@ -181,9 +181,9 @@ impl Daemon {
     #[cfg(target_os = "android")]
     pub(crate) async fn test_access_method(
         _: talpid_types::net::AllowedEndpoint,
-        _: api::AccessModeSelectorHandle,
+        _: access_mode::AccessModeSelectorHandle,
         _: crate::DaemonEventSender<(
-            api::AccessMethodEvent,
+            access_mode::AccessMethodEvent,
             futures::channel::oneshot::Sender<()>,
         )>,
         api_proxy: ApiProxy,
diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
@@ -4,12 +4,78 @@ use crate::DaemonCommand;
 use crate::DaemonEventSender;
 use futures::{channel::mpsc, StreamExt};
 use mullvad_api::{
+    access_mode::BridgeAndDNSProxy,
     availability::ApiAvailability,
     proxy::{AllowedClientsProvider, ApiConnectionMode, ProxyConfig},
 };
+use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
+use mullvad_management_interface::async_trait;
+use mullvad_types::{
+    access_method::{AccessMethod, AccessMethodSetting, BuiltInAccessMethod},
+    relay_list::ShadowsocksBridgeProvider,
+};
 #[cfg(target_os = "android")]
 use talpid_core::mpsc::Sender;
-use talpid_types::net::{AllowedClients, Connectivity};
+use talpid_types::net::{proxy::CustomProxy, AllowedClients, Connectivity};
+
+pub struct BridgeAndDNSProxyProvider<T> {
+    bridge_provider: T,
+    encrypted_dns_proxy_cache: EncryptedDnsProxyState,
+}
+
+impl<T: ShadowsocksBridgeProvider> BridgeAndDNSProxyProvider<T> {
+    pub fn new(bridge_provider: T, encrypted_dns_proxy_cache: EncryptedDnsProxyState) -> Self {
+        Self {
+            bridge_provider,
+            encrypted_dns_proxy_cache,
+        }
+    }
+}
+
+#[async_trait]
+impl<T> BridgeAndDNSProxy for BridgeAndDNSProxyProvider<T>
+where
+    T: ShadowsocksBridgeProvider,
+{
+    async fn match_access_method(
+        &mut self,
+        access_method: &AccessMethodSetting,
+    ) -> Option<ApiConnectionMode> {
+        let connection_mode = {
+            match &access_method.access_method {
+                AccessMethod::BuiltIn(BuiltInAccessMethod::Direct) => ApiConnectionMode::Direct,
+                AccessMethod::BuiltIn(BuiltInAccessMethod::Bridge) => {
+                    let Some(bridge) = self.bridge_provider.get_bridge_forced() else {
+                        log::warn!("Could not select a Mullvad bridge");
+                        log::debug!("The relay list might be empty");
+                        return None;
+                    };
+                    let proxy = CustomProxy::Shadowsocks(bridge);
+                    ApiConnectionMode::Proxied(ProxyConfig::from(proxy))
+                }
+                AccessMethod::BuiltIn(BuiltInAccessMethod::EncryptedDnsProxy) => {
+                    if let Err(error) = self
+                        .encrypted_dns_proxy_cache
+                        .fetch_configs("frakta.eu")
+                        .await
+                    {
+                        log::warn!("Failed to fetch new Encrypted DNS Proxy configurations");
+                        log::debug!("{error:#?}");
+                    }
+                    let Some(edp) = self.encrypted_dns_proxy_cache.next_configuration() else {
+                        log::warn!("Could not select next Encrypted DNS proxy config");
+                        return None;
+                    };
+                    ApiConnectionMode::Proxied(ProxyConfig::from(edp))
+                }
+                AccessMethod::Custom(config) => {
+                    ApiConnectionMode::Proxied(ProxyConfig::from(config.clone()))
+                }
+            }
+        };
+        Some(connection_mode)
+    }
+}
 
 #[derive(Clone, Copy)]
 pub struct AllowedClientsSelector {}
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
@@ -31,7 +31,7 @@ pub mod version;
 mod version_check;
 
 use crate::target_state::PersistentTargetState;
-use api::AllowedClientsSelector;
+use api::{AllowedClientsSelector, BridgeAndDNSProxyProvider};
 use device::{AccountEvent, PrivateAccountAndDevice, PrivateDeviceEvent};
 use futures::{
     channel::{mpsc, oneshot},
@@ -41,7 +41,8 @@ use futures::{
 use geoip::GeoIpHandler;
 use leak_checker::{LeakChecker, LeakInfo};
 use management_interface::ManagementInterfaceServer;
-use mullvad_api::{api::AccessMethodEvent, proxy::AllowedClientsProvider, ApiEndpoint};
+use mullvad_api::{access_mode::AccessMethodEvent, proxy::AllowedClientsProvider, ApiEndpoint};
+use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
 use mullvad_relay_selector::{RelaySelector, SelectorConfig};
 #[cfg(target_os = "android")]
 use mullvad_types::account::{PlayPurchase, PlayPurchasePaymentToken};
@@ -196,7 +197,7 @@ pub enum Error {
     AccessMethodError(#[source] access_method::Error),
 
     #[error("API connection mode error")]
-    ApiConnectionModeError(#[source] mullvad_api::api::Error),
+    ApiConnectionModeError(#[source] mullvad_api::access_mode::Error),
     #[error("No custom bridge has been specified")]
     NoCustomProxySaved,
 
@@ -610,7 +611,7 @@ pub struct Daemon {
     account_history: account_history::AccountHistory,
     device_checker: device::TunnelStateChangeHandler,
     account_manager: device::AccountManagerHandle,
-    access_mode_handler: mullvad_api::api::AccessModeSelectorHandle,
+    access_mode_handler: mullvad_api::access_mode::AccessModeSelectorHandle,
     api_runtime: mullvad_api::Runtime,
     api_handle: mullvad_api::rest::MullvadRestHandle,
     version_updater_handle: version_check::VersionUpdaterHandle,
@@ -706,10 +707,14 @@ impl Daemon {
                 .set_config(SelectorConfig::from_settings(settings));
         });
 
+        let encrypted_dns_proxy_cache = EncryptedDnsProxyState::default();
+        let bridge_dns_proxy_provider =
+            BridgeAndDNSProxyProvider::new(relay_selector.clone(), encrypted_dns_proxy_cache);
+
         let (access_mode_handler, access_mode_provider) =
-            mullvad_api::api::AccessModeSelector::<AllowedClientsSelector>::spawn(
+            mullvad_api::access_mode::AccessModeSelector::<AllowedClientsSelector>::spawn(
                 config.cache_dir.clone(),
-                relay_selector.clone(),
+                Box::new(bridge_dns_proxy_provider),
                 settings.api_access_methods.clone(),
                 #[cfg(feature = "api-override")]
                 config.endpoint.clone(),
@@ -2892,9 +2897,10 @@ impl Daemon {
         {
             Ok(Some(test_subject)) => test_subject,
             Ok(None) => {
-                let error = Error::ApiConnectionModeError(mullvad_api::api::Error::Resolve {
-                    access_method: access_method.access_method,
-                });
+                let error =
+                    Error::ApiConnectionModeError(mullvad_api::access_mode::Error::Resolve {
+                        access_method: access_method.access_method,
+                    });
                 reply(Err(error));
                 return;
             }
diff --git a/mullvad-relay-selector/src/relay_selector/mod.rs b/mullvad-relay-selector/src/relay_selector/mod.rs
diff --git a/mullvad-types/src/relay_list.rs b/mullvad-types/src/relay_list.rs
