Create `prepare_tun` helper method

1 files changed, 26 insertions, 20 deletions

diff --git a/mullvad-jni/src/vpn_service_tun_provider.rs b/mullvad-jni/src/vpn_service_tun_provider.rs
index f7b9f5e49f..92bd9b2a95 100644
--- a/mullvad-jni/src/vpn_service_tun_provider.rs
+++ b/mullvad-jni/src/vpn_service_tun_provider.rs
@@ -21,6 +21,9 @@ pub enum Error {
     #[error(display = "Failed to call Java method {}", _0)]
     CallMethod(&'static str, #[error(cause)] jni::errors::Error),
 
+    #[error(display = "Failed to create Java VM handle clone")]
+    CloneJavaVm(#[error(cause)] jni::errors::Error),
+
     #[error(display = "Failed to create global reference to MullvadVpnService instance")]
     CreateGlobalReference(#[error(cause)] jni::errors::Error),
 
@@ -52,23 +55,19 @@ impl VpnServiceTunProvider {
 
         Ok(VpnServiceTunProvider { jvm, class, object })
     }
-}
 
-impl TunProvider for VpnServiceTunProvider {
-    fn get_tun(&mut self, config: TunConfig) -> Result<Box<dyn Tun>, BoxedError> {
+    fn prepare_tun(&mut self, config: TunConfig) -> Result<RawFd, Error> {
         let env = self
             .jvm
             .attach_current_thread()
-            .map_err(|cause| BoxedError::new(Error::AttachJvmToThread(cause)))?;
+            .map_err(Error::AttachJvmToThread)?;
         let create_tun_method = env
             .get_method_id(
                 &self.class,
                 "createTun",
                 "(Lnet/mullvad/mullvadvpn/model/TunConfig;)I",
             )
-            .map_err(|cause| {
-                BoxedError::new(Error::FindMethod("MullvadVpnService.createTun", cause))
-            })?;
+            .map_err(|cause| Error::FindMethod("MullvadVpnService.createTun", cause))?;
 
         let result = env
             .call_method_unchecked(
@@ -77,27 +76,34 @@ impl TunProvider for VpnServiceTunProvider {
                 JavaType::Primitive(Primitive::Int),
                 &[JValue::Object(config.into_java(&env))],
             )
-            .map_err(|cause| {
-                BoxedError::new(Error::CallMethod("MullvadVpnService.createTun", cause))
-            })?;
+            .map_err(|cause| Error::CallMethod("MullvadVpnService.createTun", cause))?;
 
         match result {
-            JValue::Int(fd) => Ok(Box::new(VpnServiceTun {
-                tunnel: fd,
-                jvm: env
-                    .get_java_vm()
-                    .map_err(|cause| BoxedError::new(Error::GetJvmInstance(cause)))?,
-                class: self.class.clone(),
-                object: self.object.clone(),
-            })),
-            value => Err(BoxedError::new(Error::InvalidMethodResult(
+            JValue::Int(fd) => Ok(fd),
+            value => Err(Error::InvalidMethodResult(
                 "MullvadVpnService.createTun",
                 format!("{:?}", value),
-            ))),
+            )),
         }
     }
 }
 
+impl TunProvider for VpnServiceTunProvider {
+    fn get_tun(&mut self, config: TunConfig) -> Result<Box<dyn Tun>, BoxedError> {
+        let tun = self.prepare_tun(config).map_err(BoxedError::new)?;
+
+        let jvm = unsafe { JavaVM::from_raw(self.jvm.get_java_vm_pointer()) }
+            .map_err(|cause| BoxedError::new(Error::CloneJavaVm(cause)))?;
+
+        Ok(Box::new(VpnServiceTun {
+            tunnel: tun,
+            jvm,
+            class: self.class.clone(),
+            object: self.object.clone(),
+        }))
+    }
+}
+
 struct VpnServiceTun {
     tunnel: RawFd,
     jvm: JavaVM,