It passes now

Author: pinkisemils

mullvad-api/src/address_cache.rs

@@ -1,7 +1,7 @@
 //! This module keeps track of the last known good API IP address and reads and stores it on disk.
 
 use super::API;
-use crate::DnsResolver;
+use crate::{ApiEndpoint, DnsResolver};
 use async_trait::async_trait;
 use std::{io, net::SocketAddr, path::Path, sync::Arc};
 use tokio::{
@@ -40,6 +40,7 @@ impl DnsResolver for AddressCache {
 pub struct AddressCache {
     inner: Arc<Mutex<AddressCacheInner>>,
     write_path: Option<Arc<Path>>,
+    custom_endpoint: Option<ApiEndpoint>,
 }
 
 impl AddressCache {
@@ -52,6 +53,16 @@ impl AddressCache {
         Self::new_inner(address, None)
     }
 
+    pub fn with_custom_endpoint(endpoint: ApiEndpoint) -> Self {
+        let cache = AddressCacheInner::from_address(endpoint.address());
+
+        Self {
+            inner: Arc::new(Mutex::new(cache)),
+            write_path: None,
+            custom_endpoint: Some(endpoint),
+        }
+    }
+
     // #[cfg(target_os = "ios")]
     // pub fn with_static_hostname_addr(address: SocketAddr, hostname: &str) -> {
 
@@ -73,12 +84,14 @@ impl AddressCache {
         Self {
             inner: Arc::new(Mutex::new(cache)),
             write_path: write_path.map(Arc::from),
+            custom_endpoint: None,
         }
     }
 
     /// Returns the address if the hostname equals `API.host`. Otherwise, returns `None`.
     async fn resolve_hostname(&self, hostname: &str) -> Option<SocketAddr> {
-        if hostname.eq_ignore_ascii_case(API.host()) {
+        let host = self.endpoint().host();
+        if hostname.eq_ignore_ascii_case(host) {
             Some(self.get_address().await)
         } else {
             None
@@ -115,6 +128,10 @@ impl AddressCache {
             .map_err(Error::Write)?;
         file.finalize().await.map_err(Error::Write)
     }
+
+    fn endpoint(&self) -> &ApiEndpoint {
+        self.custom_endpoint.as_ref().unwrap_or(&*API)
+    }
 }
 
 #[derive(Clone, PartialEq, Eq)]

mullvad-api/src/ffi/mod.rs

@@ -7,7 +7,7 @@ use std::{
 
 use crate::{
     rest::{self, MullvadRestHandle},
-    AccountsProxy, DevicesProxy,
+    AccountsProxy, ApiEndpoint, DevicesProxy,
 };
 
 mod device;
@@ -68,12 +68,11 @@ impl FfiClient {
             )
         })?;
 
-        // The call site guarantees that
-        // api_hostname and api_address will never change after the first call to new.
-        std::env::set_var(crate::env::API_HOST_VAR, &api_hostname);
-        std::env::set_var(crate::env::API_ADDR_VAR, &addr_str);
-        std::env::set_var(crate::env::API_FORCE_DIRECT_VAR, "0");
-        std::env::set_var(crate::env::DISABLE_TLS_VAR, "0");
+        let endpoint = ApiEndpoint {
+            host: Some(api_hostname.clone()),
+            address: Some(api_address),
+        };
+
         let mut runtime_builder = tokio::runtime::Builder::new_multi_thread();
 
         runtime_builder.worker_threads(2).enable_all();
@@ -84,7 +83,7 @@ impl FfiClient {
         // It is imperative that the REST runtime is created within an async context, otherwise
         // ApiAvailability panics.
         let api_runtime = tokio_runtime.block_on(async {
-            crate::Runtime::with_static_addr(tokio_runtime.handle().clone(), api_address)
+            crate::Runtime::with_custom_endpoint(tokio_runtime.handle().clone(), endpoint)
         });
 
         let context = FfiClient {
@@ -455,7 +454,6 @@ mod test {
     #[test]
     fn test_initialization() {
         let _ = create_client();
-
     }
 
     fn create_client() -> MullvadApiClient {
@@ -468,18 +466,15 @@ mod test {
             )
             .unwrap();
         };
-        unsafe {
-            client.assume_init()
-        }
+        unsafe { client.assume_init() }
     }
 
     #[test]
     fn test_create_delete_account() {
         let client = create_client();
 
-        let mut account_buf_ptr = ptr::null_mut();
-
+        let mut account_buf = vec![(0 as libc::c_char); 100];
 
-        unsafe { mullvad_api_create_account(client, account_buf_ptr).unwrap() };
+        unsafe { mullvad_api_create_account(client, (&account_buf.as_mut_ptr()).cast()).unwrap() };
     }
 }

mullvad-api/src/lib.rs

@@ -112,7 +112,7 @@ pub mod env {
 }
 
 /// A hostname and socketaddr to reach the Mullvad REST API over.
-#[derive(Debug)]
+#[derive(Debug,Clone)]
 pub struct ApiEndpoint {
     /// An overriden API hostname. Initialized with the value of the environment
     /// variable `MULLVAD_API_HOST` if it has been set.
@@ -370,10 +370,10 @@ impl Runtime {
         )
     }
 
-    pub fn with_static_addr(handle: tokio::runtime::Handle, address: SocketAddr) -> Self {
+    pub fn with_custom_endpoint(handle: tokio::runtime::Handle, api_endpoint: ApiEndpoint) -> Self {
         Runtime {
             handle,
-            address_cache: AddressCache::with_static_addr(address),
+            address_cache: AddressCache::with_custom_endpoint(api_endpoint),
             api_availability: ApiAvailability::default(),
         }
     }