TMP: work

Author: pinkisemils

mullvad-api/src/ffi/error.rs

@@ -48,9 +48,8 @@ impl MullvadApiError {
         }
     }
 
-    #[cfg(test)]
     pub fn unwrap(&self) {
-        if ! matches!(self.kind, MullvadApiErrorKind::NoError) {
+        if !matches!(self.kind, MullvadApiErrorKind::NoError) {
             let desc = unsafe { std::ffi::CStr::from_ptr(self.description) };
             panic!("API ERROR - {:?} - {}", self.kind, desc.to_str().unwrap());
         }

mullvad-api/src/ffi/mod.rs

@@ -55,6 +55,7 @@ impl FfiClient {
     unsafe fn new(
         api_address_ptr: *const libc::c_char,
         hostname: *const libc::c_char,
+        #[cfg(debug_assertions)] disable_tls: bool,
     ) -> Result<Self, MullvadApiError> {
         // SAFETY: addr_str must be a valid pointer to a null-terminated string.
         let addr_str = unsafe { string_from_raw_ptr(api_address_ptr)? };
@@ -71,6 +72,8 @@ impl FfiClient {
         let endpoint = ApiEndpoint {
             host: Some(api_hostname.clone()),
             address: Some(api_address),
+            #[cfg(debug_assertions)]
+            disable_tls,
         };
 
         let mut runtime_builder = tokio::runtime::Builder::new_multi_thread();
@@ -238,8 +241,16 @@ pub unsafe extern "C" fn mullvad_api_client_initialize(
     client_ptr: *mut MullvadApiClient,
     api_address_ptr: *const libc::c_char,
     hostname: *const libc::c_char,
+    #[cfg(debug_assertions)] disable_tls: bool,
 ) -> MullvadApiError {
-    match unsafe { FfiClient::new(api_address_ptr, hostname) } {
+    match unsafe {
+        FfiClient::new(
+            api_address_ptr,
+            hostname,
+            #[cfg(debug_assertions)]
+            disable_tls,
+        )
+    } {
         Ok(client) => {
             unsafe {
                 std::ptr::write(client_ptr, MullvadApiClient::new(client));
@@ -445,24 +456,29 @@ unsafe fn string_from_raw_ptr(ptr: *const libc::c_char) -> Result<String, Mullva
 
 #[cfg(test)]
 mod test {
-    use std::mem::MaybeUninit;
+    use super::*;
+    use std::time::Duration;
+    use httpmock::prelude::*;
+    use std::{mem::MaybeUninit, net::Ipv4Addr, thread};
 
     use super::*;
     const STAGING_SOCK_ADDR: &[u8] = b"185.217.116.129:443\0";
     const STAGING_HOSTNAME: &[u8] = b"api-app.stagemole.eu\0";
 
     #[test]
     fn test_initialization() {
-        let _ = create_client();
+        let _ = create_client(&SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 1));
     }
 
-    fn create_client() -> MullvadApiClient {
+    fn create_client(addr: &SocketAddr) -> MullvadApiClient {
         let mut client = MaybeUninit::<MullvadApiClient>::uninit();
+        let cstr_address = CString::new(addr.to_string()).unwrap();
         let _client = unsafe {
             mullvad_api_client_initialize(
                 client.as_mut_ptr(),
-                STAGING_SOCK_ADDR.as_ptr().cast(),
+                cstr_address.as_ptr().cast(),
                 STAGING_HOSTNAME.as_ptr().cast(),
+                true,
             )
             .unwrap();
         };
@@ -471,10 +487,34 @@ mod test {
 
     #[test]
     fn test_create_delete_account() {
-        let client = create_client();
+        let server = test_server();
+        let client = create_client(server.address());
+
+        println!("SERVER ADDR: {}", server.address());
 
-        let mut account_buf = vec![(0 as libc::c_char); 100];
+        let mut account_buf = vec![0 as libc::c_char; 100];
 
         unsafe { mullvad_api_create_account(client, (&account_buf.as_mut_ptr()).cast()).unwrap() };
     }
+
+    fn test_server() -> MockServer {
+        let expected_create_account_response = br#"{"id":"085df870-0fc2-47cb-9e8c-cb43c1bdaac0","expiry":"2024-12-11T12:56:32+00:00","max_ports":0,"can_add_ports":false,"max_devices":5,"can_add_devices":true,"number":"6705749539195318"}"}"#;
+        let server = MockServer::start();
+        let mock = server.mock(|when, then| {
+            // when.method(POST)
+            //     .header("content-type", "application/json")
+                // .path(crate::ACCOUNTS_URL_PREFIX.to_owned() + "/accounts");
+            when.any_request();
+            then.status(201)
+                .body(expected_create_account_response)
+                .header("content-type", "application/json")
+                .header(
+                    "content-length",
+                    &format!("{}", expected_create_account_response.len()),
+                )
+                ;
+        });
+
+        server
+    }
 }

mullvad-api/src/https_client_with_sni.rs

@@ -41,7 +41,7 @@ use tokio::{
 };
 use tower::Service;
 
-#[cfg(feature = "api-override")]
+#[cfg(debug_assertions)]
 use crate::{proxy::ConnectionDecorator, API};
 
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(5);
@@ -206,7 +206,7 @@ impl InnerConnectionMode {
 
         let proxy = make_proxy_stream(socket).await?;
 
-        #[cfg(feature = "api-override")]
+        #[cfg(debug_assertions)]
         if API.disable_tls {
             return Ok(ApiConnection::new(Box::new(ConnectionDecorator(proxy))));
         }

mullvad-api/src/lib.rs

@@ -133,7 +133,7 @@ pub struct ApiEndpoint {
     pub address: Option<SocketAddr>,
     #[cfg(feature = "api-override")]
     pub disable_address_cache: bool,
-    #[cfg(feature = "api-override")]
+    #[cfg(debug_assertions)]
     pub disable_tls: bool,
     #[cfg(feature = "api-override")]
     /// Whether bridges/proxies can be used to access the API or not. This is
@@ -268,6 +268,8 @@ impl ApiEndpoint {
         ApiEndpoint {
             host: None,
             address: None,
+            #[cfg(debug_assertions)]
+            disable_tls: false
         }
     }
 

mullvad-api/src/rest.rs

@@ -449,6 +449,7 @@ where
                 .insert(header::AUTHORIZATION, auth);
         }
 
+        println!("rest - {:?}", self.request.uri());
         // Make request to hyper client
         let response = hyper_client
             .request(self.request)
@@ -461,7 +462,6 @@ where
         }
 
         // Parse unexpected responses and errors
-
         let response = response?;
 
         if !self.expected_status.contains(&response.status()) {