Simplify stuff

Author: dlon

mullvad-types/src/constraints/constraint.rs

@@ -5,7 +5,7 @@ use jnix::{FromJava, IntoJava};
 use serde::{Deserialize, Serialize};
 use std::{fmt, str::FromStr};
 
-use crate::Intersection;
+use crate::{Intersection, IntoProto, TryFromProto};
 
 /// Limits the set of [`crate::relay_list::Relay`]s that a `RelaySelector` may select.
 #[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
@@ -18,6 +18,23 @@ pub enum Constraint<T> {
     Only(T),
 }
 
+impl<T: IntoProto<S>, S> IntoProto<Option<S>> for Constraint<T> {
+    fn into_proto(self) -> Option<S> {
+        self.map(|v| v.into_proto()).option()
+    }
+}
+
+impl<T: TryFromProto<S>, S> TryFromProto<Option<S>> for Constraint<T> {
+    fn try_from_proto(
+        other: Option<S>,
+    ) -> Result<Self, crate::proto::types::FromProtobufTypeError> {
+        other
+            .map(|v| TryFromProto::try_from_proto(v))
+            .transpose()
+            .map(Constraint::from)
+    }
+}
+
 impl<T: Intersection> Intersection for Constraint<T> {
     /// Define the intersection between two arbitrary [`Constraint`]s.
     ///
@@ -46,6 +63,16 @@ impl<T: fmt::Display> fmt::Display for Constraint<T> {
     }
 }
 
+impl<T, E> Constraint<Result<T, E>> {
+    pub fn transpose(self) -> Result<Constraint<T>, E> {
+        match self {
+            Constraint::Any => Ok(Constraint::Any),
+            Constraint::Only(Ok(value)) => Ok(Constraint::Only(value)),
+            Constraint::Only(Err(err)) => Err(err),
+        }
+    }
+}
+
 impl<T> Constraint<T> {
     pub fn unwrap(self) -> T {
         match self {

mullvad-types/src/lib.rs

@@ -169,3 +169,18 @@ impl<T: TryFromProto<S> + Ord, S> TryFromProto<Vec<S>> for std::collections::BTr
             .collect()
     }
 }
+
+// There's no u16 type, so try to truncate a u32
+impl TryFromProto<u32> for u16 {
+    fn try_from_proto(other: u32) -> Result<Self, crate::proto::types::FromProtobufTypeError> {
+        u16::try_from(other).map_err(|_| {
+            crate::proto::types::FromProtobufTypeError::InvalidArgument("integer too large")
+        })
+    }
+}
+
+impl IntoProto<u32> for u16 {
+    fn into_proto(self) -> u32 {
+        u32::from(self)
+    }
+}

mullvad-types/src/proto/client.rs

@@ -268,7 +268,7 @@ impl MullvadProxyClient {
     }
 
     pub async fn set_obfuscation_settings(&mut self, settings: ObfuscationSettings) -> Result<()> {
-        let settings = types::ObfuscationSettings::from(&settings);
+        let settings = types::ObfuscationSettings::from(settings);
         self.0
             .set_obfuscation_settings(settings)
             .await

mullvad-types/src/proto/types/conversions/relay_constraints.rs

@@ -4,6 +4,7 @@ use crate::proto::types::{
 use crate::{
     constraints::Constraint, custom_list::Id, relay_constraints::GeographicLocationConstraint,
 };
+use crate::{IntoProto, TryFromProto};
 use std::str::FromStr;
 use talpid_types::net::proxy::CustomProxy;
 
@@ -26,7 +27,7 @@ impl TryFrom<&types::WireguardConstraints> for crate::relay_constraints::Wiregua
         };
 
         Ok(mullvad_constraints::WireguardConstraints {
-            port: Constraint::from(constraints.port.map(|port| port as u16)),
+            port: TryFromProto::try_from_proto(constraints.port)?,
             ip_version: Constraint::from(ip_version),
             use_multihop: constraints.use_multihop,
             entry_location: constraints
@@ -143,8 +144,8 @@ impl From<crate::relay_constraints::BridgeState> for types::BridgeState {
     }
 }
 
-impl From<&crate::relay_constraints::ObfuscationSettings> for types::ObfuscationSettings {
-    fn from(settings: &crate::relay_constraints::ObfuscationSettings) -> Self {
+impl From<crate::relay_constraints::ObfuscationSettings> for types::ObfuscationSettings {
+    fn from(settings: crate::relay_constraints::ObfuscationSettings) -> Self {
         use crate::relay_constraints::SelectedObfuscation;
         let selected_obfuscation = i32::from(match settings.selected_obfuscation {
             SelectedObfuscation::Auto => types::obfuscation_settings::SelectedObfuscation::Auto,
@@ -155,23 +156,7 @@ impl From<&crate::relay_constraints::ObfuscationSettings> for types::Obfuscation
         });
         Self {
             selected_obfuscation,
-            udp2tcp: Some(types::Udp2TcpObfuscationSettings::from(&settings.udp2tcp)),
-        }
-    }
-}
-
-impl From<crate::relay_constraints::ObfuscationSettings> for types::ObfuscationSettings {
-    fn from(settings: crate::relay_constraints::ObfuscationSettings) -> Self {
-        types::ObfuscationSettings::from(&settings)
-    }
-}
-
-impl From<&crate::relay_constraints::Udp2TcpObfuscationSettings>
-    for types::Udp2TcpObfuscationSettings
-{
-    fn from(settings: &crate::relay_constraints::Udp2TcpObfuscationSettings) -> Self {
-        Self {
-            port: settings.port.map(u32::from).option(),
+            udp2tcp: Some(settings.udp2tcp.into_proto()),
         }
     }
 }
@@ -441,7 +426,7 @@ impl TryFrom<types::ObfuscationSettings> for crate::relay_constraints::Obfuscati
 
         let udp2tcp = match settings.udp2tcp {
             Some(settings) => {
-                crate::relay_constraints::Udp2TcpObfuscationSettings::try_from(&settings)?
+                crate::relay_constraints::Udp2TcpObfuscationSettings::try_from(settings)?
             }
             None => {
                 return Err(FromProtobufTypeError::InvalidArgument(
@@ -457,18 +442,6 @@ impl TryFrom<types::ObfuscationSettings> for crate::relay_constraints::Obfuscati
     }
 }
 
-impl TryFrom<&types::Udp2TcpObfuscationSettings>
-    for crate::relay_constraints::Udp2TcpObfuscationSettings
-{
-    type Error = FromProtobufTypeError;
-
-    fn try_from(settings: &types::Udp2TcpObfuscationSettings) -> Result<Self, Self::Error> {
-        Ok(Self {
-            port: Constraint::from(settings.port.map(|port| port as u16)),
-        })
-    }
-}
-
 impl TryFrom<types::BridgeState> for crate::relay_constraints::BridgeState {
     type Error = FromProtobufTypeError;
 
@@ -490,7 +463,7 @@ impl TryFrom<types::TransportPort> for crate::relay_constraints::TransportPort {
     fn try_from(port: types::TransportPort) -> Result<Self, Self::Error> {
         Ok(crate::relay_constraints::TransportPort {
             protocol: super::net::try_transport_protocol_from_i32(port.protocol)?,
-            port: Constraint::from(port.port.map(|port| port as u16)),
+            port: TryFromProto::try_from_proto(port.port)?,
         })
     }
 }

mullvad-types/src/proto/types/conversions/settings.rs

@@ -1,6 +1,6 @@
 use crate::proto::types::{self, FromProtobufTypeError};
 use crate::settings::CURRENT_SETTINGS_VERSION;
-use crate::IntoProto;
+use crate::{IntoProto, TryFromProto};
 use talpid_types::ErrorExt;
 
 impl From<&crate::settings::Settings> for types::Settings {
@@ -37,7 +37,7 @@ impl From<&crate::settings::Settings> for types::Settings {
             tunnel_options: Some(types::TunnelOptions::from(&settings.tunnel_options)),
             show_beta_releases: settings.show_beta_releases,
             obfuscation_settings: Some(types::ObfuscationSettings::from(
-                &settings.obfuscation_settings,
+                settings.obfuscation_settings.clone(),
             )),
             split_tunnel,
             custom_lists: Some(settings.custom_lists.to_owned().into_proto()),
@@ -247,10 +247,10 @@ impl TryFrom<types::TunnelOptions> for crate::settings::TunnelOptions {
 
         Ok(Self {
             openvpn: net::openvpn::TunnelOptions {
-                mssfix: openvpn_options.mssfix.map(|mssfix| mssfix as u16),
+                mssfix: TryFromProto::try_from_proto(openvpn_options.mssfix)?,
             },
             wireguard: crate::wireguard::TunnelOptions {
-                mtu: wireguard_options.mtu.map(|mtu| mtu as u16),
+                mtu: TryFromProto::try_from_proto(wireguard_options.mtu)?,
                 rotation_interval: wireguard_options
                     .rotation_interval
                     .map(std::time::Duration::try_from)

mullvad-types/src/relay_constraints.rs

@@ -8,6 +8,7 @@ use crate::{
     relay_list::Relay,
     CustomTunnelEndpoint, Intersection,
 };
+use crate::{IntoProto, TryFromProto};
 #[cfg(target_os = "android")]
 use jnix::{jni::objects::JObject, FromJava, IntoJava, JnixEnv};
 use serde::{Deserialize, Serialize};
@@ -626,7 +627,18 @@ impl fmt::Display for SelectedObfuscation {
     }
 }
 
-#[derive(Default, Debug, Clone, Eq, PartialEq, Deserialize, Serialize, Intersection)]
+#[derive(
+    Default,
+    Debug,
+    Clone,
+    Eq,
+    PartialEq,
+    Deserialize,
+    Serialize,
+    Intersection,
+    TryFromProto,
+    IntoProto,
+)]
 #[cfg_attr(target_os = "android", derive(IntoJava))]
 #[cfg_attr(target_os = "android", jnix(package = "net.mullvad.mullvadvpn.model"))]
 #[serde(rename_all = "snake_case")]