]> git.bitcoin.ninja Git - ldk-java/commitdiff
Bindings updates for latest upstream, check in .so
authorMatt Corallo <git@bluematt.me>
Mon, 1 Feb 2021 21:56:18 +0000 (16:56 -0500)
committerMatt Corallo <git@bluematt.me>
Mon, 1 Feb 2021 21:57:39 +0000 (16:57 -0500)
liblightningjni.so [new file with mode: 0755]
src/main/java/org/ldk/impl/bindings.java
src/main/java/org/ldk/structs/PeerManager.java
src/main/jni/bindings.c
src/main/jni/org_ldk_impl_bindings.h
ts/bindings.c
ts/bindings.ts
ts/structs/PeerManager.ts

diff --git a/liblightningjni.so b/liblightningjni.so
new file mode 100755 (executable)
index 0000000..a1c44c6
Binary files /dev/null and b/liblightningjni.so differ
index 52da72db7bfce51e8c930e1480582ebbf696e147..6f9bd8d5f73b83b50227e8aa777b02221d06b1f7 100644 (file)
@@ -2409,6 +2409,8 @@ public class bindings {
        public static native void PeerManager_process_events(long this_arg);
        // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
        public static native void PeerManager_socket_disconnected(long this_arg, long descriptor);
+       // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
+       public static native void PeerManager_disconnect_by_node_id(long this_arg, byte[] node_id, boolean no_connection_possible);
        // void PeerManager_timer_tick_occured(const struct LDKPeerManager *NONNULL_PTR this_arg);
        public static native void PeerManager_timer_tick_occured(long this_arg);
        // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
index 1daf97aeb4a782436db5721613fe6e989cb68c3e..3c8a441ac0efb8c75d6d6e9b227fdd494d875710 100644 (file)
@@ -66,6 +66,10 @@ public class PeerManager extends CommonBase {
                this.ptrs_to.add(descriptor);
        }
 
+       public void disconnect_by_node_id(byte[] node_id, boolean no_connection_possible) {
+               bindings.PeerManager_disconnect_by_node_id(this.ptr, node_id, no_connection_possible);
+       }
+
        public void timer_tick_occured() {
                bindings.PeerManager_timer_tick_occured(this.ptr);
        }
index ad260dc2ef91b5b04de086c42f4586eb7d77229e..3aa76d3c0755058acba800c7d42dd9052d36c3c7 100644 (file)
 #include <stdatomic.h>
 #include <stdlib.h>
 
-#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)
-
-// 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
-// and free'd in Rust or C across the generated bindings shared library.
-#include <threads.h>
-#include <execinfo.h>
-#include <unistd.h>
-static mtx_t allocation_mtx;
-
-void __attribute__((constructor)) init_mtx() {
-       DO_ASSERT(mtx_init(&allocation_mtx, mtx_plain) == thrd_success);
-}
-
-#define BT_MAX 128
-typedef struct allocation {
-       struct allocation* next;
-       void* ptr;
-       const char* struct_name;
-       void* bt[BT_MAX];
-       int bt_len;
-       size_t alloc_len;
-} allocation;
-static allocation* allocation_ll = NULL;
-
-void* __real_malloc(size_t len);
-void* __real_calloc(size_t nmemb, size_t len);
-static void new_allocation(void* res, const char* struct_name, size_t len) {
-       allocation* new_alloc = __real_malloc(sizeof(allocation));
-       new_alloc->ptr = res;
-       new_alloc->struct_name = struct_name;
-       new_alloc->bt_len = backtrace(new_alloc->bt, BT_MAX);
-       new_alloc->alloc_len = len;
-       DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
-       new_alloc->next = allocation_ll;
-       allocation_ll = new_alloc;
-       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-}
-static void* MALLOC(size_t len, const char* struct_name) {
-       void* res = __real_malloc(len);
-       new_allocation(res, struct_name, len);
-       return res;
-}
-void __real_free(void* ptr);
-static void alloc_freed(void* ptr) {
-       allocation* p = NULL;
-       DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
-       allocation* it = allocation_ll;
-       while (it->ptr != ptr) {
-               p = it; it = it->next;
-               if (it == NULL) {
-                       fprintf(stderr, "Tried to free unknown pointer %p at:\n", ptr);
-                       void* bt[BT_MAX];
-                       int bt_len = backtrace(bt, BT_MAX);
-                       backtrace_symbols_fd(bt, bt_len, STDERR_FILENO);
-                       fprintf(stderr, "\n\n");
-                       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-                       return; // addrsan should catch malloc-unknown and print more info than we have
-               }
-       }
-       if (p) { p->next = it->next; } else { allocation_ll = it->next; }
-       DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
-       DO_ASSERT(it->ptr == ptr);
-       __real_free(it);
-}
-static void FREE(void* ptr) {
-       if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __wrap_malloc(size_t len) {
-       void* res = __real_malloc(len);
-       new_allocation(res, "malloc call", len);
-       return res;
-}
-void* __wrap_calloc(size_t nmemb, size_t len) {
-       void* res = __real_calloc(nmemb, len);
-       new_allocation(res, "calloc call", len);
-       return res;
-}
-void __wrap_free(void* ptr) {
-       if (ptr == NULL) return;
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __real_realloc(void* ptr, size_t newlen);
-void* __wrap_realloc(void* ptr, size_t len) {
-       if (ptr != NULL) alloc_freed(ptr);
-       void* res = __real_realloc(ptr, len);
-       new_allocation(res, "realloc call", len);
-       return res;
-}
-void __wrap_reallocarray(void* ptr, size_t new_sz) {
-       // Rust doesn't seem to use reallocarray currently
-       DO_ASSERT(false);
-}
-
-void __attribute__((destructor)) check_leaks() {
-       size_t alloc_count = 0;
-       size_t alloc_size = 0;
-       for (allocation* a = allocation_ll; a != NULL; a = a->next) {
-               fprintf(stderr, "%s %p remains:\n", a->struct_name, a->ptr);
-               backtrace_symbols_fd(a->bt, a->bt_len, STDERR_FILENO);
-               fprintf(stderr, "\n\n");
-               alloc_count++;
-               alloc_size += a->alloc_len;
-       }
-       fprintf(stderr, "%lu allocations remained for %lu bytes.\n", alloc_count, alloc_size);
-       DO_ASSERT(allocation_ll == NULL);
-}
+#define MALLOC(a, _) malloc(a)
+#define FREE(p) if ((long)(p) > 1024) { free(p); }
+#define DO_ASSERT(a) (void)(a)
+#define CHECK(a)
 
 static jmethodID ordinal_meth = NULL;
 static jmethodID slicedef_meth = NULL;
@@ -225,15 +112,15 @@ static inline jstring str_ref_to_java(JNIEnv *env, const char* chars, size_t len
        FREE(err_buf);
        return err_conv;
 }
-static jclass arr_of_B_clz = NULL;
 static jclass arr_of_J_clz = NULL;
+static jclass arr_of_B_clz = NULL;
 JNIEXPORT void Java_org_ldk_impl_bindings_init_1class_1cache(JNIEnv * env, jclass clz) {
-       arr_of_B_clz = (*env)->FindClass(env, "[B");
-       CHECK(arr_of_B_clz != NULL);
-       arr_of_B_clz = (*env)->NewGlobalRef(env, arr_of_B_clz);
        arr_of_J_clz = (*env)->FindClass(env, "[J");
        CHECK(arr_of_J_clz != NULL);
        arr_of_J_clz = (*env)->NewGlobalRef(env, arr_of_J_clz);
+       arr_of_B_clz = (*env)->FindClass(env, "[B");
+       CHECK(arr_of_B_clz != NULL);
+       arr_of_B_clz = (*env)->NewGlobalRef(env, arr_of_B_clz);
 }
 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
 static inline LDKAccessError LDKAccessError_from_java(JNIEnv *env, jclass clz) {
@@ -14286,6 +14173,16 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1socket_1disconnec
        PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
 }
 
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1disconnect_1by_1node_1id(JNIEnv *env, jclass clz, int64_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
+       LDKPeerManager this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKPublicKey node_id_ref;
+       CHECK((*env)->GetArrayLength(env, node_id) == 33);
+       (*env)->GetByteArrayRegion(env, node_id, 0, 33, node_id_ref.compressed_form);
+       PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
+}
+
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1timer_1tick_1occured(JNIEnv *env, jclass clz, int64_t this_arg) {
        LDKPeerManager this_arg_conv;
        this_arg_conv.inner = (void*)(this_arg & (~1));
index ad8358bec4ccb812ebc99b5775d00bb9d202d0e4..d8aa468f4e4c8549bc6f5b59a65cae1692ff67a3 100644 (file)
@@ -9063,6 +9063,14 @@ JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1process_1events
 JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1socket_1disconnected
   (JNIEnv *, jclass, jlong, jlong);
 
+/*
+ * Class:     org_ldk_impl_bindings
+ * Method:    PeerManager_disconnect_by_node_id
+ * Signature: (J[BZ)V
+ */
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_PeerManager_1disconnect_1by_1node_1id
+  (JNIEnv *, jclass, jlong, jbyteArray, jboolean);
+
 /*
  * Class:     org_ldk_impl_bindings
  * Method:    PeerManager_timer_tick_occured
index a383cb9d6749a4218c060c3333fd0019e32d0eb8..f842358337f3f05fd334ec2a7c1da378c186ec11 100644 (file)
@@ -13,93 +13,13 @@ static inline void assert(bool expression) {
        if (!expression) { abort(); }
 }
 
-// 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)
-
-// 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
-// and free'd in Rust or C across the generated bindings shared library.
-
-#define BT_MAX 128
-typedef struct allocation {
-       struct allocation* next;
-       void* ptr;
-       const char* struct_name;
-} allocation;
-static allocation* allocation_ll = NULL;
-
-void* __real_malloc(size_t len);
-void* __real_calloc(size_t nmemb, size_t len);
-static void new_allocation(void* res, const char* struct_name) {
-       allocation* new_alloc = __real_malloc(sizeof(allocation));
-       new_alloc->ptr = res;
-       new_alloc->struct_name = struct_name;
-       new_alloc->next = allocation_ll;
-       allocation_ll = new_alloc;
-}
-static void* MALLOC(size_t len, const char* struct_name) {
-       void* res = __real_malloc(len);
-       new_allocation(res, struct_name);
-       return res;
-}
-void __real_free(void* ptr);
-static void alloc_freed(void* ptr) {
-       allocation* p = NULL;
-       allocation* it = allocation_ll;
-       while (it->ptr != ptr) {
-               p = it; it = it->next;
-               if (it == NULL) {
-                       //XXX: fprintf(stderr, "Tried to free unknown pointer %p\n", ptr);
-                       return; // addrsan should catch malloc-unknown and print more info than we have
-               }
-       }
-       if (p) { p->next = it->next; } else { allocation_ll = it->next; }
-       DO_ASSERT(it->ptr == ptr);
-       __real_free(it);
-}
-static void FREE(void* ptr) {
-       if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __wrap_malloc(size_t len) {
-       void* res = __real_malloc(len);
-       new_allocation(res, "malloc call");
-       return res;
-}
-void* __wrap_calloc(size_t nmemb, size_t len) {
-       void* res = __real_calloc(nmemb, len);
-       new_allocation(res, "calloc call");
-       return res;
-}
-void __wrap_free(void* ptr) {
-       if (ptr == NULL) return;
-       alloc_freed(ptr);
-       __real_free(ptr);
-}
-
-void* __real_realloc(void* ptr, size_t newlen);
-void* __wrap_realloc(void* ptr, size_t len) {
-       if (ptr != NULL) alloc_freed(ptr);
-       void* res = __real_realloc(ptr, len);
-       new_allocation(res, "realloc call");
-       return res;
-}
-void __wrap_reallocarray(void* ptr, size_t new_sz) {
-       // Rust doesn't seem to use reallocarray currently
-       DO_ASSERT(false);
-}
+void *malloc(size_t size);
+void free(void *ptr);
 
-void __attribute__((destructor)) check_leaks() {
-       for (allocation* a = allocation_ll; a != NULL; a = a->next) {
-               //XXX: fprintf(stderr, "%s %p remains\n", a->struct_name, a->ptr);
-       }
-       DO_ASSERT(allocation_ll == NULL);
-}
+#define MALLOC(a, _) malloc(a)
+#define FREE(p) if ((long)(p) > 1024) { free(p); }
+#define DO_ASSERT(a) (void)(a)
+#define CHECK(a)
 
 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
@@ -13058,6 +12978,16 @@ void  __attribute__((visibility("default"))) TS_PeerManager_socket_disconnected(
        PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
 }
 
+void  __attribute__((visibility("default"))) TS_PeerManager_disconnect_by_node_id(uint32_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
+       LDKPeerManager this_arg_conv;
+       this_arg_conv.inner = (void*)(this_arg & (~1));
+       this_arg_conv.is_owned = false;
+       LDKPublicKey node_id_ref;
+       CHECK(*((uint32_t*)node_id) == 33);
+       memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
+       PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
+}
+
 void  __attribute__((visibility("default"))) TS_PeerManager_timer_tick_occured(uint32_t this_arg) {
        LDKPeerManager this_arg_conv;
        this_arg_conv.inner = (void*)(this_arg & (~1));
index 942649ebb7d55d07065425ca05b1d975366347f0..d5c6475b1f73e9cdb3183f695c251da792e26af7 100644 (file)
@@ -8200,6 +8200,14 @@ public static native long new_empty_slice_vec();
                const nativeResponseValue = wasm.PeerManager_socket_disconnected(this_arg, descriptor);
                // debug statements here
        }
+       // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
+       export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: Uint8Array, no_connection_possible: boolean): void {
+               if(!isWasmInitialized) {
+                       throw new Error("initializeWasm() must be awaited first!");
+               }
+               const nativeResponseValue = wasm.PeerManager_disconnect_by_node_id(this_arg, encodeArray(node_id), no_connection_possible);
+               // debug statements here
+       }
        // void PeerManager_timer_tick_occured(const struct LDKPeerManager *NONNULL_PTR this_arg);
        export function PeerManager_timer_tick_occured(this_arg: number): void {
                if(!isWasmInitialized) {
index 165440cf0f4564d635fa8d9433715883e36c3d92..cc01f8bda5f4aac6d12abc7f591627bef5b92734 100644 (file)
@@ -70,6 +70,10 @@ import * as bindings from '../bindings' // TODO: figure out location
                this.ptrs_to.add(descriptor);
        }
 
+       public void disconnect_by_node_id(Uint8Array node_id, boolean no_connection_possible) {
+               bindings.PeerManager_disconnect_by_node_id(this.ptr, node_id, no_connection_possible);
+       }
+
        public void timer_tick_occured() {
                bindings.PeerManager_timer_tick_occured(this.ptr);
        }