Implement TryFrom for BridgeSettings

2 files changed, 92 insertions, 77 deletions

diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 18f676a1e8..73916f29ef 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -10,9 +10,7 @@ use mullvad_rpc::{rest::Error as RestError, StatusCode};
 use mullvad_types::settings::DnsOptions;
 use mullvad_types::{
     account::AccountToken,
-    relay_constraints::{
-        BridgeConstraints, BridgeSettings, BridgeState, Constraint, Providers, RelaySettingsUpdate,
-    },
+    relay_constraints::{BridgeSettings, BridgeState, RelaySettingsUpdate},
     relay_list::RelayList,
     settings::Settings,
     states::{TargetState, TunnelState},
@@ -229,80 +227,12 @@ impl ManagementService for ManagementServiceImpl {
         &self,
         request: Request<types::BridgeSettings>,
     ) -> ServiceResult<()> {
-        use talpid_types::net;
-        use types::bridge_settings::Type as BridgeSettingType;
-
-        let settings = request
-            .into_inner()
-            .r#type
-            .ok_or(Status::invalid_argument("no settings provided"))?;
-
-        let settings = match settings {
-            BridgeSettingType::Normal(constraints) => {
-                let location = match constraints.location {
-                    None => Constraint::Any,
-                    Some(location) => Constraint::<
-                        mullvad_types::relay_constraints::LocationConstraint,
-                    >::from(location),
-                };
-                let providers = if constraints.providers.is_empty() {
-                    Constraint::Any
-                } else {
-                    Constraint::Only(
-                        Providers::new(constraints.providers.clone().into_iter()).map_err(
-                            |_| Status::invalid_argument("must specify at least one provider"),
-                        )?,
-                    )
-                };
-
-                BridgeSettings::Normal(BridgeConstraints {
-                    location,
-                    providers,
-                })
-            }
-            BridgeSettingType::Local(proxy_settings) => {
-                let peer = proxy_settings
-                    .peer
-                    .parse()
-                    .map_err(|_| Status::invalid_argument("failed to parse peer address"))?;
-                let proxy_settings =
-                    net::openvpn::ProxySettings::Local(net::openvpn::LocalProxySettings {
-                        port: proxy_settings.port as u16,
-                        peer,
-                    });
-                BridgeSettings::Custom(proxy_settings)
-            }
-            BridgeSettingType::Remote(proxy_settings) => {
-                let address = proxy_settings
-                    .address
-                    .parse()
-                    .map_err(|_| Status::invalid_argument("failed to parse IP address"))?;
-                let auth = proxy_settings.auth.map(|auth| net::openvpn::ProxyAuth {
-                    username: auth.username,
-                    password: auth.password,
-                });
-                let proxy_settings =
-                    net::openvpn::ProxySettings::Remote(net::openvpn::RemoteProxySettings {
-                        address,
-                        auth,
-                    });
-                BridgeSettings::Custom(proxy_settings)
-            }
-            BridgeSettingType::Shadowsocks(proxy_settings) => {
-                let peer = proxy_settings
-                    .peer
-                    .parse()
-                    .map_err(|_| Status::invalid_argument("failed to parse peer address"))?;
-                let proxy_settings = net::openvpn::ProxySettings::Shadowsocks(
-                    net::openvpn::ShadowsocksProxySettings {
-                        peer,
-                        password: proxy_settings.password,
-                        cipher: proxy_settings.cipher,
-                    },
-                );
-                BridgeSettings::Custom(proxy_settings)
-            }
-        };
+        let settings =
+            BridgeSettings::try_from(request.into_inner()).map_err(|error| match error {
+                types::FromProtobufTypeError::InvalidArgument(error) => {
+                    Status::invalid_argument(error)
+                }
+            })?;
 
         log::debug!("set_bridge_settings({:?})", settings);
 
diff --git a/mullvad-management-interface/src/types.rs b/mullvad-management-interface/src/types.rs
index 49ab04d5c5..ad68c57360 100644
--- a/mullvad-management-interface/src/types.rs
+++ b/mullvad-management-interface/src/types.rs
@@ -904,6 +904,91 @@ impl From<RelayLocation> for Constraint<mullvad_types::relay_constraints::Locati
     }
 }
 
+impl TryFrom<BridgeSettings> for mullvad_types::relay_constraints::BridgeSettings {
+    type Error = FromProtobufTypeError;
+
+    fn try_from(settings: BridgeSettings) -> Result<Self, Self::Error> {
+        use mullvad_types::relay_constraints as mullvad_constraints;
+        use talpid_types::net as talpid_net;
+
+        match settings
+            .r#type
+            .ok_or(FromProtobufTypeError::InvalidArgument(
+                "no settings provided",
+            ))? {
+            bridge_settings::Type::Normal(constraints) => {
+                let location = match constraints.location {
+                    None => Constraint::Any,
+                    Some(location) => {
+                        Constraint::<mullvad_constraints::LocationConstraint>::from(location)
+                    }
+                };
+                let providers = if constraints.providers.is_empty() {
+                    Constraint::Any
+                } else {
+                    Constraint::Only(
+                        mullvad_constraints::Providers::new(
+                            constraints.providers.clone().into_iter(),
+                        )
+                        .map_err(|_| {
+                            FromProtobufTypeError::InvalidArgument(
+                                "must specify at least one provider",
+                            )
+                        })?,
+                    )
+                };
+
+                Ok(mullvad_constraints::BridgeSettings::Normal(
+                    mullvad_constraints::BridgeConstraints {
+                        location,
+                        providers,
+                    },
+                ))
+            }
+            bridge_settings::Type::Local(proxy_settings) => {
+                let peer = proxy_settings.peer.parse().map_err(|_| {
+                    FromProtobufTypeError::InvalidArgument("failed to parse peer address")
+                })?;
+                let proxy_settings = talpid_net::openvpn::ProxySettings::Local(
+                    talpid_net::openvpn::LocalProxySettings {
+                        port: proxy_settings.port as u16,
+                        peer,
+                    },
+                );
+                Ok(mullvad_constraints::BridgeSettings::Custom(proxy_settings))
+            }
+            bridge_settings::Type::Remote(proxy_settings) => {
+                let address = proxy_settings.address.parse().map_err(|_| {
+                    FromProtobufTypeError::InvalidArgument("failed to parse IP address")
+                })?;
+                let auth = proxy_settings
+                    .auth
+                    .map(|auth| talpid_net::openvpn::ProxyAuth {
+                        username: auth.username,
+                        password: auth.password,
+                    });
+                let proxy_settings = talpid_net::openvpn::ProxySettings::Remote(
+                    talpid_net::openvpn::RemoteProxySettings { address, auth },
+                );
+                Ok(mullvad_constraints::BridgeSettings::Custom(proxy_settings))
+            }
+            bridge_settings::Type::Shadowsocks(proxy_settings) => {
+                let peer = proxy_settings.peer.parse().map_err(|_| {
+                    FromProtobufTypeError::InvalidArgument("failed to parse peer address")
+                })?;
+                let proxy_settings = talpid_net::openvpn::ProxySettings::Shadowsocks(
+                    talpid_net::openvpn::ShadowsocksProxySettings {
+                        peer,
+                        password: proxy_settings.password,
+                        cipher: proxy_settings.cipher,
+                    },
+                );
+                Ok(mullvad_constraints::BridgeSettings::Custom(proxy_settings))
+            }
+        }
+    }
+}
+
 fn convert_providers_constraint(
     providers: &Constraint<mullvad_types::relay_constraints::Providers>,
 ) -> Vec<String> {