System.loadLibrary(\"lightningjni\");
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);
"""
self.c_file_pfx = """#include \"org_ldk_impl_bindings.h\"
-#include <rust_types.h>
#include <lightning.h>
#include <string.h>
#include <stdatomic.h>
if not DEBUG:
self.c_file_pfx = self.c_file_pfx + """#define MALLOC(a, _) malloc(a)
-#define FREE(p) if ((long)(p) > 1024) { free(p); }
+#define FREE(p) if ((uint64_t)(p) > 1024) { free(p); }
#define DO_ASSERT(a) (void)(a)
#define CHECK(a)
"""
// 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());
+}
+
// 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
__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;
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)
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):
projects / ldk-java / blobdiff