Merge branch 'edp-infallible-constructor'

2 files changed, 9 insertions, 9 deletions

diff --git a/mullvad-api/src/https_client_with_sni.rs b/mullvad-api/src/https_client_with_sni.rs
index 09e198ca3b..09ce493431 100644
--- a/mullvad-api/src/https_client_with_sni.rs
+++ b/mullvad-api/src/https_client_with_sni.rs
@@ -159,7 +159,8 @@ impl InnerConnectionMode {
             InnerConnectionMode::EncryptedDnsProxy(proxy_config) => {
                 let first_hop = SocketAddr::V4(proxy_config.addr);
                 let make_proxy_stream = |tcp_stream| async {
-                    EncryptedDNSForwarder::from_stream(&proxy_config, tcp_stream)
+                    let forwarder = EncryptedDNSForwarder::from_stream(&proxy_config, tcp_stream);
+                    Ok(forwarder)
                 };
                 Self::connect_proxied(
                     first_hop,
diff --git a/mullvad-encrypted-dns-proxy/src/forwarder.rs b/mullvad-encrypted-dns-proxy/src/forwarder.rs
index 0cac1f6072..d69d38426a 100644
--- a/mullvad-encrypted-dns-proxy/src/forwarder.rs
+++ b/mullvad-encrypted-dns-proxy/src/forwarder.rs
@@ -7,12 +7,11 @@ use tokio::{
     net::TcpStream,
 };
 
-use crate::config::Obfuscator;
+use crate::config::{Obfuscator, ProxyConfig};
 
 /// Forwards local traffic to a proxy endpoint, obfuscating it if the proxy config says so.
 ///
-/// Obtain [`ProxyConfig`](crate::config::ProxyConfig)s with
-/// [resolve_configs](crate::config_resolver::resolve_configs).
+/// Obtain [`ProxyConfig`](ProxyConfig)s with [resolve_configs](crate::config_resolver::resolve_configs).
 pub struct Forwarder<S> {
     read_obfuscator: Option<Box<dyn Obfuscator>>,
     write_obfuscator: Option<Box<dyn Obfuscator>>,
@@ -24,7 +23,7 @@ where
     S: AsyncRead + AsyncWrite + Unpin,
 {
     /// Create a [`Forwarder`] with a connected `stream` to an encrypted DNS proxy server
-    pub fn from_stream(proxy_config: &crate::config::ProxyConfig, stream: S) -> io::Result<Self> {
+    pub fn from_stream(proxy_config: &ProxyConfig, stream: S) -> Self {
         let (read_obfuscator, write_obfuscator) =
             if let Some(obfuscation_config) = &proxy_config.obfuscation {
                 (
@@ -35,20 +34,20 @@ where
                 (None, None)
             };
 
-        Ok(Self {
+        Self {
             read_obfuscator,
             write_obfuscator,
             stream,
-        })
+        }
     }
 }
 
 /// Forward TCP traffic over various proxy configurations.
 impl Forwarder<TcpStream> {
     /// Create a forwarder that will connect to a given proxy endpoint.
-    pub async fn connect(proxy_config: &crate::config::ProxyConfig) -> io::Result<Self> {
+    pub async fn connect(proxy_config: &ProxyConfig) -> io::Result<Self> {
         let server_connection = TcpStream::connect(proxy_config.addr).await?;
-        Self::from_stream(proxy_config, server_connection)
+        Ok(Self::from_stream(proxy_config, server_connection))
     }
 
     /// Forwards traffic from the client stream to the remote proxy, obfuscating and deobfuscating