from bindingstypes import *
from enum import Enum
+import sys
class Target(Enum):
JAVA = 1,
self.bindings_header = """package org.ldk.impl;
import org.ldk.enums.*;
+import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
public class bindings {
public static class VecOrSliceDef {
}
}
static {
- System.loadLibrary(\"lightningjni\");
+ try {
+ // Try to load natively first, this works on Android and in testing.
+ System.loadLibrary(\"lightningjni\");
+ } catch (UnsatisfiedLinkError _ignored) {
+ // Otherwise try to load from the library jar.
+ File tmpdir = new File(System.getProperty("java.io.tmpdir"), "ldk-java-nativelib");
+ tmpdir.mkdir(); // If it fails to create, assume it was there already
+ tmpdir.deleteOnExit();
+ String libname = "liblightningjni_" + System.getProperty("os.name").replaceAll(" ", "") +
+ "-" + System.getProperty("os.arch").replaceAll(" ", "") + ".nativelib";
+ try (InputStream is = bindings.class.getResourceAsStream("/" + libname)) {
+ Path libpath = new File(tmpdir.toPath().toString(), "liblightningjni.so").toPath();
+ Files.copy(is, libpath, StandardCopyOption.REPLACE_EXISTING);
+ Runtime.getRuntime().load(libpath.toString());
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
init(java.lang.Enum.class, VecOrSliceDef.class);
init_class_cache();
+ if (!get_lib_version_string().equals(get_ldk_java_bindings_version()))
+ throw new IllegalArgumentException("Compiled LDK library and LDK class failes do not match");
+ // Fetching the LDK versions from C also checks that the header and binaries match
+ get_ldk_c_bindings_version();
+ get_ldk_version();
}
static native void init(java.lang.Class c, java.lang.Class slicedef);
static native void init_class_cache();
+ static native String get_lib_version_string();
+
+ public static String get_ldk_java_bindings_version() {
+ return "<git_version_ldk_garbagecollected>";
+ }
+ public static native String get_ldk_c_bindings_version();
+ public static native String get_ldk_version();
public static native boolean deref_bool(long ptr);
public static native long deref_long(long ptr);
long ptr;
LinkedList<Object> ptrs_to = new LinkedList();
protected CommonBase(long ptr) { this.ptr = ptr; }
- public long _test_only_get_ptr() { return this.ptr; }
}
"""
- self.c_file_pfx = """#include \"org_ldk_impl_bindings.h\"
-#include <rust_types.h>
+ self.c_file_pfx = """#include <jni.h>
+// On OSX jlong (ie long long) is not equivalent to int64_t, so we override here
+#define int64_t jlong
+#include \"org_ldk_impl_bindings.h\"
#include <lightning.h>
#include <string.h>
#include <stdatomic.h>
else:
self.c_file_pfx = self.c_file_pfx + "#define DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)\n"
- if not DEBUG:
+ if not DEBUG or sys.platform == "darwin":
self.c_file_pfx = self.c_file_pfx + """#define MALLOC(a, _) malloc(a)
-#define FREE(p) if ((long)(p) > 1024) { free(p); }
-#define DO_ASSERT(a) (void)(a)
+#define FREE(p) if ((uint64_t)(p) > 1024) { free(p); }
+"""
+ if not DEBUG:
+ self.c_file_pfx += """#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
"""
- else:
+ if DEBUG:
self.c_file_pfx = self.c_file_pfx + """#include <assert.h>
// Always run a, then assert it is true:
#define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
// Assert a is true or do nothing
#define CHECK(a) DO_ASSERT(a)
+void __attribute__((constructor)) debug_log_version() {
+ if (check_get_ldk_version() == NULL)
+ DEBUG_PRINT("LDK version did not match the header we built against\\n");
+ if (check_get_ldk_bindings_version() == NULL)
+ DEBUG_PRINT("LDK C Bindings version did not match the header we built against\\n");
+ DEBUG_PRINT("Loaded LDK-Java Bindings with LDK %s and LDK-C-Bindings %s\\n", check_get_ldk_version(), check_get_ldk_bindings_version());
+}
+"""
+
+ if sys.platform != "darwin":
+ self.c_file_pfx += """
// Running a leak check across all the allocations and frees of the JDK is a mess,
// so instead we implement our own naive leak checker here, relying on the -wrap
// linker option to wrap malloc/calloc/realloc/free, tracking everyhing allocated
#include <threads.h>
"""
- if self.target == Target.ANDROID:
- self.c_file_pfx = self.c_file_pfx + """
+ if self.target == Target.ANDROID:
+ self.c_file_pfx = self.c_file_pfx + """
#include <unwind.h>
#include <dlfcn.h>
}
}
"""
- else:
- self.c_file_pfx = self.c_file_pfx + "#include <execinfo.h>\n"
- self.c_file_pfx = self.c_file_pfx + """
+ else:
+ self.c_file_pfx = self.c_file_pfx + "#include <execinfo.h>\n"
+ self.c_file_pfx = self.c_file_pfx + """
#include <unistd.h>
static mtx_t allocation_mtx;
__real_free(it);
}
static void FREE(void* ptr) {
- if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
+ if ((uint64_t)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
alloc_freed(ptr);
__real_free(ptr);
}
vec->datalen = (*env)->GetArrayLength(env, bytes);
vec->data = (uint8_t*)MALLOC(vec->datalen, "LDKCVec_u8Z Bytes");
(*env)->GetByteArrayRegion (env, bytes, 0, vec->datalen, vec->data);
- return (long)vec;
+ return (uint64_t)vec;
}
JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_txpointer_1get_1buffer (JNIEnv * env, jclass _b, jlong ptr) {
LDKTransaction *txdata = (LDKTransaction*)ptr;
LDKu8slice slice;
slice.data = txdata->data;
slice.datalen = txdata->datalen;
- return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (long)&slice);
+ return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (uint64_t)&slice);
}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1txpointer_1copy_1data (JNIEnv * env, jclass _b, jbyteArray bytes) {
LDKTransaction *txdata = (LDKTransaction*)MALLOC(sizeof(LDKTransaction), "LDKTransaction");
txdata->data = (uint8_t*)MALLOC(txdata->datalen, "Tx Data Bytes");
txdata->data_is_owned = false;
(*env)->GetByteArrayRegion (env, bytes, 0, txdata->datalen, txdata->data);
- return (long)txdata;
+ return (uint64_t)txdata;
}
JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_txpointer_1free (JNIEnv * env, jclass _b, jlong ptr) {
LDKTransaction *tx = (LDKTransaction*)ptr;
_Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_EventZ, datalen), "Vec<*> needs to be mapped identically");
_Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_C2Tuple_usizeTransactionZZ, datalen), "Vec<*> needs to be mapped identically");
LDKCVec_u8Z *vec = (LDKCVec_u8Z*)ptr;
- return (long)vec->datalen;
+ return (uint64_t)vec->datalen;
}
JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec (JNIEnv * env, jclass _b) {
// Check sizes of a few Vec types are all consistent as we're meant to be generic across types
LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "Empty LDKCVec");
vec->data = NULL;
vec->datalen = 0;
- return (long)vec;
+ return (uint64_t)vec;
}
// We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
};
return res;
}
+
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1lib_1version_1string(JNIEnv *env, jclass _c) {
+ return str_ref_to_java(env, "<git_version_ldk_garbagecollected>", strlen("<git_version_ldk_garbagecollected>"));
+}
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1c_1bindings_1version(JNIEnv *env, jclass _c) {
+ return str_ref_to_java(env, check_get_ldk_bindings_version(), strlen(check_get_ldk_bindings_version()));
+}
+JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1version(JNIEnv *env, jclass _c) {
+ return str_ref_to_java(env, check_get_ldk_version(), strlen(check_get_ldk_version()));
+}
"""
self.hu_struct_file_prefix = """package org.ldk.structs;
self.ptr_arr = "jobjectArray"
self.get_native_arr_len_call = ("(*env)->GetArrayLength(env, ", ")")
+ def construct_jenv(self):
+ res = "JNIEnv *env;\n"
+ res += "jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);\n"
+ res += "if (get_jenv_res == JNI_EDETACHED) {\n"
+ if self.target == Target.ANDROID:
+ res += "\tDO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, &env, NULL) == JNI_OK);\n"
+ else:
+ res += "\tDO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);\n"
+ res += "} else {\n"
+ res += "\tDO_ASSERT(get_jenv_res == JNI_OK);\n"
+ res += "}\n"
+ return res
+ def deconstruct_jenv(self):
+ res = "if (get_jenv_res == JNI_EDETACHED) {\n"
+ res += "\tDO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);\n"
+ res += "}\n"
+ return res
+
def release_native_arr_ptr_call(self, ty_info, arr_var, arr_ptr_var):
if ty_info.subty is None or not ty_info.subty.c_ty.endswith("Array"):
return "(*env)->ReleasePrimitiveArrayCritical(env, " + arr_var + ", " + arr_ptr_var + ", 0)"
out_java_enum = "package org.ldk.enums;\n\n"
out_java = ""
out_c = ""
- out_c = out_c + "static inline " + struct_name + " " + struct_name + "_from_java(" + self.c_fn_args_pfx + ") {\n"
+ out_c = out_c + "static inline LDK" + struct_name + " LDK" + struct_name + "_from_java(" + self.c_fn_args_pfx + ") {\n"
out_c = out_c + "\tswitch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {\n"
if enum_doc_comment is not None:
out_c = out_c + "\t" + struct_name + "_" + var + " = (*env)->GetStaticFieldID(env, " + struct_name + "_class, \"" + var + "\", \"Lorg/ldk/enums/" + struct_name + ";\");\n"
out_c = out_c + "\tCHECK(" + struct_name + "_" + var + " != NULL);\n"
out_c = out_c + "}\n"
- out_c = out_c + "static inline jclass " + struct_name + "_to_java(JNIEnv *env, " + struct_name + " val) {\n"
+ out_c = out_c + "static inline jclass LDK" + struct_name + "_to_java(JNIEnv *env, LDK" + struct_name + " val) {\n"
out_c = out_c + "\tswitch (val) {\n"
ord_v = 0
for var in variants:
out_c = out_c + "static void " + struct_name + "_JCalls_free(void* this_arg) {\n"
out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n"
out_c = out_c + "\tif (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {\n"
- out_c = out_c + "\t\tJNIEnv *env;\n"
- out_c = out_c + "\t\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);\n"
+ out_c += "\t\t" + self.construct_jenv().replace("\n", "\n\t\t").strip() + "\n"
out_c = out_c + "\t\t(*env)->DeleteWeakGlobalRef(env, j_calls->o);\n"
+ out_c += "\t\t" + self.deconstruct_jenv().replace("\n", "\n\t\t").strip() + "\n"
out_c = out_c + "\t\tFREE(j_calls);\n"
out_c = out_c + "\t}\n}\n"
out_c = out_c + ") {\n"
out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n"
- out_c = out_c + "\tJNIEnv *env;\n"
- out_c = out_c + "\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);\n"
+ out_c += "\t" + self.construct_jenv().replace("\n", "\n\t").strip() + "\n"
for arg_info in fn_line.args_ty:
if arg_info.ret_conv is not None:
out_c = out_c + "\tjobject obj = (*env)->NewLocalRef(env, j_calls->o);\n\tCHECK(obj != NULL);\n"
if fn_line.ret_ty_info.c_ty.endswith("Array"):
out_c = out_c + "\t" + fn_line.ret_ty_info.c_ty + " ret = (*env)->CallObjectMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth"
+ elif fn_line.ret_ty_info.c_ty == "void":
+ out_c += "\t(*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth"
elif not fn_line.ret_ty_info.passed_as_ptr:
- out_c = out_c + "\treturn (*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth"
+ out_c += "\t" + fn_line.ret_ty_info.c_ty + " ret = (*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth"
else:
out_c = out_c + "\t" + fn_line.ret_ty_info.rust_obj + "* ret = (" + fn_line.ret_ty_info.rust_obj + "*)(*env)->CallLongMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth"
else:
out_c = out_c + ", " + arg_info.arg_name
out_c = out_c + ");\n"
+
+ out_c += "\tif ((*env)->ExceptionCheck(env)) {\n"
+ out_c += "\t\t(*env)->ExceptionDescribe(env);\n"
+ out_c += "\t\t(*env)->FatalError(env, \"A Java interface method called from rust threw an exception.\");\n"
+ out_c += "\t}\n"
+
if fn_line.ret_ty_info.arg_conv is not None:
- out_c = out_c + "\t" + fn_line.ret_ty_info.arg_conv.replace("\n", "\n\t") + "\n\treturn " + fn_line.ret_ty_info.arg_conv_name + ";\n"
+ out_c += "\t" + fn_line.ret_ty_info.arg_conv.replace("\n", "\n\t") + "\n"
+ out_c += "\t" + self.deconstruct_jenv().replace("\n", "\n\t").strip() + "\n"
+ out_c += "\treturn " + fn_line.ret_ty_info.arg_conv_name + ";\n"
+ else:
+ out_c += "\t" + self.deconstruct_jenv().replace("\n", "\n\t").strip() + "\n"
+ if not fn_line.ret_ty_info.passed_as_ptr and fn_line.ret_ty_info.c_ty != "void":
+ out_c += "\treturn ret;\n"
out_c = out_c + "}\n"
else:
out_c = out_c + ", " + var[1]
out_c = out_c + ");\n"
- out_c = out_c + "\treturn (long)res_ptr;\n"
+ out_c = out_c + "\treturn (uint64_t)res_ptr;\n"
out_c = out_c + "}\n"
return (out_java, out_java_trait, out_c)
init_meth_body = ""
hu_conv_body = ""
for idx, field_ty in enumerate(var.fields):
- out_java += ("\t\t\tpublic " + field_ty.java_ty + " " + field_ty.arg_name + ";\n")
- java_hu_subclasses = java_hu_subclasses + "\t\tpublic final " + field_ty.java_hu_ty + " " + field_ty.arg_name + ";\n"
+ if idx > 0:
+ init_meth_params = init_meth_params + ", "
+
+ if field_ty.java_hu_ty == var.var_name:
+ field_path = field_ty.java_fn_ty_arg.strip("L;").replace("/", ".")
+ out_java += "\t\t\tpublic " + field_path + " " + field_ty.arg_name + ";\n"
+ java_hu_subclasses = java_hu_subclasses + "\t\tpublic final " + field_path + " " + field_ty.arg_name + ";\n"
+ init_meth_params = init_meth_params + field_path + " " + field_ty.arg_name
+ else:
+ out_java += "\t\t\tpublic " + field_ty.java_ty + " " + field_ty.arg_name + ";\n"
+ java_hu_subclasses = java_hu_subclasses + "\t\tpublic final " + field_ty.java_hu_ty + " " + field_ty.arg_name + ";\n"
+ init_meth_params = init_meth_params + field_ty.java_ty + " " + field_ty.arg_name
+ init_meth_body = init_meth_body + "this." + field_ty.arg_name + " = " + field_ty.arg_name + "; "
if field_ty.to_hu_conv is not None:
hu_conv_body = hu_conv_body + "\t\t\t" + field_ty.java_ty + " " + field_ty.arg_name + " = obj." + field_ty.arg_name + ";\n"
hu_conv_body = hu_conv_body + "\t\t\t" + field_ty.to_hu_conv.replace("\n", "\n\t\t\t") + "\n"
else:
hu_conv_body = hu_conv_body + "\t\t\tthis." + field_ty.arg_name + " = obj." + field_ty.arg_name + ";\n"
init_meth_jty_str = init_meth_jty_str + field_ty.java_fn_ty_arg
- if idx > 0:
- init_meth_params = init_meth_params + ", "
- init_meth_params = init_meth_params + field_ty.java_ty + " " + field_ty.arg_name
- init_meth_body = init_meth_body + "this." + field_ty.arg_name + " = " + field_ty.arg_name + "; "
out_java += ("\t\t\t" + var.var_name + "(" + init_meth_params + ") { ")
out_java += (init_meth_body)
out_java += ("}\n")
return out_opaque_struct_human
- def map_function(self, argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, type_mapping_generator, doc_comment):
+ def map_function(self, argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, takes_self_as_ref, args_known, type_mapping_generator, doc_comment):
out_java = ""
out_c = ""
out_java_struct = None
if not args_known:
out_java_struct += ("\t// Skipped " + method_name + "\n")
else:
- meth_n = method_name[len(struct_meth) + 1:].strip("_")
+ meth_n = method_name[len(struct_meth) + 1 if len(struct_meth) != 0 else 0:].strip("_")
if doc_comment is not None:
out_java_struct += "\t/**\n\t * " + doc_comment.replace("\n", "\n\t * ") + "\n\t */\n"
if not takes_self:
- out_java_struct += (
- "\tpublic static " + return_type_info.java_hu_ty + " constructor_" + meth_n + "(")
+ if meth_n == "new":
+ out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " of("
+ elif meth_n == "default":
+ out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " with_default("
+ else:
+ out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " " + meth_n + "("
else:
out_java_struct += ("\tpublic " + return_type_info.java_hu_ty + " " + meth_n + "(")
for idx, arg in enumerate(argument_types):
if idx != 0:
if not takes_self or idx > 1:
- out_java_struct += (", ")
+ out_java_struct += ", "
elif takes_self:
continue
if arg.java_ty != "void":
else:
out_java_struct += ("\t\t" + info.from_hu_conv[1].replace("\n", "\n\t\t") + ";\n")
+ if takes_self and not takes_self_as_ref:
+ out_java_struct += "\t\t" + argument_types[0].from_hu_conv[1].replace("\n", "\n\t\t").replace("this_arg", "this") + ";\n"
if return_type_info.to_hu_conv_name is not None:
out_java_struct += ("\t\treturn " + return_type_info.to_hu_conv_name + ";\n")
elif return_type_info.java_ty != "void" and return_type_info.rust_obj != "LDK" + struct_meth: