Merge pull request #179 from neacsu:feature/callback_ios

Complete interface for nym device configuration

Author: neacsu

nym-vpn-lib/src/error.rs

@@ -171,6 +171,10 @@ pub enum Error {
 
     #[error("{0}")]
     TalpidCoreMpsc(#[from] talpid_core::mpsc::Error),
+
+    #[cfg(target_os = "ios")]
+    #[error("{0}")]
+    UniffiError(#[from] crate::platform::error::FFIError),
 }
 
 // Result type based on our error type

nym-vpn-lib/src/lib.rs

@@ -45,7 +45,7 @@ pub use nym_task::{
 };
 
 #[cfg(target_os = "ios")]
-use crate::platform::ios::{initVPN, OSTunProvider, VPNConfig, WgConfig};
+use crate::platform::ios::{initVPN, NymConfig, OSTunProvider, VPNConfig, WgConfig};
 #[cfg(target_os = "macos")]
 use crate::platform::macos::{initVPN, VPNConfig, WgConfig};
 #[cfg(any(target_os = "macos", target_os = "android", target_os = "ios"))]
@@ -233,7 +233,13 @@ impl NymVpn {
             mixnet_client.gateway_ws_fd().await,
         );
         debug!("Routing config: {}", routing_config);
-        let mixnet_tun_dev = routing::setup_routing(route_manager, routing_config).await?;
+        let mixnet_tun_dev = routing::setup_routing(
+            route_manager,
+            routing_config,
+            #[cfg(target_os = "ios")]
+            self.ios_tun_provider.clone(),
+        )
+        .await?;
 
         info!("Setting up mixnet processor");
         let processor_config = mixnet_processor::Config::new(*exit_router);

nym-vpn-lib/src/nym_vpn_lib_ios.udl

@@ -56,6 +56,13 @@ dictionary WgConfig {
     u16 mtu;
 };
 
+dictionary NymConfig {
+    Ipv4Addr ipv4_addr;
+    Ipv6Addr ipv6_addr;
+    u16 mtu;
+    IpAddr? entry_mixnet_gateway_ip;
+};
+
 dictionary VPNConfig {
     Url api_url;
     Url explorer_url;
@@ -84,7 +91,7 @@ interface OSTunProvider {
     [Throws=FFIError]
     void configure_wg(WgConfig config);
     [Throws=FFIError]
-    void configure_nym();
+    i32 configure_nym(NymConfig config);
 };
 
 namespace nym_vpn_lib_ios {

nym-vpn-lib/src/platform/ios.rs

@@ -3,12 +3,14 @@
 
 use super::*;
 use crate::gateway_client::{EntryPoint, ExitPoint};
+use crate::routing::RoutingConfig;
 use crate::NymVpn;
 use error::FFIError;
 use log::warn;
 use oslog::OsLogger;
 use std::fmt::Debug;
-use std::net::{Ipv4Addr, Ipv6Addr};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::os::fd::RawFd;
 use talpid_types::net::wireguard::{PeerConfig, TunnelConfig};
 use url::Url;
 
@@ -50,6 +52,30 @@ impl From<talpid_wireguard::config::Config> for WgConfig {
     }
 }
 
+#[derive(Clone)]
+pub struct NymConfig {
+    pub ipv4_addr: Ipv4Addr,
+    pub ipv6_addr: Ipv6Addr,
+    pub mtu: u16,
+    pub entry_mixnet_gateway_ip: Option<IpAddr>,
+}
+
+impl From<RoutingConfig> for NymConfig {
+    fn from(value: RoutingConfig) -> Self {
+        let entry_mixnet_gateway_ip = if value.enable_wireguard() {
+            Some(value.entry_mixnet_gateway_ip())
+        } else {
+            None
+        };
+        NymConfig {
+            ipv4_addr: value.tun_ips().ipv4,
+            ipv6_addr: value.tun_ips().ipv6,
+            mtu: value.mtu(),
+            entry_mixnet_gateway_ip,
+        }
+    }
+}
+
 pub struct VPNConfig {
     pub api_url: Url,
     pub explorer_url: Url,
@@ -60,7 +86,7 @@ pub struct VPNConfig {
 
 pub trait OSTunProvider: Send + Sync + Debug {
     fn configure_wg(&self, config: WgConfig) -> Result<(), FFIError>;
-    fn configure_nym(&self) -> Result<(), FFIError>;
+    fn configure_nym(&self, config: NymConfig) -> Result<RawFd, FFIError>;
 }
 
 #[allow(non_snake_case)]

nym-vpn-lib/src/routing.rs

@@ -26,10 +26,13 @@ use crate::NymVpn;
 
 const DEFAULT_TUN_MTU: u16 = 1500;
 
+#[derive(Clone)]
 pub struct RoutingConfig {
     pub(crate) mixnet_tun_config: tun2::Configuration,
-    // In case we need it, as it's not read-accessible in the tun2 config
+    // In case we need them, as they're not read-accessible in the tun2 config
     pub(crate) tun_ips: IpPair,
+    pub(crate) mtu: u16,
+
     pub(crate) entry_mixnet_gateway_ip: IpAddr,
     pub(crate) lan_gateway_ip: LanGatewayIp,
     pub(crate) tunnel_gateway_ip: TunnelGatewayIp,
@@ -45,9 +48,10 @@ impl Display for RoutingConfig {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "mixnet_tun_config: {:?}\ntun_ips: {:?}\nentry_mixnet_gateway_ip: {:?}\nlan_gateway_ip: {:?}\ntunnel_gateway_ip: {:?}\nenable_wireguard: {:?}\ndisable_routing: {:?}",
+            "mixnet_tun_config: {:?}\ntun_ips: {:?}\nmtu: {}\nentry_mixnet_gateway_ip: {:?}\nlan_gateway_ip: {:?}\ntunnel_gateway_ip: {:?}\nenable_wireguard: {:?}\ndisable_routing: {:?}",
             self.mixnet_tun_config,
             self.tun_ips,
+            self.mtu,
             self.entry_mixnet_gateway_ip,
             self.lan_gateway_ip,
             self.tunnel_gateway_ip,
@@ -68,14 +72,16 @@ impl RoutingConfig {
     ) -> Self {
         debug!("TUN device IPs: {}", tun_ips);
         let mut mixnet_tun_config = tun2::Configuration::default();
+        let mtu = vpn.nym_mtu.unwrap_or(DEFAULT_TUN_MTU);
         // only IPv4 is supported by tun2 for now
         mixnet_tun_config.address(tun_ips.ipv4);
-        mixnet_tun_config.mtu(vpn.nym_mtu.unwrap_or(DEFAULT_TUN_MTU));
+        mixnet_tun_config.mtu(mtu);
         mixnet_tun_config.up();
 
         Self {
             mixnet_tun_config,
             tun_ips,
+            mtu,
             entry_mixnet_gateway_ip,
             lan_gateway_ip,
             tunnel_gateway_ip,
@@ -91,9 +97,21 @@ impl RoutingConfig {
     pub fn tun_ips(&self) -> IpPair {
         self.tun_ips
     }
+
+    pub fn mtu(&self) -> u16 {
+        self.mtu
+    }
+
+    pub fn entry_mixnet_gateway_ip(&self) -> IpAddr {
+        self.entry_mixnet_gateway_ip
+    }
+
+    pub fn enable_wireguard(&self) -> bool {
+        self.enable_wireguard
+    }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct TunnelGatewayIp {
     pub ipv4: Ipv4Addr,
     pub ipv6: Option<Ipv6Addr>,
@@ -123,7 +141,7 @@ impl std::fmt::Display for TunnelGatewayIp {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct LanGatewayIp(pub Interface);
 
 impl LanGatewayIp {
@@ -189,6 +207,9 @@ fn replace_default_prefixes(network: IpNetwork) -> Vec<IpNetwork> {
 pub async fn setup_routing(
     route_manager: &mut RouteManager,
     config: RoutingConfig,
+    #[cfg(target_os = "ios")] ios_tun_provider: std::sync::Arc<
+        dyn crate::platform::ios::OSTunProvider,
+    >,
 ) -> Result<tun2::AsyncDevice> {
     debug!("Creating tun device");
     let mixnet_tun_config = config.mixnet_tun_config.clone();
@@ -215,6 +236,13 @@ pub async fn setup_routing(
         mixnet_tun_config.raw_fd(fd);
         mixnet_tun_config
     };
+    #[cfg(target_os = "ios")]
+    let mixnet_tun_config = {
+        let fd = ios_tun_provider.configure_nym(config.clone().into())?;
+        let mut mixnet_tun_config = mixnet_tun_config.clone();
+        mixnet_tun_config.raw_fd(fd);
+        mixnet_tun_config
+    };
     let dev = tun2::create_as_async(&mixnet_tun_config)
         .tap_err(|err| error!("Failed to create tun device: {}", err))?;
     let device_name = dev.as_ref().tun_name().unwrap().to_string();