Remove ANY_PROTOCOL and ANY_TUNNEL from protobuf schema

4 files changed, 99 insertions, 73 deletions

diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index ba00654258..b23f8638d3 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -10,7 +10,8 @@ use mullvad_management_interface::types::{
     connection_config::{self, OpenvpnConfig, WireguardConfig},
     relay_settings, relay_settings_update, ConnectionConfig, CustomRelaySettings,
     NormalRelaySettingsUpdate, OpenvpnConstraints, RelaySettingsUpdate, TransportProtocol,
-    TunnelType, TunnelTypeUpdate, WireguardConstraints,
+    TransportProtocolConstraint, TunnelType, TunnelTypeConstraint, TunnelTypeUpdate,
+    WireguardConstraints,
 };
 use mullvad_types::relay_constraints::Constraint;
 use talpid_types::net::all_of_the_internet;
@@ -351,7 +352,11 @@ impl Relay {
                         NormalRelaySettingsUpdate {
                             openvpn_constraints: Some(OpenvpnConstraints {
                                 port: port.unwrap_or(0) as u32,
-                                protocol: protocol.unwrap_or(TransportProtocol::AnyProtocol) as i32,
+                                protocol: protocol.option().map(|protocol| {
+                                    TransportProtocolConstraint {
+                                        protocol: protocol as i32,
+                                    }
+                                }),
                             }),
                             ..Default::default()
                         },
@@ -365,16 +370,18 @@ impl Relay {
 
     async fn set_tunnel_protocol(&self, matches: &clap::ArgMatches<'_>) -> Result<()> {
         let tunnel_type = match matches.value_of("tunnel protocol").unwrap() {
-            "wireguard" => TunnelType::Wireguard,
-            "openvpn" => TunnelType::Openvpn,
-            "any" => TunnelType::AnyTunnel,
+            "wireguard" => Some(TunnelType::Wireguard),
+            "openvpn" => Some(TunnelType::Openvpn),
+            "any" => None,
             _ => unreachable!(),
         };
         self.update_constraints(RelaySettingsUpdate {
             r#type: Some(relay_settings_update::Type::Normal(
                 NormalRelaySettingsUpdate {
                     tunnel_type: Some(TunnelTypeUpdate {
-                        tunnel_type: tunnel_type as i32,
+                        tunnel_type: tunnel_type.map(|tunnel_type| TunnelTypeConstraint {
+                            tunnel_type: tunnel_type as i32,
+                        }),
                     }),
                     ..Default::default()
                 },
@@ -395,18 +402,16 @@ impl Relay {
         print!("Current constraints: ");
 
         match constraints.endpoint.unwrap() {
-            relay_settings::Endpoint::Normal(settings) => {
-                match TunnelType::from_i32(settings.tunnel_type).expect("unknown tunnel type") {
-                    TunnelType::AnyTunnel => {
-                        println!(
-                            "Any tunnel protocol with OpenVPN over {} and WireGuard over {} in {}",
-                            Self::format_openvpn_constraints(settings.openvpn_constraints.as_ref()),
-                            Self::format_wireguard_constraints(
-                                settings.wireguard_constraints.as_ref()
-                            ),
-                            location::format_location(settings.location.as_ref())
-                        );
-                    }
+            relay_settings::Endpoint::Normal(settings) => match settings.tunnel_type {
+                None => {
+                    println!(
+                        "Any tunnel protocol with OpenVPN over {} and WireGuard over {} in {}",
+                        Self::format_openvpn_constraints(settings.openvpn_constraints.as_ref()),
+                        Self::format_wireguard_constraints(settings.wireguard_constraints.as_ref()),
+                        location::format_location(settings.location.as_ref())
+                    );
+                }
+                Some(constraint) => match TunnelType::from_i32(constraint.tunnel_type).unwrap() {
                     TunnelType::Wireguard => {
                         println!(
                             "WireGuard over {} in {}",
@@ -423,8 +428,8 @@ impl Relay {
                             location::format_location(settings.location.as_ref())
                         );
                     }
-                }
-            }
+                },
+            },
 
             relay_settings::Endpoint::Custom(settings) => {
                 let config = settings.config.unwrap();
@@ -433,9 +438,9 @@ impl Relay {
                         println!(
                             "custom OpenVPN relay - {} {}",
                             config.address,
-                            Self::format_transport_protocol(
+                            Self::format_transport_protocol(Some(
                                 TransportProtocol::from_i32(config.protocol).unwrap()
-                            ),
+                            )),
                         );
                     }
                     connection_config::Config::Wireguard(config) => {
@@ -522,11 +527,11 @@ impl Relay {
         Ok(())
     }
 
-    fn format_transport_protocol(protocol: TransportProtocol) -> &'static str {
+    fn format_transport_protocol(protocol: Option<TransportProtocol>) -> &'static str {
         match protocol {
-            TransportProtocol::AnyProtocol => "any transport protocol",
-            TransportProtocol::Udp => "UDP",
-            TransportProtocol::Tcp => "TCP",
+            None => "any transport protocol",
+            Some(TransportProtocol::Udp) => "UDP",
+            Some(TransportProtocol::Tcp) => "TCP",
         }
     }
 
@@ -544,7 +549,10 @@ impl Relay {
                 "{} over {}",
                 Self::format_port(constraints.port),
                 Self::format_transport_protocol(
-                    TransportProtocol::from_i32(constraints.protocol).unwrap()
+                    constraints
+                        .protocol
+                        .clone()
+                        .map(|protocol| TransportProtocol::from_i32(protocol.protocol).unwrap())
                 )
             )
         } else {
diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index 5084cea8b8..339439fffc 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -133,7 +133,6 @@ fn format_endpoint(endpoint: &TunnelEndpoint) -> String {
         match TunnelType::from_i32(endpoint.tunnel_type).expect("unknown tunnel protocol") {
             TunnelType::Wireguard => "WireGuard",
             TunnelType::Openvpn => "OpenVPN",
-            TunnelType::AnyTunnel => panic!("unexpected tunnel protocol"),
         },
         endpoint.address,
         format_protocol(
@@ -284,6 +283,5 @@ fn format_protocol(protocol: TransportProtocol) -> &'static str {
     match protocol {
         TransportProtocol::Udp => "UDP",
         TransportProtocol::Tcp => "TCP",
-        TransportProtocol::AnyProtocol => panic!("unexpected transport protocol"),
     }
 }
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 01dfffbcfe..6f9b3a0068 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -830,9 +830,9 @@ fn convert_relay_settings_update(
                             protocol: match types::TransportProtocol::from_i32(config.protocol) {
                                 Some(types::TransportProtocol::Udp) => TransportProtocol::Udp,
                                 Some(types::TransportProtocol::Tcp) => TransportProtocol::Tcp,
-                                None | Some(types::TransportProtocol::AnyProtocol) => {
+                                None => {
                                     return Err(Status::invalid_argument(
-                                        "unknown transport protocol",
+                                        "invalid transport protocol",
                                     ))
                                 }
                             },
@@ -934,13 +934,34 @@ fn convert_relay_settings_update(
             let location = settings.location.map(convert_proto_location);
 
             let tunnel_protocol = if let Some(update) = settings.tunnel_type {
-                match types::TunnelType::from_i32(update.tunnel_type) {
-                    Some(types::TunnelType::AnyTunnel) => Some(Constraint::Any),
-                    Some(types::TunnelType::Openvpn) => Some(Constraint::Only(TunnelType::OpenVpn)),
-                    Some(types::TunnelType::Wireguard) => {
-                        Some(Constraint::Only(TunnelType::Wireguard))
+                match update.tunnel_type {
+                    Some(constraint) => match types::TunnelType::from_i32(constraint.tunnel_type) {
+                        Some(types::TunnelType::Openvpn) => {
+                            Some(Constraint::Only(TunnelType::OpenVpn))
+                        }
+                        Some(types::TunnelType::Wireguard) => {
+                            Some(Constraint::Only(TunnelType::Wireguard))
+                        }
+                        None => return Err(Status::invalid_argument("unknown tunnel protocol")),
+                    },
+                    None => Some(Constraint::Any),
+                }
+            } else {
+                None
+            };
+
+            let transport_protocol = if let Some(ref constraints) = settings.openvpn_constraints {
+                match &constraints.protocol {
+                    Some(constraint) => {
+                        match types::TransportProtocol::from_i32(constraint.protocol) {
+                            Some(types::TransportProtocol::Udp) => Some(TransportProtocol::Udp),
+                            Some(types::TransportProtocol::Tcp) => Some(TransportProtocol::Tcp),
+                            None => {
+                                return Err(Status::invalid_argument("unknown transport protocol"))
+                            }
+                        }
                     }
-                    None => return Err(Status::invalid_argument("unknown tunnel protocol")),
+                    None => None,
                 }
             } else {
                 None
@@ -965,15 +986,7 @@ fn convert_relay_settings_update(
                         } else {
                             Constraint::Any
                         },
-                        protocol: match types::TransportProtocol::from_i32(constraints.protocol) {
-                            Some(types::TransportProtocol::Udp) => {
-                                Constraint::Only(TransportProtocol::Udp)
-                            }
-                            Some(types::TransportProtocol::Tcp) => {
-                                Constraint::Only(TransportProtocol::Tcp)
-                            }
-                            _ => Constraint::Any,
-                        },
+                        protocol: Constraint::from(transport_protocol),
                     }
                 }),
             }))
@@ -995,12 +1008,13 @@ fn convert_relay_settings(settings: &RelaySettings) -> types::RelaySettings {
             relay_settings::Endpoint::Normal(types::NormalRelaySettings {
                 location: convert_location_constraint(&constraints.location),
                 tunnel_type: match constraints.tunnel_protocol {
-                    Constraint::Any => i32::from(types::TunnelType::AnyTunnel),
-                    Constraint::Only(TunnelType::Wireguard) => {
-                        i32::from(types::TunnelType::Wireguard)
-                    }
-                    Constraint::Only(TunnelType::OpenVpn) => i32::from(types::TunnelType::Openvpn),
-                },
+                    Constraint::Any => None,
+                    Constraint::Only(TunnelType::Wireguard) => Some(types::TunnelType::Wireguard),
+                    Constraint::Only(TunnelType::OpenVpn) => Some(types::TunnelType::Openvpn),
+                }
+                .map(|tunnel_type| types::TunnelTypeConstraint {
+                    tunnel_type: i32::from(tunnel_type),
+                }),
 
                 wireguard_constraints: Some(types::WireguardConstraints {
                     port: u32::from(constraints.wireguard_constraints.port.unwrap_or(0)),
@@ -1008,16 +1022,18 @@ fn convert_relay_settings(settings: &RelaySettings) -> types::RelaySettings {
 
                 openvpn_constraints: Some(types::OpenvpnConstraints {
                     port: u32::from(constraints.openvpn_constraints.port.unwrap_or(0)),
-                    protocol: i32::from(
-                        constraints
-                            .openvpn_constraints
-                            .protocol
-                            .map(|protocol| match protocol {
-                                TransportProtocol::Tcp => types::TransportProtocol::Tcp,
-                                TransportProtocol::Udp => types::TransportProtocol::Udp,
-                            })
-                            .unwrap_or(types::TransportProtocol::AnyProtocol),
-                    ),
+                    protocol: constraints
+                        .openvpn_constraints
+                        .protocol
+                        .as_ref()
+                        .option()
+                        .map(|protocol| match protocol {
+                            TransportProtocol::Tcp => types::TransportProtocol::Tcp,
+                            TransportProtocol::Udp => types::TransportProtocol::Udp,
+                        })
+                        .map(|protocol| types::TransportProtocolConstraint {
+                            protocol: i32::from(protocol),
+                        }),
                 }),
             })
         }
diff --git a/mullvad-management-interface/proto/management_interface.proto b/mullvad-management-interface/proto/management_interface.proto
index ea62f6976e..6eabb0965a 100644
--- a/mullvad-management-interface/proto/management_interface.proto
+++ b/mullvad-management-interface/proto/management_interface.proto
@@ -155,9 +155,8 @@ message TunnelState {
 }
 
 enum TunnelType {
-	ANY_TUNNEL = 0;
-	OPENVPN = 1;
-	WIREGUARD = 2;
+	OPENVPN = 0;
+	WIREGUARD = 1;
 }
 
 message TunnelStateRelayInfo {
@@ -267,9 +266,13 @@ message RelaySettings {
 	}
 }
 
+message TunnelTypeConstraint {
+	TunnelType tunnel_type = 1;
+}
+
 message NormalRelaySettings {
 	RelayLocation location = 1;
-	TunnelType tunnel_type = 2;
+	TunnelTypeConstraint tunnel_type = 2;
 	WireguardConstraints wireguard_constraints = 3;
 	OpenvpnConstraints openvpn_constraints = 4;
 }
@@ -283,14 +286,16 @@ message NormalRelaySettingsUpdate {
 }
 
 message TunnelTypeUpdate {
-	TunnelType tunnel_type = 1;
+	TunnelTypeConstraint tunnel_type = 2;
+}
+
+message TransportProtocolConstraint {
+	TransportProtocol protocol = 1;
 }
 
 message OpenvpnConstraints {
-	// NOTE: optional
 	uint32 port = 1;
-	// NOTE: optional
-	TransportProtocol protocol = 2;
+	TransportProtocolConstraint protocol = 2;
 }
 message WireguardConstraints {
 	// NOTE: optional
@@ -422,9 +427,8 @@ message RelayBridges {
 }
 
 enum TransportProtocol {
-	ANY_PROTOCOL = 0;
-	UDP = 1;
-	TCP = 2;
+	UDP = 0;
+	TCP = 1;
 }
 
 message ShadowsocksEndpointData {