Catch cxx exception

libsession-util/src/main/cpp/contacts.cpp

@@ -1,10 +1,14 @@
 #include "contacts.h"
 #include "util.h"
+#include "jni_utils.h"
 
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_get(JNIEnv *env, jobject thiz,
                                                           jstring session_id) {
+    // If an exception is thrown, return nullptr
+    return jni_utils::run_catching_cxx_exception_or<jobject>(
+            [=]() -> jobject {
                 std::lock_guard lock{util::util_mutex_};
                 auto contacts = ptrToContacts(env, thiz);
                 auto session_id_chars = env->GetStringUTFChars(session_id, nullptr);
@@ -13,34 +17,42 @@ Java_network_loki_messenger_libsession_1util_Contacts_get(JNIEnv *env, jobject t
                 if (!contact) return nullptr;
                 jobject j_contact = serialize_contact(env, contact.value());
                 return j_contact;
+            },
+            [](const char *) -> jobject { return nullptr; }
+    );
 }
 
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_getOrConstruct(JNIEnv *env, jobject thiz,
                                                                      jstring session_id) {
+    return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto contacts = ptrToContacts(env, thiz);
         auto session_id_chars = env->GetStringUTFChars(session_id, nullptr);
         auto contact = contacts->get_or_construct(session_id_chars);
         env->ReleaseStringUTFChars(session_id, session_id_chars);
         return serialize_contact(env, contact);
+    });
 }
 
 extern "C"
 JNIEXPORT void JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_set(JNIEnv *env, jobject thiz,
                                                           jobject contact) {
+    jni_utils::run_catching_cxx_exception_or_throws<void>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto contacts = ptrToContacts(env, thiz);
         auto contact_info = deserialize_contact(env, contact, contacts);
         contacts->set(contact_info);
+    });
 }
 
 extern "C"
 JNIEXPORT jboolean JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_erase(JNIEnv *env, jobject thiz,
                                                             jstring session_id) {
+    return jni_utils::run_catching_cxx_exception_or_throws<jboolean>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto contacts = ptrToContacts(env, thiz);
         auto session_id_chars = env->GetStringUTFChars(session_id, nullptr);
@@ -48,6 +60,7 @@ Java_network_loki_messenger_libsession_1util_Contacts_erase(JNIEnv *env, jobject
         bool result = contacts->erase(session_id_chars);
         env->ReleaseStringUTFChars(session_id, session_id_chars);
         return result;
+    });
 }
 extern "C"
 #pragma clang diagnostic push
@@ -56,45 +69,53 @@ JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_00024Companion_newInstance___3B(JNIEnv *env,
                                                                                       jobject thiz,
                                                                                       jbyteArray ed25519_secret_key) {
+    return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto secret_key = util::ustring_from_bytes(env, ed25519_secret_key);
-    auto* contacts = new session::config::Contacts(secret_key, std::nullopt);
+        auto *contacts = new session::config::Contacts(secret_key, std::nullopt);
 
         jclass contactsClass = env->FindClass("network/loki/messenger/libsession_util/Contacts");
         jmethodID constructor = env->GetMethodID(contactsClass, "<init>", "(J)V");
-    jobject newConfig = env->NewObject(contactsClass, constructor, reinterpret_cast<jlong>(contacts));
+        jobject newConfig = env->NewObject(contactsClass, constructor,
+                                           reinterpret_cast<jlong>(contacts));
 
         return newConfig;
+    });
 }
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_00024Companion_newInstance___3B_3B(
         JNIEnv *env, jobject thiz, jbyteArray ed25519_secret_key, jbyteArray initial_dump) {
+    return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto secret_key = util::ustring_from_bytes(env, ed25519_secret_key);
         auto initial = util::ustring_from_bytes(env, initial_dump);
 
-    auto* contacts = new session::config::Contacts(secret_key, initial);
+        auto *contacts = new session::config::Contacts(secret_key, initial);
 
         jclass contactsClass = env->FindClass("network/loki/messenger/libsession_util/Contacts");
         jmethodID constructor = env->GetMethodID(contactsClass, "<init>", "(J)V");
-    jobject newConfig = env->NewObject(contactsClass, constructor, reinterpret_cast<jlong>(contacts));
+        jobject newConfig = env->NewObject(contactsClass, constructor,
+                                           reinterpret_cast<jlong>(contacts));
 
         return newConfig;
+    });
 }
 #pragma clang diagnostic pop
 extern "C"
 JNIEXPORT jobject JNICALL
 Java_network_loki_messenger_libsession_1util_Contacts_all(JNIEnv *env, jobject thiz) {
+    return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
         std::lock_guard lock{util::util_mutex_};
         auto contacts = ptrToContacts(env, thiz);
         jclass stack = env->FindClass("java/util/Stack");
         jmethodID init = env->GetMethodID(stack, "<init>", "()V");
         jobject our_stack = env->NewObject(stack, init);
         jmethodID push = env->GetMethodID(stack, "push", "(Ljava/lang/Object;)Ljava/lang/Object;");
-    for (const auto& contact : *contacts) {
+        for (const auto &contact: *contacts) {
             auto contact_obj = serialize_contact(env, contact);
             env->CallObjectMethod(our_stack, push, contact_obj);
         }
         return our_stack;
+    });
 }

libsession-util/src/main/cpp/jni_utils.h

@@ -0,0 +1,53 @@
+#ifndef SESSION_ANDROID_JNI_UTILS_H
+#define SESSION_ANDROID_JNI_UTILS_H
+
+#include <jni.h>
+#include <exception>
+
+namespace jni_utils {
+    /**
+     * Run a C++ function and catch any exceptions, throwing a Java exception if one is caught,
+     * and returning a default-constructed value of the specified type.
+     *
+     * @tparam RetT The return type of the function
+     * @tparam Func The function type
+     * @param f The function to run
+     * @param fallbackRun The function to run if an exception is caught. The optional exception message reference will be passed to this function.
+     * @return The return value of the function, or the return value of the fallback function if an exception was caught
+     */
+    template<class RetT, class Func, class FallbackRun>
+    RetT run_catching_cxx_exception_or(Func f, FallbackRun fallbackRun) {
+        try {
+            return f();
+        } catch (const std::exception &e) {
+            return fallbackRun(e.what());
+        } catch (...) {
+            return fallbackRun(nullptr);
+        }
+    }
+
+    /**
+     * Run a C++ function and catch any exceptions, throwing a Java exception if one is caught.
+     *
+     * @tparam RetT The return type of the function
+     * @tparam Func The function type
+     * @param env The JNI environment
+     * @param f The function to run
+     * @return The return value of the function, or a default-constructed value of the specified type if an exception was caught
+     */
+    template<class RetT, class Func>
+    RetT run_catching_cxx_exception_or_throws(JNIEnv *env, Func f) {
+        return run_catching_cxx_exception_or<RetT>(f, [env](const char *msg) {
+            jclass exceptionClass = env->FindClass("java/lang/RuntimeException");
+            if (msg) {
+                env->ThrowNew(exceptionClass, msg);
+            } else {
+                env->ThrowNew(exceptionClass, "Unknown C++ exception");
+            }
+
+            return RetT();
+        });
+    }
+}
+
+#endif //SESSION_ANDROID_JNI_UTILS_H