(void)c;
(void)request;
- /* TODO: Check if this is an edge we would own. */
return true;
}
(void)c;
(void)request;
- /* TODO: Check if this is an edge we would own. */
return true;
}
/import-export
/invite-join
/sign-verify
+/storage-policy
/trio
/*.[0123456789]
/channels_aio_fd.in
TESTS = \
basic \
- basicpp \
- channels \
- channels-aio \
- channels-aio-abort \
- channels-aio-cornercases \
- channels-aio-fd \
- channels-buffer-storage \
- channels-cornercases \
- channels-failure \
- channels-fork \
- channels-no-partial \
- channels-udp \
- channels-udp-cornercases \
- duplicate \
encrypted \
ephemeral \
- get-all-nodes \
import-export \
- meta-connections \
+ invite-join \
sign-verify \
- storage-policy \
- trio \
- trio2 \
- utcp-benchmark \
- utcp-benchmark-stream
-
-TESTS += \
- api_set_node_status_cb
+ storage-policy
dist_check_SCRIPTS = $(TESTS)
AM_LDFLAGS = $(PTHREAD_LIBS)
check_PROGRAMS = \
- api_set_node_status_cb \
basic \
- basicpp \
- channels \
- channels-aio \
- channels-aio-abort \
- channels-aio-cornercases \
- channels-aio-fd \
- channels-buffer-storage \
- channels-cornercases \
- channels-failure \
- channels-fork \
- channels-no-partial \
- channels-udp \
- channels-udp-cornercases \
- duplicate \
- echo-fork \
encrypted \
ephemeral \
- get-all-nodes \
import-export \
- meta-connections \
+ invite-join \
sign-verify \
- storage-policy \
- stream \
- trio \
- trio2
+ storage-policy
if INSTALL_TESTS
bin_PROGRAMS = $(check_PROGRAMS)
endif
-api_set_node_status_cb_SOURCES = api_set_node_status_cb.c utils.c utils.h
-api_set_node_status_cb_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-basic_SOURCES = basic.c utils.c utils.h
-basic_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-basicpp_SOURCES = basicpp.cpp utils.c utils.h
-basicpp_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_SOURCES = channels.c utils.c utils.h
-channels_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_aio_SOURCES = channels-aio.c utils.c utils.h
-channels_aio_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_aio_abort_SOURCES = channels-aio-abort.c utils.c utils.h
-channels_aio_abort_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_aio_cornercases_SOURCES = channels-aio-cornercases.c utils.c utils.h
-channels_aio_cornercases_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_aio_fd_SOURCES = channels-aio-fd.c utils.c utils.h
-channels_aio_fd_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_buffer_storage_SOURCES = channels-buffer-storage.c utils.c utils.h
-channels_buffer_storage_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_no_partial_SOURCES = channels-no-partial.c utils.c utils.h
-channels_no_partial_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_failure_SOURCES = channels-failure.c utils.c utils.h
-channels_failure_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_fork_SOURCES = channels-fork.c utils.c utils.h
-channels_fork_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_cornercases_SOURCES = channels-cornercases.c utils.c utils.h
-channels_cornercases_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_udp_SOURCES = channels-udp.c utils.c utils.h
-channels_udp_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-channels_udp_cornercases_SOURCES = channels-udp-cornercases.c utils.c utils.h
-channels_udp_cornercases_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-duplicate_SOURCES = duplicate.c utils.c utils.h
-duplicate_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-echo_fork_SOURCES = echo-fork.c utils.c utils.h
-echo_fork_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-encrypted_SOURCES = encrypted.c utils.c utils.h
-encrypted_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-ephemeral_SOURCES = ephemeral.c utils.c utils.h
-ephemeral_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-get_all_nodes_SOURCES = get-all-nodes.c utils.c utils.h
-get_all_nodes_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-import_export_SOURCES = import-export.c utils.c utils.h
-import_export_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-meta_connections_SOURCES = meta-connections.c netns_utils.c netns_utils.h utils.c utils.h
-meta_connections_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-sign_verify_SOURCES = sign-verify.c utils.c utils.h
-sign_verify_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
-
-storage_policy_SOURCES = storage-policy.c utils.c utils.h
-storage_policy_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
+default_SOURCES = \
+ full.c full.h \
+ utils.c utils.h
-trio_SOURCES = trio.c utils.c utils.h
-trio_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
+LDADD = $(top_builddir)/src/libmeshlink-tiny.la -ldl
-trio2_SOURCES = trio2.c utils.c utils.h
-trio2_LDADD = $(top_builddir)/src/libmeshlink-tiny.la
+basic_SOURCES = basic.c $(default_SOURCES)
+encrypted_SOURCES = encrypted.c $(default_SOURCES)
+ephemeral_SOURCES = ephemeral.c $(default_SOURCES)
+get_all_nodes_SOURCES = get-all-nodes.c $(default_SOURCES)
+import_export_SOURCES = import-export.c $(default_SOURCES)
+invite_join_SOURCES = invite-join.c $(default_SOURCES)
+sign_verify_SOURCES = sign-verify.c $(default_SOURCES)
+storage_policy_SOURCES = storage-policy.c $(default_SOURCES)
+++ /dev/null
-#ifdef NDEBUG
-#undef NDEBUG
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <assert.h>
-
-#include "meshlink-tiny.h"
-#include "utils.h"
-
-static struct sync_flag duplicate_detected;
-
-static void handle_duplicate(meshlink_handle_t *mesh, meshlink_node_t *node) {
- set_sync_flag(&duplicate_detected, true);
-}
-
-int main(void) {
- init_sync_flag(&duplicate_detected);
-
- meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
-
- // Open meshlink instances
-
- static const char *name[4] = {"foo", "bar", "baz", "foo"};
- meshlink_handle_t *mesh[4];
-
- for(int i = 0; i < 4; i++) {
- char dirname[100];
- snprintf(dirname, sizeof dirname, "duplicate_conf.%d", i);
-
- assert(meshlink_destroy(dirname));
- mesh[i] = meshlink_open(dirname, name[i], "duplicate", DEV_CLASS_BACKBONE);
- assert(mesh[i]);
-
- assert(meshlink_set_canonical_address(mesh[i], meshlink_get_self(mesh[i]), "localhost", NULL));
-
- meshlink_set_node_duplicate_cb(mesh[i], handle_duplicate);
- }
-
- // Link them in a chain
-
- char *data[4];
-
- for(int i = 0; i < 4; i++) {
- data[i] = meshlink_export(mesh[i]);
- assert(data[i]);
- }
-
- for(int i = 0; i < 3; i++) {
- assert(meshlink_import(mesh[i], data[i + 1]));
- assert(meshlink_import(mesh[i + 1], data[i]));
- }
-
- for(int i = 0; i < 4; i++) {
- free(data[i]);
- }
-
- // Start the meshes
-
- for(int i = 0; i < 4; i++) {
- assert(meshlink_start(mesh[i]));
- }
-
- // Wait for the duplicate node to be detected
-
- assert(wait_sync_flag(&duplicate_detected, 20));
-
- // Clean up
-
- for(int i = 0; i < 4; i++) {
- meshlink_close(mesh[i]);
- }
-}
--- /dev/null
+#include <assert.h>
+#include <dlfcn.h>
+
+#include "full.h"
+
+meshlink_errno_t *full_meshlink_errno;
+const char *(*full_meshlink_strerror)(meshlink_errno_t err) __attribute__((__warn_unused_result__));
+meshlink_open_params_t *(*full_meshlink_open_params_init)(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+void (*full_meshlink_open_params_free)(meshlink_open_params_t *params);
+bool (*full_meshlink_open_params_set_netns)(meshlink_open_params_t *params, int netns) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_open_params_set_storage_key)(meshlink_open_params_t *params, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_open_params_set_storage_policy)(meshlink_open_params_t *params, meshlink_storage_policy_t policy) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_open_params_set_lock_filename)(meshlink_open_params_t *params, const char *filename) __attribute__((__warn_unused_result__));
+struct meshlink_handle *(*full_meshlink_open_ex)(const meshlink_open_params_t *params) __attribute__((__warn_unused_result__));
+struct meshlink_handle *(*full_meshlink_open)(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+struct meshlink_handle *(*full_meshlink_open_encrypted)(const char *confbase, const char *name, const char *appname, dev_class_t devclass, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+struct meshlink_handle *(*full_meshlink_open_ephemeral)(const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+struct meshlink_submesh *(*full_meshlink_submesh_open)(struct meshlink_handle *mesh, const char *submesh) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_start)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+void (*full_meshlink_stop)(struct meshlink_handle *mesh);
+void (*full_meshlink_close)(struct meshlink_handle *mesh);
+bool (*full_meshlink_destroy)(const char *confbase) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_destroy_ex)(const meshlink_open_params_t *params) __attribute__((__warn_unused_result__));
+void (*full_meshlink_set_receive_cb)(struct meshlink_handle *mesh, meshlink_receive_cb_t cb);
+void (*full_meshlink_set_connection_try_cb)(struct meshlink_handle *mesh, meshlink_connection_try_cb_t cb);
+void (*full_meshlink_set_node_status_cb)(struct meshlink_handle *mesh, meshlink_node_status_cb_t cb);
+void (*full_meshlink_set_node_pmtu_cb)(struct meshlink_handle *mesh, meshlink_node_pmtu_cb_t cb);
+void (*full_meshlink_set_node_duplicate_cb)(struct meshlink_handle *mesh, meshlink_node_duplicate_cb_t cb);
+void (*full_meshlink_set_log_cb)(struct meshlink_handle *mesh, meshlink_log_level_t level, meshlink_log_cb_t cb);
+void (*full_meshlink_set_error_cb)(struct meshlink_handle *mesh, meshlink_error_cb_t cb);
+void (*full_meshlink_set_blacklisted_cb)(struct meshlink_handle *mesh, meshlink_blacklisted_cb_t cb);
+bool (*full_meshlink_send)(struct meshlink_handle *mesh, struct meshlink_node *destination, const void *data, size_t len) __attribute__((__warn_unused_result__));
+ssize_t (*full_meshlink_get_pmtu)(struct meshlink_handle *mesh, struct meshlink_node *destination) __attribute__((__warn_unused_result__));
+struct meshlink_node *(*full_meshlink_get_self)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+struct meshlink_node *(*full_meshlink_get_node)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+struct meshlink_submesh *(*full_meshlink_get_submesh)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+char *(*full_meshlink_get_fingerprint)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+struct meshlink_node **(*full_meshlink_get_all_nodes)(struct meshlink_handle *mesh, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_sign)(struct meshlink_handle *mesh, const void *data, size_t len, void *signature, size_t *siglen) __attribute__((__warn_unused_result__));
+struct meshlink_node **(*full_meshlink_get_all_nodes_by_dev_class)(struct meshlink_handle *mesh, dev_class_t devclass, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+struct meshlink_node **(*full_meshlink_get_all_nodes_by_submesh)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+struct meshlink_node **(*full_meshlink_get_all_nodes_by_last_reachable)(struct meshlink_handle *mesh, time_t start, time_t end, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+struct meshlink_node **(*full_meshlink_get_all_nodes_by_blacklisted)(struct meshlink_handle *mesh, bool blacklisted, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+dev_class_t (*full_meshlink_get_node_dev_class)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_get_node_blacklisted)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+struct meshlink_submesh *(*full_meshlink_get_node_submesh)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_get_node_reachability)(struct meshlink_handle *mesh, struct meshlink_node *node, time_t *last_reachable, time_t *last_unreachable);
+bool (*full_meshlink_verify)(struct meshlink_handle *mesh, struct meshlink_node *source, const void *data, size_t len, const void *signature, size_t siglen) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_set_canonical_address)(struct meshlink_handle *mesh, struct meshlink_node *node, const char *address, const char *port) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_clear_canonical_address)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_add_invitation_address)(struct meshlink_handle *mesh, const char *address, const char *port) __attribute__((__warn_unused_result__));
+void (*full_meshlink_clear_invitation_addresses)(struct meshlink_handle *mesh);
+char *(*full_meshlink_get_external_address)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+char *(*full_meshlink_get_external_address_for_family)(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
+char *(*full_meshlink_get_local_address_for_family)(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_add_external_address)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+int (*full_meshlink_get_port)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_set_port)(struct meshlink_handle *mesh, int port) __attribute__((__warn_unused_result__));
+void (*full_meshlink_set_invitation_timeout)(struct meshlink_handle *mesh, int timeout);
+char *(*full_meshlink_invite_ex)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name, uint32_t flags) __attribute__((__warn_unused_result__));
+char *(*full_meshlink_invite)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_join)(struct meshlink_handle *mesh, const char *invitation) __attribute__((__warn_unused_result__));
+char *(*full_meshlink_export)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_import)(struct meshlink_handle *mesh, const char *data) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_forget_node)(struct meshlink_handle *mesh, struct meshlink_node *node);
+bool (*full_meshlink_blacklist)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_blacklist_by_name)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_whitelist)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_whitelist_by_name)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+void (*full_meshlink_set_default_blacklist)(struct meshlink_handle *mesh, bool blacklist);
+void (*full_meshlink_set_channel_listen_cb)(struct meshlink_handle *mesh, meshlink_channel_listen_cb_t cb);
+void (*full_meshlink_set_channel_accept_cb)(struct meshlink_handle *mesh, meshlink_channel_accept_cb_t cb);
+void (*full_meshlink_set_channel_receive_cb)(struct meshlink_handle *mesh, struct meshlink_channel *channel, meshlink_channel_receive_cb_t cb);
+void (*full_meshlink_set_channel_poll_cb)(struct meshlink_handle *mesh, struct meshlink_channel *channel, meshlink_channel_poll_cb_t cb);
+void (*full_meshlink_set_channel_sndbuf)(struct meshlink_handle *mesh, struct meshlink_channel *channel, size_t size);
+void (*full_meshlink_set_channel_rcvbuf)(struct meshlink_handle *mesh, struct meshlink_channel *channel, size_t size);
+void (*full_meshlink_set_channel_sndbuf_storage)(struct meshlink_handle *mesh, struct meshlink_channel *channel, void *buf, size_t size);
+void (*full_meshlink_set_channel_rcvbuf_storage)(struct meshlink_handle *mesh, struct meshlink_channel *channel, void *buf, size_t size);
+void (*full_meshlink_set_channel_flags)(struct meshlink_handle *mesh, struct meshlink_channel *channel, uint32_t flags);
+struct meshlink_channel *(*full_meshlink_channel_open_ex)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len, uint32_t flags) __attribute__((__warn_unused_result__));
+struct meshlink_channel *(*full_meshlink_channel_open)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len) __attribute__((__warn_unused_result__));
+void (*full_meshlink_channel_shutdown)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int direction);
+void (*full_meshlink_channel_close)(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+void (*full_meshlink_channel_abort)(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+ssize_t (*full_meshlink_channel_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_channel_aio_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_channel_aio_fd_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_channel_aio_receive)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+bool (*full_meshlink_channel_aio_fd_receive)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+uint32_t (*full_meshlink_channel_get_flags)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+size_t (*full_meshlink_channel_get_sendq)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+size_t (*full_meshlink_channel_get_recvq)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+size_t (*full_meshlink_channel_get_mss)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+void (*full_meshlink_set_node_channel_timeout)(struct meshlink_handle *mesh, struct meshlink_node *node, int timeout);
+void (*full_meshlink_hint_address)(struct meshlink_handle *mesh, struct meshlink_node *node, const struct sockaddr *addr);
+void (*full_meshlink_enable_discovery)(struct meshlink_handle *mesh, bool enable);
+void (*full_meshlink_hint_network_change)(struct meshlink_handle *mesh);
+bool (*full_meshlink_encrypted_key_rotate)(struct meshlink_handle *mesh, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+void (*full_meshlink_set_dev_class_timeouts)(struct meshlink_handle *mesh, dev_class_t devclass, int pinginterval, int pingtimeout);
+void (*full_meshlink_set_dev_class_fast_retry_period)(struct meshlink_handle *mesh, dev_class_t devclass, int fast_retry_period);
+void (*full_meshlink_set_dev_class_maxtimeout)(struct meshlink_handle *mesh, dev_class_t devclass, int maxtimeout);
+void (*full_meshlink_reset_timers)(struct meshlink_handle *mesh);
+void (*full_meshlink_set_inviter_commits_first)(struct meshlink_handle *mesh, bool inviter_commits_first);
+void (*full_meshlink_set_external_address_discovery_url)(struct meshlink_handle *mesh, const char *url);
+void (*full_meshlink_set_scheduling_granularity)(struct meshlink_handle *mesh, long granularity);
+void (*full_meshlink_set_storage_policy)(struct meshlink_handle *mesh, meshlink_storage_policy_t policy);
+
+full_devtool_set_inviter_commits_first_t *full_devtool_set_inviter_commits_first;
+
+void init_full(void) {
+ void *handle = dlopen("libmeshlink.so", RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
+ assert(handle);
+
+ full_meshlink_errno = dlsym(handle, "meshlink_errno");
+ full_meshlink_strerror = dlsym(handle, "meshlink_strerror");
+ full_meshlink_open_params_init = dlsym(handle, "meshlink_open_params_init");
+ full_meshlink_open_params_free = dlsym(handle, "meshlink_open_params_free");
+ full_meshlink_open_params_set_netns = dlsym(handle, "meshlink_open_params_set_netns");
+ full_meshlink_open_params_set_storage_key = dlsym(handle, "meshlink_open_params_set_storage_key");
+ full_meshlink_open_params_set_storage_policy = dlsym(handle, "meshlink_open_params_set_storage_policy");
+ full_meshlink_open_params_set_lock_filename = dlsym(handle, "meshlink_open_params_set_lock_filename");
+ full_meshlink_open_ex = dlsym(handle, "meshlink_open_ex");
+ full_meshlink_open = dlsym(handle, "meshlink_open");
+ full_meshlink_open_encrypted = dlsym(handle, "meshlink_open_encrypted");
+ full_meshlink_open_ephemeral = dlsym(handle, "meshlink_open_ephemeral");
+ full_meshlink_submesh_open = dlsym(handle, "meshlink_submesh_open");
+ full_meshlink_start = dlsym(handle, "meshlink_start");
+ full_meshlink_stop = dlsym(handle, "meshlink_stop");
+ full_meshlink_close = dlsym(handle, "meshlink_close");
+ full_meshlink_destroy = dlsym(handle, "meshlink_destroy");
+ full_meshlink_destroy_ex = dlsym(handle, "meshlink_destroy_ex");
+ full_meshlink_set_receive_cb = dlsym(handle, "meshlink_set_receive_cb");
+ full_meshlink_set_connection_try_cb = dlsym(handle, "meshlink_set_connection_try_cb");
+ full_meshlink_set_node_status_cb = dlsym(handle, "meshlink_set_node_status_cb");
+ full_meshlink_set_node_pmtu_cb = dlsym(handle, "meshlink_set_node_pmtu_cb");
+ full_meshlink_set_node_duplicate_cb = dlsym(handle, "meshlink_set_node_duplicate_cb");
+ full_meshlink_set_log_cb = dlsym(handle, "meshlink_set_log_cb");
+ full_meshlink_set_error_cb = dlsym(handle, "meshlink_set_error_cb");
+ full_meshlink_set_blacklisted_cb = dlsym(handle, "meshlink_set_blacklisted_cb");
+ full_meshlink_send = dlsym(handle, "meshlink_send");
+ full_meshlink_get_pmtu = dlsym(handle, "meshlink_get_pmtu");
+ full_meshlink_get_self = dlsym(handle, "meshlink_get_self");
+ full_meshlink_get_node = dlsym(handle, "meshlink_get_node");
+ full_meshlink_get_submesh = dlsym(handle, "meshlink_get_submesh");
+ full_meshlink_get_fingerprint = dlsym(handle, "meshlink_get_fingerprint");
+ full_meshlink_get_all_nodes = dlsym(handle, "meshlink_get_all_nodes");
+ full_meshlink_sign = dlsym(handle, "meshlink_sign");
+ full_meshlink_get_all_nodes_by_dev_class = dlsym(handle, "meshlink_get_all_nodes_by_dev_class");
+ full_meshlink_get_all_nodes_by_submesh = dlsym(handle, "meshlink_get_all_nodes_by_submesh");
+ full_meshlink_get_all_nodes_by_last_reachable = dlsym(handle, "meshlink_get_all_nodes_by_last_reachable");
+ full_meshlink_get_all_nodes_by_blacklisted = dlsym(handle, "meshlink_get_all_nodes_by_blacklisted");
+ full_meshlink_get_node_dev_class = dlsym(handle, "meshlink_get_node_dev_class");
+ full_meshlink_get_node_blacklisted = dlsym(handle, "meshlink_get_node_blacklisted");
+ full_meshlink_get_node_submesh = dlsym(handle, "meshlink_get_node_submesh");
+ full_meshlink_get_node_reachability = dlsym(handle, "meshlink_get_node_reachability");
+ full_meshlink_verify = dlsym(handle, "meshlink_verify");
+ full_meshlink_set_canonical_address = dlsym(handle, "meshlink_set_canonical_address");
+ full_meshlink_clear_canonical_address = dlsym(handle, "meshlink_clear_canonical_address");
+ full_meshlink_add_invitation_address = dlsym(handle, "meshlink_add_invitation_address");
+ full_meshlink_clear_invitation_addresses = dlsym(handle, "meshlink_clear_invitation_addresses");
+ full_meshlink_get_external_address = dlsym(handle, "meshlink_get_external_address");
+ full_meshlink_get_external_address_for_family = dlsym(handle, "meshlink_get_external_address_for_family");
+ full_meshlink_get_local_address_for_family = dlsym(handle, "meshlink_get_local_address_for_family");
+ full_meshlink_add_external_address = dlsym(handle, "meshlink_add_external_address");
+ full_meshlink_get_port = dlsym(handle, "meshlink_get_port");
+ full_meshlink_set_port = dlsym(handle, "meshlink_set_port");
+ full_meshlink_set_invitation_timeout = dlsym(handle, "meshlink_set_invitation_timeout");
+ full_meshlink_invite_ex = dlsym(handle, "meshlink_invite_ex");
+ full_meshlink_invite = dlsym(handle, "meshlink_invite");
+ full_meshlink_join = dlsym(handle, "meshlink_join");
+ full_meshlink_export = dlsym(handle, "meshlink_export");
+ full_meshlink_import = dlsym(handle, "meshlink_import");
+ full_meshlink_forget_node = dlsym(handle, "meshlink_forget_node");
+ full_meshlink_blacklist = dlsym(handle, "meshlink_blacklist");
+ full_meshlink_blacklist_by_name = dlsym(handle, "meshlink_blacklist_by_name");
+ full_meshlink_whitelist = dlsym(handle, "meshlink_whitelist");
+ full_meshlink_whitelist_by_name = dlsym(handle, "meshlink_whitelist_by_name");
+ full_meshlink_set_default_blacklist = dlsym(handle, "meshlink_set_default_blacklist");
+ full_meshlink_set_channel_listen_cb = dlsym(handle, "meshlink_set_channel_listen_cb");
+ full_meshlink_set_channel_accept_cb = dlsym(handle, "meshlink_set_channel_accept_cb");
+ full_meshlink_set_channel_receive_cb = dlsym(handle, "meshlink_set_channel_receive_cb");
+ full_meshlink_set_channel_poll_cb = dlsym(handle, "meshlink_set_channel_poll_cb");
+ full_meshlink_set_channel_sndbuf = dlsym(handle, "meshlink_set_channel_sndbuf");
+ full_meshlink_set_channel_rcvbuf = dlsym(handle, "meshlink_set_channel_rcvbuf");
+ full_meshlink_set_channel_sndbuf_storage = dlsym(handle, "meshlink_set_channel_sndbuf_storage");
+ full_meshlink_set_channel_rcvbuf_storage = dlsym(handle, "meshlink_set_channel_rcvbuf_storage");
+ full_meshlink_set_channel_flags = dlsym(handle, "meshlink_set_channel_flags");
+ full_meshlink_channel_open_ex = dlsym(handle, "meshlink_channel_open_ex");
+ full_meshlink_channel_open = dlsym(handle, "meshlink_channel_open");
+ full_meshlink_channel_shutdown = dlsym(handle, "meshlink_channel_shutdown");
+ full_meshlink_channel_close = dlsym(handle, "meshlink_channel_close");
+ full_meshlink_channel_abort = dlsym(handle, "meshlink_channel_abort");
+ full_meshlink_channel_send = dlsym(handle, "meshlink_channel_send");
+ full_meshlink_channel_aio_send = dlsym(handle, "meshlink_channel_aio_send");
+ full_meshlink_channel_aio_fd_send = dlsym(handle, "meshlink_channel_aio_fd_send");
+ full_meshlink_channel_aio_receive = dlsym(handle, "meshlink_channel_aio_receive");
+ full_meshlink_channel_aio_fd_receive = dlsym(handle, "meshlink_channel_aio_fd_receive");
+ full_meshlink_channel_get_flags = dlsym(handle, "meshlink_channel_get_flags");
+ full_meshlink_channel_get_sendq = dlsym(handle, "meshlink_channel_get_sendq");
+ full_meshlink_channel_get_recvq = dlsym(handle, "meshlink_channel_get_recvq");
+ full_meshlink_channel_get_mss = dlsym(handle, "meshlink_channel_get_mss");
+ full_meshlink_set_node_channel_timeout = dlsym(handle, "meshlink_set_node_channel_timeout");
+ full_meshlink_hint_address = dlsym(handle, "meshlink_hint_address");
+ full_meshlink_enable_discovery = dlsym(handle, "meshlink_enable_discovery");
+ full_meshlink_hint_network_change = dlsym(handle, "meshlink_hint_network_change");
+ full_meshlink_encrypted_key_rotate = dlsym(handle, "meshlink_encrypted_key_rotate");
+ full_meshlink_set_dev_class_timeouts = dlsym(handle, "meshlink_set_dev_class_timeouts");
+ full_meshlink_set_dev_class_fast_retry_period = dlsym(handle, "meshlink_set_dev_class_fast_retry_period");
+ full_meshlink_set_dev_class_maxtimeout = dlsym(handle, "meshlink_set_dev_class_maxtimeout");
+ full_meshlink_reset_timers = dlsym(handle, "meshlink_reset_timers");
+ full_meshlink_set_inviter_commits_first = dlsym(handle, "meshlink_set_inviter_commits_first");
+ full_meshlink_set_external_address_discovery_url = dlsym(handle, "meshlink_set_external_address_discovery_url");
+ full_meshlink_set_scheduling_granularity = dlsym(handle, "meshlink_set_scheduling_granularity");
+ full_meshlink_set_storage_policy = dlsym(handle, "meshlink_set_storage_policy");
+
+ full_devtool_set_inviter_commits_first = dlsym(handle, "devtool_set_inviter_commits_first");
+}
--- /dev/null
+#ifndef FULL_H
+#define FULL_H
+
+#include "meshlink-tiny.h"
+
+typedef struct meshlink_channel meshlink_channel_t;
+typedef struct meshlink_submesh meshlink_submesh_t;
+
+struct meshlink_channel {
+ struct meshlink_node *const node; ///< Pointer to the peer of this channel.
+ void *priv; ///< Private pointer which may be set freely by the application, and is never used or modified by MeshLink.
+};
+
+struct meshlink_submesh {
+ const char *const name; ///< Textual name of this Sub-Mesh. It is stored in a nul-terminated C string, which is allocated by MeshLink.
+ void *priv; ///< Private pointer which may be set freely by the application, and is never used or modified by MeshLink.
+};
+
+typedef void (*meshlink_node_pmtu_cb_t)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t pmtu);
+typedef void (*meshlink_blacklisted_cb_t)(struct meshlink_handle *mesh, struct meshlink_node *node);
+typedef bool (*meshlink_channel_listen_cb_t)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port);
+typedef bool (*meshlink_channel_accept_cb_t)(struct meshlink_handle *mesh, struct meshlink_channel *channel, uint16_t port, const void *data, size_t len);
+typedef void (*meshlink_channel_receive_cb_t)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len);
+typedef void (*meshlink_channel_poll_cb_t)(struct meshlink_handle *mesh, struct meshlink_channel *channel, size_t len);
+typedef void (*meshlink_aio_cb_t)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len, void *priv);
+typedef void (*meshlink_aio_fd_cb_t)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int fd, size_t len, void *priv);
+
+extern meshlink_errno_t *full_meshlink_errno;
+extern const char *(*full_meshlink_strerror)(meshlink_errno_t err) __attribute__((__warn_unused_result__));
+extern meshlink_open_params_t *(*full_meshlink_open_params_init)(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_open_params_free)(meshlink_open_params_t *params);
+extern bool (*full_meshlink_open_params_set_netns)(meshlink_open_params_t *params, int netns) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_open_params_set_storage_key)(meshlink_open_params_t *params, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_open_params_set_storage_policy)(meshlink_open_params_t *params, meshlink_storage_policy_t policy) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_open_params_set_lock_filename)(meshlink_open_params_t *params, const char *filename) __attribute__((__warn_unused_result__));
+extern struct meshlink_handle *(*full_meshlink_open_ex)(const meshlink_open_params_t *params) __attribute__((__warn_unused_result__));
+extern struct meshlink_handle *(*full_meshlink_open)(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+extern struct meshlink_handle *(*full_meshlink_open_encrypted)(const char *confbase, const char *name, const char *appname, dev_class_t devclass, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+extern struct meshlink_handle *(*full_meshlink_open_ephemeral)(const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
+extern struct meshlink_submesh *(*full_meshlink_submesh_open)(struct meshlink_handle *mesh, const char *submesh) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_start)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_stop)(struct meshlink_handle *mesh);
+extern void (*full_meshlink_close)(struct meshlink_handle *mesh);
+extern bool (*full_meshlink_destroy)(const char *confbase) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_destroy_ex)(const meshlink_open_params_t *params) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_set_receive_cb)(struct meshlink_handle *mesh, meshlink_receive_cb_t cb);
+extern void (*full_meshlink_set_connection_try_cb)(struct meshlink_handle *mesh, meshlink_connection_try_cb_t cb);
+extern void (*full_meshlink_set_node_status_cb)(struct meshlink_handle *mesh, meshlink_node_status_cb_t cb);
+extern void (*full_meshlink_set_node_pmtu_cb)(struct meshlink_handle *mesh, meshlink_node_pmtu_cb_t cb);
+extern void (*full_meshlink_set_node_duplicate_cb)(struct meshlink_handle *mesh, meshlink_node_duplicate_cb_t cb);
+extern void (*full_meshlink_set_log_cb)(struct meshlink_handle *mesh, meshlink_log_level_t level, meshlink_log_cb_t cb);
+extern void (*full_meshlink_set_error_cb)(struct meshlink_handle *mesh, meshlink_error_cb_t cb);
+extern void (*full_meshlink_set_blacklisted_cb)(struct meshlink_handle *mesh, meshlink_blacklisted_cb_t cb);
+extern bool (*full_meshlink_send)(struct meshlink_handle *mesh, struct meshlink_node *destination, const void *data, size_t len) __attribute__((__warn_unused_result__));
+extern ssize_t (*full_meshlink_get_pmtu)(struct meshlink_handle *mesh, struct meshlink_node *destination) __attribute__((__warn_unused_result__));
+extern struct meshlink_node *(*full_meshlink_get_self)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern struct meshlink_node *(*full_meshlink_get_node)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+extern struct meshlink_submesh *(*full_meshlink_get_submesh)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+extern char *(*full_meshlink_get_fingerprint)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern struct meshlink_node **(*full_meshlink_get_all_nodes)(struct meshlink_handle *mesh, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_sign)(struct meshlink_handle *mesh, const void *data, size_t len, void *signature, size_t *siglen) __attribute__((__warn_unused_result__));
+extern struct meshlink_node **(*full_meshlink_get_all_nodes_by_dev_class)(struct meshlink_handle *mesh, dev_class_t devclass, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+extern struct meshlink_node **(*full_meshlink_get_all_nodes_by_submesh)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+extern struct meshlink_node **(*full_meshlink_get_all_nodes_by_last_reachable)(struct meshlink_handle *mesh, time_t start, time_t end, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+extern struct meshlink_node **(*full_meshlink_get_all_nodes_by_blacklisted)(struct meshlink_handle *mesh, bool blacklisted, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
+extern dev_class_t (*full_meshlink_get_node_dev_class)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_get_node_blacklisted)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern struct meshlink_submesh *(*full_meshlink_get_node_submesh)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_get_node_reachability)(struct meshlink_handle *mesh, struct meshlink_node *node, time_t *last_reachable, time_t *last_unreachable);
+extern bool (*full_meshlink_verify)(struct meshlink_handle *mesh, struct meshlink_node *source, const void *data, size_t len, const void *signature, size_t siglen) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_set_canonical_address)(struct meshlink_handle *mesh, struct meshlink_node *node, const char *address, const char *port) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_clear_canonical_address)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_add_invitation_address)(struct meshlink_handle *mesh, const char *address, const char *port) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_clear_invitation_addresses)(struct meshlink_handle *mesh);
+extern char *(*full_meshlink_get_external_address)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern char *(*full_meshlink_get_external_address_for_family)(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
+extern char *(*full_meshlink_get_local_address_for_family)(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_add_external_address)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern int (*full_meshlink_get_port)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_set_port)(struct meshlink_handle *mesh, int port) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_set_invitation_timeout)(struct meshlink_handle *mesh, int timeout);
+extern char *(*full_meshlink_invite_ex)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name, uint32_t flags) __attribute__((__warn_unused_result__));
+extern char *(*full_meshlink_invite)(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_join)(struct meshlink_handle *mesh, const char *invitation) __attribute__((__warn_unused_result__));
+extern char *(*full_meshlink_export)(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_import)(struct meshlink_handle *mesh, const char *data) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_forget_node)(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern bool (*full_meshlink_blacklist)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_blacklist_by_name)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_whitelist)(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_whitelist_by_name)(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_set_default_blacklist)(struct meshlink_handle *mesh, bool blacklist);
+extern void (*full_meshlink_set_channel_listen_cb)(struct meshlink_handle *mesh, meshlink_channel_listen_cb_t cb);
+extern void (*full_meshlink_set_channel_accept_cb)(struct meshlink_handle *mesh, meshlink_channel_accept_cb_t cb);
+extern void (*full_meshlink_set_channel_receive_cb)(struct meshlink_handle *mesh, struct meshlink_channel *channel, meshlink_channel_receive_cb_t cb);
+extern void (*full_meshlink_set_channel_poll_cb)(struct meshlink_handle *mesh, struct meshlink_channel *channel, meshlink_channel_poll_cb_t cb);
+extern void (*full_meshlink_set_channel_sndbuf)(struct meshlink_handle *mesh, struct meshlink_channel *channel, size_t size);
+extern void (*full_meshlink_set_channel_rcvbuf)(struct meshlink_handle *mesh, struct meshlink_channel *channel, size_t size);
+extern void (*full_meshlink_set_channel_sndbuf_storage)(struct meshlink_handle *mesh, struct meshlink_channel *channel, void *buf, size_t size);
+extern void (*full_meshlink_set_channel_rcvbuf_storage)(struct meshlink_handle *mesh, struct meshlink_channel *channel, void *buf, size_t size);
+extern void (*full_meshlink_set_channel_flags)(struct meshlink_handle *mesh, struct meshlink_channel *channel, uint32_t flags);
+extern struct meshlink_channel *(*full_meshlink_channel_open_ex)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len, uint32_t flags) __attribute__((__warn_unused_result__));
+extern struct meshlink_channel *(*full_meshlink_channel_open)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_channel_shutdown)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int direction);
+extern void (*full_meshlink_channel_close)(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+extern void (*full_meshlink_channel_abort)(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+extern ssize_t (*full_meshlink_channel_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_channel_aio_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_channel_aio_fd_send)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_channel_aio_receive)(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+extern bool (*full_meshlink_channel_aio_fd_receive)(struct meshlink_handle *mesh, struct meshlink_channel *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv) __attribute__((__warn_unused_result__));
+extern uint32_t (*full_meshlink_channel_get_flags)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+extern size_t (*full_meshlink_channel_get_sendq)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+extern size_t (*full_meshlink_channel_get_recvq)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+extern size_t (*full_meshlink_channel_get_mss)(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_set_node_channel_timeout)(struct meshlink_handle *mesh, struct meshlink_node *node, int timeout);
+extern void (*full_meshlink_hint_address)(struct meshlink_handle *mesh, struct meshlink_node *node, const struct sockaddr *addr);
+extern void (*full_meshlink_enable_discovery)(struct meshlink_handle *mesh, bool enable);
+extern void (*full_meshlink_hint_network_change)(struct meshlink_handle *mesh);
+extern bool (*full_meshlink_encrypted_key_rotate)(struct meshlink_handle *mesh, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
+extern void (*full_meshlink_set_dev_class_timeouts)(struct meshlink_handle *mesh, dev_class_t devclass, int pinginterval, int pingtimeout);
+extern void (*full_meshlink_set_dev_class_fast_retry_period)(struct meshlink_handle *mesh, dev_class_t devclass, int fast_retry_period);
+extern void (*full_meshlink_set_dev_class_maxtimeout)(struct meshlink_handle *mesh, dev_class_t devclass, int maxtimeout);
+extern void (*full_meshlink_reset_timers)(struct meshlink_handle *mesh);
+extern void (*full_meshlink_set_inviter_commits_first)(struct meshlink_handle *mesh, bool inviter_commits_first);
+extern void (*full_meshlink_set_external_address_discovery_url)(struct meshlink_handle *mesh, const char *url);
+extern void (*full_meshlink_set_scheduling_granularity)(struct meshlink_handle *mesh, long granularity);
+extern void (*full_meshlink_set_storage_policy)(struct meshlink_handle *mesh, meshlink_storage_policy_t policy);
+
+typedef void (*full_devtool_set_inviter_commits_first_t)(bool inviter_commited_first);
+extern full_devtool_set_inviter_commits_first_t *full_devtool_set_inviter_commits_first;
+
+void init_full(void);
+#endif
#include "utils.h"
static struct sync_flag bar_reachable;
-static struct sync_flag pmtu_flag;
static void status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
(void)mesh;
}
}
-static void pmtu_cb(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t pmtu) {
- (void)mesh;
-
- if(pmtu && !strcmp(node->name, "bar")) {
- set_sync_flag(&pmtu_flag, true);
- }
-}
-
int main(void) {
init_sync_flag(&bar_reachable);
- init_sync_flag(&pmtu_flag);
meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
// Check that foo knows bar, but that it is not reachable.
- time_t last_reachable;
- time_t last_unreachable;
meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
assert(bar);
- assert(!meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
- assert(!last_reachable);
- assert(!last_unreachable);
-
- // Start both instances
-
- meshlink_set_node_status_cb(mesh1, status_cb);
- meshlink_set_node_pmtu_cb(mesh1, pmtu_cb);
-
- assert(meshlink_start(mesh1));
- assert(meshlink_start(mesh2));
-
- // Wait for the two to connect.
-
- assert(wait_sync_flag(&bar_reachable, 10));
-
- // Wait for UDP communication to become possible.
-
- assert(wait_sync_flag(&pmtu_flag, 10));
-
- // Check that we now have reachability information
-
- assert(meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
- assert(last_reachable);
-
- // Stop the meshes.
-
- meshlink_stop(mesh1);
- meshlink_stop(mesh2);
-
- // Check that bar is no longer reachable
-
- assert(!meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
- assert(last_reachable);
- assert(last_unreachable);
- assert(last_reachable <= last_unreachable);
// Clean up.
#include "devtools.h"
#include "utils.h"
+#include "full.h"
+
static struct sync_flag baz_reachable;
static struct sync_flag seven_reachable;
static struct sync_flag commits_first_flag;
}
int main(void) {
+ init_full();
+
init_sync_flag(&baz_reachable);
init_sync_flag(&seven_reachable);
init_sync_flag(&commits_first_flag);
// Open thee new meshlink instance.
- meshlink_handle_t *mesh1 = meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
+ meshlink_handle_t *mesh1 = full_meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh1);
meshlink_handle_t *mesh2 = meshlink_open("invite_join_conf.2", "bar", "invite-join", DEV_CLASS_BACKBONE);
// Have the first instance generate invitations.
- meshlink_set_node_status_cb(mesh1, status_cb);
+ full_meshlink_set_node_status_cb(mesh1, status_cb);
- assert(meshlink_set_canonical_address(mesh1, meshlink_get_self(mesh1), "localhost", NULL));
+ assert(full_meshlink_set_canonical_address(mesh1, full_meshlink_get_self(mesh1), "localhost", NULL));
- char *baz_url = meshlink_invite(mesh1, NULL, "baz");
+ char *baz_url = full_meshlink_invite(mesh1, NULL, "baz");
assert(baz_url);
- char *quux_url = meshlink_invite(mesh1, NULL, "quux");
+ char *quux_url = full_meshlink_invite(mesh1, NULL, "quux");
assert(quux_url);
// Check that the second instances cannot join if it is already started
- assert(meshlink_start(mesh1));
+ assert(full_meshlink_start(mesh1));
assert(meshlink_start(mesh2));
meshlink_errno = MESHLINK_OK;
assert(!meshlink_join(mesh2, baz_url));
// Wait for UDP communication to become possible.
- int pmtu = meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
+ int pmtu = full_meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
for(int i = 0; i < 10 && !pmtu; i++) {
sleep(1);
- pmtu = meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
+ pmtu = full_meshlink_get_pmtu(mesh1, meshlink_get_node(mesh1, "baz"));
}
assert(pmtu);
// Check that nodes cannot join with expired invitations
- meshlink_set_invitation_timeout(mesh1, 0);
+ full_meshlink_set_invitation_timeout(mesh1, 0);
assert(!meshlink_join(mesh3, quux_url));
free(quux_url);
// Check that existing nodes cannot join another mesh
- char *corge_url = meshlink_invite(mesh3, NULL, "corge");
+ char *corge_url = full_meshlink_invite(mesh1, NULL, "corge");
assert(corge_url);
- assert(meshlink_start(mesh3));
-
meshlink_stop(mesh2);
assert(!meshlink_join(mesh2, corge_url));
// Check that invitations work correctly after changing ports
- meshlink_set_invitation_timeout(mesh1, 86400);
- meshlink_stop(mesh1);
+ full_meshlink_set_invitation_timeout(mesh1, 86400);
+ full_meshlink_stop(mesh1);
meshlink_stop(mesh3);
- int oldport = meshlink_get_port(mesh1);
+ int oldport = full_meshlink_get_port(mesh1);
bool success = false;
for(int i = 0; !success && i < 100; i++) {
- success = meshlink_set_port(mesh1, 0x9000 + rand() % 0x1000);
+ success = full_meshlink_set_port(mesh1, 0x9000 + rand() % 0x1000);
}
assert(success);
- int newport = meshlink_get_port(mesh1);
+ int newport = full_meshlink_get_port(mesh1);
assert(oldport != newport);
- assert(meshlink_set_canonical_address(mesh1, meshlink_get_self(mesh1), "localhost", NULL));
+ assert(full_meshlink_set_canonical_address(mesh1, meshlink_get_self(mesh1), "localhost", NULL));
- assert(meshlink_start(mesh1));
- quux_url = meshlink_invite(mesh1, NULL, "quux");
+ assert(full_meshlink_start(mesh1));
+ quux_url = full_meshlink_invite(mesh1, NULL, "quux");
assert(quux_url);
// The old port should not be in the invitation URL
// Check that adding duplicate addresses get removed correctly
- assert(meshlink_add_invitation_address(mesh1, "localhost", portstr + 1));
- corge_url = meshlink_invite(mesh1, NULL, "corge");
+ assert(full_meshlink_add_invitation_address(mesh1, "localhost", portstr + 1));
+ corge_url = full_meshlink_invite(mesh1, NULL, "corge");
assert(corge_url);
char *localhost = strstr(corge_url, "localhost");
assert(localhost);
// Check that resetting and adding multiple, different invitation address works
- meshlink_clear_invitation_addresses(mesh1);
- assert(meshlink_add_invitation_address(mesh1, "1.invalid.", "12345"));
- assert(meshlink_add_invitation_address(mesh1, "2.invalid.", NULL));
- assert(meshlink_add_invitation_address(mesh1, "3.invalid.", NULL));
- assert(meshlink_add_invitation_address(mesh1, "4.invalid.", NULL));
- assert(meshlink_add_invitation_address(mesh1, "5.invalid.", NULL));
- char *grault_url = meshlink_invite(mesh1, NULL, "grault");
+ full_meshlink_clear_invitation_addresses(mesh1);
+ assert(full_meshlink_add_invitation_address(mesh1, "1.invalid.", "12345"));
+ assert(full_meshlink_add_invitation_address(mesh1, "2.invalid.", NULL));
+ assert(full_meshlink_add_invitation_address(mesh1, "3.invalid.", NULL));
+ assert(full_meshlink_add_invitation_address(mesh1, "4.invalid.", NULL));
+ assert(full_meshlink_add_invitation_address(mesh1, "5.invalid.", NULL));
+ char *grault_url = full_meshlink_invite(mesh1, NULL, "grault");
assert(grault_url);
localhost = strstr(grault_url, "localhost");
assert(localhost);
// Check inviting nodes into a submesh
- assert(!meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)));
+ assert(!full_meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)));
meshlink_handle_t *mesh4 = meshlink_open("invite_join_conf.4", "four", "invite-join", DEV_CLASS_BACKBONE);
meshlink_handle_t *mesh5 = meshlink_open("invite_join_conf.5", "five", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh5);
assert(mesh6);
- meshlink_enable_discovery(mesh4, false);
- meshlink_enable_discovery(mesh5, false);
- meshlink_enable_discovery(mesh6, false);
-
- meshlink_submesh_t *submesh1 = meshlink_submesh_open(mesh1, "submesh1");
- meshlink_submesh_t *submesh2 = meshlink_submesh_open(mesh1, "submesh2");
+ meshlink_submesh_t *submesh1 = full_meshlink_submesh_open(mesh1, "submesh1");
+ meshlink_submesh_t *submesh2 = full_meshlink_submesh_open(mesh1, "submesh2");
assert(submesh1);
assert(submesh2);
- char *four_url = meshlink_invite(mesh1, submesh1, mesh4->name);
- char *five_url = meshlink_invite(mesh1, submesh1, mesh5->name);
- char *six_url = meshlink_invite(mesh1, submesh2, mesh6->name);
+ char *four_url = full_meshlink_invite(mesh1, submesh1, mesh4->name);
+ char *five_url = full_meshlink_invite(mesh1, submesh1, mesh5->name);
+ char *six_url = full_meshlink_invite(mesh1, submesh2, mesh6->name);
assert(four_url);
assert(five_url);
assert(six_url);
assert(meshlink_start(mesh5));
assert(meshlink_start(mesh6));
- // Check that each node knows in which submesh it is
-
- meshlink_submesh_t *mesh4_submesh = meshlink_get_node_submesh(mesh4, meshlink_get_self(mesh4));
- meshlink_submesh_t *mesh5_submesh = meshlink_get_node_submesh(mesh4, meshlink_get_self(mesh5));
- meshlink_submesh_t *mesh6_submesh = meshlink_get_node_submesh(mesh6, meshlink_get_self(mesh6));
- assert(mesh4_submesh);
- assert(mesh5_submesh);
- assert(mesh6_submesh);
- assert(!strcmp(mesh4_submesh->name, "submesh1"));
- assert(!strcmp(mesh5_submesh->name, "submesh1"));
- assert(!strcmp(mesh6_submesh->name, "submesh2"));
-
// Wait for nodes to connect, and check that foo sees the right submeshes
sleep(2);
- meshlink_node_t *mesh1_four = meshlink_get_node(mesh1, mesh4->name);
- meshlink_node_t *mesh1_six = meshlink_get_node(mesh1, mesh6->name);
- assert(meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)) == NULL);
- assert(meshlink_get_node_submesh(mesh1, mesh1_four) == submesh1);
- assert(meshlink_get_node_submesh(mesh1, mesh1_six) == submesh2);
-
- // Check that the new invitees still have the right submesh information
+ meshlink_node_t *mesh1_four = full_meshlink_get_node(mesh1, mesh4->name);
+ meshlink_node_t *mesh1_six = full_meshlink_get_node(mesh1, mesh6->name);
+ assert(full_meshlink_get_node_submesh(mesh1, meshlink_get_self(mesh1)) == NULL);
+ assert(full_meshlink_get_node_submesh(mesh1, mesh1_four) == submesh1);
+ assert(full_meshlink_get_node_submesh(mesh1, mesh1_six) == submesh2);
- meshlink_node_t *mesh4_four = meshlink_get_node(mesh4, mesh4->name);
- meshlink_node_t *mesh4_five = meshlink_get_node(mesh4, mesh5->name);
- meshlink_node_t *mesh6_six = meshlink_get_node(mesh6, mesh6->name);
- assert(meshlink_get_node_submesh(mesh4, mesh4_four) == mesh4_submesh);
- assert(meshlink_get_node_submesh(mesh4, mesh4_five) == mesh4_submesh);
- assert(meshlink_get_node_submesh(mesh6, mesh6_six) == mesh6_submesh);
+ // Check that none of the tiny nodes can see each other, regardless of which submesh they are in
- // Check that bar can see all the nodes in submeshes and vice versa
+ assert(!meshlink_get_node(mesh2, mesh4->name));
+ assert(!meshlink_get_node(mesh2, mesh5->name));
+ assert(!meshlink_get_node(mesh2, mesh6->name));
+ assert(!meshlink_get_node(mesh4, mesh2->name));
+ assert(!meshlink_get_node(mesh5, mesh2->name));
+ assert(!meshlink_get_node(mesh6, mesh2->name));
- assert(meshlink_get_node(mesh2, mesh4->name));
- assert(meshlink_get_node(mesh2, mesh5->name));
- assert(meshlink_get_node(mesh2, mesh6->name));
- assert(meshlink_get_node(mesh4, mesh2->name));
- assert(meshlink_get_node(mesh5, mesh2->name));
- assert(meshlink_get_node(mesh6, mesh2->name));
+ assert(!meshlink_get_node(mesh4, mesh5->name));
+ assert(!meshlink_get_node(mesh5, mesh4->name));
- // Check that four and five can see each other
-
- assert(meshlink_get_node(mesh4, mesh5->name));
- assert(meshlink_get_node(mesh5, mesh4->name));
-
- // Check that the nodes in different submeshes cannot see each other
assert(!meshlink_get_node(mesh4, mesh6->name));
assert(!meshlink_get_node(mesh5, mesh6->name));
assert(!meshlink_get_node(mesh6, mesh4->name));
assert(!meshlink_get_node(mesh6, mesh5->name));
- // Check that bar sees the right submesh information for the nodes in submeshes
-
- meshlink_submesh_t *mesh2_four_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh4->name));
- meshlink_submesh_t *mesh2_five_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh5->name));
- meshlink_submesh_t *mesh2_six_submesh = meshlink_get_node_submesh(mesh2, meshlink_get_node(mesh2, mesh6->name));
- assert(mesh2_four_submesh);
- assert(mesh2_five_submesh);
- assert(mesh2_six_submesh);
- assert(!strcmp(mesh2_four_submesh->name, "submesh1"));
- assert(!strcmp(mesh2_five_submesh->name, "submesh1"));
- assert(!strcmp(mesh2_six_submesh->name, "submesh2"));
-
// Test case #2: check invalid parameters
meshlink_handle_t *mesh7 = meshlink_open("invite_join_conf.7", "seven", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh7);
- meshlink_enable_discovery(mesh7, false);
- char *seven_url = meshlink_invite(mesh1, NULL, "seven");
+ char *seven_url = full_meshlink_invite(mesh1, NULL, "seven");
assert(seven_url);
meshlink_errno = MESHLINK_OK;
- assert(!meshlink_invite(NULL, NULL, "seven"));
- assert(meshlink_errno == MESHLINK_EINVAL);
+ assert(!full_meshlink_invite(NULL, NULL, "seven"));
+ assert(*full_meshlink_errno == MESHLINK_EINVAL);
meshlink_errno = MESHLINK_OK;
- assert(!meshlink_invite(mesh1, NULL, NULL));
- assert(meshlink_errno == MESHLINK_EINVAL);
+ assert(!full_meshlink_invite(mesh1, NULL, NULL));
+ assert(*full_meshlink_errno == MESHLINK_EINVAL);
meshlink_errno = MESHLINK_OK;
- assert(!meshlink_invite(mesh1, NULL, ""));
- assert(meshlink_errno == MESHLINK_EINVAL);
+ assert(!full_meshlink_invite(mesh1, NULL, ""));
+ assert(*full_meshlink_errno == MESHLINK_EINVAL);
meshlink_errno = MESHLINK_OK;
assert(!meshlink_join(NULL, seven_url));
assert(meshlink_join(mesh7, seven_url));
free(seven_url);
- meshlink_close(mesh1);
+ full_meshlink_close(mesh1);
meshlink_stop(mesh2);
meshlink_stop(mesh3);
meshlink_stop(mesh4);
meshlink_stop(mesh5);
meshlink_stop(mesh6);
meshlink_close(mesh7);
- mesh1 = meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("invite_join_conf.1", "foo", "invite-join", DEV_CLASS_BACKBONE);
mesh7 = meshlink_open("invite_join_conf.7", "seven", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh7);
- meshlink_enable_discovery(mesh1, false);
- meshlink_enable_discovery(mesh7, false);
- meshlink_set_node_status_cb(mesh1, status_cb);
- assert(meshlink_start(mesh1));
+ full_meshlink_enable_discovery(mesh1, false);
+ full_meshlink_set_node_status_cb(mesh1, status_cb);
+ assert(full_meshlink_start(mesh1));
assert(meshlink_start(mesh7));
assert(wait_sync_flag(&seven_reachable, 5));
meshlink_stop(mesh7);
meshlink_handle_t *mesh8 = meshlink_open("invite_join_conf.8", "eight", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh8);
- meshlink_enable_discovery(mesh8, false);
- char *eight_url = meshlink_invite(mesh1, NULL, "eight");
+ char *eight_url = full_meshlink_invite(mesh1, NULL, "eight");
assert(eight_url);
- meshlink_set_inviter_commits_first(mesh1, true);
+ full_meshlink_set_inviter_commits_first(mesh1, true);
meshlink_set_inviter_commits_first(mesh8, false);
assert(!meshlink_join(mesh8, eight_url));
free(eight_url);
- eight_url = meshlink_invite(mesh1, NULL, "eight");
- meshlink_set_inviter_commits_first(mesh1, false);
+ eight_url = full_meshlink_invite(mesh1, NULL, "eight");
+ full_meshlink_set_inviter_commits_first(mesh1, false);
meshlink_set_inviter_commits_first(mesh8, true);
assert(!meshlink_join(mesh8, eight_url));
free(eight_url);
// Test case #5: test invitee committing first scenario
- eight_url = meshlink_invite(mesh1, NULL, "eight");
- meshlink_set_inviter_commits_first(mesh1, false);
+ eight_url = full_meshlink_invite(mesh1, NULL, "eight");
+ full_meshlink_set_inviter_commits_first(mesh1, false);
meshlink_set_inviter_commits_first(mesh8, false);
devtool_set_inviter_commits_first = invitee_commits_first_cb;
assert(meshlink_join(mesh8, eight_url));
meshlink_handle_t *mesh9 = meshlink_open("invite_join_conf.9", "nine", "invite-join", DEV_CLASS_BACKBONE);
assert(mesh9);
- meshlink_enable_discovery(mesh9, false);
- char *nine_url = meshlink_invite(mesh1, NULL, "nine");
- meshlink_set_inviter_commits_first(mesh1, true);
+ char *nine_url = full_meshlink_invite(mesh1, NULL, "nine");
+ full_meshlink_set_inviter_commits_first(mesh1, true);
meshlink_set_inviter_commits_first(mesh9, true);
- devtool_set_inviter_commits_first = inviter_commits_first_cb;
+ *full_devtool_set_inviter_commits_first = inviter_commits_first_cb;
reset_sync_flag(&commits_first_flag);
assert(meshlink_join(mesh9, nine_url));
free(nine_url);
meshlink_close(mesh4);
meshlink_close(mesh3);
meshlink_close(mesh2);
- meshlink_close(mesh1);
+ full_meshlink_close(mesh1);
}
#include <sys/time.h>
#include <assert.h>
+#include "full.h"
#include "meshlink-tiny.h"
#include "utils.h"
int main(void) {
+ init_full();
+
+ full_meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
meshlink_handle_t *mesh1;
// Open two instances
- assert(meshlink_destroy("storage-policy_conf.1"));
+ assert(full_meshlink_destroy("storage-policy_conf.1"));
assert(meshlink_destroy("storage-policy_conf.2"));
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_DISABLED);
+ full_meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_DISABLED);
meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_DISABLED);
// Exchange data
- char *export1 = meshlink_export(mesh1);
+ char *export1 = full_meshlink_export(mesh1);
char *export2 = meshlink_export(mesh2);
assert(export1);
assert(export2);
- assert(meshlink_import(mesh1, export2));
+ assert(full_meshlink_import(mesh1, export2));
assert(meshlink_import(mesh2, export1));
// Check that they know each other
- assert(meshlink_get_node(mesh1, "bar"));
+ assert(full_meshlink_get_node(mesh1, "bar"));
assert(meshlink_get_node(mesh2, "foo"));
- start_meshlink_pair(mesh1, mesh2);
+ start_full_tiny_pair(mesh1, mesh2);
// Close the instances and reopen them.
- close_meshlink_pair(mesh1, mesh2);
+ close_full_tiny_pair(mesh1, mesh2);
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
+ full_meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
// Check that the nodes no longer know each other
- assert(!meshlink_get_node(mesh1, "bar"));
+ assert(!full_meshlink_get_node(mesh1, "bar"));
assert(!meshlink_get_node(mesh2, "foo"));
// Exchange data again
- assert(meshlink_import(mesh1, export2));
+ assert(full_meshlink_import(mesh1, export2));
assert(meshlink_import(mesh2, export1));
free(export1);
// Close the instances and reopen them.
- close_meshlink_pair(mesh1, mesh2);
+ close_full_tiny_pair(mesh1, mesh2);
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
+ full_meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
// Check that the nodes know each other
- assert(meshlink_get_node(mesh1, "bar"));
- assert(meshlink_get_node(mesh2, "foo"));
-
- // Check that we update reachability
-
- time_t last_reachable;
- time_t last_unreachable;
- assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
- assert(!last_reachable);
- assert(!last_unreachable);
-
- start_meshlink_pair(mesh1, mesh2);
- stop_meshlink_pair(mesh1, mesh2);
-
- assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
- assert(last_reachable);
- assert(last_unreachable);
-
- // But have not stored it
-
- close_meshlink_pair(mesh1, mesh2);
-
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
- mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
- assert(mesh1);
- assert(mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
- meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
-
- assert(meshlink_get_node(mesh1, "bar"));
+ assert(full_meshlink_get_node(mesh1, "bar"));
assert(meshlink_get_node(mesh2, "foo"));
- assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
- assert(!last_reachable);
- assert(!last_unreachable);
-
// Check that if we change back to STORAGE_ENABLED right before closing, pending changes are still saved
- start_meshlink_pair(mesh1, mesh2);
- stop_meshlink_pair(mesh1, mesh2);
+ start_full_tiny_pair(mesh1, mesh2);
+ stop_full_tiny_pair(mesh1, mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_ENABLED);
+ full_meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_ENABLED);
meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_ENABLED);
- close_meshlink_pair(mesh1, mesh2);
+ close_full_tiny_pair(mesh1, mesh2);
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh2);
- assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
- assert(last_reachable);
- assert(last_unreachable);
-
// Close the instances and reopen them.
- close_meshlink_pair(mesh1, mesh2);
+ close_full_tiny_pair(mesh1, mesh2);
- mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
+ mesh1 = full_meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
assert(mesh1);
assert(mesh2);
- meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
+ full_meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
// Check that the nodes know each other
- assert(meshlink_get_node(mesh1, "bar"));
+ assert(full_meshlink_get_node(mesh1, "bar"));
assert(meshlink_get_node(mesh2, "foo"));
// Done.
- close_meshlink_pair(mesh1, mesh2);
+ close_full_tiny_pair(mesh1, mesh2);
}
#include <errno.h>
#include <time.h>
+#include "full.h"
#include "utils.h"
void init_sync_flag(struct sync_flag *s) {
a->priv = NULL;
}
+void start_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
+ struct sync_flag pair_status = {.flag = false};
+ init_sync_flag(&pair_status);
+
+ a->priv = &pair_status;
+ full_meshlink_set_node_status_cb(a, pair_status_cb);
+
+ assert(full_meshlink_start(a));
+ assert(meshlink_start(b));
+
+ assert(wait_sync_flag(&pair_status, 5));
+
+ full_meshlink_set_node_status_cb(a, NULL);
+ a->priv = NULL;
+}
+
void stop_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
meshlink_stop(a);
meshlink_stop(b);
}
+void stop_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
+ full_meshlink_stop(a);
+ meshlink_stop(b);
+}
+
void close_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
meshlink_close(a);
meshlink_close(b);
}
+void close_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
+ full_meshlink_close(a);
+ meshlink_close(b);
+}
+
void log_cb(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
static const char *levelstr[] = {
[MESHLINK_DEBUG] = "DEBUG",
/// Start a pair of meshlink instances and wait for them to connect together.
extern void start_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b);
+extern void start_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b);
/// Stop a pair of meshlink instances.
extern void stop_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b);
+extern void stop_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b);
/// Stop and cleanup a pair of meshlink instances.
extern void close_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b);
+extern void close_full_tiny_pair(meshlink_handle_t *a, meshlink_handle_t *b);
/// Link two meshlink instances.
extern void link_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b);
projects / meshlink-tiny / commitdiff