Remove allowed clients provider

Author: buggmagnet

mullvad-api/src/access_mode.rs

@@ -7,7 +7,7 @@
 #[cfg(feature = "api-override")]
 use crate::ApiEndpoint;
 use crate::{
-    proxy::{AllowedClientsProvider, ApiConnectionMode, ConnectionModeProvider},
+    proxy::{ApiConnectionMode, ConnectionModeProvider},
     AddressCache,
 };
 use async_trait::async_trait;
@@ -16,8 +16,8 @@ use futures::{
     StreamExt,
 };
 use mullvad_types::access_method::{AccessMethod, AccessMethodSetting, Id, Settings};
-use std::{marker::PhantomData, net::SocketAddr, path::PathBuf};
-use talpid_types::net::{AllowedEndpoint, Endpoint, TransportProtocol};
+use std::{net::SocketAddr, path::PathBuf};
+use talpid_types::net::{AllowedClients, AllowedEndpoint, Endpoint, TransportProtocol};
 
 pub enum Message {
     Get(ResponseTx<ResolvedConnectionMode>),
@@ -242,29 +242,25 @@ impl ConnectionModeProvider for AccessModeConnectionModeProvider {
 /// [`ApiConnectionMode::Direct`]) via a bridge ([`ApiConnectionMode::Proxied`])
 /// or via any supported custom proxy protocol
 /// ([`talpid_types::net::proxy::CustomProxy`]).
-pub struct AccessModeSelector<P> {
+pub struct AccessModeSelector<B: BridgeAndDNSProxy> {
     #[cfg(feature = "api-override")]
     api_endpoint: ApiEndpoint,
     cmd_rx: mpsc::UnboundedReceiver<Message>,
     cache_dir: PathBuf,
-    bridge_dns_proxy_provider: Box<dyn BridgeAndDNSProxy>,
+    bridge_dns_proxy_provider: B,
     access_method_settings: Settings,
     address_cache: AddressCache,
     access_method_event_sender: mpsc::UnboundedSender<(AccessMethodEvent, oneshot::Sender<()>)>,
     connection_mode_provider_sender: mpsc::UnboundedSender<ApiConnectionMode>,
     current: ResolvedConnectionMode,
     /// `index` is used to keep track of the [`AccessMethodSetting`] to use.
     index: usize,
-    provider: PhantomData<P>,
 }
 
-impl<P> AccessModeSelector<P>
-where
-    P: AllowedClientsProvider + 'static,
-{
+impl<B: BridgeAndDNSProxy + 'static> AccessModeSelector<B> {
     pub async fn spawn(
         cache_dir: PathBuf,
-        mut bridge_dns_proxy_provider: Box<dyn BridgeAndDNSProxy>,
+        mut bridge_dns_proxy_provider: B,
         #[cfg_attr(not(feature = "api-override"), allow(unused_mut))]
         mut access_method_settings: Settings,
         #[cfg(feature = "api-override")] api_endpoint: ApiEndpoint,
@@ -283,18 +279,15 @@ where
 
         // 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,
-            &address_cache,
-            &mut *bridge_dns_proxy_provider,
-        )
-        .await;
+        let initial_connection_mode =
+            Self::resolve_inner_with_default(&next, &address_cache, &mut bridge_dns_proxy_provider)
+                .await;
 
         let (change_tx, change_rx) = mpsc::unbounded();
 
         let api_connection_mode = initial_connection_mode.connection_mode.clone();
 
-        let selector: AccessModeSelector<P> = AccessModeSelector {
+        let selector = AccessModeSelector {
             #[cfg(feature = "api-override")]
             api_endpoint,
             cmd_rx,
@@ -306,7 +299,6 @@ where
             connection_mode_provider_sender: change_tx,
             current: initial_connection_mode,
             index,
-            provider: PhantomData,
         };
 
         tokio::spawn(selector.into_future());
@@ -527,21 +519,21 @@ where
         Self::resolve_inner(
             &access_method,
             &self.address_cache,
-            &mut *self.bridge_dns_proxy_provider,
+            &mut self.bridge_dns_proxy_provider,
         )
         .await
     }
 
     async fn resolve_inner(
         access_method: &AccessMethodSetting,
         address_cache: &AddressCache,
-        bridge_dns_proxy_provider: &mut dyn BridgeAndDNSProxy,
+        bridge_dns_proxy_provider: &mut B,
     ) -> Option<ResolvedConnectionMode> {
         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);
+            resolve_allowed_endpoint::<B>(&connection_mode, address_cache.get_address().await);
         Some(ResolvedConnectionMode {
             connection_mode,
             endpoint,
@@ -558,21 +550,21 @@ where
         Self::resolve_inner_with_default(
             &access_method,
             &self.address_cache,
-            &mut *self.bridge_dns_proxy_provider,
+            &mut self.bridge_dns_proxy_provider,
         )
         .await
     }
 
     async fn resolve_inner_with_default(
         access_method: &AccessMethodSetting,
         address_cache: &AddressCache,
-        bridge_dns_proxy_provider: &mut dyn BridgeAndDNSProxy,
+        bridge_dns_proxy_provider: &mut B,
     ) -> ResolvedConnectionMode {
         match Self::resolve_inner(access_method, address_cache, bridge_dns_proxy_provider).await {
             Some(resolved) => resolved,
             None => {
                 log::trace!("Defaulting to direct API connection");
-                let endpoint = resolve_allowed_endpoint::<P>(
+                let endpoint = resolve_allowed_endpoint::<B>(
                     &ApiConnectionMode::Direct,
                     address_cache.get_address().await,
                 );
@@ -592,19 +584,21 @@ pub trait BridgeAndDNSProxy: Send + Sync {
         &mut self,
         access_method: &AccessMethodSetting,
     ) -> Option<ApiConnectionMode>;
+
+    fn allowed_clients(connection_mode: &ApiConnectionMode) -> AllowedClients;
 }
 
-pub fn resolve_allowed_endpoint<P>(
+pub fn resolve_allowed_endpoint<B>(
     connection_mode: &ApiConnectionMode,
     fallback: SocketAddr,
 ) -> AllowedEndpoint
 where
-    P: AllowedClientsProvider,
+    B: BridgeAndDNSProxy,
 {
     let endpoint = match connection_mode.get_endpoint() {
         Some(endpoint) => endpoint,
         None => Endpoint::from_socket_address(fallback, TransportProtocol::Tcp),
     };
-    let clients = P::allowed_clients(connection_mode);
+    let clients = B::allowed_clients(connection_mode);
     AllowedEndpoint { endpoint, clients }
 }

mullvad-api/src/proxy.rs

@@ -53,10 +53,6 @@ impl ConnectionModeProvider for StaticConnectionModeProvider {
     }
 }
 
-pub trait AllowedClientsProvider: Send + Sync {
-    fn allowed_clients(connection_mode: &ApiConnectionMode) -> AllowedClients;
-}
-
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum ApiConnectionMode {
     /// Connect directly to the target.

mullvad-daemon/src/api.rs

@@ -6,7 +6,7 @@ use futures::{channel::mpsc, StreamExt};
 use mullvad_api::{
     access_mode::BridgeAndDNSProxy,
     availability::ApiAvailability,
-    proxy::{AllowedClientsProvider, ApiConnectionMode, ProxyConfig},
+    proxy::{ApiConnectionMode, ProxyConfig},
 };
 use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
 use mullvad_management_interface::async_trait;
@@ -73,12 +73,7 @@ impl BridgeAndDNSProxy for BridgeAndDNSProxyProvider {
         };
         Some(connection_mode)
     }
-}
-
-#[derive(Clone, Copy)]
-pub struct AllowedClientsSelector {}
 
-impl AllowedClientsProvider for AllowedClientsSelector {
     #[cfg(unix)]
     fn allowed_clients(connection_mode: &ApiConnectionMode) -> AllowedClients {
         match connection_mode {

mullvad-daemon/src/lib.rs

@@ -31,7 +31,7 @@ pub mod version;
 mod version_check;
 
 use crate::target_state::PersistentTargetState;
-use api::{AllowedClientsSelector, BridgeAndDNSProxyProvider};
+use api::BridgeAndDNSProxyProvider;
 use device::{AccountEvent, PrivateAccountAndDevice, PrivateDeviceEvent};
 use futures::{
     channel::{mpsc, oneshot},
@@ -41,7 +41,10 @@ use futures::{
 use geoip::GeoIpHandler;
 use leak_checker::{LeakChecker, LeakInfo};
 use management_interface::ManagementInterfaceServer;
-use mullvad_api::{access_mode::AccessMethodEvent, proxy::AllowedClientsProvider, ApiEndpoint};
+use mullvad_api::{
+    access_mode::{AccessMethodEvent, BridgeAndDNSProxy},
+    ApiEndpoint,
+};
 use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
 use mullvad_relay_selector::{RelaySelector, SelectorConfig};
 #[cfg(target_os = "android")]
@@ -712,9 +715,9 @@ impl Daemon {
             BridgeAndDNSProxyProvider::new(relay_selector.clone(), encrypted_dns_proxy_cache);
 
         let (access_mode_handler, access_mode_provider) =
-            mullvad_api::access_mode::AccessModeSelector::<AllowedClientsSelector>::spawn(
+            mullvad_api::access_mode::AccessModeSelector::spawn(
                 config.cache_dir.clone(),
-                Box::new(bridge_dns_proxy_provider),
+                bridge_dns_proxy_provider,
                 settings.api_access_methods.clone(),
                 #[cfg(feature = "api-override")]
                 config.endpoint.clone(),
@@ -2855,7 +2858,7 @@ impl Daemon {
         let api_proxy = self.create_limited_api_proxy(connection_mode.clone());
         let proxy_endpoint = AllowedEndpoint {
             endpoint: proxy.get_remote_endpoint().endpoint,
-            clients: AllowedClientsSelector::allowed_clients(&connection_mode),
+            clients: BridgeAndDNSProxyProvider::allowed_clients(&connection_mode),
         };
 
         let daemon_event_sender = self.tx.to_specialized_sender();