Make ProxyType private again

Author: MarkusPettersson98

mullvad-encrypted-dns-proxy/src/config/mod.rs

@@ -38,7 +38,7 @@ impl std::error::Error for Error {}
 /// Type of a proxy configuration. Derived from the 2nd hextet of an IPv6 address in network byte
 /// order. E.g. an IPv6 address such as `7f7f:2323::`  would have a proxy type value of `0x2323`.
 #[derive(PartialEq, Debug, Eq, Hash, Clone)]
-pub enum ProxyType {
+enum ProxyType {
     /// Plain proxy type
     Plain,
     /// XorV1 - deprecated
@@ -75,8 +75,6 @@ pub struct ProxyConfig {
     /// If the proxy requires some obfuscation of the data sent to/received from it,
     /// it's represented by an obfuscation config here.
     pub obfuscation: Option<ObfuscationConfig>,
-
-    pub r#type: ProxyType,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]

mullvad-encrypted-dns-proxy/src/config/plain.rs

@@ -28,15 +28,14 @@ pub fn parse_plain(data: [u8; 12]) -> Result<super::ProxyConfig, super::Error> {
     Ok(super::ProxyConfig {
         addr,
         obfuscation: None,
-        r#type: super::ProxyType::Plain,
     })
 }
 
 #[cfg(test)]
 mod tests {
     use std::net::{Ipv6Addr, SocketAddrV4};
 
-    use crate::config::{Error, ProxyConfig, ProxyType};
+    use crate::config::{Error, ProxyConfig};
 
     #[test]
     fn parsing() {
@@ -50,23 +49,20 @@ mod tests {
                 expected: Ok(ProxyConfig {
                     addr: "127.0.0.1:1337".parse::<SocketAddrV4>().unwrap(),
                     obfuscation: None,
-                    r#type: ProxyType::Plain,
                 }),
             },
             Test {
                 input: "2001:100:c0a8:101:bb01::".parse::<Ipv6Addr>().unwrap(),
                 expected: Ok(ProxyConfig {
                     addr: "192.168.1.1:443".parse::<SocketAddrV4>().unwrap(),
                     obfuscation: None,
-                    r#type: ProxyType::Plain,
                 }),
             },
             Test {
                 input: "2001:100:c0a8:101:bb01:404::".parse::<Ipv6Addr>().unwrap(),
                 expected: Ok(ProxyConfig {
                     addr: "192.168.1.1:443".parse::<SocketAddrV4>().unwrap(),
                     obfuscation: None,
-                    r#type: ProxyType::Plain,
                 }),
             },
             Test {

mullvad-encrypted-dns-proxy/src/config/xor.rs

@@ -1,4 +1,3 @@
-use super::ProxyType;
 use core::fmt;
 use std::net::{Ipv4Addr, SocketAddrV4};
 
@@ -33,7 +32,6 @@ pub fn parse_xor(data: [u8; 12]) -> Result<super::ProxyConfig, super::Error> {
     Ok(super::ProxyConfig {
         addr,
         obfuscation: Some(super::ObfuscationConfig::XorV2(key)),
-        r#type: ProxyType::XorV2,
     })
 }
 
@@ -112,7 +110,7 @@ mod tests {
     use std::net::{Ipv6Addr, SocketAddrV4};
 
     use crate::config::xor::{XorKey, XorObfuscator};
-    use crate::config::{Error, ObfuscationConfig, Obfuscator, ProxyConfig, ProxyType};
+    use crate::config::{Error, ObfuscationConfig, Obfuscator, ProxyConfig};
 
     #[test]
     fn xor_parsing() {
@@ -130,7 +128,6 @@ mod tests {
                     obfuscation: Some(ObfuscationConfig::XorV2(
                         XorKey::try_from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06]).unwrap(),
                     )),
-                    r#type: ProxyType::XorV2,
                 }),
             },
             Test {
@@ -142,7 +139,6 @@ mod tests {
                     obfuscation: Some(ObfuscationConfig::XorV2(
                         XorKey::try_from([0x01, 0, 0, 0, 0, 0]).unwrap(),
                     )),
-                    r#type: ProxyType::XorV2,
                 }),
             },
             Test {
@@ -154,7 +150,6 @@ mod tests {
                     obfuscation: Some(ObfuscationConfig::XorV2(
                         XorKey::try_from([0xff, 0x04, 0x02, 0x04, 0, 0]).unwrap(),
                     )),
-                    r#type: ProxyType::XorV2,
                 }),
             },
         ];

mullvad-ios/src/encrypted_dns_proxy.rs

@@ -1,9 +1,6 @@
 use crate::ProxyHandle;
 
-use mullvad_encrypted_dns_proxy::{
-    config::{ProxyConfig, ProxyType},
-    config_resolver, Forwarder,
-};
+use mullvad_encrypted_dns_proxy::{config::ProxyConfig, config_resolver, Forwarder};
 use std::{
     collections::HashSet,
     io, mem,
@@ -102,7 +99,8 @@ impl EncryptedDnsProxyState {
             if let Some(xor_config) = self
                 .configurations
                 .iter()
-                .find(|config| config.r#type == ProxyType::XorV2)
+                // prefer obfuscated proxy configurations.
+                .find(|config| config.obfuscation.is_some())
             {
                 self.tried_configurations.insert(xor_config.clone());
                 return Some(xor_config.clone());