Merge remote-tracking branch 'origin/main' into feat/android-react-to…

…-network

rust/connlib/clients/android/src/lib.rs

@@ -138,14 +138,12 @@ fn init_logging(log_dir: &Path, log_filter: String) -> file_logger::Handle {
 }
 
 impl Callbacks for CallbackHandler {
-    type Error = CallbackError;
-
     fn on_set_interface_config(
         &self,
         tunnel_address_v4: Ipv4Addr,
         tunnel_address_v6: Ipv6Addr,
         dns_addresses: Vec<IpAddr>,
-    ) -> Result<Option<RawFd>, Self::Error> {
+    ) -> Option<RawFd> {
         self.env(|mut env| {
             let tunnel_address_v4 =
                 env.new_string(tunnel_address_v4.to_string())
@@ -180,9 +178,10 @@ impl Callbacks for CallbackHandler {
             .map(Some)
             .map_err(|source| CallbackError::CallMethodFailed { name, source })
         })
+        .expect("onSetInterfaceConfig callback failed")
     }
 
-    fn on_tunnel_ready(&self) -> Result<(), Self::Error> {
+    fn on_tunnel_ready(&self) {
         self.env(|mut env| {
             call_method(
                 &mut env,
@@ -192,13 +191,14 @@ impl Callbacks for CallbackHandler {
                 &[],
             )
         })
+        .expect("onTunnelReady callback failed")
     }
 
     fn on_update_routes(
         &self,
         route_list_4: Vec<Cidrv4>,
         route_list_6: Vec<Cidrv6>,
-    ) -> Result<Option<RawFd>, Self::Error> {
+    ) -> Option<RawFd> {
         self.env(|mut env| {
             let route_list_4 = env
                 .new_string(serde_json::to_string(&route_list_4)?)
@@ -224,10 +224,11 @@ impl Callbacks for CallbackHandler {
             .map(Some)
             .map_err(|source| CallbackError::CallMethodFailed { name, source })
         })
+        .expect("onUpdateRoutes callback failed")
     }
 
     #[cfg(target_os = "android")]
-    fn protect_file_descriptor(&self, file_descriptor: RawFd) -> Result<(), Self::Error> {
+    fn protect_file_descriptor(&self, file_descriptor: RawFd) {
         self.env(|mut env| {
             call_method(
                 &mut env,
@@ -237,12 +238,10 @@ impl Callbacks for CallbackHandler {
                 &[JValue::Int(file_descriptor)],
             )
         })
+        .expect("protectFileDescriptor callback failed");
     }
 
-    fn on_update_resources(
-        &self,
-        resource_list: Vec<ResourceDescription>,
-    ) -> Result<(), Self::Error> {
+    fn on_update_resources(&self, resource_list: Vec<ResourceDescription>) {
         self.env(|mut env| {
             let resource_list = env
                 .new_string(serde_json::to_string(&resource_list)?)
@@ -258,9 +257,10 @@ impl Callbacks for CallbackHandler {
                 &[JValue::from(&resource_list)],
             )
         })
+        .expect("onUpdateResources callback failed")
     }
 
-    fn on_disconnect(&self, error: &Error) -> Result<(), Self::Error> {
+    fn on_disconnect(&self, error: &Error) {
         self.env(|mut env| {
             let error = env
                 .new_string(serde_json::to_string(&error.to_string())?)
@@ -276,6 +276,7 @@ impl Callbacks for CallbackHandler {
                 &[JValue::from(&error)],
             )
         })
+        .expect("onDisconnect callback failed")
     }
 
     fn roll_log_file(&self) -> Option<PathBuf> {
@@ -286,7 +287,7 @@ impl Callbacks for CallbackHandler {
         })
     }
 
-    fn get_system_default_resolvers(&self) -> Result<Option<Vec<IpAddr>>, Self::Error> {
+    fn get_system_default_resolvers(&self) -> Option<Vec<IpAddr>> {
         self.env(|mut env| {
             let name = "getSystemDefaultResolvers";
             let addrs = env
@@ -297,6 +298,7 @@ impl Callbacks for CallbackHandler {
 
             Ok(Some(addrs.iter().filter_map(|v| to_ip(v)).collect()))
         })
+        .expect("getSystemDefaultResolvers callback failed")
     }
 }
 

rust/connlib/clients/apple/src/lib.rs

@@ -98,54 +98,48 @@ pub struct CallbackHandler {
 }
 
 impl Callbacks for CallbackHandler {
-    type Error = std::convert::Infallible;
-
     fn on_set_interface_config(
         &self,
         tunnel_address_v4: Ipv4Addr,
         tunnel_address_v6: Ipv6Addr,
         dns_addresses: Vec<IpAddr>,
-    ) -> Result<Option<RawFd>, Self::Error> {
+    ) -> Option<RawFd> {
         self.inner.on_set_interface_config(
             tunnel_address_v4.to_string(),
             tunnel_address_v6.to_string(),
             serde_json::to_string(&dns_addresses)
                 .expect("developer error: a list of ips should always be serializable"),
         );
-        Ok(None)
+
+        None
     }
 
-    fn on_tunnel_ready(&self) -> Result<(), Self::Error> {
+    fn on_tunnel_ready(&self) {
         self.inner.on_tunnel_ready();
-        Ok(())
     }
 
     fn on_update_routes(
         &self,
         route_list_4: Vec<Cidrv4>,
         route_list_6: Vec<Cidrv6>,
-    ) -> Result<Option<RawFd>, Self::Error> {
+    ) -> Option<RawFd> {
         self.inner.on_update_routes(
             serde_json::to_string(&route_list_4).unwrap(),
             serde_json::to_string(&route_list_6).unwrap(),
         );
-        Ok(None)
+
+        None
     }
 
-    fn on_update_resources(
-        &self,
-        resource_list: Vec<ResourceDescription>,
-    ) -> Result<(), Self::Error> {
+    fn on_update_resources(&self, resource_list: Vec<ResourceDescription>) {
         self.inner.on_update_resources(
             serde_json::to_string(&resource_list)
                 .expect("developer error: failed to serialize resource list"),
         );
-        Ok(())
     }
 
-    fn on_disconnect(&self, error: &Error) -> Result<(), Self::Error> {
+    fn on_disconnect(&self, error: &Error) {
         self.inner.on_disconnect(error.to_string());
-        Ok(())
     }
 
     fn roll_log_file(&self) -> Option<PathBuf> {

rust/connlib/clients/shared/src/lib.rs

@@ -7,7 +7,7 @@ use tokio::sync::mpsc::UnboundedReceiver;
 pub use tracing_appender::non_blocking::WorkerGuard;
 
 use backoff::ExponentialBackoffBuilder;
-use connlib_shared::{get_user_agent, CallbackErrorFacade};
+use connlib_shared::get_user_agent;
 use firezone_tunnel::ClientTunnel;
 use phoenix_channel::PhoenixChannel;
 use std::net::IpAddr;
@@ -44,7 +44,6 @@ impl Session {
         max_partition_time: Option<Duration>,
         handle: tokio::runtime::Handle,
     ) -> connlib_shared::Result<Self> {
-        let callbacks = CallbackErrorFacade(callbacks);
         let (tx, rx) = tokio::sync::mpsc::channel(1);
         let (dns_updater, dns_updated) = tokio::sync::mpsc::unbounded_channel();
 
@@ -140,20 +139,20 @@ where
         }
         Ok(Err(e)) => {
             tracing::error!("connlib failed: {e}");
-            let _ = callbacks.on_disconnect(&e);
+            callbacks.on_disconnect(&e);
         }
         Err(e) => match e.try_into_panic() {
             Ok(panic) => {
                 if let Some(msg) = panic.downcast_ref::<&str>() {
-                    let _ = callbacks.on_disconnect(&Error::Panic(msg.to_string()));
+                    callbacks.on_disconnect(&Error::Panic(msg.to_string()));
                     return;
                 }
 
-                let _ = callbacks.on_disconnect(&Error::PanicNonStringPayload);
+                callbacks.on_disconnect(&Error::PanicNonStringPayload);
             }
             Err(_) => {
                 tracing::error!("connlib task was cancelled");
-                let _ = callbacks.on_disconnect(&Error::Cancelled);
+                callbacks.on_disconnect(&Error::Cancelled);
             }
         },
     }

rust/connlib/shared/src/callbacks.rs

@@ -1,8 +1,7 @@
 use crate::messages::ResourceDescription;
 use ip_network::{Ipv4Network, Ipv6Network};
 use serde::Serialize;
-use std::error::Error;
-use std::fmt::{Debug, Display};
+use std::fmt::Debug;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::path::PathBuf;
 
@@ -43,47 +42,32 @@ impl From<Ipv6Network> for Cidrv6 {
 
 /// Traits that will be used by connlib to callback the client upper layers.
 pub trait Callbacks: Clone + Send + Sync {
-    /// Error returned when a callback fails.
-    type Error: Debug + Display + Error;
-
     /// Called when the tunnel address is set.
     ///
     /// This should return a new `fd` if there is one.
     /// (Only happens on android for now)
-    fn on_set_interface_config(
-        &self,
-        _: Ipv4Addr,
-        _: Ipv6Addr,
-        _: Vec<IpAddr>,
-    ) -> Result<Option<RawFd>, Self::Error> {
-        Ok(None)
+    fn on_set_interface_config(&self, _: Ipv4Addr, _: Ipv6Addr, _: Vec<IpAddr>) -> Option<RawFd> {
+        None
     }
 
     /// Called when the tunnel is connected.
-    fn on_tunnel_ready(&self) -> Result<(), Self::Error> {
+    fn on_tunnel_ready(&self) {
         tracing::trace!("tunnel_connected");
-        Ok(())
     }
 
     /// Called when the route list changes.
-    fn on_update_routes(
-        &self,
-        _: Vec<Cidrv4>,
-        _: Vec<Cidrv6>,
-    ) -> Result<Option<RawFd>, Self::Error> {
-        Ok(None)
+    fn on_update_routes(&self, _: Vec<Cidrv4>, _: Vec<Cidrv6>) -> Option<RawFd> {
+        None
     }
 
     /// Called when the resource list changes.
-    fn on_update_resources(&self, _: Vec<ResourceDescription>) -> Result<(), Self::Error> {
-        Ok(())
-    }
+    fn on_update_resources(&self, _: Vec<ResourceDescription>) {}
 
     /// Called when the tunnel is disconnected.
     ///
     /// If the tunnel disconnected due to a fatal error, `error` is the error
     /// that caused the disconnect.
-    fn on_disconnect(&self, error: &crate::Error) -> Result<(), Self::Error> {
+    fn on_disconnect(&self, error: &crate::Error) {
         tracing::error!(error = ?error, "tunnel_disconnected");
         // Note that we can't panic here, since we already hooked the panic to this function.
         std::process::exit(0);
@@ -93,16 +77,13 @@ pub trait Callbacks: Clone + Send + Sync {
     ///
     /// It's okay for clients to include Firezone's own DNS here, e.g. 100.100.111.1.
     /// connlib internally filters them out.
-    fn get_system_default_resolvers(&self) -> Result<Option<Vec<IpAddr>>, Self::Error> {
-        Ok(None)
+    fn get_system_default_resolvers(&self) -> Option<Vec<IpAddr>> {
+        None
     }
 
     /// Protects the socket file descriptor from routing loops.
     #[cfg(target_os = "android")]
-    fn protect_file_descriptor(
-        &self,
-        file_descriptor: std::os::fd::RawFd,
-    ) -> Result<(), Self::Error>;
+    fn protect_file_descriptor(&self, file_descriptor: std::os::fd::RawFd);
 
     fn roll_log_file(&self) -> Option<PathBuf> {
         None