Implement From for BridgeSettings

2 files changed, 53 insertions, 56 deletions

diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 8447996892..3ca6da5c24 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -765,7 +765,9 @@ fn convert_settings(settings: &Settings) -> types::Settings {
     types::Settings {
         account_token: settings.get_account_token().unwrap_or_default(),
         relay_settings: Some(types::RelaySettings::from(settings.get_relay_settings())),
-        bridge_settings: Some(convert_bridge_settings(&settings.bridge_settings)),
+        bridge_settings: Some(types::BridgeSettings::from(
+            settings.bridge_settings.clone(),
+        )),
         bridge_state: Some(convert_bridge_state(settings.get_bridge_state())),
         allow_lan: settings.allow_lan,
         block_when_disconnected: settings.block_when_disconnected,
@@ -998,54 +1000,6 @@ fn convert_relay_settings_update(
     }
 }
 
-fn convert_bridge_settings(settings: &BridgeSettings) -> types::BridgeSettings {
-    use talpid_types::net;
-    use types::bridge_settings::{self, Type as BridgeSettingType};
-
-    let settings = match settings {
-        BridgeSettings::Normal(constraints) => {
-            BridgeSettingType::Normal(types::bridge_settings::BridgeConstraints {
-                location: constraints
-                    .location
-                    .clone()
-                    .option()
-                    .map(types::RelayLocation::from),
-                providers: convert_providers_constraint(&constraints.providers),
-            })
-        }
-        BridgeSettings::Custom(proxy_settings) => match proxy_settings {
-            net::openvpn::ProxySettings::Local(proxy_settings) => {
-                BridgeSettingType::Local(bridge_settings::LocalProxySettings {
-                    port: u32::from(proxy_settings.port),
-                    peer: proxy_settings.peer.to_string(),
-                })
-            }
-            net::openvpn::ProxySettings::Remote(proxy_settings) => {
-                BridgeSettingType::Remote(bridge_settings::RemoteProxySettings {
-                    address: proxy_settings.address.to_string(),
-                    auth: proxy_settings.auth.as_ref().map(|auth| {
-                        bridge_settings::RemoteProxyAuth {
-                            username: auth.username.clone(),
-                            password: auth.password.clone(),
-                        }
-                    }),
-                })
-            }
-            net::openvpn::ProxySettings::Shadowsocks(proxy_settings) => {
-                BridgeSettingType::Shadowsocks(bridge_settings::ShadowsocksProxySettings {
-                    peer: proxy_settings.peer.to_string(),
-                    password: proxy_settings.password.clone(),
-                    cipher: proxy_settings.cipher.clone(),
-                })
-            }
-        },
-    };
-
-    types::BridgeSettings {
-        r#type: Some(settings),
-    }
-}
-
 fn convert_wireguard_key_event(
     event: &mullvad_types::wireguard::KeygenEvent,
 ) -> types::KeygenEvent {
@@ -1076,13 +1030,6 @@ fn convert_public_key(public_key: &wireguard::PublicKey) -> types::PublicKey {
     }
 }
 
-fn convert_providers_constraint(providers: &Constraint<Providers>) -> Vec<String> {
-    match providers.as_ref() {
-        Constraint::Any => vec![],
-        Constraint::Only(providers) => Vec::from(providers.clone()),
-    }
-}
-
 fn convert_bridge_state(state: &BridgeState) -> types::BridgeState {
     let state = match state {
         BridgeState::Auto => types::bridge_state::State::Auto,
diff --git a/mullvad-management-interface/src/types.rs b/mullvad-management-interface/src/types.rs
index 6f13cef8dd..30fe78250b 100644
--- a/mullvad-management-interface/src/types.rs
+++ b/mullvad-management-interface/src/types.rs
@@ -119,6 +119,56 @@ impl From<mullvad_types::relay_constraints::LocationConstraint> for RelayLocatio
     }
 }
 
+impl From<mullvad_types::relay_constraints::BridgeSettings> for BridgeSettings {
+    fn from(settings: mullvad_types::relay_constraints::BridgeSettings) -> Self {
+        use mullvad_types::relay_constraints::BridgeSettings as MullvadBridgeSettings;
+        use talpid_types::net as talpid_net;
+
+        let settings = match settings {
+            MullvadBridgeSettings::Normal(constraints) => {
+                bridge_settings::Type::Normal(bridge_settings::BridgeConstraints {
+                    location: constraints
+                        .location
+                        .clone()
+                        .option()
+                        .map(RelayLocation::from),
+                    providers: convert_providers_constraint(&constraints.providers),
+                })
+            }
+            MullvadBridgeSettings::Custom(proxy_settings) => match proxy_settings {
+                talpid_net::openvpn::ProxySettings::Local(proxy_settings) => {
+                    bridge_settings::Type::Local(bridge_settings::LocalProxySettings {
+                        port: u32::from(proxy_settings.port),
+                        peer: proxy_settings.peer.to_string(),
+                    })
+                }
+                talpid_net::openvpn::ProxySettings::Remote(proxy_settings) => {
+                    bridge_settings::Type::Remote(bridge_settings::RemoteProxySettings {
+                        address: proxy_settings.address.to_string(),
+                        auth: proxy_settings.auth.as_ref().map(|auth| {
+                            bridge_settings::RemoteProxyAuth {
+                                username: auth.username.clone(),
+                                password: auth.password.clone(),
+                            }
+                        }),
+                    })
+                }
+                talpid_net::openvpn::ProxySettings::Shadowsocks(proxy_settings) => {
+                    bridge_settings::Type::Shadowsocks(bridge_settings::ShadowsocksProxySettings {
+                        peer: proxy_settings.peer.to_string(),
+                        password: proxy_settings.password.clone(),
+                        cipher: proxy_settings.cipher.clone(),
+                    })
+                }
+            },
+        };
+
+        BridgeSettings {
+            r#type: Some(settings),
+        }
+    }
+}
+
 impl From<mullvad_types::relay_constraints::RelaySettings> for RelaySettings {
     fn from(settings: mullvad_types::relay_constraints::RelaySettings) -> Self {
         use mullvad_types::relay_constraints::RelaySettings as MullvadRelaySettings;