/* * FalsoJNI.c * * Fake Java Native Interface, providing JavaVM and JNIEnv objects. * * Copyright (C) 2022-2023 Volodymyr Atamanenko * * This software may be modified and distributed under the terms * of the MIT license. See the LICENSE file for details. * * Contains parts of Dalvik implementation of JNI interfaces, * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 */ #pragma ide diagnostic ignored "UnusedParameter" #include #include #include #include "FalsoJNI_ImplBridge.h" #include "FalsoJNI_Logger.h" #include "converter.h" // Objects to be passed to client applications: JavaVM jvm; JNIEnv jni; // Private structs backing the above objects: struct JNIInvokeInterface * _jvm; // NOLINT(bugprone-reserved-identifier) struct JNINativeInterface * _jni; // NOLINT(bugprone-reserved-identifier) /* * JavaVM Methods */ jint DestroyJavaVM(JavaVM* vm) { fjni_log_dbg("[JVM] DestroyJavaVM(): ignored"); return 0; } jint AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* thr_args) { fjni_log_dbg("[JVM] AttachCurrentThread(vm, *p_env, thr_args)"); *p_env = &jni; return 0; } jint DetachCurrentThread(JavaVM* vm) { fjni_log_dbg("[JVM] DetachCurrentThread(): ignored"); // Since we don't operate the actual Java VM, we don't need to care about // it being available only in one thread. Anyway, due to this restriction, // client applications are guaranteed to use JNI in a safe way. return 0; } jint GetEnv(JavaVM* vm, void** env, jint version) { fjni_logv_dbg("[JVM] GetEnv(vm, **env, version:%i)", version); if (!env) { fjni_logv_err("[JVM] GetEnv(vm, **env, version:%i): env is NULL!", version); return JNI_EINVAL; } *env = &jni; return JNI_OK; } jint AttachCurrentThreadAsDaemon(JavaVM* vm, JNIEnv** penv, void* thr_args) { fjni_log_dbg("[JVM] AttachCurrentThreadAsDaemon(vm, *p_env, thr_args)"); if (!penv) { fjni_log_err("[JVM] AttachCurrentThreadAsDaemon(vm, *p_env, thr_args): p_env is NULL!"); return JNI_EINVAL; } *penv = &jni; return JNI_OK; } /* * JNIEnv Methods */ jint GetVersion(JNIEnv * env) { fjni_log_dbg("[JNI] GetVersion(env)"); return JNI_VERSION_1_6; } jclass DefineClass(JNIEnv* env, const char* name, jobject loader, const jbyte* buf, jsize bufLen) { // Supposed to load Java class from `.class`-containing `buf`. Can not be implemented. fjni_logv_warn("[JNI] DefineClass(env, \"%s\", 0x%x, 0x%x, %i): not implemented", name, loader, buf, bufLen); return NULL; } jclass FindClass(JNIEnv* env, const char* name) { // While we don't manipulate any actual classes here, the following code // serves two purposes: // 1) Being able to uniquely identify constructor methods for classes // (""), since in GetMethodID we only receive class pointer. // 2) Providing a valid pointer to a valid object so that it behaves // normally in memory and can be freed. jclass clazz = (jclass) strdup(name); fjni_logv_dbg("[JNI] FindClass(%s): 0x%x", name, (int)clazz); return clazz; } jclass GetSuperclass(JNIEnv* env, jclass clazz) { fjni_logv_warn("[JNI] GetSuperclass(env, 0x%x): not implemented", (int)clazz); return NULL; } jboolean IsAssignableFrom(JNIEnv* env, jclass clazz1, jclass clazz2) { // Supposed to determine whether an object of clazz1 can be safely cast to clazz2. // We can not check that, so return JNI_TRUE always. fjni_logv_warn("[JNI] IsAssignableFrom(env, 0x%x, 0x%x): not implemented", (int)clazz1, (int)clazz2); return JNI_TRUE; } jmethodID FromReflectedMethod(JNIEnv* env, jobject method) { fjni_logv_warn("[JNI] FromReflectedMethod(env, 0x%x): not implemented", (int)method); return NULL; } jfieldID FromReflectedField(JNIEnv* env, jobject field) { fjni_logv_warn("[JNI] FromReflectedField(env, 0x%x): not implemented", (int)field); return NULL; } jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic) { fjni_logv_warn("[JNI] ToReflectedMethod(env, 0x%x, %i, %i): not implemented", (int)cls, methodID, isStatic); return NULL; } jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic) { fjni_logv_warn("[JNI] ToReflectedField(env, 0x%x, %i, %i): not implemented", (int)cls, fieldID, isStatic); return 0; } // TODO: Handle exceptions jint Throw(JNIEnv* env, jthrowable obj) { fjni_logv_warn("[JNI] Throw(env, 0x%x): not implemented", (int)obj); return 0; } jint ThrowNew(JNIEnv* env, jclass clazz, const char* message) { fjni_logv_warn("[JNI] ThrowNew(env, 0x%x, \"%s\"): not implemented", (int)clazz, message); return 0; } jthrowable ExceptionOccurred(JNIEnv* env) { fjni_log_dbg("[JNI] ExceptionOccurred(env): ignored"); // We never have exceptions. return NULL; } void ExceptionDescribe(JNIEnv* env) { fjni_log_dbg("[JNI] ExceptionDescribe(env): ignored"); // We never have exceptions. } void ExceptionClear(JNIEnv* env) { fjni_log_dbg("[JNI] ExceptionClear(env): ignored"); // We never have exceptions. } void FatalError(JNIEnv* env, const char* msg) { fjni_log_err(msg); abort(); } jint PushLocalFrame(JNIEnv* env, jint capacity) { fjni_logv_dbg("[JNI] PushLocalFrame(env, %i): ignored", capacity); // Since we operate with global pointers everywhere, no need to scope them. return 0; } jobject PopLocalFrame(JNIEnv* env, jobject result) { fjni_logv_dbg("[JNI] PopLocalFrame(env, 0x%x): ignored", (int)result); // Since we operate with global pointers everywhere, no need to scope them. return NULL; } jobject NewGlobalRef(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] NewGlobalRef(env, 0x%x)", (int)obj); // The concept of global/local references really makes sense only with // a real JVM. Here, since we basically operate with shared global pointers // everywhere, it should be safe to just return `obj` back return obj; } void DeleteGlobalRef(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] DeleteGlobalRef(env, 0x%x)", (int)obj); // Empirically, DeleteGlobalRef() is called on dynamically allocated things // returned from other JNI functions. For most of them it's safe to just // call free(), except for dynamically allocated arrays. We provide // a separate "destructor" for those. // Reserved fake identifiers if ((int)obj != 0x42424242 && (int)obj != 0x69696969) { if (jda_free(obj) == JNI_FALSE) { if (obj) free(obj); } } } void DeleteLocalRef(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] DeleteLocalRef(env, 0x%x): ignored", (int)obj); // Local references are useless in the setting of our fake JVM. } jboolean IsSameObject(JNIEnv* env, jobject ref1, jobject ref2) { fjni_logv_dbg("[JNI] IsSameObject(env, 0x%x, 0x%x)", (int)ref1, (int)ref2); return (ref1 == ref2) ? JNI_TRUE : JNI_FALSE; } jobject NewLocalRef(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] NewLocalRef(env, 0x%x): ignored", (int)obj); // Local references are useless in the setting of our fake JVM. // Just return `obj` back. return obj; } jint EnsureLocalCapacity(JNIEnv* env, jint capacity) { fjni_logv_dbg("[JNI] EnsureLocalCapacity(env, %i)", capacity); return JNI_OK; } jobject AllocObject(JNIEnv* env, jclass clazz) { fjni_logv_warn("[JNI] AllocObject(env, 0x%x): not implemented", (int)clazz); return (jobject)0x42424242; } jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] NewObject(env, 0x%x, %i)", clazz, methodID); jobject ret; va_list args; va_start(args, methodID); ret = methodObjectCall(methodID, args); va_end(args); return ret; } jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] NewObjectV(env, 0x%x, %i)", clazz, methodID); return methodObjectCall(methodID, args); } jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue *args) { fjni_logv_dbg("[JNI] NewObjectA(env, 0x%x, %i)", (int)clazz, methodID); return methodObjectCall(methodID, _AtoV(0, args)); } jclass GetObjectClass(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] GetObjectClass(0x%x)", (int)obj); // Due to the way we implement class methods, it's safe to not waste // resources on mapping objects to classess and return just a constant val. return (jclass)0x42424242; } jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz) { fjni_logv_warn("[JNI] IsInstanceOf(env, 0x%x, 0x%x): not implemented", (int)obj, (int)clazz); return JNI_FALSE; } jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char* _name, const char* sig) { jmethodID ret; char name[512]; if (strcmp("", _name) == 0) { if (!clazz) { fjni_log_err("Cannot find constructor method ID for class NULL"); return NULL; } // In FindClass we return a char ptr of class name as `clazz`, so we // can use it here for distinguishing different constructors snprintf(name, sizeof(name), "%s/%s", (char*)clazz, _name); } else { snprintf(name, sizeof(name), "%s", _name); } ret = getMethodIdByName(name); if (ret != NULL) { fjni_logv_dbg("[JNI] GetMethodID(env, 0x%x, \"%s\", \"%s\"): %i", (int)clazz, name, sig, (int)ret); } else { fjni_logv_err("[JNI] GetMethodID(env, 0x%x, \"%s\", \"%s\"): not found", (int)clazz, name, sig, (int)ret); } return ret; } jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallObjectMethod(env, 0x%x, %i)", (int)obj, methodID); jobject ret; va_list args; va_start(args, methodID); ret = methodObjectCall(methodID, args); va_end(args); return ret; } jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallObjectMethodV(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodObjectCall(methodID, args); } jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallObjectMethodA(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodObjectCall(methodID, _AtoV(0, args)); } jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallBooleanMethod(env, 0x%x, %i)", (int)obj, methodID); jboolean ret; va_list args; va_start(args, methodID); ret = methodBooleanCall(methodID, args); va_end(args); return ret; } jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallBooleanMethodV(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodBooleanCall(methodID, args); } jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallBooleanMethodA(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodBooleanCall(methodID, _AtoV(0, args)); } jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallByteMethod(env, 0x%x, %i)", (int)obj, methodID); jbyte ret; va_list args; va_start(args, methodID); ret = methodByteCall(methodID, args); va_end(args); return ret; } jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallByteMethodV(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodByteCall(methodID, args); } jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallByteMethodA(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodByteCall(methodID, _AtoV(0, args)); } jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallCharMethod(env, 0x%x, %i)", (int)obj, methodID); jchar ret; va_list args; va_start(args, methodID); ret = methodCharCall(methodID, args); va_end(args); return ret; } jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallCharMethodV(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodCharCall(methodID, args); } jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallCharMethodA(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodCharCall(methodID, _AtoV(0, args)); } jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallShortMethod(env, 0x%x, %i)", (int)obj, methodID); jshort ret; va_list args; va_start(args, methodID); ret = methodShortCall(methodID, args); va_end(args); return ret; } jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallShortMethodV(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodShortCall(methodID, args); } jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallShortMethodA(env, 0x%x, %i, args)", (int)obj, (int)methodID); return methodShortCall(methodID, _AtoV(0, args)); } jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallIntMethod(env, 0x%x, %i, ...)", (int)obj, methodID); jint ret; va_list args; va_start(args, methodID); ret = methodIntCall(methodID, args); va_end(args); return ret; } jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallIntMethodV(env, 0x%x, %i, args)", (int)obj, methodID); return methodIntCall(methodID, args); } jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallIntMethodA(env, 0x%x, %i, args)", (int)obj, methodID); return methodIntCall(methodID, _AtoV(0, args)); } jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallLongMethod(env, 0x%x, %i, ...)", (int)obj, methodID); jlong ret; va_list args; va_start(args, methodID); ret = methodLongCall(methodID, args); va_end(args); return ret; } jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallLongMethodV(env, 0x%x, %i, args)", (int)obj, methodID); return methodLongCall(methodID, args); } jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallLongMethodA(env, 0x%x, %i, args)", (int)obj, methodID); return methodLongCall(methodID, _AtoV(0, args)); } jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallFloatMethod(env, 0x%x, %i, ...)", (int)obj, methodID); jfloat ret; va_list args; va_start(args, methodID); ret = methodFloatCall(methodID, args); va_end(args); return ret; } jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallFloatMethodV(env, 0x%x, %i, args)", (int)obj, methodID); return methodFloatCall(methodID, args); } jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallFloatMethodA(env, 0x%x, %i, args)", (int)obj, methodID); return methodFloatCall(methodID, _AtoV(0, args)); } jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallDoubleMethod(env, 0x%x, %i, ...)", (int)obj, methodID); jdouble ret; va_list args; va_start(args, methodID); ret = methodDoubleCall(methodID, args); va_end(args); return ret; } jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallDoubleMethodV(env, 0x%x, %i, args)", (int)obj, methodID); return methodDoubleCall(methodID, args); } jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallDoubleMethodA(env, 0x%x, %i, args)", (int)obj, methodID); return methodDoubleCall(methodID, _AtoV(0, args)); } void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallVoidMethod(env, 0x%x, %i, ...)", (int)obj, methodID); va_list args; va_start(args, methodID); methodVoidCall(methodID, args); va_end(args); } void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallVoidMethodV(env, 0x%x, %i, args)", (int)obj, methodID); methodVoidCall(methodID, args); } void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallVoidMethodA(env, 0x%x, %i, args)", (int)obj, methodID); methodVoidCall(methodID, _AtoV(0, args)); } jobject CallNonvirtualObjectMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualObjectMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jobject ret; va_list args; va_start(args, methodID); ret = methodObjectCall(methodID, args); va_end(args); return ret; } jobject CallNonvirtualObjectMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualObjectMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodObjectCall(methodID, args); } jobject CallNonvirtualObjectMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualObjectMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodObjectCall(methodID, _AtoV(0, args)); } jboolean CallNonvirtualBooleanMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualBooleanMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jboolean ret; va_list args; va_start(args, methodID); ret = methodBooleanCall(methodID, args); va_end(args); return ret; } jboolean CallNonvirtualBooleanMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualBooleanMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodBooleanCall(methodID, args); } jboolean CallNonvirtualBooleanMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualBooleanMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodBooleanCall(methodID, _AtoV(0, args)); } jbyte CallNonvirtualByteMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualByteMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jbyte ret; va_list args; va_start(args, methodID); ret = methodByteCall(methodID, args); va_end(args); return ret; } jbyte CallNonvirtualByteMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualByteMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodByteCall(methodID, args); } jbyte CallNonvirtualByteMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualByteMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodByteCall(methodID, _AtoV(0, args)); } jchar CallNonvirtualCharMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualCharMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jchar ret; va_list args; va_start(args, methodID); ret = methodCharCall(methodID, args); va_end(args); return ret; } jchar CallNonvirtualCharMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualCharMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodCharCall(methodID, args); } jchar CallNonvirtualCharMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualCharMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodCharCall(methodID, _AtoV(0, args)); } jshort CallNonvirtualShortMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualShortMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jshort ret; va_list args; va_start(args, methodID); ret = methodShortCall(methodID, args); va_end(args); return ret; } jshort CallNonvirtualShortMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualShortMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodShortCall(methodID, args); } jshort CallNonvirtualShortMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualShortMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodShortCall(methodID, _AtoV(0, args)); } jint CallNonvirtualIntMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualIntMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jint ret; va_list args; va_start(args, methodID); ret = methodIntCall(methodID, args); va_end(args); return ret; } jint CallNonvirtualIntMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualIntMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodIntCall(methodID, args); } jint CallNonvirtualIntMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualIntMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodIntCall(methodID, _AtoV(0, args)); } jlong CallNonvirtualLongMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualLongMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jlong ret; va_list args; va_start(args, methodID); ret = methodLongCall(methodID, args); va_end(args); return ret; } jlong CallNonvirtualLongMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualLongMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodLongCall(methodID, args); } jlong CallNonvirtualLongMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualLongMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodLongCall(methodID, _AtoV(0, args)); } jfloat CallNonvirtualFloatMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualFloatMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jfloat ret; va_list args; va_start(args, methodID); ret = methodFloatCall(methodID, args); va_end(args); return ret; } jfloat CallNonvirtualFloatMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualFloatMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodFloatCall(methodID, args); } jfloat CallNonvirtualFloatMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualFloatMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodFloatCall(methodID, _AtoV(0, args)); } jdouble CallNonvirtualDoubleMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualDoubleMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); jdouble ret; va_list args; va_start(args, methodID); ret = methodDoubleCall(methodID, args); va_end(args); return ret; } jdouble CallNonvirtualDoubleMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualDoubleMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodDoubleCall(methodID, args); } jdouble CallNonvirtualDoubleMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualDoubleMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); return methodDoubleCall(methodID, _AtoV(0, args)); } void CallNonvirtualVoidMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallNonvirtualVoidMethod(env, 0x%x, 0x%x, %i, ...)", (int)obj, (int)clazz, methodID); va_list args; va_start(args, methodID); methodVoidCall(methodID, args); va_end(args); } void CallNonvirtualVoidMethodV(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallNonvirtualVoidMethodV(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); methodVoidCall(methodID, args); } void CallNonvirtualVoidMethodA(JNIEnv* env, jobject obj, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallNonvirtualVoidMethodA(env, 0x%x, 0x%x, %i, args)", (int)obj, (int)clazz, methodID); methodVoidCall(methodID, _AtoV(0, args)); } jfieldID GetFieldID(JNIEnv * env, jclass clazz, const char* name, const char* t) { fjni_logv_dbg("[JNI] GetFieldID(env, 0x%x, \"%s\", \"%s\")", (int)clazz, name, t); return getFieldIdByName(name); } jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetObjectField(env, 0x%x, %i)", (int)obj, fieldID); return getObjectFieldValueById(fieldID); } jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetBooleanField(env, 0x%x, %i)", (int)obj, fieldID); return getBooleanFieldValueById(fieldID); } jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetByteField(env, 0x%x, %i)", (int)obj, fieldID); return getByteFieldValueById(fieldID); } jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetCharField(env, 0x%x, %i)", (int)obj, fieldID); return getCharFieldValueById(fieldID); } jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetShortField(env, 0x%x, %i)", (int)obj, fieldID); return getShortFieldValueById(fieldID); } jint GetIntField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetIntField(env, 0x%x, %i)", (int)obj, fieldID); return getIntFieldValueById(fieldID); } jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetLongField(env, 0x%x, %i)", (int)obj, fieldID); return getLongFieldValueById(fieldID); } jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetFloatField(env, 0x%x, %i)", (int)obj, fieldID); return getFloatFieldValueById(fieldID); } jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetFloatField(env, 0x%x, %i)", (int)obj, fieldID); return getDoubleFieldValueById(fieldID); } void SetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID, jobject value) { fjni_logv_dbg("[JNI] SetObjectField(env, 0x%x, %i, 0x%x)", (int)obj, fieldID, (int)value); setObjectFieldValueById(fieldID, value); } void SetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID, jboolean value) { fjni_logv_dbg("[JNI] SetBooleanField(env, 0x%x, %i, 0x%x)", (int)obj, fieldID, (int)value); setBooleanFieldValueById(fieldID, value); } void SetByteField(JNIEnv* env, jobject obj, jfieldID fieldID, jbyte value) { fjni_logv_dbg("[JNI] SetByteField(env, 0x%x, %i, 0x%x)", (int)obj, fieldID, (int)value); setByteFieldValueById(fieldID, value); } void SetCharField(JNIEnv* env, jobject obj, jfieldID fieldID, jchar value) { fjni_logv_dbg("[JNI] SetCharField(env, 0x%x, %i, '%s')", (int)obj, fieldID, value); setCharFieldValueById(fieldID, value); } void SetShortField(JNIEnv* env, jobject obj, jfieldID fieldID, jshort value) { fjni_logv_dbg("[JNI] SetShortField(env, 0x%x, %i, %i)", (int)obj, fieldID, (int)value); setShortFieldValueById(fieldID, value); } void SetIntField(JNIEnv* env, jobject obj, jfieldID fieldID, jint value) { fjni_logv_dbg("[JNI] SetIntField(env, 0x%x, %i, %i)", (int)obj, fieldID, (int)value); setIntFieldValueById(fieldID, value); } void SetLongField(JNIEnv* env, jobject obj, jfieldID fieldID, jlong value) { fjni_logv_dbg("[JNI] SetLongField(env, 0x%x, %i, %i)", (int)obj, fieldID, (int)value); setLongFieldValueById(fieldID, value); } void SetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID, jfloat value) { fjni_logv_dbg("[JNI] SetFloatField(env, 0x%x, %i, %f)", (int)obj, fieldID, value); setFloatFieldValueById(fieldID, value); } void SetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID, jdouble value) { fjni_logv_dbg("[JNI] SetFloatField(env, 0x%x, %i, %i)", (int)obj, fieldID, value); setDoubleFieldValueById(fieldID, value); } jmethodID GetStaticMethodID(JNIEnv* env, jclass clazz, const char* _name, const char* sig) { jmethodID ret; char name[512]; if (strcmp("", _name) == 0) { if (!clazz) { fjni_log_err("Cannot find constructor method ID for class NULL"); return NULL; } // In FindClass we return a char ptr of class name as `clazz`, so we // can use it here for distinguishing different constructors snprintf(name, sizeof(name), "%s/%s", (char*)clazz, _name); } else { snprintf(name, sizeof(name), "%s", _name); } ret = getMethodIdByName(name); if (ret != NULL) { fjni_logv_dbg("[JNI] GetStaticMethodID(env, 0x%x, \"%s\", \"%s\"): %i", (int)clazz, name, sig, (int)ret); } else { fjni_logv_err("[JNI] GetStaticMethodID(env, 0x%x, \"%s\", \"%s\"): not found", (int)clazz, name, sig, (int)ret); } return ret; } jobject CallStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticObjectMethod(env, 0x%x, %i)", (int)clazz, methodID); jobject ret; va_list args; va_start(args, methodID); ret = methodObjectCall(methodID, args); va_end(args); return ret; } jobject CallStaticObjectMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticObjectMethodV(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodObjectCall(methodID, args); } jobject CallStaticObjectMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticObjectMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodObjectCall(methodID, _AtoV(0, args)); } jboolean CallStaticBooleanMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticBooleanMethod(env, 0x%x, %i)", (int)clazz, methodID); jboolean ret; va_list args; va_start(args, methodID); ret = methodBooleanCall(methodID, args); va_end(args); return ret; } jboolean CallStaticBooleanMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticBooleanMethodV(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodBooleanCall(methodID, args); } jboolean CallStaticBooleanMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticBooleanMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodBooleanCall(methodID, _AtoV(0, args)); } jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticByteMethod(env, 0x%x, %i)", (int)clazz, methodID); jbyte ret; va_list args; va_start(args, methodID); ret = methodByteCall(methodID, args); va_end(args); return ret; } jbyte CallStaticByteMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticByteMethodV(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodByteCall(methodID, args); } jbyte CallStaticByteMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticByteMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodByteCall(methodID, _AtoV(0, args)); } jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticCharMethod(env, 0x%x, %i)", (int)clazz, methodID); jchar ret; va_list args; va_start(args, methodID); ret = methodCharCall(methodID, args); va_end(args); return ret; } jchar CallStaticCharMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticCharMethodV(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodCharCall(methodID, args); } jchar CallStaticCharMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticCharMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodCharCall(methodID, _AtoV(0, args)); } jshort CallStaticShortMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticShortMethod(env, 0x%x, %i)", (int)clazz, methodID); jshort ret; va_list args; va_start(args, methodID); ret = methodShortCall(methodID, args); va_end(args); return ret; } jshort CallStaticShortMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticShortMethodV(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodShortCall(methodID, args); } jshort CallStaticShortMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticShortMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodShortCall(methodID, _AtoV(0, args)); } jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticIntMethod(env, 0x%x, %i, ...)", (int)clazz, methodID); jint ret; va_list args; va_start(args, methodID); ret = methodIntCall(methodID, args); va_end(args); return ret; } jint CallStaticIntMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticIntMethodV(env, 0x%x, %i, args)", (int)clazz, methodID); return methodIntCall(methodID, args); } jint CallStaticIntMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticIntMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodIntCall(methodID, _AtoV(0, args)); } jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticLongMethod(env, 0x%x, %i, ...)", (int)clazz, methodID); jlong ret; va_list args; va_start(args, methodID); ret = methodLongCall(methodID, args); va_end(args); return ret; } jlong CallStaticLongMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticLongMethodV(env, 0x%x, %i, args)", (int)clazz, methodID); return methodLongCall(methodID, args); } jlong CallStaticLongMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticLongMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodLongCall(methodID, _AtoV(0, args)); } jfloat CallStaticFloatMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticFloatMethod(env, 0x%x, %i, ...)", (int)clazz, methodID); jfloat ret; va_list args; va_start(args, methodID); ret = methodFloatCall(methodID, args); va_end(args); return ret; } jfloat CallStaticFloatMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticFloatMethodV(env, 0x%x, %i, args)", (int)clazz, methodID); return methodFloatCall(methodID, args); } jfloat CallStaticFloatMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticFloatMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodFloatCall(methodID, _AtoV(0, args)); } jdouble CallStaticDoubleMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticDoubleMethod(env, 0x%x, %i, ...)", (int)clazz, methodID); jdouble ret; va_list args; va_start(args, methodID); ret = methodDoubleCall(methodID, args); va_end(args); return ret; } jdouble CallStaticDoubleMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticDoubleMethodV(env, 0x%x, %i, args)", (int)clazz, methodID); return methodDoubleCall(methodID, args); } jdouble CallStaticDoubleMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticDoubleMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); return methodDoubleCall(methodID, _AtoV(0, args)); } void CallStaticVoidMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) { fjni_logv_dbg("[JNI] CallStaticVoidMethod(env, 0x%x, %i, ...)", (int)clazz, methodID); va_list args; va_start(args, methodID); methodVoidCall(methodID, args); va_end(args); } void CallStaticVoidMethodV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) { fjni_logv_dbg("[JNI] CallStaticVoidMethodV(env, 0x%x, %i, args)", (int)clazz, methodID); methodVoidCall(methodID, args); } void CallStaticVoidMethodA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue* args) { fjni_logv_dbg("[JNI] CallStaticVoidMethodA(env, 0x%x, %i, args)", (int)clazz, (int)methodID); methodVoidCall(methodID, _AtoV(0, args)); } jfieldID GetStaticFieldID(JNIEnv* env, jclass clazz, const char* name, const char* t) { fjni_logv_dbg("[JNI] GetStaticFieldID(env, 0x%x, \"%s\", \"%s\")", (int)clazz, name, t); return getFieldIdByName(name); } jobject GetStaticObjectField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticObjectField(env, 0x%x, %i)", (int)clazz, fieldID); return getObjectFieldValueById(fieldID); } jboolean GetStaticBooleanField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticBooleanField(env, 0x%x, %i)", (int)clazz, fieldID); return getBooleanFieldValueById(fieldID); } jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticByteField(env, 0x%x, %i)", (int)clazz, fieldID); return getByteFieldValueById(fieldID); } jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticCharField(env, 0x%x, %i)", (int)clazz, fieldID); return getCharFieldValueById(fieldID); } jshort GetStaticShortField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticShortField(env, 0x%x, %i)", (int)clazz, fieldID); return getShortFieldValueById(fieldID); } jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticIntField(env, 0x%x, %i): ", (int)clazz, fieldID); return getIntFieldValueById(fieldID); } jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticLongField(env, 0x%x, %i)", (int)clazz, fieldID); return getLongFieldValueById(fieldID); } jfloat GetStaticFloatField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticFloatField(env, 0x%x, %i)", (int)clazz, fieldID); return getFloatFieldValueById(fieldID); } jdouble GetStaticDoubleField(JNIEnv* env, jclass clazz, jfieldID fieldID) { fjni_logv_dbg("[JNI] GetStaticDoubleField(env, 0x%x, %i)", (int)clazz, fieldID); return getDoubleFieldValueById(fieldID); } void SetStaticObjectField(JNIEnv* env, jclass clazz, jfieldID fieldID, jobject value) { fjni_logv_dbg("[JNI] SetStaticObjectField(env, 0x%x, %i, 0x%x)", (int)clazz, fieldID, (int)value); setObjectFieldValueById(fieldID, value); } void SetStaticBooleanField(JNIEnv* env, jclass clazz, jfieldID fieldID, jboolean value) { fjni_logv_dbg("[JNI] SetStaticBooleanField(env, 0x%x, %i, 0x%x)", (int)clazz, fieldID, (int)value); setBooleanFieldValueById(fieldID, value); } void SetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID, jbyte value) { fjni_logv_dbg("[JNI] SetStaticByteField(env, 0x%x, %i, 0x%x)", (int)clazz, fieldID, (int)value); setByteFieldValueById(fieldID, value); } void SetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID, jchar value) { fjni_logv_dbg("[JNI] SetStaticCharField(env, 0x%x, %i, '%s')", (int)clazz, fieldID, value); setCharFieldValueById(fieldID, value); } void SetStaticShortField(JNIEnv* env, jclass clazz, jfieldID fieldID, jshort value) { fjni_logv_dbg("[JNI] SetStaticShortField(env, 0x%x, %i, %i)", (int)clazz, fieldID, (int)value); setShortFieldValueById(fieldID, value); } void SetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID, jint value) { fjni_logv_dbg("[JNI] SetStaticIntField(env, 0x%x, %i, %i)", (int)clazz, fieldID, (int)value); setIntFieldValueById(fieldID, value); } void SetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID, jlong value) { fjni_logv_dbg("[JNI] SetStaticLongField(env, 0x%x, %i, %i)", (int)clazz, fieldID, (int)value); setLongFieldValueById(fieldID, value); } void SetStaticFloatField(JNIEnv* env, jclass clazz, jfieldID fieldID, jfloat value) { fjni_logv_dbg("[JNI] SetStaticFloatField(env, 0x%x, %i, %f)", (int)clazz, fieldID, value); setFloatFieldValueById(fieldID, value); } void SetStaticDoubleField(JNIEnv* env, jclass clazz, jfieldID fieldID, jdouble value) { fjni_logv_dbg("[JNI] SetStaticFloatField(env, 0x%x, %i, %i)", (int)clazz, fieldID, value); setDoubleFieldValueById(fieldID, value); } jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) { // abort()s here replicate Dalvik behavior. if (char_count < 0) { fjni_logv_err("[JNI] NewString(env, %p, %i): Fatal: char_count < 0! Aborting.", chars, char_count); abort(); } if (chars == NULL && char_count > 0) { fjni_logv_err("[JNI] NewString(env, %p, %i): Fatal: chars == null && char_count > 0", chars, char_count); abort(); } JavaString * res = malloc(sizeof(JavaString)); if (res == NULL) { fjni_logv_err("[JNI] NewString(env, %p, %i): Fatal: malloc failed", chars, char_count); return NULL; } res->utf8 = NULL; res->utf16 = jda_alloc(char_count, FIELD_TYPE_CHAR); if (res->utf16 == NULL) { fjni_logv_err("[JNI] NewString(env, %p, %i): Fatal: jda_alloc failed", chars, char_count); return NULL; } memcpy(res->utf16->array, chars, char_count * sizeof(jchar)); // Performing extraneous conversion on debug builds to show the string in the console output #if FALSOJNI_DEBUGLEVEL <= FALSOJNI_DEBUG_ALL if (jstr_utf16_to_utf8(res) == JNI_FALSE) { fjni_logv_err("[JNI] NewString(env, %p, %i): debug utf16 conversion failed", chars, char_count); } else { fjni_logv_dbg("[JNI] NewString(env, \"%s\", %i)", (char *)res->utf8->array, char_count); } #endif return res; } jsize GetStringLength(JNIEnv* env, jstring string) { JavaString * str = string; // Performing extraneous conversion on debug builds to show the string in the console output #if FALSOJNI_DEBUGLEVEL <= FALSOJNI_DEBUG_ALL if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] GetStringLength(env, %p): debug utf16 conversion failed", string); } else { fjni_logv_dbg("[JNI] GetStringLength(env, \"%s\")", (char *)str->utf8->array); } #endif return str->utf16->len; } const jchar * GetStringChars(JNIEnv* env, jstring string, jboolean *isCopy) { if (!string) { fjni_logv_err("[JNI] GetStringChars(env, %p, *isCopy): string is null", string); return NULL; } JavaString * str = string; if (isCopy != NULL) { *isCopy = JNI_TRUE; } jchar * ret = malloc(str->utf16->len * sizeof(jchar)); if (ret == NULL) { fjni_logv_err("[JNI] GetStringChars(env, %p, *isCopy): malloc failed", string); return NULL; } memcpy(ret, str->utf16->array, str->utf16->len * sizeof(jchar)); // Performing extraneous conversion on debug builds to show the string in the console output #if FALSOJNI_DEBUGLEVEL <= FALSOJNI_DEBUG_ALL if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] GetStringChars(env, %p, *isCopy): debug utf16 conversion failed", string); } else { fjni_logv_dbg("[JNI] GetStringChars(env, \"%s\", *isCopy)", (char *)str->utf8->array); } #endif return ret; } void ReleaseStringChars(JNIEnv* env, jstring string, const jchar *chars) { if (chars == NULL) { fjni_logv_err("[JNI] ReleaseStringChars(env, %p, %p): chars is null", string, chars); return; } // Performing extraneous conversion on debug builds to show the string in the console output #if FALSOJNI_DEBUGLEVEL <= FALSOJNI_DEBUG_ALL JavaString * str = string; if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] ReleaseStringChars(env, %p, %p): debug utf16 conversion failed", string, chars); } else { fjni_logv_dbg("[JNI] ReleaseStringChars(env, \"%s\", %p)", (char *)str->utf8->array, chars); } #endif free((jchar *)chars); } jstring NewStringUTF(JNIEnv* env, const char* bytes) { fjni_logv_dbg("[JNI] NewStringUTF(env, \"%s\")", bytes); int len = strlen(bytes) + 1; // with null terminator JavaString * res = malloc(sizeof(JavaString)*2); if (res == NULL) { fjni_logv_err("[JNI] NewStringUTF(env, \"%s\"): Fatal: malloc failed", bytes); return NULL; } res->utf8 = jda_alloc(len, FIELD_TYPE_BYTE); if (res->utf8 == NULL) { fjni_logv_err("[JNI] NewStringUTF(env, \"%s\"): Fatal: jda_alloc failed", bytes); free(res); return NULL; } res->utf16 = jda_alloc(len - 1, FIELD_TYPE_CHAR); if (res->utf16 == NULL) { fjni_logv_err("[JNI] NewStringUTF(env, \"%s\"): Fatal: jda_alloc failed", bytes); free(res); return NULL; } memcpy(res->utf8->array, bytes, res->utf8->len); if (jstr_utf8_to_utf16(res) == JNI_FALSE) { fjni_logv_err("[JNI] NewStringUTF(env, \"%s\"): utf16 conversion failed", bytes); jda_free(res->utf8); jda_free(res->utf16); free(res); return NULL; } return res; } jsize GetStringUTFLength(JNIEnv* env, jstring string) { if (!string) { fjni_logv_err("[JNI] GetStringUTFLength(env, %p): string is null", string); } JavaString * str = string; // Performing extraneous conversion on debug builds to show the string in the console output #if FALSOJNI_DEBUGLEVEL <= FALSOJNI_DEBUG_ALL if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] GetStringUTFLength(env, %p): debug utf16 conversion failed", string); } else { fjni_logv_dbg("[JNI] GetStringUTFLength(env, \"%s\")", str->utf8->array); } #endif return str->utf16->len; } const char* GetStringUTFChars(JNIEnv* env, jstring string, jboolean* isCopy) { if (!string) { fjni_logv_err("[JNI] GetStringUTFChars(env, %p, *isCopy): string is null", string); return NULL; } JavaString * str = string; if (isCopy != NULL) { *isCopy = JNI_TRUE; } char * ret = malloc(str->utf16->len + 1); if (ret == NULL) { fjni_logv_err("[JNI] GetStringUTFChars(env, %p, *isCopy): malloc failed", string); return NULL; } if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] GetStringUTFChars(env, %p, *isCopy): utf16 conversion failed", string); free(ret); return NULL; } memcpy(ret, str->utf8->array, str->utf8->len); fjni_logv_dbg("[JNI] GetStringUTFChars(env, \"%s\", *isCopy)", (char *)str->utf8->array); return ret; } void ReleaseStringUTFChars(JNIEnv* env, jstring string, char* chars) { fjni_logv_dbg("[JNI] ReleaseStringUTFChars(env, %p, \"%s\")", string, chars); if (chars) { free(chars); } } jsize GetArrayLength(JNIEnv* env, jarray array) { fjni_logv_dbg("[JNI] GetArrayLength(env, 0x%x)", (int)array); // TODO: this can theoretically be called for ObjectField values. Need to keep track of their sizes too? jsize ret = jda_sizeof(array); if (ret > -1) return ret; fjni_logv_warn("Array 0x%x not found. Unknown array type?", (int)array); return 0; } jobjectArray NewObjectArray(JNIEnv* env, jsize length, jclass elementClass, jobject initialElement) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_OBJECT); if (!jda) { fjni_logv_err("[JNI] NewObjectArray(env, %i, 0x%x, 0x%x): Could not allocate a new array!", length, elementClass, initialElement); return NULL; } jobject* arr = jda->array; for (int i = 0; i < length; ++i) arr[i] = initialElement; fjni_logv_dbg("[JNI] NewObjectArray(env, %i, 0x%x, 0x%x): 0x%x", length, elementClass, initialElement, (int)jda); return jda; } jobject GetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetObjectArrayElement(env, 0x%x, idx:%i): Could not find the array", array, index); return NULL; } if (index >= jda->len || index < 0) { fjni_logv_err("[JNI] GetObjectArrayElement(env, 0x%x, idx:%i): Index out of bounds", array, index); return NULL; } jobject * arr = jda->array; fjni_logv_dbg("[JNI] GetObjectArrayElement(env, 0x%x, idx:%i): 0x%x", array, index, (int)arr[index]); return arr[index]; } void SetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index, jobject value) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] SetObjectArrayElement(env, 0x%x, idx:%i, val:0x%x): Could not find the array", array, index, value); return; } if (index >= jda->len || index < 0) { fjni_logv_err("[JNI] SetObjectArrayElement(env, 0x%x, idx:%i, val:0x%x): Index out of bounds", array, index, value); return; } fjni_logv_dbg("[JNI] SetObjectArrayElement(env, 0x%x, idx:%i, val:0x%x)", array, index, value); jobject * arr = jda->array; arr[index] = value; } jbooleanArray NewBooleanArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_BOOLEAN); if (!jda) { fjni_logv_err("[JNI] NewBooleanArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewBooleanArray(env, %i): 0x%x", length, (int)jda); return jda; } jbyteArray NewByteArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_BYTE); if (!jda) { fjni_logv_err("[JNI] NewByteArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewByteArray(env, %i): 0x%x", length, (int)jda); return jda; } jcharArray NewCharArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_CHAR); if (!jda) { fjni_logv_err("[JNI] NewCharArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewCharArray(env, %i): 0x%x", length, (int)jda); return jda; } jshortArray NewShortArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_SHORT); if (!jda) { fjni_logv_err("[JNI] NewShortArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewShortArray(env, %i): 0x%x", length, (int)jda); return jda; } jintArray NewIntArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_INT); if (!jda) { fjni_logv_err("[JNI] NewIntArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewIntArray(env, %i): 0x%x", length, (int)jda); return jda; } jlongArray NewLongArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_LONG); if (!jda) { fjni_logv_err("[JNI] NewLongArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewLongArray(env, %i): 0x%x", length, (int)jda); return jda; } jfloatArray NewFloatArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_FLOAT); if (!jda) { fjni_logv_err("[JNI] NewFloatArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewFloatArray(env, %i): 0x%x", length, (int)jda); return jda; } jdoubleArray NewDoubleArray(JNIEnv* env, jsize length) { JavaDynArray * jda = jda_alloc(length, FIELD_TYPE_DOUBLE); if (!jda) { fjni_logv_err("[JNI] NewDoubleArray(env, %i): Could not allocate a new array!", length); return NULL; } fjni_logv_dbg("[JNI] NewDoubleArray(env, %i): 0x%x", length, (int)jda); return jda; } jboolean* GetBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetBooleanArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetBooleanArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetByteArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetByteArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetCharArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetCharArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jshort* GetShortArrayElements(JNIEnv* env, jshortArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetShortArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetShortArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetIntArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetIntArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetLongArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetLongArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jfloat* GetFloatArrayElements(JNIEnv* env, jfloatArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetFloatArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetFloatArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } jdouble* GetDoubleArrayElements(JNIEnv* env, jdoubleArray array, jboolean* isCopy) { JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetDoubleArrayElements(env, 0x%x, 0x%x): Could not find the array", array, isCopy); return NULL; } fjni_logv_dbg("[JNI] GetDoubleArrayElements(env, 0x%x, 0x%x)", (int)array, (int)isCopy); if (isCopy != NULL) *isCopy = JNI_FALSE; return jda->array; } // In GetArrayElements we never make copies, so ReleaseArrayElements can be ignored void ReleaseBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseBooleanArrayElements(): ignored"); } void ReleaseByteArrayElements(JNIEnv* env, jbyteArray array, jbyte* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseByteArrayElements(): ignored"); } void ReleaseCharArrayElements(JNIEnv* env, jcharArray array, jchar* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseCharArrayElements(): ignored"); } void ReleaseShortArrayElements(JNIEnv* env, jshortArray array, jshort* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseShortArrayElements(): ignored"); } void ReleaseIntArrayElements(JNIEnv* env, jintArray array, jint* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseIntArrayElements(): ignored"); } void ReleaseLongArrayElements(JNIEnv* env, jlongArray array, jlong* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseLongArrayElements(): ignored"); } void ReleaseFloatArrayElements(JNIEnv* env, jfloatArray array, jfloat* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseFloatArrayElements(): ignored"); } void ReleaseDoubleArrayElements(JNIEnv* env, jdoubleArray array, jdouble* elems, jint mode) { fjni_log_dbg("[JNI] ReleaseDoubleArrayElements(): ignored"); } void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length, jboolean* buffer) { GetPrimitiveArrayRegion("GetBooleanArrayRegion", FIELD_TYPE_BOOLEAN, jboolean, array, start, length, buffer); } void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length, jbyte* buffer) { GetPrimitiveArrayRegion("GetByteArrayRegion", FIELD_TYPE_BYTE, jbyte, array, start, length, buffer); } void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length, jchar* buffer) { GetPrimitiveArrayRegion("GetCharArrayRegion", FIELD_TYPE_CHAR, jchar, array, start, length, buffer); } void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length, jshort* buffer) { GetPrimitiveArrayRegion("GetShortArrayRegion", FIELD_TYPE_SHORT, jshort, array, start, length, buffer); } void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length, jint* buffer) { GetPrimitiveArrayRegion("GetIntArrayRegion", FIELD_TYPE_INT, jint, array, start, length, buffer); } void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length, jlong* buffer) { GetPrimitiveArrayRegion("GetLongArrayRegion", FIELD_TYPE_LONG, jlong, array, start, length, buffer); } void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length, jfloat* buffer) { GetPrimitiveArrayRegion("GetFloatArrayRegion", FIELD_TYPE_FLOAT, jfloat, array, start, length, buffer); } void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length, jdouble* buffer) { GetPrimitiveArrayRegion("GetDoubleArrayRegion", FIELD_TYPE_DOUBLE, jdouble, array, start, length, buffer); } void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, const jboolean* buf) { SetPrimitiveArrayRegion("SetBooleanArrayRegion", FIELD_TYPE_BOOLEAN, jboolean, array, start, len, buf); } void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, const jbyte* buf) { SetPrimitiveArrayRegion("SetByteArrayRegion", FIELD_TYPE_BYTE, jbyte, array, start, len, buf); } void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, const jchar* buf) { SetPrimitiveArrayRegion("SetCharArrayRegion", FIELD_TYPE_CHAR, jchar, array, start, len, buf); } void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, const jshort* buf) { SetPrimitiveArrayRegion("SetShortArrayRegion", FIELD_TYPE_SHORT, jshort, array, start, len, buf); } void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, const jint* buf) { SetPrimitiveArrayRegion("SetIntArrayRegion", FIELD_TYPE_INT, jint, array, start, len, buf); } void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, const jlong* buf) { SetPrimitiveArrayRegion("SetLongArrayRegion", FIELD_TYPE_LONG, jlong, array, start, len, buf); } void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, const jfloat* buf) { SetPrimitiveArrayRegion("SetFloatArrayRegion", FIELD_TYPE_FLOAT, jfloat, array, start, len, buf); } void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, const jdouble* buf) { SetPrimitiveArrayRegion("SetDoubleArrayRegion", FIELD_TYPE_DOUBLE, jdouble, array, start, len, buf); } // Due to the way we define and execute functions, Register/UnregisterNatives are redundant jint RegisterNatives(JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) { fjni_logv_dbg("[JNI] RegisterNatives(env, 0x%x, 0x%x, n:%i): ignored", (int)clazz, (int)methods, nMethods); return JNI_OK; } jint UnregisterNatives(JNIEnv* env, jclass clazz) { fjni_logv_dbg("[JNI] UnregisterNatives(env, 0x%x): ignored", (int)clazz); return JNI_OK; } // TODO: Implement MonitorEnter/MonitorExit with semaphores? jint MonitorEnter(JNIEnv* env, jobject obj) { // Here reduced log level to dbg to avoid a million logs fjni_logv_dbg("[JNI] MonitorEnter(env, 0x%x): not implemented", (int)obj); return JNI_OK; } jint MonitorExit(JNIEnv* env, jobject obj) { // Here reduced log level to dbg to avoid a million logs fjni_logv_dbg("[JNI] MonitorExit(env, 0x%x): not implemented", (int)obj); return JNI_OK; } jint GetJavaVM(JNIEnv* env, JavaVM** vm) { fjni_log_dbg("[JNI] GetJavaVM(env, *vm)"); *vm = &jvm; return JNI_OK; } void GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar* buf) { fjni_logv_dbg("[JNI] GetStringRegion(env, %p, start:%i, len:%i, %p)", str, start, len, buf); if (str == NULL || buf == NULL) { fjni_logv_err("[JNI] GetStringRegion(env, %p, start:%i, len:%i, %p): string or buf is null", str, start, len, buf); return; } JavaString * string = str; if ((start + len) > string->utf16->len) { fjni_logv_err("[JNI] GetStringRegion(env, %p, start:%i, len:%i, %p): StringIndexOutOfBoundsException", str, start, len, buf); return; } memcpy(buf, string->utf16 + (start * sizeof(jchar)), len * sizeof(jchar)); } void GetStringUTFRegion(JNIEnv* env, jstring str, jsize start, jsize len, char* buf) { fjni_logv_dbg("[JNI] GetStringUTFRegion(env, %p, start:%i, len:%i, %p)", str, start, len, buf); if (str == NULL || buf == NULL) { fjni_logv_err("[JNI] GetStringUTFRegion(env, %p, start:%i, len:%i, %p): string or buf is null", str, start, len, buf); return; } JavaString * string = str; if ((start + len) > string->utf16->len) { fjni_logv_err("[JNI] GetStringUTFRegion(env, %p, start:%i, len:%i, %p): StringIndexOutOfBoundsException", str, start, len, buf); return; } if (jstr_utf16_to_utf8(str) == JNI_FALSE) { fjni_logv_err("[JNI] GetStringUTFRegion(env, %p, start:%i, len:%i, %p): utf16 conversion failed", str, start, len, buf); return; } memcpy(buf, string->utf8 + start, len); buf[len] = '\0'; } void* GetPrimitiveArrayCritical(JNIEnv* env, jarray array, jboolean* isCopy) { if (isCopy) *isCopy = JNI_FALSE; JavaDynArray * jda = (JavaDynArray *) array; if (!jda) { fjni_logv_err("[JNI] GetPrimitiveArrayCritical(env, 0x%x, 0x%x): Array not found.", (int)array, (int)isCopy); return NULL; } fjni_logv_dbg("[JNI] GetPrimitiveArrayCritical(env, 0x%x, 0x%x)", (int)array, (int)isCopy); return jda->array; } void ReleasePrimitiveArrayCritical(JNIEnv* env, jarray array, void* carray, jint mode) { // We never copy in GetPrimitiveArrayCritical, so can ignore Release* fjni_logv_dbg("[JNI] ReleasePrimitiveArrayCritical(env, 0x%x, 0x%x, %i): ignored", (int)array, (int)carray, mode); } const jchar* GetStringCritical(JNIEnv* env, jstring string, jboolean* isCopy) { fjni_logv_dbg("[JNI] GetStringCritical(env, %p, *isCopy)", string); if (!string) { fjni_logv_err("[JNI] GetStringCritical(env, %p, *isCopy): string is null", string); return NULL; } if (isCopy != NULL) { *isCopy = JNI_FALSE; } return ((JavaString *)string)->utf16->array; } void ReleaseStringCritical(JNIEnv* env, jstring string, const jchar* carray) { fjni_logv_dbg("[JNI] ReleaseStringCritical(env, %p, %p)", string, carray); // We never issue copies in GetStringCritical => do nothing here } jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) { fjni_logv_dbg("[JNI] NewWeakGlobalRef(env, 0x%x): ignored", (int)obj); return (jweak)obj; } void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) { fjni_logv_dbg("[JNI] DeleteWeakGlobalRef(env, 0x%x)", (int)obj); // Do not free, since we have not created any additional references above. } jboolean ExceptionCheck(JNIEnv* env) { fjni_log_dbg("[JNI] ExceptionCheck(env): ignored"); return JNI_FALSE; } // TODO: Implement DirectByteBuffers jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) { fjni_logv_warn("[JNI] NewDirectByteBuffer(env, 0x%x, %i): not implemented", (int)address, capacity); return NULL; } void* GetDirectBufferAddress(JNIEnv* env, jobject buf) { fjni_logv_warn("[JNI] GetDirectBufferAddress(env, 0x%x)", (int)buf); return NULL; } jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf) { fjni_logv_warn("[JNI] GetDirectBufferCapacity(env, 0x%x)", (int)buf); return 0; } jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj) { fjni_logv_warn("[JNI] GetObjectRefType(env, 0x%x): not implemented", (int)obj); return JNIInvalidRefType; } void jni_init() { _jvm = (struct JNIInvokeInterface *) malloc(sizeof(struct JNIInvokeInterface)); _jvm->DestroyJavaVM = DestroyJavaVM; _jvm->AttachCurrentThread = AttachCurrentThread; _jvm->DetachCurrentThread = DetachCurrentThread; _jvm->GetEnv = GetEnv; _jvm->AttachCurrentThreadAsDaemon = AttachCurrentThreadAsDaemon; _jni = (struct JNINativeInterface *) malloc(sizeof(struct JNINativeInterface)); _jni->GetVersion = GetVersion; _jni->DefineClass = DefineClass; _jni->FindClass = FindClass; _jni->FromReflectedMethod = FromReflectedMethod; _jni->FromReflectedField = FromReflectedField; _jni->ToReflectedMethod = ToReflectedMethod; _jni->GetSuperclass = GetSuperclass; _jni->IsAssignableFrom = IsAssignableFrom; _jni->ToReflectedField = ToReflectedField; _jni->Throw = Throw; _jni->ThrowNew = ThrowNew; _jni->ExceptionOccurred = ExceptionOccurred; _jni->ExceptionDescribe = ExceptionDescribe; _jni->ExceptionClear = ExceptionClear; _jni->FatalError = FatalError; _jni->PushLocalFrame = PushLocalFrame; _jni->PopLocalFrame = PopLocalFrame; _jni->NewGlobalRef = NewGlobalRef; _jni->DeleteGlobalRef = DeleteGlobalRef; _jni->DeleteLocalRef = DeleteLocalRef; _jni->IsSameObject = IsSameObject; _jni->NewLocalRef = NewLocalRef; _jni->EnsureLocalCapacity = EnsureLocalCapacity; _jni->AllocObject = AllocObject; _jni->NewObject = NewObject; _jni->NewObjectV = NewObjectV; _jni->NewObjectA = NewObjectA; _jni->GetObjectClass = GetObjectClass; _jni->IsInstanceOf = IsInstanceOf; _jni->GetMethodID = GetMethodID; _jni->CallObjectMethod = CallObjectMethod; _jni->CallObjectMethodV = CallObjectMethodV; _jni->CallObjectMethodA = CallObjectMethodA; _jni->CallBooleanMethod = CallBooleanMethod; _jni->CallBooleanMethodV = CallBooleanMethodV; _jni->CallBooleanMethodA = CallBooleanMethodA; _jni->CallByteMethod = CallByteMethod; _jni->CallByteMethodV = CallByteMethodV; _jni->CallByteMethodA = CallByteMethodA; _jni->CallCharMethod = CallCharMethod; _jni->CallCharMethodV = CallCharMethodV; _jni->CallCharMethodA = CallCharMethodA; _jni->CallShortMethod = CallShortMethod; _jni->CallShortMethodV = CallShortMethodV; _jni->CallShortMethodA = CallShortMethodA; _jni->CallIntMethod = CallIntMethod; _jni->CallIntMethodV = CallIntMethodV; _jni->CallIntMethodA = CallIntMethodA; _jni->CallLongMethod = CallLongMethod; _jni->CallLongMethodV = CallLongMethodV; _jni->CallLongMethodA = CallLongMethodA; _jni->CallFloatMethod = CallFloatMethod; _jni->CallFloatMethodV = CallFloatMethodV; _jni->CallFloatMethodA = CallFloatMethodA; _jni->CallDoubleMethod = CallDoubleMethod; _jni->CallDoubleMethodV = CallDoubleMethodV; _jni->CallDoubleMethodA = CallDoubleMethodA; _jni->CallVoidMethod = CallVoidMethod; _jni->CallVoidMethodV = CallVoidMethodV; _jni->CallVoidMethodA = CallVoidMethodA; _jni->CallNonvirtualObjectMethod = CallNonvirtualObjectMethod; _jni->CallNonvirtualObjectMethodV = CallNonvirtualObjectMethodV; _jni->CallNonvirtualObjectMethodA = CallNonvirtualObjectMethodA; _jni->CallNonvirtualBooleanMethod = CallNonvirtualBooleanMethod; _jni->CallNonvirtualBooleanMethodV = CallNonvirtualBooleanMethodV; _jni->CallNonvirtualBooleanMethodA = CallNonvirtualBooleanMethodA; _jni->CallNonvirtualByteMethod = CallNonvirtualByteMethod; _jni->CallNonvirtualByteMethodV = CallNonvirtualByteMethodV; _jni->CallNonvirtualByteMethodA = CallNonvirtualByteMethodA; _jni->CallNonvirtualCharMethod = CallNonvirtualCharMethod; _jni->CallNonvirtualCharMethodV = CallNonvirtualCharMethodV; _jni->CallNonvirtualCharMethodA = CallNonvirtualCharMethodA; _jni->CallNonvirtualShortMethod = CallNonvirtualShortMethod; _jni->CallNonvirtualShortMethodV = CallNonvirtualShortMethodV; _jni->CallNonvirtualShortMethodA = CallNonvirtualShortMethodA; _jni->CallNonvirtualIntMethod = CallNonvirtualIntMethod; _jni->CallNonvirtualIntMethodV = CallNonvirtualIntMethodV; _jni->CallNonvirtualIntMethodA = CallNonvirtualIntMethodA; _jni->CallNonvirtualLongMethod = CallNonvirtualLongMethod; _jni->CallNonvirtualLongMethodV = CallNonvirtualLongMethodV; _jni->CallNonvirtualLongMethodA = CallNonvirtualLongMethodA; _jni->CallNonvirtualFloatMethod = CallNonvirtualFloatMethod; _jni->CallNonvirtualFloatMethodV = CallNonvirtualFloatMethodV; _jni->CallNonvirtualFloatMethodA = CallNonvirtualFloatMethodA; _jni->CallNonvirtualDoubleMethod = CallNonvirtualDoubleMethod; _jni->CallNonvirtualDoubleMethodV = CallNonvirtualDoubleMethodV; _jni->CallNonvirtualDoubleMethodA = CallNonvirtualDoubleMethodA; _jni->CallNonvirtualVoidMethod = CallNonvirtualVoidMethod; _jni->CallNonvirtualVoidMethodV = CallNonvirtualVoidMethodV; _jni->CallNonvirtualVoidMethodA = CallNonvirtualVoidMethodA; _jni->GetFieldID = GetFieldID; _jni->GetObjectField = GetObjectField; _jni->GetBooleanField = GetBooleanField; _jni->GetByteField = GetByteField; _jni->GetCharField = GetCharField; _jni->GetShortField = GetShortField; _jni->GetIntField = GetIntField; _jni->GetLongField = GetLongField; _jni->GetFloatField = GetFloatField; _jni->GetDoubleField = GetDoubleField; _jni->SetObjectField = SetObjectField; _jni->SetBooleanField = SetBooleanField; _jni->SetByteField = SetByteField; _jni->SetCharField = SetCharField; _jni->SetShortField = SetShortField; _jni->SetIntField = SetIntField; _jni->SetLongField = SetLongField; _jni->SetFloatField = SetFloatField; _jni->SetDoubleField = SetDoubleField; _jni->GetStaticMethodID = GetStaticMethodID; _jni->CallStaticObjectMethod = CallStaticObjectMethod; _jni->CallStaticObjectMethodV = CallStaticObjectMethodV; _jni->CallStaticObjectMethodA = CallStaticObjectMethodA; _jni->CallStaticBooleanMethod = CallStaticBooleanMethod; _jni->CallStaticBooleanMethodV = CallStaticBooleanMethodV; _jni->CallStaticBooleanMethodA = CallStaticBooleanMethodA; _jni->CallStaticByteMethod = CallStaticByteMethod; _jni->CallStaticByteMethodV = CallStaticByteMethodV; _jni->CallStaticByteMethodA = CallStaticByteMethodA; _jni->CallStaticCharMethod = CallStaticCharMethod; _jni->CallStaticCharMethodV = CallStaticCharMethodV; _jni->CallStaticCharMethodA = CallStaticCharMethodA; _jni->CallStaticShortMethod = CallStaticShortMethod; _jni->CallStaticShortMethodV = CallStaticShortMethodV; _jni->CallStaticShortMethodA = CallStaticShortMethodA; _jni->CallStaticIntMethod = CallStaticIntMethod; _jni->CallStaticIntMethodV = CallStaticIntMethodV; _jni->CallStaticIntMethodA = CallStaticIntMethodA; _jni->CallStaticLongMethod = CallStaticLongMethod; _jni->CallStaticLongMethodV = CallStaticLongMethodV; _jni->CallStaticLongMethodA = CallStaticLongMethodA; _jni->CallStaticFloatMethod = CallStaticFloatMethod; _jni->CallStaticFloatMethodV = CallStaticFloatMethodV; _jni->CallStaticFloatMethodA = CallStaticFloatMethodA; _jni->CallStaticDoubleMethod = CallStaticDoubleMethod; _jni->CallStaticDoubleMethodV = CallStaticDoubleMethodV; _jni->CallStaticDoubleMethodA = CallStaticDoubleMethodA; _jni->CallStaticVoidMethod = CallStaticVoidMethod; _jni->CallStaticVoidMethodV = CallStaticVoidMethodV; _jni->CallStaticVoidMethodA = CallStaticVoidMethodA; _jni->GetStaticFieldID = GetStaticFieldID; _jni->GetStaticObjectField = GetStaticObjectField; _jni->GetStaticBooleanField = GetStaticBooleanField; _jni->GetStaticByteField = GetStaticByteField; _jni->GetStaticCharField = GetStaticCharField; _jni->GetStaticShortField = GetStaticShortField; _jni->GetStaticIntField = GetStaticIntField; _jni->GetStaticLongField = GetStaticLongField; _jni->GetStaticFloatField = GetStaticFloatField; _jni->GetStaticDoubleField = GetStaticDoubleField; _jni->SetStaticObjectField = SetStaticObjectField; _jni->SetStaticBooleanField = SetStaticBooleanField; _jni->SetStaticByteField = SetStaticByteField; _jni->SetStaticCharField = SetStaticCharField; _jni->SetStaticShortField = SetStaticShortField; _jni->SetStaticIntField = SetStaticIntField; _jni->SetStaticLongField = SetStaticLongField; _jni->SetStaticFloatField = SetStaticFloatField; _jni->SetStaticDoubleField = SetStaticDoubleField; _jni->NewString = NewString; _jni->GetStringLength = GetStringLength; _jni->GetStringChars = GetStringChars; _jni->ReleaseStringChars = ReleaseStringChars; _jni->NewStringUTF = NewStringUTF; _jni->GetStringUTFLength = GetStringUTFLength; _jni->GetStringUTFChars = GetStringUTFChars; _jni->ReleaseStringUTFChars = ReleaseStringUTFChars; _jni->GetArrayLength = GetArrayLength; _jni->NewObjectArray = NewObjectArray; _jni->GetObjectArrayElement = GetObjectArrayElement; _jni->SetObjectArrayElement = SetObjectArrayElement; _jni->NewBooleanArray = NewBooleanArray; _jni->NewByteArray = NewByteArray; _jni->NewCharArray = NewCharArray; _jni->NewShortArray = NewShortArray; _jni->NewIntArray = NewIntArray; _jni->NewLongArray = NewLongArray; _jni->NewFloatArray = NewFloatArray; _jni->NewDoubleArray = NewDoubleArray; _jni->GetBooleanArrayElements = GetBooleanArrayElements; _jni->GetByteArrayElements = GetByteArrayElements; _jni->GetCharArrayElements = GetCharArrayElements; _jni->GetShortArrayElements = GetShortArrayElements; _jni->GetIntArrayElements = GetIntArrayElements; _jni->GetLongArrayElements = GetLongArrayElements; _jni->GetFloatArrayElements = GetFloatArrayElements; _jni->GetDoubleArrayElements = GetDoubleArrayElements; _jni->ReleaseBooleanArrayElements = ReleaseBooleanArrayElements; _jni->ReleaseByteArrayElements = ReleaseByteArrayElements; _jni->ReleaseCharArrayElements = ReleaseCharArrayElements; _jni->ReleaseShortArrayElements = ReleaseShortArrayElements; _jni->ReleaseIntArrayElements = ReleaseIntArrayElements; _jni->ReleaseLongArrayElements = ReleaseLongArrayElements; _jni->ReleaseFloatArrayElements = ReleaseFloatArrayElements; _jni->ReleaseDoubleArrayElements = ReleaseDoubleArrayElements; _jni->GetBooleanArrayRegion = GetBooleanArrayRegion; _jni->GetByteArrayRegion = GetByteArrayRegion; _jni->GetCharArrayRegion = GetCharArrayRegion; _jni->GetShortArrayRegion = GetShortArrayRegion; _jni->GetIntArrayRegion = GetIntArrayRegion; _jni->GetLongArrayRegion = GetLongArrayRegion; _jni->GetFloatArrayRegion = GetFloatArrayRegion; _jni->GetDoubleArrayRegion = GetDoubleArrayRegion; _jni->SetBooleanArrayRegion = SetBooleanArrayRegion; _jni->SetByteArrayRegion = SetByteArrayRegion; _jni->SetCharArrayRegion = SetCharArrayRegion; _jni->SetShortArrayRegion = SetShortArrayRegion; _jni->SetIntArrayRegion = SetIntArrayRegion; _jni->SetLongArrayRegion = SetLongArrayRegion; _jni->SetFloatArrayRegion = SetFloatArrayRegion; _jni->SetDoubleArrayRegion = SetDoubleArrayRegion; _jni->RegisterNatives = RegisterNatives; _jni->UnregisterNatives = UnregisterNatives; _jni->MonitorEnter = MonitorEnter; _jni->MonitorExit = MonitorExit; _jni->GetJavaVM = GetJavaVM; _jni->GetStringRegion = GetStringRegion; _jni->GetStringUTFRegion = GetStringUTFRegion; _jni->GetPrimitiveArrayCritical = GetPrimitiveArrayCritical; _jni->ReleasePrimitiveArrayCritical = ReleasePrimitiveArrayCritical; _jni->GetStringCritical = GetStringCritical; _jni->ReleaseStringCritical = ReleaseStringCritical; _jni->NewWeakGlobalRef = NewWeakGlobalRef; _jni->DeleteWeakGlobalRef = DeleteWeakGlobalRef; _jni->ExceptionCheck = ExceptionCheck; _jni->NewDirectByteBuffer = NewDirectByteBuffer; _jni->GetDirectBufferAddress = GetDirectBufferAddress; _jni->GetDirectBufferCapacity = GetDirectBufferCapacity; _jni->GetObjectRefType = GetObjectRefType; jvm = _jvm; jni = _jni; }