]> git.meshlink.io Git - meshlink/commitdiff
Fix __warn_unused_result__, add more of it and fix the resulting warnings.
authorGuus Sliepen <guus@meshlink.io>
Sat, 9 Nov 2019 16:57:55 +0000 (17:57 +0100)
committerGuus Sliepen <guus@meshlink.io>
Sat, 9 Nov 2019 17:33:57 +0000 (18:33 +0100)
Due to a bug in the autoconf test for function attributes, we were always
disabling __warn_unused_result__. Fix this, and add this function attribute
to a lot more functions whose results are definitely important.

This change makes it clear where we ignore the results of a function that
might fail. The proper fix in most cases is to propagate the result to the
caller. For meshlink_blacklist() and meshlink_whitelist(), we were not
return an error condition, even if we might fail to commit the blacklist
operation to permanent storage. So we now make these functions return a
bool.

111 files changed:
examples/channels.c
examples/chat.c
examples/groupchat.c
examples/manynodes.c
examples/meshlinkapp.c
m4/attribute.m4
src/conf.c
src/conf.h
src/edge.h
src/event.h
src/fake-getaddrinfo.h
src/fake-getnameinfo.h
src/meshlink++.h
src/meshlink.c
src/meshlink.h
src/meshlink_queue.h
src/meta.h
src/net.c
src/net.h
src/net_packet.c
src/net_setup.c
src/net_socket.c
src/netutl.h
src/node.h
src/packmsg.h
src/protocol.h
src/protocol_auth.c
src/protocol_key.c
src/sptps.h
src/submesh.h
src/utils.h
src/xoshiro.h
test/blackbox/run_blackbox_tests/test_cases_add_addr.c
test/blackbox/run_blackbox_tests/test_cases_add_ex_addr.c
test/blackbox/run_blackbox_tests/test_cases_autoconnect.c
test/blackbox/run_blackbox_tests/test_cases_blacklist.c
test/blackbox/run_blackbox_tests/test_cases_channel_blacklist.c
test/blackbox/run_blackbox_tests/test_cases_channel_close.c
test/blackbox/run_blackbox_tests/test_cases_channel_ex.c
test/blackbox/run_blackbox_tests/test_cases_channel_get_flags.c
test/blackbox/run_blackbox_tests/test_cases_channel_open.c
test/blackbox/run_blackbox_tests/test_cases_channel_send.c
test/blackbox/run_blackbox_tests/test_cases_channel_set_accept_cb.c
test/blackbox/run_blackbox_tests/test_cases_channel_set_poll_cb.c
test/blackbox/run_blackbox_tests/test_cases_channel_set_receive_cb.c
test/blackbox/run_blackbox_tests/test_cases_channel_shutdown.c
test/blackbox/run_blackbox_tests/test_cases_default_blacklist.c
test/blackbox/run_blackbox_tests/test_cases_export.c
test/blackbox/run_blackbox_tests/test_cases_get_all_nodes.c
test/blackbox/run_blackbox_tests/test_cases_get_all_nodes_by_dev_class.c
test/blackbox/run_blackbox_tests/test_cases_get_ex_addr.c
test/blackbox/run_blackbox_tests/test_cases_get_fingerprint.c
test/blackbox/run_blackbox_tests/test_cases_get_node.c
test/blackbox/run_blackbox_tests/test_cases_get_port.c
test/blackbox/run_blackbox_tests/test_cases_get_self.c
test/blackbox/run_blackbox_tests/test_cases_hint_address.c
test/blackbox/run_blackbox_tests/test_cases_import.c
test/blackbox/run_blackbox_tests/test_cases_invite.c
test/blackbox/run_blackbox_tests/test_cases_join.c
test/blackbox/run_blackbox_tests/test_cases_key_rotation.c
test/blackbox/run_blackbox_tests/test_cases_open.c
test/blackbox/run_blackbox_tests/test_cases_pmtu.c
test/blackbox/run_blackbox_tests/test_cases_random_port_bindings01.c
test/blackbox/run_blackbox_tests/test_cases_random_port_bindings02.c
test/blackbox/run_blackbox_tests/test_cases_rec_cb.c
test/blackbox/run_blackbox_tests/test_cases_send.c
test/blackbox/run_blackbox_tests/test_cases_set_connection_try_cb.c
test/blackbox/run_blackbox_tests/test_cases_set_log_cb.c
test/blackbox/run_blackbox_tests/test_cases_set_port.c
test/blackbox/run_blackbox_tests/test_cases_sign.c
test/blackbox/run_blackbox_tests/test_cases_start.c
test/blackbox/run_blackbox_tests/test_cases_status_cb.c
test/blackbox/run_blackbox_tests/test_cases_verify.c
test/blackbox/run_blackbox_tests/test_cases_whitelist.c
test/blackbox/run_blackbox_tests/test_optimal_pmtu.c
test/blackbox/test_case_channel_blacklist_01/node_sim_nut_01.c
test/blackbox/test_case_channel_blacklist_01/node_sim_relay_01.c
test/blackbox/test_case_channel_conn_04/node_sim_nut.c
test/blackbox/test_case_channel_conn_05/node_sim_relay.c
test/blackbox/test_case_channel_conn_06/node_sim_relay.c
test/blackbox/test_case_channel_conn_07/node_sim_relay.c
test/blackbox/test_case_channel_conn_08/node_sim_nut.c
test/blackbox/test_case_channel_conn_08/node_sim_relay.c
test/blackbox/test_case_meta_conn_01/node_sim_nut.c
test/blackbox/test_case_meta_conn_01/node_sim_peer.c
test/blackbox/test_case_meta_conn_01/node_sim_relay.c
test/blackbox/test_case_meta_conn_02/node_sim_nut.c
test/blackbox/test_case_meta_conn_02/node_sim_peer.c
test/blackbox/test_case_meta_conn_02/node_sim_relay.c
test/blackbox/test_case_meta_conn_03/node_sim_nut.c
test/blackbox/test_case_meta_conn_03/node_sim_peer.c
test/blackbox/test_case_meta_conn_03/node_sim_relay.c
test/blackbox/test_case_meta_conn_04/node_sim_nut.c
test/blackbox/test_case_meta_conn_04/node_sim_peer.c
test/blackbox/test_case_meta_conn_04/node_sim_relay.c
test/blackbox/test_case_meta_conn_05/node_sim_nut.c
test/blackbox/test_case_meta_conn_05/node_sim_peer.c
test/blackbox/test_case_meta_conn_05/node_sim_relay.c
test/blackbox/test_case_optimal_pmtu_01/node_sim_nut.c
test/blackbox/test_case_optimal_pmtu_01/node_sim_relay.c
test/blackbox/test_cases_submesh04/node_sim_app1node2.c
test/channels-cornercases.c
test/channels-fork.c
test/channels-no-partial.c
test/channels.c
test/duplicate.c
test/import-export.c
test/invite-join.c
test/trio.c
test/trio2.c
test/utils.c

index 70c27004fb4f7216dad47f3f738d1de129477499..0f23de89c617af11a66b8615b9589b878586c712 100644 (file)
@@ -136,7 +136,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_blacklist(mesh, node);
+               if(!meshlink_blacklist(mesh, node)) {
+                       fprintf(stderr, "Error blacklising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
@@ -152,7 +155,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_whitelist(mesh, node);
+               if(!meshlink_whitelist(mesh, node)) {
+                       fprintf(stderr, "Error whitelising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
index 77ba59e60f784ae7180f748d3a6d245362e3b743..88fe127a1df25368512078c89868a0dddc2336c6 100644 (file)
@@ -99,7 +99,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_blacklist(mesh, node);
+               if(!meshlink_blacklist(mesh, node)) {
+                       fprintf(stderr, "Error blacklising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
@@ -115,7 +118,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_whitelist(mesh, node);
+               if(!meshlink_whitelist(mesh, node)) {
+                       fprintf(stderr, "Error whitelising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
index 7a5a300fb526f7f8be3790338e90a10ca3e9831e..c049dd8a49b79ab868dbe39e1cd43d6072b3ae93 100644 (file)
@@ -227,7 +227,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_blacklist(mesh, node);
+               if(!meshlink_blacklist(mesh, node)) {
+                       fprintf(stderr, "Error blacklising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                fprintf(stderr, "Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
 
                fprintf(stderr, "Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
@@ -243,7 +246,10 @@ static void parse_command(meshlink_handle_t *mesh, char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_whitelist(mesh, node);
+               if(!meshlink_whitelist(mesh, node)) {
+                       fprintf(stderr, "Error whitelising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                fprintf(stderr, "Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
 
                fprintf(stderr, "Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
index fbfd215fe171b797aa5d2335c766af54578bf081..d9fb0a41fee1f826458a4a18af3a0d20f24e95d9 100644 (file)
@@ -71,8 +71,11 @@ static void linkmesh() {
 
                for(int j = i + 1; j < n; j++) {
                        char *dataj = meshlink_export(mesh[j]);
 
                for(int j = i + 1; j < n; j++) {
                        char *dataj = meshlink_export(mesh[j]);
-                       meshlink_import(mesh[i], dataj);
-                       meshlink_import(mesh[j], datai);
+
+                       if(!meshlink_import(mesh[i], dataj) || !meshlink_import(mesh[j], datai)) {
+                               fprintf(stderr, "Could not exchange keys between %s and %s: %s\n", mesh[i]->name, mesh[j]->name, meshlink_strerror(meshlink_errno));
+                       }
+
                        free(dataj);
                }
 
                        free(dataj);
                }
 
@@ -248,7 +251,10 @@ static void parse_command(char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_blacklist(mesh[nodeindex], node);
+               if(!meshlink_blacklist(mesh[nodeindex], node)) {
+                       fprintf(stderr, "Error blacklising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
 
                printf("Node '%s' blacklisted.\n", arg);
        } else if(!strcasecmp(buf, "whitelist")) {
@@ -264,7 +270,10 @@ static void parse_command(char *buf) {
                        return;
                }
 
                        return;
                }
 
-               meshlink_whitelist(mesh[nodeindex], node);
+               if(!meshlink_whitelist(mesh[nodeindex], node)) {
+                       fprintf(stderr, "Error whitelising '%s': %s", arg, meshlink_strerror(meshlink_errno));
+                       return;
+               }
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
 
                printf("Node '%s' whitelisted.\n", arg);
        } else if(!strcasecmp(buf, "who")) {
index 2c12ea114220348acecab1763fb2f85998a6acaf..54e82a39ed4099fcc0d5d2bb752970091f333779 100644 (file)
@@ -18,10 +18,18 @@ int main(int argc, char **argv) {
 
        myhandle = meshlink_open(confbase, name, "meshlinkapp", DEV_CLASS_STATIONARY);
 
 
        myhandle = meshlink_open(confbase, name, "meshlinkapp", DEV_CLASS_STATIONARY);
 
+       if(!myhandle) {
+               fprintf(stderr, "Could not open MeshLink: %s", meshlink_strerror(meshlink_errno));
+               return 1;
+       }
+
        //Register callback function for incoming data
        meshlink_set_receive_cb(myhandle, (meshlink_receive_cb_t)handle_recv_data);
 
        //Register callback function for incoming data
        meshlink_set_receive_cb(myhandle, (meshlink_receive_cb_t)handle_recv_data);
 
-       meshlink_start(myhandle);
+       if(!meshlink_start(myhandle)) {
+               fprintf(stderr, "Could not start MeshLink: %s", meshlink_strerror(meshlink_errno));
+               return 1;
+       }
 
        while(1) {
                sleep(10);
 
        while(1) {
                sleep(10);
@@ -39,7 +47,10 @@ int main(int argc, char **argv) {
                strcpy(mydata, "Hello World!");
 
                //send out data
                strcpy(mydata, "Hello World!");
 
                //send out data
-               meshlink_send(myhandle, remotenode, mydata, sizeof(mydata));
+               if(!meshlink_send(myhandle, remotenode, mydata, sizeof(mydata))) {
+                       fprintf(stderr, "Error sending data: %s", meshlink_strerror(meshlink_errno));
+                       return 1;
+               }
        }
 
        meshlink_stop(myhandle);
        }
 
        meshlink_stop(myhandle);
index 11142d8ed919344848a030796505dfc07d5a9935..0678485903f41d7b69627adf862a5c71a576992a 100644 (file)
@@ -9,8 +9,8 @@ AC_DEFUN([MeshLink_ATTRIBUTE],
     CFLAGS="$CFLAGS -Wall -Werror"
     AC_COMPILE_IFELSE(
       [AC_LANG_SOURCE(
     CFLAGS="$CFLAGS -Wall -Werror"
     AC_COMPILE_IFELSE(
       [AC_LANG_SOURCE(
-        [void test(void) __attribute__ (($1));
-        void test(void) { return; }
+        [void *test(void *arg) __attribute__ (($1));
+        void *test(void *arg) { return arg; }
        ],
        )],
        [MeshLink_cv_attribute_$1=yes],
        ],
        )],
        [MeshLink_cv_attribute_$1=yes],
index 7f92048ce30603245946a047a264172861a2e304..9a1387126e8263d29b42bb0605be746718133bb4 100644 (file)
@@ -444,8 +444,9 @@ bool meshlink_confbase_exists(meshlink_handle_t *mesh) {
 
        // Cleanup if current is existing with old and new
        if(confbase_exists && confbase_decryptable) {
 
        // Cleanup if current is existing with old and new
        if(confbase_exists && confbase_decryptable) {
-               config_destroy(mesh->confbase, "old");
-               config_destroy(mesh->confbase, "new");
+               if(!config_destroy(mesh->confbase, "old") || !config_destroy(mesh->confbase, "new")) {
+                       return false;
+               }
        }
 
        return confbase_exists;
        }
 
        return confbase_exists;
index 49598ee5ba33073b7b79bdeb14c8503abac1412f..f3d1e358b0f2376c79cc6da4d717e0c8719f8b55 100644 (file)
@@ -29,32 +29,32 @@ typedef struct config_t {
 
 typedef bool (*config_scan_action_t)(struct meshlink_handle *mesh, const char *name, void *arg);
 
 
 typedef bool (*config_scan_action_t)(struct meshlink_handle *mesh, const char *name, void *arg);
 
-extern bool config_read_file(struct meshlink_handle *mesh, FILE *f, struct config_t *, const void *key);
-extern bool config_write_file(struct meshlink_handle *mesh, FILE *f, const struct config_t *, const void *key);
+extern bool config_read_file(struct meshlink_handle *mesh, FILE *f, struct config_t *, const void *key) __attribute__((__warn_unused_result__));
+extern bool config_write_file(struct meshlink_handle *mesh, FILE *f, const struct config_t *, const void *key) __attribute__((__warn_unused_result__));
 extern void config_free(struct config_t *config);
 
 extern void config_free(struct config_t *config);
 
-extern bool meshlink_confbase_exists(struct meshlink_handle *mesh);
+extern bool meshlink_confbase_exists(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 
-extern bool config_init(struct meshlink_handle *mesh, const char *conf_subdir);
-extern bool config_destroy(const char *confbase, const char *conf_subdir);
-extern bool config_copy(struct meshlink_handle *mesh, const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key);
-extern bool config_rename(struct meshlink_handle *mesh, const char *old_conf_subdir, const char *new_conf_subdir);
-extern bool config_sync(struct meshlink_handle *mesh, const char *conf_subdir);
+extern bool config_init(struct meshlink_handle *mesh, const char *conf_subdir) __attribute__((__warn_unused_result__));
+extern bool config_destroy(const char *confbase, const char *conf_subdir) __attribute__((__warn_unused_result__));
+extern bool config_copy(struct meshlink_handle *mesh, const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key) __attribute__((__warn_unused_result__));
+extern bool config_rename(struct meshlink_handle *mesh, const char *old_conf_subdir, const char *new_conf_subdir) __attribute__((__warn_unused_result__));
+extern bool config_sync(struct meshlink_handle *mesh, const char *conf_subdir) __attribute__((__warn_unused_result__));
 extern bool sync_path(const char *path) __attribute__((__warn_unused_result__));
 
 extern bool sync_path(const char *path) __attribute__((__warn_unused_result__));
 
-extern bool main_config_exists(struct meshlink_handle *mesh, const char *conf_subdir);
-extern bool main_config_lock(struct meshlink_handle *mesh);
+extern bool main_config_exists(struct meshlink_handle *mesh, const char *conf_subdir) __attribute__((__warn_unused_result__));
+extern bool main_config_lock(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 extern void main_config_unlock(struct meshlink_handle *mesh);
 extern void main_config_unlock(struct meshlink_handle *mesh);
-extern bool main_config_read(struct meshlink_handle *mesh, const char *conf_subdir, struct config_t *, void *key);
-extern bool main_config_write(struct meshlink_handle *mesh, const char *conf_subdir, const struct config_t *, void *key);
+extern bool main_config_read(struct meshlink_handle *mesh, const char *conf_subdir, struct config_t *, void *key) __attribute__((__warn_unused_result__));
+extern bool main_config_write(struct meshlink_handle *mesh, const char *conf_subdir, const struct config_t *, void *key) __attribute__((__warn_unused_result__));
 
 
-extern bool config_exists(struct meshlink_handle *mesh, const char *conf_subdir, const char *name);
-extern bool config_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key);
-extern bool config_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key);
-extern bool config_scan_all(struct meshlink_handle *mesh, const char *conf_subdir, const char *conf_type, config_scan_action_t action, void *arg);
+extern bool config_exists(struct meshlink_handle *mesh, const char *conf_subdir, const char *name) __attribute__((__warn_unused_result__));
+extern bool config_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key) __attribute__((__warn_unused_result__));
+extern bool config_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key) __attribute__((__warn_unused_result__));
+extern bool config_scan_all(struct meshlink_handle *mesh, const char *conf_subdir, const char *conf_type, config_scan_action_t action, void *arg) __attribute__((__warn_unused_result__));
 
 
-extern bool invitation_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key);
-extern bool invitation_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key);
+extern bool invitation_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key) __attribute__((__warn_unused_result__));
+extern bool invitation_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key) __attribute__((__warn_unused_result__));
 extern size_t invitation_purge_old(struct meshlink_handle *mesh, time_t deadline);
 
 #endif
 extern size_t invitation_purge_old(struct meshlink_handle *mesh, time_t deadline);
 
 #endif
index ba18e875df95108ef1bfa49c8c0f080868295831..3805e557c634146b87beafd5efa4438260e859b2 100644 (file)
@@ -45,6 +45,6 @@ extern struct splay_tree_t *new_edge_tree(void) __attribute__((__malloc__));
 extern void free_edge_tree(struct splay_tree_t *);
 extern void edge_add(struct meshlink_handle *mesh, edge_t *);
 extern void edge_del(struct meshlink_handle *mesh, edge_t *);
 extern void free_edge_tree(struct splay_tree_t *);
 extern void edge_add(struct meshlink_handle *mesh, edge_t *);
 extern void edge_del(struct meshlink_handle *mesh, edge_t *);
-extern edge_t *lookup_edge(struct node_t *, struct node_t *);
+extern edge_t *lookup_edge(struct node_t *, struct node_t *) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index 245656a338bdf178bad4d0dc01beb25c3c0204e0..8a61e81b2d20899d859b41f8fa21e348a90b6881 100644 (file)
@@ -93,7 +93,7 @@ extern void idle_set(event_loop_t *loop, idle_cb_t cb, void *data);
 
 extern void event_loop_init(event_loop_t *loop);
 extern void event_loop_exit(event_loop_t *loop);
 
 extern void event_loop_init(event_loop_t *loop);
 extern void event_loop_exit(event_loop_t *loop);
-extern bool event_loop_run(event_loop_t *loop, pthread_mutex_t *mutex);
+extern bool event_loop_run(event_loop_t *loop, pthread_mutex_t *mutex) __attribute__((__warn_unused_result__));
 extern void event_loop_flush_output(event_loop_t *loop);
 extern void event_loop_start(event_loop_t *loop);
 extern void event_loop_stop(event_loop_t *loop);
 extern void event_loop_flush_output(event_loop_t *loop);
 extern void event_loop_start(event_loop_t *loop);
 extern void event_loop_stop(event_loop_t *loop);
index db3621b4fc9d89b4fc735bf7e386ce71ba40a3da..7fbd91b534ce2ab88447319b39cebec35f603cc6 100644 (file)
@@ -32,11 +32,11 @@ struct addrinfo {
 #endif /* !HAVE_STRUCT_ADDRINFO */
 
 #if !HAVE_DECL_GETADDRINFO
 #endif /* !HAVE_STRUCT_ADDRINFO */
 
 #if !HAVE_DECL_GETADDRINFO
-int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res);
+int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res) __attribute__((__warn_unused_result__));
 #endif /* !HAVE_GETADDRINFO */
 
 #if !HAVE_DECL_GAI_STRERROR
 #endif /* !HAVE_GETADDRINFO */
 
 #if !HAVE_DECL_GAI_STRERROR
-char *gai_strerror(int ecode);
+char *gai_strerror(int ecode) __attribute__((__warn_unused_result__));
 #endif /* !HAVE_GAI_STRERROR */
 
 #if !HAVE_DECL_FREEADDRINFO
 #endif /* !HAVE_GAI_STRERROR */
 
 #if !HAVE_DECL_FREEADDRINFO
index e6951642922e37a8b684465a66e8bfd25c2d774c..fc1f1d40c1e5faa49a33d335bfc57da16e9354e8 100644 (file)
@@ -2,7 +2,7 @@
 #define MESHLINK_FAKE_GETNAMEINFO_H
 
 #if !HAVE_DECL_GETNAMEINFO
 #define MESHLINK_FAKE_GETNAMEINFO_H
 
 #if !HAVE_DECL_GETNAMEINFO
-int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags);
+int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) __attribute__((__warn_unused_result__));
 #endif /* !HAVE_GETNAMEINFO */
 
 #ifndef NI_MAXSERV
 #endif /* !HAVE_GETNAMEINFO */
 
 #ifndef NI_MAXSERV
index 64673f58cb42dc119ef9eea30e6d2d67826a9b8b..980e5b12c5d4591da998015105c5ee4bb6dae5cd 100644 (file)
@@ -664,11 +664,26 @@ public:
         *  and will not send data to it nor accept any data received from it any more.
         *
         *  @param node         A pointer to a meshlink::node describing the node to be blacklisted.
         *  and will not send data to it nor accept any data received from it any more.
         *
         *  @param node         A pointer to a meshlink::node describing the node to be blacklisted.
+        *
+        *  @return             This function returns true if the node has been whitelisted, false otherwise.
         */
         */
-       void blacklist(node *node) {
+       bool blacklist(node *node) {
                return meshlink_blacklist(handle, node);
        }
 
                return meshlink_blacklist(handle, node);
        }
 
+       /// Whitelist a node on the mesh.
+       /** This function causes the local node to whitelist another node.
+        *  The local node will allow connections to and from that node,
+        *  and will send data to it and accept any data received from it.
+        *
+        *  @param node         A pointer to a meshlink::node describing the node to be whitelisted.
+        *
+        *  @return             This function returns true if the node has been whitelisted, false otherwise.
+        */
+       bool whitelist(node *node) {
+               return meshlink_whitelist(handle, node);
+       }
+
        /// Set the poll callback.
        /** This functions sets the callback that is called whenever data can be sent to another node.
         *  The callback is run in MeshLink's own thread.
        /// Set the poll callback.
        /** This functions sets the callback that is called whenever data can be sent to another node.
         *  The callback is run in MeshLink's own thread.
index e6aea4dd3f708a644e482ee8de504414fd4c3e1d..75458fe6940ed221059e39b29035a2f84de6ccc8 100644 (file)
@@ -1361,7 +1361,11 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) {
        }
 
        add_local_addresses(mesh);
        }
 
        add_local_addresses(mesh);
-       node_write_config(mesh, mesh->self);
+
+       if(!node_write_config(mesh, mesh->self)) {
+               logger(NULL, MESHLINK_ERROR, "Cannot update configuration\n");
+               return NULL;
+       }
 
        idle_set(&mesh->loop, idle, mesh);
 
 
        idle_set(&mesh->loop, idle, mesh);
 
@@ -1550,12 +1554,11 @@ void meshlink_stop(meshlink_handle_t *mesh) {
 
        exit_outgoings(mesh);
 
 
        exit_outgoings(mesh);
 
-       // Write out any changed node config files
+       // Try to write out any changed node config files, ignore errors at this point.
        if(mesh->nodes) {
                for splay_each(node_t, n, mesh->nodes) {
                        if(n->status.dirty) {
        if(mesh->nodes) {
                for splay_each(node_t, n, mesh->nodes) {
                        if(n->status.dirty) {
-                               node_write_config(mesh, n);
-                               n->status.dirty = false;
+                               n->status.dirty = !node_write_config(mesh, n);
                        }
                }
        }
                        }
                }
        }
@@ -2169,11 +2172,15 @@ bool meshlink_set_canonical_address(meshlink_handle_t *mesh, meshlink_node_t *no
        node_t *n = (node_t *)node;
        free(n->canonical_address);
        n->canonical_address = canonical_address;
        node_t *n = (node_t *)node;
        free(n->canonical_address);
        n->canonical_address = canonical_address;
-       node_write_config(mesh, n);
+
+       if(!node_write_config(mesh, n)) {
+               pthread_mutex_unlock(&mesh->mutex);
+               return false;
+       }
 
        pthread_mutex_unlock(&mesh->mutex);
 
 
        pthread_mutex_unlock(&mesh->mutex);
 
-       return true;
+       return config_sync(mesh, "current");
 }
 
 bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) {
 }
 
 bool meshlink_add_address(meshlink_handle_t *mesh, const char *address) {
@@ -2805,7 +2812,11 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
                        break;
                }
 
                        break;
                }
 
-               config_write(mesh, "current", n->name, &config, mesh->config_key);
+               if(!config_write(mesh, "current", n->name, &config, mesh->config_key)) {
+                       free_node(n);
+                       return false;
+               }
+
                node_add(mesh, n);
        }
 
                node_add(mesh, n);
        }
 
@@ -2826,10 +2837,10 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) {
        return true;
 }
 
        return true;
 }
 
-void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
+bool meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
        if(!mesh || !node) {
                meshlink_errno = MESHLINK_EINVAL;
        if(!mesh || !node) {
                meshlink_errno = MESHLINK_EINVAL;
-               return;
+               return false;
        }
 
        pthread_mutex_lock(&mesh->mutex);
        }
 
        pthread_mutex_lock(&mesh->mutex);
@@ -2841,20 +2852,16 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
                logger(mesh, MESHLINK_ERROR, "%s blacklisting itself?\n", node->name);
                meshlink_errno = MESHLINK_EINVAL;
                pthread_mutex_unlock(&mesh->mutex);
                logger(mesh, MESHLINK_ERROR, "%s blacklisting itself?\n", node->name);
                meshlink_errno = MESHLINK_EINVAL;
                pthread_mutex_unlock(&mesh->mutex);
-               return;
+               return false;
        }
 
        if(n->status.blacklisted) {
                logger(mesh, MESHLINK_DEBUG, "Node %s already blacklisted\n", node->name);
                pthread_mutex_unlock(&mesh->mutex);
        }
 
        if(n->status.blacklisted) {
                logger(mesh, MESHLINK_DEBUG, "Node %s already blacklisted\n", node->name);
                pthread_mutex_unlock(&mesh->mutex);
-               return;
+               return true;
        }
 
        n->status.blacklisted = true;
        }
 
        n->status.blacklisted = true;
-       node_write_config(mesh, n);
-       config_sync(mesh, "current");
-
-       logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name);
 
        /* Immediately shut down any connections we have with the blacklisted node.
         * We can't call terminate_connection(), because we might be called from a callback function.
 
        /* Immediately shut down any connections we have with the blacklisted node.
         * We can't call terminate_connection(), because we might be called from a callback function.
@@ -2873,13 +2880,22 @@ void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node) {
        n->mtuprobes = 0;
        n->status.udp_confirmed = false;
 
        n->mtuprobes = 0;
        n->status.udp_confirmed = false;
 
+       if(!node_write_config(mesh, n)) {
+               pthread_mutex_unlock(&mesh->mutex);
+               return false;
+       }
+
+       logger(mesh, MESHLINK_DEBUG, "Blacklisted %s.\n", node->name);
+
        pthread_mutex_unlock(&mesh->mutex);
        pthread_mutex_unlock(&mesh->mutex);
+
+       return config_sync(mesh, "current");
 }
 
 }
 
-void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
+bool meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
        if(!mesh || !node) {
                meshlink_errno = MESHLINK_EINVAL;
        if(!mesh || !node) {
                meshlink_errno = MESHLINK_EINVAL;
-               return;
+               return false;
        }
 
        pthread_mutex_lock(&mesh->mutex);
        }
 
        pthread_mutex_lock(&mesh->mutex);
@@ -2890,27 +2906,31 @@ void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
                logger(mesh, MESHLINK_ERROR, "%s whitelisting itself?\n", node->name);
                meshlink_errno = MESHLINK_EINVAL;
                pthread_mutex_unlock(&mesh->mutex);
                logger(mesh, MESHLINK_ERROR, "%s whitelisting itself?\n", node->name);
                meshlink_errno = MESHLINK_EINVAL;
                pthread_mutex_unlock(&mesh->mutex);
-               return;
+               return false;
        }
 
        if(!n->status.blacklisted) {
                logger(mesh, MESHLINK_DEBUG, "Node %s was already whitelisted\n", node->name);
                pthread_mutex_unlock(&mesh->mutex);
        }
 
        if(!n->status.blacklisted) {
                logger(mesh, MESHLINK_DEBUG, "Node %s was already whitelisted\n", node->name);
                pthread_mutex_unlock(&mesh->mutex);
-               return;
+               return true;
        }
 
        n->status.blacklisted = false;
        }
 
        n->status.blacklisted = false;
-       node_write_config(mesh, n);
-       config_sync(mesh, "current");
 
        if(n->status.reachable) {
                update_node_status(mesh, n);
        }
 
 
        if(n->status.reachable) {
                update_node_status(mesh, n);
        }
 
+       if(!node_write_config(mesh, n)) {
+               pthread_mutex_unlock(&mesh->mutex);
+               return false;
+       }
+
        logger(mesh, MESHLINK_DEBUG, "Whitelisted %s.\n", node->name);
 
        pthread_mutex_unlock(&mesh->mutex);
        logger(mesh, MESHLINK_DEBUG, "Whitelisted %s.\n", node->name);
 
        pthread_mutex_unlock(&mesh->mutex);
-       return;
+
+       return config_sync(mesh, "current");
 }
 
 void meshlink_set_default_blacklist(meshlink_handle_t *mesh, bool blacklist) {
 }
 
 void meshlink_set_default_blacklist(meshlink_handle_t *mesh, bool blacklist) {
@@ -2931,7 +2951,10 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
        node_t *n = (node_t *)node;
        memmove(n->recent + 1, n->recent, 4 * sizeof(*n->recent));
        memcpy(n->recent, addr, SALEN(*addr));
        node_t *n = (node_t *)node;
        memmove(n->recent + 1, n->recent, 4 * sizeof(*n->recent));
        memcpy(n->recent, addr, SALEN(*addr));
-       node_write_config(mesh, n);
+
+       if(!node_write_config(mesh, n)) {
+               logger(mesh, MESHLINK_DEBUG, "Could not update %s\n", n->name);
+       }
 
        pthread_mutex_unlock(&mesh->mutex);
        // @TODO do we want to fire off a connection attempt right away?
 
        pthread_mutex_unlock(&mesh->mutex);
        // @TODO do we want to fire off a connection attempt right away?
index 3d12af6b87b40e4679b426a2015ab1fc1567622f..dd08436d78fd982957612f59896eed48960712b8 100644 (file)
@@ -140,7 +140,7 @@ struct meshlink_channel {
  *                  The pointer is to static storage that is valid for the lifetime of the application.
  *                  This function will always return a valid pointer, even if an invalid error code has been passed.
  */
  *                  The pointer is to static storage that is valid for the lifetime of the application.
  *                  This function will always return a valid pointer, even if an invalid error code has been passed.
  */
-extern const char *meshlink_strerror(meshlink_errno_t err);
+extern const char *meshlink_strerror(meshlink_errno_t err) __attribute__((__warn_unused_result__));
 
 /// Create a new meshlink_open_params_t struct.
 /** This function allocates and initializes a new meshlink_open_params_t struct that can be passed to meshlink_open_ex().
 
 /// Create a new meshlink_open_params_t struct.
 /** This function allocates and initializes a new meshlink_open_params_t struct that can be passed to meshlink_open_ex().
@@ -158,7 +158,7 @@ extern const char *meshlink_strerror(meshlink_errno_t err);
  *  @return         A pointer to a meshlink_open_params_t which can be passed to meshlink_open_ex(), or NULL in case of an error.
  *                  The pointer is valid until meshlink_open_params_free() is called.
  */
  *  @return         A pointer to a meshlink_open_params_t which can be passed to meshlink_open_ex(), or NULL in case of an error.
  *                  The pointer is valid until meshlink_open_params_free() is called.
  */
-extern meshlink_open_params_t *meshlink_open_params_init(const char *confbase, const char *name, const char *appname, dev_class_t devclass);
+extern meshlink_open_params_t *meshlink_open_params_init(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
 
 /// Free a meshlink_open_params_t struct.
 /** This function frees a meshlink_open_params_t struct and all resources associated with it.
 
 /// Free a meshlink_open_params_t struct.
 /** This function frees a meshlink_open_params_t struct and all resources associated with it.
@@ -175,7 +175,7 @@ extern void meshlink_open_params_free(meshlink_open_params_t *params);
  *
  *  @return         This function will return true if the open parameters have been succesfully updated, false otherwise.
  */
  *
  *  @return         This function will return true if the open parameters have been succesfully updated, false otherwise.
  */
-extern bool meshlink_open_params_set_netns(meshlink_open_params_t *params, int netns);
+extern bool meshlink_open_params_set_netns(meshlink_open_params_t *params, int netns) __attribute__((__warn_unused_result__));
 
 /// Set the encryption key MeshLink should use for local storage.
 /** This function changes the open parameters to use the given key for encrypting MeshLink's own configuration files.
 
 /// Set the encryption key MeshLink should use for local storage.
 /** This function changes the open parameters to use the given key for encrypting MeshLink's own configuration files.
@@ -186,7 +186,7 @@ extern bool meshlink_open_params_set_netns(meshlink_open_params_t *params, int n
  *
  *  @return         This function will return true if the open parameters have been succesfully updated, false otherwise.
  */
  *
  *  @return         This function will return true if the open parameters have been succesfully updated, false otherwise.
  */
-extern bool meshlink_open_params_set_storage_key(meshlink_open_params_t *params, const void *key, size_t keylen);
+extern bool meshlink_open_params_set_storage_key(meshlink_open_params_t *params, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
 
 /// Open or create a MeshLink instance.
 /** This function opens or creates a MeshLink instance.
 
 /// Open or create a MeshLink instance.
 /** This function opens or creates a MeshLink instance.
@@ -206,7 +206,7 @@ extern bool meshlink_open_params_set_storage_key(meshlink_open_params_t *params,
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-extern struct meshlink_handle *meshlink_open_ex(const meshlink_open_params_t *params);
+extern struct meshlink_handle *meshlink_open_ex(const meshlink_open_params_t *params) __attribute__((__warn_unused_result__));
 
 /// Open or create a MeshLink instance.
 /** This function opens or creates a MeshLink instance.
 
 /// Open or create a MeshLink instance.
 /** This function opens or creates a MeshLink instance.
@@ -235,7 +235,7 @@ extern struct meshlink_handle *meshlink_open_ex(const meshlink_open_params_t *pa
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-extern struct meshlink_handle *meshlink_open(const char *confbase, const char *name, const char *appname, dev_class_t devclass);
+extern struct meshlink_handle *meshlink_open(const char *confbase, const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
 
 /// Open or create a MeshLink instance that uses encrypted storage.
 /** This function opens or creates a MeshLink instance.
 
 /// Open or create a MeshLink instance that uses encrypted storage.
 /** This function opens or creates a MeshLink instance.
@@ -266,7 +266,7 @@ extern struct meshlink_handle *meshlink_open(const char *confbase, const char *n
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-extern struct meshlink_handle *meshlink_open_encrypted(const char *confbase, const char *name, const char *appname, dev_class_t devclass, const void *key, size_t keylen);
+extern struct meshlink_handle *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__));
 
 /// Create an ephemeral MeshLink instance that does not store any state.
 /** This function creates a MeshLink instance.
 
 /// Create an ephemeral MeshLink instance that does not store any state.
 /** This function creates a MeshLink instance.
@@ -290,7 +290,7 @@ extern struct meshlink_handle *meshlink_open_encrypted(const char *confbase, con
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
  *  @return         A pointer to a struct meshlink_handle which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-extern struct meshlink_handle *meshlink_open_ephemeral(const char *name, const char *appname, dev_class_t devclass);
+extern struct meshlink_handle *meshlink_open_ephemeral(const char *name, const char *appname, dev_class_t devclass) __attribute__((__warn_unused_result__));
 
 /// Create Sub-Mesh.
 /** This function causes MeshLink to open a new Sub-Mesh network
 
 /// Create Sub-Mesh.
 /** This function causes MeshLink to open a new Sub-Mesh network
@@ -306,7 +306,7 @@ extern struct meshlink_handle *meshlink_open_ephemeral(const char *name, const c
  *  @return         A pointer to a struct meshlink_submesh which represents this instance of SubMesh, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
  *  @return         A pointer to a struct meshlink_submesh which represents this instance of SubMesh, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-struct meshlink_submesh *meshlink_submesh_open(struct meshlink_handle *mesh, const char *submesh);
+struct meshlink_submesh *meshlink_submesh_open(struct meshlink_handle *mesh, const char *submesh) __attribute__((__warn_unused_result__));
 
 /// Start MeshLink.
 /** This function causes MeshLink to open network sockets, make outgoing connections, and
 
 /// Start MeshLink.
 /** This function causes MeshLink to open network sockets, make outgoing connections, and
@@ -319,7 +319,7 @@ struct meshlink_submesh *meshlink_submesh_open(struct meshlink_handle *mesh, con
  *
  *  @return         This function will return true if MeshLink has successfully started, false otherwise.
  */
  *
  *  @return         This function will return true if MeshLink has successfully started, false otherwise.
  */
-extern bool meshlink_start(struct meshlink_handle *mesh);
+extern bool meshlink_start(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Stop MeshLink.
 /** This function causes MeshLink to disconnect from all other nodes,
 
 /// Stop MeshLink.
 /** This function causes MeshLink to disconnect from all other nodes,
@@ -357,7 +357,7 @@ extern void meshlink_close(struct meshlink_handle *mesh);
  *
  *  @return         This function will return true if the MeshLink instance was successfully destroyed, false otherwise.
  */
  *
  *  @return         This function will return true if the MeshLink instance was successfully destroyed, false otherwise.
  */
-extern bool meshlink_destroy(const char *confbase);
+extern bool meshlink_destroy(const char *confbase) __attribute__((__warn_unused_result__));
 
 /// A callback for receiving data from the mesh.
 /** @param mesh      A handle which represents an instance of MeshLink.
 
 /// A callback for receiving data from the mesh.
 /** @param mesh      A handle which represents an instance of MeshLink.
@@ -563,7 +563,7 @@ extern void meshlink_set_error_cb(struct meshlink_handle *mesh, meshlink_error_c
  *  @return             This function will return true if MeshLink has queued the message for transmission, and false otherwise.
  *                      A return value of true does not guarantee that the message will actually arrive at the destination.
  */
  *  @return             This function will return true if MeshLink has queued the message for transmission, and false otherwise.
  *                      A return value of true does not guarantee that the message will actually arrive at the destination.
  */
-extern bool meshlink_send(struct meshlink_handle *mesh, struct meshlink_node *destination, const void *data, size_t len);
+extern bool meshlink_send(struct meshlink_handle *mesh, struct meshlink_node *destination, const void *data, size_t len) __attribute__((__warn_unused_result__));
 
 /// Query the maximum packet size that can be sent to a node.
 /** This functions returns the maximum size of packets (path MTU) that can be sent to a specific node with meshlink_send().
 
 /// Query the maximum packet size that can be sent to a node.
 /** This functions returns the maximum size of packets (path MTU) that can be sent to a specific node with meshlink_send().
@@ -579,7 +579,7 @@ extern bool meshlink_send(struct meshlink_handle *mesh, struct meshlink_node *de
  *  @return             The recommended maximum size of packets that are to be sent to the destination node, 0 if the node is unreachable,
  *                      or a negative value in case of an error.
  */
  *  @return             The recommended maximum size of packets that are to be sent to the destination node, 0 if the node is unreachable,
  *                      or a negative value in case of an error.
  */
-extern ssize_t meshlink_get_pmtu(struct meshlink_handle *mesh, struct meshlink_node *destination);
+extern ssize_t meshlink_get_pmtu(struct meshlink_handle *mesh, struct meshlink_node *destination) __attribute__((__warn_unused_result__));
 
 /// Get a handle for our own node.
 /** This function returns a handle for the local node.
 
 /// Get a handle for our own node.
 /** This function returns a handle for the local node.
@@ -590,7 +590,7 @@ extern ssize_t meshlink_get_pmtu(struct meshlink_handle *mesh, struct meshlink_n
  *  @return             A pointer to a struct meshlink_node which represents the local node.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
  *  @return             A pointer to a struct meshlink_node which represents the local node.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
-extern struct meshlink_node *meshlink_get_self(struct meshlink_handle *mesh);
+extern struct meshlink_node *meshlink_get_self(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Get a handle for a specific node.
 /** This function returns a handle for the node with the given name.
 
 /// Get a handle for a specific node.
 /** This function returns a handle for the node with the given name.
@@ -604,7 +604,7 @@ extern struct meshlink_node *meshlink_get_self(struct meshlink_handle *mesh);
  *                      or NULL if the requested node does not exist.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
  *                      or NULL if the requested node does not exist.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
-extern struct meshlink_node *meshlink_get_node(struct meshlink_handle *mesh, const char *name);
+extern struct meshlink_node *meshlink_get_node(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
 
 /// Get a handle for a specific submesh.
 /** This function returns a handle for the submesh with the given name.
 
 /// Get a handle for a specific submesh.
 /** This function returns a handle for the submesh with the given name.
@@ -618,7 +618,7 @@ extern struct meshlink_node *meshlink_get_node(struct meshlink_handle *mesh, con
  *                      or NULL if the requested submesh does not exist.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
  *                      or NULL if the requested submesh does not exist.
  *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  */
-extern struct meshlink_submesh *meshlink_get_submesh(struct meshlink_handle *mesh, const char *name);
+extern struct meshlink_submesh *meshlink_get_submesh(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
 
 /// Get the fingerprint of a node's public key.
 /** This function returns a fingerprint of the node's public key.
 
 /// Get the fingerprint of a node's public key.
 /** This function returns a fingerprint of the node's public key.
@@ -631,7 +631,7 @@ extern struct meshlink_submesh *meshlink_get_submesh(struct meshlink_handle *mes
  *  @return             A nul-terminated C string containing the fingerprint of the node's public key in a printable ASCII format.
  *                      The application should call free() after it is done using this string.
  */
  *  @return             A nul-terminated C string containing the fingerprint of the node's public key in a printable ASCII format.
  *                      The application should call free() after it is done using this string.
  */
-extern char *meshlink_get_fingerprint(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern char *meshlink_get_fingerprint(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
 /// Get a list of all nodes.
 /** This function returns a list with handles for all known nodes.
 
 /// Get a list of all nodes.
 /** This function returns a list with handles for all known nodes.
@@ -651,7 +651,7 @@ extern char *meshlink_get_fingerprint(struct meshlink_handle *mesh, struct meshl
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
-extern struct meshlink_node **meshlink_get_all_nodes(struct meshlink_handle *mesh, struct meshlink_node **nodes, size_t *nmemb);
+extern struct meshlink_node **meshlink_get_all_nodes(struct meshlink_handle *mesh, struct meshlink_node **nodes, size_t *nmemb) __attribute__((__warn_unused_result__));
 
 /// Sign data using the local node's MeshLink key.
 /** This function signs data using the local node's MeshLink key.
 
 /// Sign data using the local node's MeshLink key.
 /** This function signs data using the local node's MeshLink key.
@@ -668,7 +668,7 @@ extern struct meshlink_node **meshlink_get_all_nodes(struct meshlink_handle *mes
  *
  *  @return             This function returns true if the signature was correctly generated, false otherwise.
  */
  *
  *  @return             This function returns true if the signature was correctly generated, false otherwise.
  */
-extern bool meshlink_sign(struct meshlink_handle *mesh, const void *data, size_t len, void *signature, size_t *siglen);
+extern bool meshlink_sign(struct meshlink_handle *mesh, const void *data, size_t len, void *signature, size_t *siglen) __attribute__((__warn_unused_result__));
 
 /// Get the list of all nodes by device class.
 /** This function returns a list with handles for all the nodes that matches with the given @a devclass.
 
 /// Get the list of all nodes by device class.
 /** This function returns a list with handles for all the nodes that matches with the given @a devclass.
@@ -689,7 +689,7 @@ extern bool meshlink_sign(struct meshlink_handle *mesh, const void *data, size_t
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
-extern struct meshlink_node **meshlink_get_all_nodes_by_dev_class(struct meshlink_handle *mesh, dev_class_t devclass, struct meshlink_node **nodes, size_t *nmemb);
+extern struct meshlink_node **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__));
 
 /// Get the list of all nodes by Submesh.
 /** This function returns a list with handles for all the nodes that matches with the given @a Submesh.
 
 /// Get the list of all nodes by Submesh.
 /** This function returns a list with handles for all the nodes that matches with the given @a Submesh.
@@ -710,7 +710,7 @@ extern struct meshlink_node **meshlink_get_all_nodes_by_dev_class(struct meshlin
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
  *                      If it is a new value, the old value of @a nodes should not be used anymore.
  *                      If the new value is NULL, then the old array will have been freed by MeshLink.
  */
-extern struct meshlink_node **meshlink_get_all_nodes_by_submesh(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, struct meshlink_node **nodes, size_t *nmemb);
+extern struct meshlink_node **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__));
 
 /// Get the node's device class.
 /** This function returns the device class of the given node.
 
 /// Get the node's device class.
 /** This function returns the device class of the given node.
@@ -721,7 +721,7 @@ extern struct meshlink_node **meshlink_get_all_nodes_by_submesh(struct meshlink_
  *
  *  @return              This function returns the device class of the @a node, or -1 in case of an error.
  */
  *
  *  @return              This function returns the device class of the @a node, or -1 in case of an error.
  */
-extern dev_class_t meshlink_get_node_dev_class(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern dev_class_t meshlink_get_node_dev_class(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
 /// Get the node's submesh handle.
 /** This function returns the submesh handle of the given node.
 
 /// Get the node's submesh handle.
 /** This function returns the submesh handle of the given node.
@@ -732,7 +732,7 @@ extern dev_class_t meshlink_get_node_dev_class(struct meshlink_handle *mesh, str
  *
  *  @return              This function returns the submesh handle of the @a node, or NULL in case of an error.
  */
  *
  *  @return              This function returns the submesh handle of the @a node, or NULL in case of an error.
  */
-extern struct meshlink_submesh *meshlink_get_node_submesh(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern struct meshlink_submesh *meshlink_get_node_submesh(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
 /// Verify the signature generated by another node of a piece of data.
 /** This function verifies the signature that another node generated for a piece of data.
 
 /// Verify the signature generated by another node of a piece of data.
 /** This function verifies the signature that another node generated for a piece of data.
@@ -748,7 +748,7 @@ extern struct meshlink_submesh *meshlink_get_node_submesh(struct meshlink_handle
  *
  *  @return             This function returns true if the signature is valid, false otherwise.
  */
  *
  *  @return             This function returns true if the signature is valid, false otherwise.
  */
-extern bool meshlink_verify(struct meshlink_handle *mesh, struct meshlink_node *source, const void *data, size_t len, const void *signature, size_t siglen);
+extern bool 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__));
 
 /// Set the canonical Address for a node.
 /** This function sets the canonical Address for a node.
 
 /// Set the canonical Address for a node.
 /** This function sets the canonical Address for a node.
@@ -768,7 +768,7 @@ extern bool meshlink_verify(struct meshlink_handle *mesh, struct meshlink_node *
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
-extern bool meshlink_set_canonical_address(struct meshlink_handle *mesh, struct meshlink_node *node, const char *address, const char *port);
+extern bool meshlink_set_canonical_address(struct meshlink_handle *mesh, struct meshlink_node *node, const char *address, const char *port) __attribute__((__warn_unused_result__));
 
 /// Add an Address for the local node.
 /** This function adds an Address for the local node, which will be used for invitation URLs.
 
 /// Add an Address for the local node.
 /** This function adds an Address for the local node, which will be used for invitation URLs.
@@ -779,7 +779,7 @@ extern bool meshlink_set_canonical_address(struct meshlink_handle *mesh, struct
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
-extern bool meshlink_add_address(struct meshlink_handle *mesh, const char *address);
+extern bool meshlink_add_address(struct meshlink_handle *mesh, const char *address) __attribute__((__warn_unused_result__));
 
 /// Try to discover the external address for the local node.
 /** This function performs tries to discover the local node's external address
 
 /// Try to discover the external address for the local node.
 /** This function performs tries to discover the local node's external address
@@ -803,7 +803,7 @@ extern bool meshlink_add_address(struct meshlink_handle *mesh, const char *addre
  *                      or NULL if there was an error looking up the address.
  *                      After meshlink_get_external_address() returns, the application is free to overwrite or free this string.
  */
  *                      or NULL if there was an error looking up the address.
  *                      After meshlink_get_external_address() returns, the application is free to overwrite or free this string.
  */
-extern char *meshlink_get_external_address(struct meshlink_handle *mesh);
+extern char *meshlink_get_external_address(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Try to discover the external address for the local node.
 /** This function performs tries to discover the local node's external address
 
 /// Try to discover the external address for the local node.
 /** This function performs tries to discover the local node's external address
@@ -829,7 +829,7 @@ extern char *meshlink_get_external_address(struct meshlink_handle *mesh);
  *                         or NULL if there was an error looking up the address.
  *                         After meshlink_get_external_address_for_family() returns, the application is free to overwrite or free this string.
  */
  *                         or NULL if there was an error looking up the address.
  *                         After meshlink_get_external_address_for_family() returns, the application is free to overwrite or free this string.
  */
-extern char *meshlink_get_external_address_for_family(struct meshlink_handle *mesh, int address_family);
+extern char *meshlink_get_external_address_for_family(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
 
 /// Try to discover the local address for the local node.
 /** This function performs tries to discover the address of the local interface used for outgoing connection.
 
 /// Try to discover the local address for the local node.
 /** This function performs tries to discover the address of the local interface used for outgoing connection.
@@ -852,7 +852,7 @@ extern char *meshlink_get_external_address_for_family(struct meshlink_handle *me
  *                         or NULL if there was an error looking up the address.
  *                         After meshlink_get_local_address_for_family() returns, the application is free to overwrite or free this string.
  */
  *                         or NULL if there was an error looking up the address.
  *                         After meshlink_get_local_address_for_family() returns, the application is free to overwrite or free this string.
  */
-extern char *meshlink_get_local_address_for_family(struct meshlink_handle *mesh, int address_family);
+extern char *meshlink_get_local_address_for_family(struct meshlink_handle *mesh, int address_family) __attribute__((__warn_unused_result__));
 
 /// Try to discover the external address for the local node, and add it to its list of addresses.
 /** This function is equivalent to:
 
 /// Try to discover the external address for the local node, and add it to its list of addresses.
 /** This function is equivalent to:
@@ -866,7 +866,7 @@ extern char *meshlink_get_local_address_for_family(struct meshlink_handle *mesh,
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
  *
  *  @return             This function returns true if the address was added, false otherwise.
  */
-extern bool meshlink_add_external_address(struct meshlink_handle *mesh);
+extern bool meshlink_add_external_address(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Get the network port used by the local node.
 /** This function returns the network port that the local node is listening on.
 
 /// Get the network port used by the local node.
 /** This function returns the network port that the local node is listening on.
@@ -876,7 +876,7 @@ extern bool meshlink_add_external_address(struct meshlink_handle *mesh);
  *
  *  @return              This function returns the port number, or -1 in case of an error.
  */
  *
  *  @return              This function returns the port number, or -1 in case of an error.
  */
-extern int meshlink_get_port(struct meshlink_handle *mesh);
+extern int meshlink_get_port(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Set the network port used by the local node.
 /** This function sets the network port that the local node is listening on.
 
 /// Set the network port used by the local node.
 /** This function sets the network port that the local node is listening on.
@@ -897,7 +897,7 @@ extern int meshlink_get_port(struct meshlink_handle *mesh);
  *                       is no guarantee that MeshLink is listening on the old port.
  */
 
  *                       is no guarantee that MeshLink is listening on the old port.
  */
 
-extern bool meshlink_set_port(struct meshlink_handle *mesh, int port);
+extern bool meshlink_set_port(struct meshlink_handle *mesh, int port) __attribute__((__warn_unused_result__));
 
 /// Set the timeout for invitations.
 /** This function sets the timeout for invitations.
 
 /// Set the timeout for invitations.
 /** This function sets the timeout for invitations.
@@ -926,7 +926,7 @@ extern void meshlink_set_invitation_timeout(struct meshlink_handle *mesh, int ti
  *  @return             This function returns a nul-terminated C string that contains the invitation URL, or NULL in case of an error.
  *                      The application should call free() after it has finished using the URL.
  */
  *  @return             This function returns a nul-terminated C string that contains the invitation URL, or NULL in case of an error.
  *                      The application should call free() after it has finished using the URL.
  */
-extern char *meshlink_invite_ex(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name, uint32_t flags);
+extern char *meshlink_invite_ex(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name, uint32_t flags) __attribute__((__warn_unused_result__));
 
 /// Invite another node into the mesh.
 /** This function generates an invitation that can be used by another node to join the same mesh as the local node.
 
 /// Invite another node into the mesh.
 /** This function generates an invitation that can be used by another node to join the same mesh as the local node.
@@ -945,7 +945,7 @@ extern char *meshlink_invite_ex(struct meshlink_handle *mesh, struct meshlink_su
  *  @return             This function returns a nul-terminated C string that contains the invitation URL, or NULL in case of an error.
  *                      The application should call free() after it has finished using the URL.
  */
  *  @return             This function returns a nul-terminated C string that contains the invitation URL, or NULL in case of an error.
  *                      The application should call free() after it has finished using the URL.
  */
-extern char *meshlink_invite(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name);
+extern char *meshlink_invite(struct meshlink_handle *mesh, struct meshlink_submesh *submesh, const char *name) __attribute__((__warn_unused_result__));
 
 /// Use an invitation to join a mesh.
 /** This function allows the local node to join an existing mesh using an invitation URL generated by another node.
 
 /// Use an invitation to join a mesh.
 /** This function allows the local node to join an existing mesh using an invitation URL generated by another node.
@@ -965,7 +965,7 @@ extern char *meshlink_invite(struct meshlink_handle *mesh, struct meshlink_subme
  *
  *  @return             This function returns true if the local node joined the mesh it was invited to, false otherwise.
  */
  *
  *  @return             This function returns true if the local node joined the mesh it was invited to, false otherwise.
  */
-extern bool meshlink_join(struct meshlink_handle *mesh, const char *invitation);
+extern bool meshlink_join(struct meshlink_handle *mesh, const char *invitation) __attribute__((__warn_unused_result__));
 
 /// Export the local node's key and addresses.
 /** This function generates a string that contains the local node's public key and one or more IP addresses.
 
 /// Export the local node's key and addresses.
 /** This function generates a string that contains the local node's public key and one or more IP addresses.
@@ -981,7 +981,7 @@ extern bool meshlink_join(struct meshlink_handle *mesh, const char *invitation);
  *  @return             This function returns a nul-terminated C string that contains the exported key and addresses, or NULL in case of an error.
  *                      The application should call free() after it has finished using this string.
  */
  *  @return             This function returns a nul-terminated C string that contains the exported key and addresses, or NULL in case of an error.
  *                      The application should call free() after it has finished using this string.
  */
-extern char *meshlink_export(struct meshlink_handle *mesh);
+extern char *meshlink_export(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 
 /// Import another node's key and addresses.
 /** This function accepts a string containing the exported public key and addresses of another node.
 
 /// Import another node's key and addresses.
 /** This function accepts a string containing the exported public key and addresses of another node.
@@ -997,7 +997,7 @@ extern char *meshlink_export(struct meshlink_handle *mesh);
  *
  *  @return             This function returns true if the data was valid and the other node has been granted access to the mesh, false otherwise.
  */
  *
  *  @return             This function returns true if the data was valid and the other node has been granted access to the mesh, false otherwise.
  */
-extern bool meshlink_import(struct meshlink_handle *mesh, const char *data);
+extern bool meshlink_import(struct meshlink_handle *mesh, const char *data) __attribute__((__warn_unused_result__));
 
 /// Blacklist a node from the mesh.
 /** This function causes the local node to blacklist another node.
 
 /// Blacklist a node from the mesh.
 /** This function causes the local node to blacklist another node.
@@ -1007,8 +1007,10 @@ extern bool meshlink_import(struct meshlink_handle *mesh, const char *data);
  *  \memberof meshlink_node
  *  @param mesh         A handle which represents an instance of MeshLink.
  *  @param node         A pointer to a struct meshlink_node describing the node to be blacklisted.
  *  \memberof meshlink_node
  *  @param mesh         A handle which represents an instance of MeshLink.
  *  @param node         A pointer to a struct meshlink_node describing the node to be blacklisted.
+ *
+ *  @return             This function returns true if the node has been blacklisted, false otherwise.
  */
  */
-extern void meshlink_blacklist(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern bool meshlink_blacklist(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
 /// Whitelist a node on the mesh.
 /** This function causes the local node to whitelist a previously blacklisted node.
 
 /// Whitelist a node on the mesh.
 /** This function causes the local node to whitelist a previously blacklisted node.
@@ -1018,8 +1020,10 @@ extern void meshlink_blacklist(struct meshlink_handle *mesh, struct meshlink_nod
  *  \memberof meshlink_node
  *  @param mesh         A handle which represents an instance of MeshLink.
  *  @param node         A pointer to a struct meshlink_node describing the node to be whitelisted.
  *  \memberof meshlink_node
  *  @param mesh         A handle which represents an instance of MeshLink.
  *  @param node         A pointer to a struct meshlink_node describing the node to be whitelisted.
+ *
+ *  @return             This function returns true if the node has been whitelisted, false otherwise.
  */
  */
-extern void meshlink_whitelist(struct meshlink_handle *mesh, struct meshlink_node *node);
+extern bool meshlink_whitelist(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
 /// Set whether new nodes are blacklisted by default.
 /** This function sets the blacklist behaviour for newly discovered nodes.
 
 /// Set whether new nodes are blacklisted by default.
 /** This function sets the blacklist behaviour for newly discovered nodes.
@@ -1179,7 +1183,7 @@ extern void meshlink_set_channel_rcvbuf(struct meshlink_handle *mesh, struct mes
  *  @return             A handle for the channel, or NULL in case of an error.
  *                      The handle is valid until meshlink_channel_close() is called.
  */
  *  @return             A handle for the channel, or NULL in case of an error.
  *                      The handle is valid until meshlink_channel_close() is called.
  */
-extern struct meshlink_channel *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);
+extern struct meshlink_channel *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__));
 
 /// Open a reliable stream channel to another node.
 /** This function is called whenever a remote node wants to open a channel to the local node.
 
 /// Open a reliable stream channel to another node.
 /** This function is called whenever a remote node wants to open a channel to the local node.
@@ -1206,7 +1210,7 @@ extern struct meshlink_channel *meshlink_channel_open_ex(struct meshlink_handle
  *  @return             A handle for the channel, or NULL in case of an error.
  *                      The handle is valid until meshlink_channel_close() is called.
  */
  *  @return             A handle for the channel, or NULL in case of an error.
  *                      The handle is valid until meshlink_channel_close() is called.
  */
-extern struct meshlink_channel *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);
+extern struct meshlink_channel *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__));
 
 /// Partially close a reliable stream channel.
 /** This shuts down the read or write side of a channel, or both, without closing the handle.
 
 /// Partially close a reliable stream channel.
 /** This shuts down the read or write side of a channel, or both, without closing the handle.
@@ -1251,7 +1255,7 @@ extern void meshlink_channel_close(struct meshlink_handle *mesh, struct meshlink
  *                      If MESHLINK_CHANNEL_NO_PARTIAL is set, then the result will either be len,
  *                      0 if the buffer is currently too full, or -1 if len is too big even for an empty buffer.
  */
  *                      If MESHLINK_CHANNEL_NO_PARTIAL is set, then the result will either be len,
  *                      0 if the buffer is currently too full, or -1 if len is too big even for an empty buffer.
  */
-extern ssize_t meshlink_channel_send(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len);
+extern ssize_t meshlink_channel_send(struct meshlink_handle *mesh, struct meshlink_channel *channel, const void *data, size_t len) __attribute__((__warn_unused_result__));
 
 /// A callback for cleaning up buffers submitted for asynchronous I/O.
 /** This callbacks signals that MeshLink has finished using this buffer.
 
 /// A callback for cleaning up buffers submitted for asynchronous I/O.
 /** This callbacks signals that MeshLink has finished using this buffer.
@@ -1293,7 +1297,7 @@ typedef void (*meshlink_aio_fd_cb_t)(struct meshlink_handle *mesh, struct meshli
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
-extern bool 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);
+extern bool 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__));
 
 /// Transmit data on a channel asynchronously from a filedescriptor
 /** This will read up to the specified length number of bytes from the given filedescriptor, and send it over the channel.
 
 /// Transmit data on a channel asynchronously from a filedescriptor
 /** This will read up to the specified length number of bytes from the given filedescriptor, and send it over the channel.
@@ -1310,7 +1314,7 @@ extern bool meshlink_channel_aio_send(struct meshlink_handle *mesh, struct meshl
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
-extern bool 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);
+extern bool 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__));
 
 /// Receive data on a channel asynchronously
 /** This registers a buffer that will be filled with incoming channel data.
 
 /// Receive data on a channel asynchronously
 /** This registers a buffer that will be filled with incoming channel data.
@@ -1329,7 +1333,7 @@ extern bool meshlink_channel_aio_fd_send(struct meshlink_handle *mesh, struct me
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
-extern bool 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);
+extern bool 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__));
 
 /// Receive data on a channel asynchronously and send it to a filedescriptor
 /** This will read up to the specified length number of bytes from the channel, and send it to the filedescriptor.
 
 /// Receive data on a channel asynchronously and send it to a filedescriptor
 /** This will read up to the specified length number of bytes from the channel, and send it to the filedescriptor.
@@ -1346,7 +1350,7 @@ extern bool meshlink_channel_aio_receive(struct meshlink_handle *mesh, struct me
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
  *
  *  @return             True if the buffer was enqueued, false otherwise.
  */
-extern bool 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);
+extern bool 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__));
 
 /// Get channel flags.
 /** This returns the flags used when opening this channel.
 
 /// Get channel flags.
 /** This returns the flags used when opening this channel.
@@ -1357,7 +1361,7 @@ extern bool meshlink_channel_aio_fd_receive(struct meshlink_handle *mesh, struct
  *
  *  @return             The flags set for this channel.
  */
  *
  *  @return             The flags set for this channel.
  */
-extern uint32_t meshlink_channel_get_flags(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+extern uint32_t meshlink_channel_get_flags(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
 
 /// Get the amount of bytes in the send buffer.
 /** This returns the amount of bytes in the send buffer.
 
 /// Get the amount of bytes in the send buffer.
 /** This returns the amount of bytes in the send buffer.
@@ -1369,7 +1373,7 @@ extern uint32_t meshlink_channel_get_flags(struct meshlink_handle *mesh, struct
  *
  *  @return             The amount of un-ACKed bytes in the send buffer.
  */
  *
  *  @return             The amount of un-ACKed bytes in the send buffer.
  */
-extern size_t meshlink_channel_get_sendq(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+extern size_t meshlink_channel_get_sendq(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
 
 /// Get the amount of bytes in the receive buffer.
 /** This returns the amount of bytes in the receive buffer.
 
 /// Get the amount of bytes in the receive buffer.
 /** This returns the amount of bytes in the receive buffer.
@@ -1381,7 +1385,7 @@ extern size_t meshlink_channel_get_sendq(struct meshlink_handle *mesh, struct me
  *
  *  @return             The amount of bytes in the receive buffer.
  */
  *
  *  @return             The amount of bytes in the receive buffer.
  */
-extern size_t meshlink_channel_get_recvq(struct meshlink_handle *mesh, struct meshlink_channel *channel);
+extern size_t meshlink_channel_get_recvq(struct meshlink_handle *mesh, struct meshlink_channel *channel) __attribute__((__warn_unused_result__));
 
 /// Set the connection timeout used for channels to the given node.
 /** This sets the timeout after which unresponsive channels will be reported as closed.
 
 /// Set the connection timeout used for channels to the given node.
 /** This sets the timeout after which unresponsive channels will be reported as closed.
@@ -1429,7 +1433,7 @@ extern void meshlink_enable_discovery(struct meshlink_handle *mesh, bool enable)
  *
  *  @return         This function returns true if the key rotation for the encrypted storage succeeds, false otherwise.
  */
  *
  *  @return         This function returns true if the key rotation for the encrypted storage succeeds, false otherwise.
  */
-extern bool meshlink_encrypted_key_rotate(struct meshlink_handle *mesh, const void *key, size_t keylen);
+extern bool meshlink_encrypted_key_rotate(struct meshlink_handle *mesh, const void *key, size_t keylen) __attribute__((__warn_unused_result__));
 
 /// Set device class timeouts
 /** This sets the ping interval and timeout for a given device class.
 
 /// Set device class timeouts
 /** This sets the ping interval and timeout for a given device class.
index 764f4162c4b62728752ca042ea3e5a1808adfb14..d075f1c8497b887ea17cc0e171c39a6c4fcda7f0 100644 (file)
@@ -49,7 +49,7 @@ static inline void meshlink_queue_exit(meshlink_queue_t *queue) {
        pthread_mutex_destroy(&queue->mutex);
 }
 
        pthread_mutex_destroy(&queue->mutex);
 }
 
-static inline bool meshlink_queue_push(meshlink_queue_t *queue, void *data) {
+static inline __attribute__((__warn_unused_result__)) bool meshlink_queue_push(meshlink_queue_t *queue, void *data) {
        meshlink_queue_item_t *item = malloc(sizeof(*item));
 
        if(!item) {
        meshlink_queue_item_t *item = malloc(sizeof(*item));
 
        if(!item) {
@@ -70,7 +70,7 @@ static inline bool meshlink_queue_push(meshlink_queue_t *queue, void *data) {
        return true;
 }
 
        return true;
 }
 
-static inline void *meshlink_queue_pop(meshlink_queue_t *queue) {
+static inline __attribute__((__warn_unused_result__)) void *meshlink_queue_pop(meshlink_queue_t *queue) {
        meshlink_queue_item_t *item;
        void *data;
        pthread_mutex_lock(&queue->mutex);
        meshlink_queue_item_t *item;
        void *data;
        pthread_mutex_lock(&queue->mutex);
index 88e601a3fb9f98a3694bbb524df46c126ca5b7db..768c7acf8a98396871009eace22b306a72d26658 100644 (file)
@@ -28,6 +28,6 @@ extern bool receive_meta_sptps(void *, uint8_t, const void *, uint16_t);
 extern void broadcast_meta(struct meshlink_handle *mesh, struct connection_t *, const char *, int);
 extern void broadcast_submesh_meta(struct meshlink_handle *mesh, connection_t *from, submesh_t *s,
                                    const char *buffer, int length);
 extern void broadcast_meta(struct meshlink_handle *mesh, struct connection_t *, const char *, int);
 extern void broadcast_submesh_meta(struct meshlink_handle *mesh, connection_t *from, submesh_t *s,
                                    const char *buffer, int length);
-extern bool receive_meta(struct meshlink_handle *mesh, struct connection_t *);
+extern bool receive_meta(struct meshlink_handle *mesh, struct connection_t *) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index 80490efadb785ab59db7cb6e8a43e850008b9131..b9f441a0d0b9b774d3ab7fb914395dca3b9ba9d5 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -604,7 +604,10 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
        for splay_each(node_t, n, mesh->nodes) {
                if(n->status.dirty) {
 
        for splay_each(node_t, n, mesh->nodes) {
                if(n->status.dirty) {
-                       node_write_config(mesh, n);
+                       if(node_write_config(mesh, n)) {
+                               logger(mesh, MESHLINK_DEBUG, "Could not update %s", n->name);
+                       }
+
                        n->status.dirty = false;
                }
        }
                        n->status.dirty = false;
                }
        }
@@ -696,7 +699,7 @@ void retry(meshlink_handle_t *mesh) {
 /*
   this is where it all happens...
 */
 /*
   this is where it all happens...
 */
-int main_loop(meshlink_handle_t *mesh) {
+void main_loop(meshlink_handle_t *mesh) {
        timeout_add(&mesh->loop, &mesh->pingtimer, timeout_handler, &mesh->pingtimer, &(struct timeval) {
                default_timeout, prng(mesh, TIMER_FUDGE)
        });
        timeout_add(&mesh->loop, &mesh->pingtimer, timeout_handler, &mesh->pingtimer, &(struct timeval) {
                default_timeout, prng(mesh, TIMER_FUDGE)
        });
@@ -710,17 +713,10 @@ int main_loop(meshlink_handle_t *mesh) {
 
        if(!event_loop_run(&mesh->loop, &mesh->mutex)) {
                logger(mesh, MESHLINK_ERROR, "Error while waiting for input: %s", strerror(errno));
 
        if(!event_loop_run(&mesh->loop, &mesh->mutex)) {
                logger(mesh, MESHLINK_ERROR, "Error while waiting for input: %s", strerror(errno));
-               abort();
-               signal_del(&mesh->loop, &mesh->datafromapp);
-               timeout_del(&mesh->loop, &mesh->periodictimer);
-               timeout_del(&mesh->loop, &mesh->pingtimer);
-
-               return 1;
+               call_error_cb(mesh, MESHLINK_ENETWORK);
        }
 
        signal_del(&mesh->loop, &mesh->datafromapp);
        timeout_del(&mesh->loop, &mesh->periodictimer);
        timeout_del(&mesh->loop, &mesh->pingtimer);
        }
 
        signal_del(&mesh->loop, &mesh->datafromapp);
        timeout_del(&mesh->loop, &mesh->periodictimer);
        timeout_del(&mesh->loop, &mesh->pingtimer);
-
-       return 0;
 }
 }
index 4da61bd4f2320a5abfa78c8bfd6e93df7b50017c..262696d823a7522c7656a70d1dc20ddd222ec9b3 100644 (file)
--- a/src/net.h
+++ b/src/net.h
@@ -82,26 +82,26 @@ extern void exit_outgoings(struct meshlink_handle *mesh);
 extern void retry_outgoing(struct meshlink_handle *mesh, outgoing_t *);
 extern void handle_incoming_vpn_data(struct event_loop_t *loop, void *, int);
 extern void finish_connecting(struct meshlink_handle *mesh, struct connection_t *);
 extern void retry_outgoing(struct meshlink_handle *mesh, outgoing_t *);
 extern void handle_incoming_vpn_data(struct event_loop_t *loop, void *, int);
 extern void finish_connecting(struct meshlink_handle *mesh, struct connection_t *);
-extern bool do_outgoing_connection(struct meshlink_handle *mesh, struct outgoing_t *);
+extern void do_outgoing_connection(struct meshlink_handle *mesh, struct outgoing_t *);
 extern void handle_new_meta_connection(struct event_loop_t *loop, void *, int);
 extern void handle_new_meta_connection(struct event_loop_t *loop, void *, int);
-extern int setup_listen_socket(const sockaddr_t *);
-extern int setup_vpn_in_socket(struct meshlink_handle *mesh, const sockaddr_t *);
+extern int setup_listen_socket(const sockaddr_t *) __attribute__((__warn_unused_result__));
+extern int setup_vpn_in_socket(struct meshlink_handle *mesh, const sockaddr_t *) __attribute__((__warn_unused_result__));
 extern bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len);
 extern bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len);
-extern bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len);
+extern bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) __attribute__((__warn_unused_result__));
 extern void send_packet(struct meshlink_handle *mesh, struct node_t *, struct vpn_packet_t *);
 extern void send_packet(struct meshlink_handle *mesh, struct node_t *, struct vpn_packet_t *);
-extern char *get_name(struct meshlink_handle *mesh);
+extern char *get_name(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 extern void load_all_nodes(struct meshlink_handle *mesh);
 extern void load_all_nodes(struct meshlink_handle *mesh);
-extern bool setup_myself_reloadable(struct meshlink_handle *mesh);
-extern bool setup_network(struct meshlink_handle *mesh);
+extern bool setup_myself_reloadable(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern bool setup_network(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
 extern void setup_outgoing_connection(struct meshlink_handle *mesh, struct outgoing_t *);
 extern void close_network_connections(struct meshlink_handle *mesh);
 extern void setup_outgoing_connection(struct meshlink_handle *mesh, struct outgoing_t *);
 extern void close_network_connections(struct meshlink_handle *mesh);
-extern int main_loop(struct meshlink_handle *mesh);
+extern void main_loop(struct meshlink_handle *mesh);
 extern void terminate_connection(struct meshlink_handle *mesh, struct connection_t *, bool);
 extern void terminate_connection(struct meshlink_handle *mesh, struct connection_t *, bool);
-extern bool node_read_public_key(struct meshlink_handle *mesh, struct node_t *);
-extern bool node_read_from_config(struct meshlink_handle *mesh, struct node_t *, const config_t *config);
-extern bool read_ecdsa_public_key(struct meshlink_handle *mesh, struct connection_t *);
-extern bool read_ecdsa_private_key(struct meshlink_handle *mesh);
-extern bool node_write_config(struct meshlink_handle *mesh, struct node_t *);
+extern bool node_read_public_key(struct meshlink_handle *mesh, struct node_t *) __attribute__((__warn_unused_result__));
+extern bool node_read_from_config(struct meshlink_handle *mesh, struct node_t *, const config_t *config) __attribute__((__warn_unused_result__));
+extern bool read_ecdsa_public_key(struct meshlink_handle *mesh, struct connection_t *) __attribute__((__warn_unused_result__));
+extern bool read_ecdsa_private_key(struct meshlink_handle *mesh) __attribute__((__warn_unused_result__));
+extern bool node_write_config(struct meshlink_handle *mesh, struct node_t *) __attribute__((__warn_unused_result__));
 extern void send_mtu_probe(struct meshlink_handle *mesh, struct node_t *);
 extern void handle_meta_connection_data(struct meshlink_handle *mesh, struct connection_t *);
 extern void retry(struct meshlink_handle *mesh);
 extern void send_mtu_probe(struct meshlink_handle *mesh, struct node_t *);
 extern void handle_meta_connection_data(struct meshlink_handle *mesh, struct connection_t *);
 extern void retry(struct meshlink_handle *mesh);
index a2709553fb9893f555d548cc57a8c62372730289..953887a53d3eed52c741c76712fb7ccffb42f263 100644 (file)
@@ -256,7 +256,9 @@ static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *
                return;
        }
 
                return;
        }
 
-       sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
+       if(!sptps_receive_data(&n->sptps, inpkt->data, inpkt->len)) {
+               logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", n->name, strerror(errno));
+       }
 }
 
 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
 }
 
 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
index aeceb1f892d00fb58789fc25415674aea34b845c..559f0496579ba38540c01635416160ca60c2d2a8 100644 (file)
@@ -116,7 +116,6 @@ bool node_read_public_key(meshlink_handle_t *mesh, node_t *n) {
                n->recent[i + known_count] = packmsg_get_sockaddr(&in);
        }
 
                n->recent[i + known_count] = packmsg_get_sockaddr(&in);
        }
 
-
        config_free(&config);
        return true;
 }
        config_free(&config);
        return true;
 }
@@ -233,6 +232,7 @@ bool node_write_config(meshlink_handle_t *mesh, node_t *n) {
        }
 
        if(!packmsg_output_ok(&out)) {
        }
 
        if(!packmsg_output_ok(&out)) {
+               meshlink_errno = MESHLINK_EINTERNAL;
                return false;
        }
 
                return false;
        }
 
@@ -402,7 +402,9 @@ bool setup_myself(meshlink_handle_t *mesh) {
 
        graph(mesh);
 
 
        graph(mesh);
 
-       config_scan_all(mesh, "current", "hosts", load_node, NULL);
+       if(!config_scan_all(mesh, "current", "hosts", load_node, NULL)) {
+               logger(mesh, MESHLINK_WARNING, "Could not scan all host config files");
+       }
 
        /* Open sockets */
 
 
        /* Open sockets */
 
index 51e0caccfd19c1696cf5bf69c8c0aa4f7ed87189..31bc608f1d43fd56f346d9d2736de43c3b79e951 100644 (file)
@@ -493,7 +493,7 @@ static bool get_next_outgoing_address(meshlink_handle_t *mesh, outgoing_t *outgo
        return false;
 }
 
        return false;
 }
 
-bool do_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
+void do_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
        struct addrinfo *proxyai = NULL;
        int result;
 
        struct addrinfo *proxyai = NULL;
        int result;
 
@@ -507,7 +507,7 @@ begin:
                        retry_outgoing(mesh, outgoing);
                }
 
                        retry_outgoing(mesh, outgoing);
                }
 
-               return false;
+               return;
        }
 
        connection_t *c = new_connection();
        }
 
        connection_t *c = new_connection();
@@ -586,8 +586,6 @@ begin:
        connection_add(mesh, c);
 
        io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ | IO_WRITE);
        connection_add(mesh, c);
 
        io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ | IO_WRITE);
-
-       return true;
 }
 
 void setup_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
 }
 
 void setup_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
index ebba1ac3c27c3b2553712d906b37990e2c677bb9..6c777bdec39fc05647c55900520591b81ee6bf22 100644 (file)
@@ -27,14 +27,14 @@ extern struct addrinfo *str2addrinfo(const char *, const char *, int) __attribut
 extern sockaddr_t str2sockaddr(const char *, const char *);
 extern void sockaddr2str(const sockaddr_t *, char **, char **);
 extern char *sockaddr2hostname(const sockaddr_t *) __attribute__((__malloc__));
 extern sockaddr_t str2sockaddr(const char *, const char *);
 extern void sockaddr2str(const sockaddr_t *, char **, char **);
 extern char *sockaddr2hostname(const sockaddr_t *) __attribute__((__malloc__));
-extern int sockaddrcmp(const sockaddr_t *, const sockaddr_t *);
-extern int sockaddrcmp_noport(const sockaddr_t *, const sockaddr_t *);
+extern int sockaddrcmp(const sockaddr_t *, const sockaddr_t *) __attribute__((__warn_unused_result__));
+extern int sockaddrcmp_noport(const sockaddr_t *, const sockaddr_t *) __attribute__((__warn_unused_result__));
 extern void sockaddrunmap(sockaddr_t *);
 extern void sockaddrfree(sockaddr_t *);
 extern void sockaddrcpy(sockaddr_t *, const sockaddr_t *);
 extern void sockaddrcpy_setport(sockaddr_t *, const sockaddr_t *, uint16_t port);
 
 extern void packmsg_add_sockaddr(struct packmsg_output *out, const sockaddr_t *);
 extern void sockaddrunmap(sockaddr_t *);
 extern void sockaddrfree(sockaddr_t *);
 extern void sockaddrcpy(sockaddr_t *, const sockaddr_t *);
 extern void sockaddrcpy_setport(sockaddr_t *, const sockaddr_t *, uint16_t port);
 
 extern void packmsg_add_sockaddr(struct packmsg_output *out, const sockaddr_t *);
-extern sockaddr_t packmsg_get_sockaddr(struct packmsg_input *in);
+extern sockaddr_t packmsg_get_sockaddr(struct packmsg_input *in) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index 28464520aabcf4fc4e907f5044092a0058925bc7..d307e5f26094de6bf96476adb87be83a43f59349 100644 (file)
@@ -100,8 +100,8 @@ extern node_t *new_node(void) __attribute__((__malloc__));
 extern void free_node(node_t *n);
 extern void node_add(struct meshlink_handle *mesh, node_t *n);
 extern void node_del(struct meshlink_handle *mesh, node_t *n);
 extern void free_node(node_t *n);
 extern void node_add(struct meshlink_handle *mesh, node_t *n);
 extern void node_del(struct meshlink_handle *mesh, node_t *n);
-extern node_t *lookup_node(struct meshlink_handle *mesh, const char *name);
-extern node_t *lookup_node_udp(struct meshlink_handle *mesh, const sockaddr_t *sa);
+extern node_t *lookup_node(struct meshlink_handle *mesh, const char *name) __attribute__((__warn_unused_result__));
+extern node_t *lookup_node_udp(struct meshlink_handle *mesh, const sockaddr_t *sa) __attribute__((__warn_unused_result__));
 extern void update_node_udp(struct meshlink_handle *mesh, node_t *n, const sockaddr_t *sa);
 
 #endif
 extern void update_node_udp(struct meshlink_handle *mesh, node_t *n, const sockaddr_t *sa);
 
 #endif
index 7adf2f916a2ef3d873d7716b5d90edad8ecaf2dc..a145722df79b646e2bc2442cca42f989483f0e8f 100644 (file)
@@ -173,7 +173,7 @@ static inline size_t packmsg_output_size(const packmsg_output_t *buf, const uint
  * \return     True if all read operations performed on the input buffer so far have completed successfully,
  *             false if any error has occurred.
  */
  * \return     True if all read operations performed on the input buffer so far have completed successfully,
  *             false if any error has occurred.
  */
-static inline bool packmsg_input_ok(const packmsg_input_t *buf) {
+static inline __attribute__((__warn_unused_result__)) bool packmsg_input_ok(const packmsg_input_t *buf) {
        assert(buf);
 
        return packmsg_likely(buf->len >= 0);
        assert(buf);
 
        return packmsg_likely(buf->len >= 0);
@@ -192,7 +192,7 @@ static inline bool packmsg_input_ok(const packmsg_input_t *buf) {
  *             false if there is still data remaining in the input buffer,
  *             or if any error has occurred.
  */
  *             false if there is still data remaining in the input buffer,
  *             or if any error has occurred.
  */
-static inline bool packmsg_done(const packmsg_input_t *buf) {
+static inline __attribute__((__warn_unused_result__)) bool packmsg_done(const packmsg_input_t *buf) {
        assert(buf);
 
        return buf->len == 0;
        assert(buf);
 
        return buf->len == 0;
index 47aacd990f1966fb1a6dc0a04219311c55d9fea8..f97682a1717af4277fc460f01f31b88fd8d8a562 100644 (file)
@@ -87,7 +87,6 @@ extern bool send_ping(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_pong(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_add_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *, int contradictions);
 extern bool send_del_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *, int contradictions);
 extern bool send_pong(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_add_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *, int contradictions);
 extern bool send_del_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *, int contradictions);
-extern void send_key_changed(struct meshlink_handle *mesh);
 extern bool send_req_key(struct meshlink_handle *mesh, struct node_t *);
 
 /* Request handlers  */
 extern bool send_req_key(struct meshlink_handle *mesh, struct node_t *);
 
 /* Request handlers  */
index beeef54e289045da4de1cb3c6d7e405360def36e..e80af7d94a7c3f246e9267eb5fde93d6fd4b534d 100644 (file)
@@ -343,9 +343,7 @@ bool id_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
                return false;
        }
 
                return false;
        }
 
-       node_read_public_key(mesh, n);
-
-       if(!ecdsa_active(n->ecdsa)) {
+       if(!node_read_public_key(mesh, n)) {
                logger(mesh, MESHLINK_ERROR, "No key known for peer %s", c->name);
 
                if(n->status.reachable && !n->status.waitingforkey) {
                logger(mesh, MESHLINK_ERROR, "No key known for peer %s", c->name);
 
                if(n->status.reachable && !n->status.waitingforkey) {
index 641e2b969434c8941a5ca752b9dca69822175dea..8a1d6000947df5057953c5212c44529ebb2b5026 100644 (file)
 
 static const int req_key_timeout = 2;
 
 
 static const int req_key_timeout = 2;
 
-void send_key_changed(meshlink_handle_t *mesh) {
-       send_request(mesh, mesh->everyone, NULL, "%d %x %s", KEY_CHANGED, prng(mesh, UINT_MAX), mesh->self->name);
-
-       /* Force key exchange for connections using SPTPS */
-
-       for splay_each(node_t, n, mesh->nodes)
-               if(n->status.reachable && n->status.validkey) {
-                       sptps_force_kex(&n->sptps);
-               }
-}
-
 bool key_changed_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        assert(request);
        assert(*request);
 bool key_changed_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        assert(request);
        assert(*request);
@@ -188,8 +177,17 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char *
                from->status.validkey = false;
                from->status.waitingforkey = true;
                from->last_req_key = mesh->loop.now.tv_sec;
                from->status.validkey = false;
                from->status.waitingforkey = true;
                from->last_req_key = mesh->loop.now.tv_sec;
-               sptps_start(&from->sptps, from, false, true, mesh->private_key, from->ecdsa, label, sizeof(label) - 1, send_sptps_data, receive_sptps_record);
-               sptps_receive_data(&from->sptps, buf, len);
+
+               if(!sptps_start(&from->sptps, from, false, true, mesh->private_key, from->ecdsa, label, sizeof(label) - 1, send_sptps_data, receive_sptps_record)) {
+                       logger(mesh, MESHLINK_ERROR, "Could not start SPTPS session with %s: %s", from->name, strerror(errno));
+                       return true;
+               }
+
+               if(!sptps_receive_data(&from->sptps, buf, len)) {
+                       logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", from->name, strerror(errno));
+                       return true;
+               }
+
                return true;
        }
 
                return true;
        }
 
@@ -207,7 +205,11 @@ static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char *
                        return true;
                }
 
                        return true;
                }
 
-               sptps_receive_data(&from->sptps, buf, len);
+               if(!sptps_receive_data(&from->sptps, buf, len)) {
+                       logger(mesh, MESHLINK_ERROR, "Could not process SPTPS data from %s: %s", from->name, strerror(errno));
+                       return true;
+               }
+
                return true;
        }
 
                return true;
        }
 
index 66ac564a4a3d6bf6fbfc31d35f926c37af6cd71b..c91d3882b428d09ea5c4d4f9154941a83a0727ed 100644 (file)
@@ -90,11 +90,11 @@ typedef struct sptps {
 extern void sptps_log_quiet(sptps_t *s, int s_errno, const char *format, va_list ap);
 extern void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap);
 extern void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap);
 extern void sptps_log_quiet(sptps_t *s, int s_errno, const char *format, va_list ap);
 extern void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap);
 extern void (*sptps_log)(sptps_t *s, int s_errno, const char *format, va_list ap);
-extern bool sptps_start(sptps_t *s, void *handle, bool initiator, bool datagram, ecdsa_t *mykey, ecdsa_t *hiskey, const char *label, size_t labellen, send_data_t send_data, receive_record_t receive_record);
+extern bool sptps_start(sptps_t *s, void *handle, bool initiator, bool datagram, ecdsa_t *mykey, ecdsa_t *hiskey, const char *label, size_t labellen, send_data_t send_data, receive_record_t receive_record) __attribute__((__warn_unused_result__));
 extern bool sptps_stop(sptps_t *s);
 extern bool sptps_send_record(sptps_t *s, uint8_t type, const void *data, uint16_t len);
 extern bool sptps_stop(sptps_t *s);
 extern bool sptps_send_record(sptps_t *s, uint8_t type, const void *data, uint16_t len);
-extern bool sptps_receive_data(sptps_t *s, const void *data, size_t len);
-extern bool sptps_force_kex(sptps_t *s);
-extern bool sptps_verify_datagram(sptps_t *s, const void *data, size_t len);
+extern bool sptps_receive_data(sptps_t *s, const void *data, size_t len) __attribute__((__warn_unused_result__));
+extern bool sptps_force_kex(sptps_t *s) __attribute__((__warn_unused_result__));
+extern bool sptps_verify_datagram(sptps_t *s, const void *data, size_t len) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index d6122d8fd10f3bf8aedcbef7da26fe1aaf5eaf2a..15720aab604747d4b9d22bc392b47710145d91f1 100644 (file)
@@ -33,9 +33,9 @@ typedef struct submesh_t {
 
 extern void init_submeshes(struct meshlink_handle *mesh);
 extern void exit_submeshes(struct meshlink_handle *mesh);
 
 extern void init_submeshes(struct meshlink_handle *mesh);
 extern void exit_submeshes(struct meshlink_handle *mesh);
-extern submesh_t *create_submesh(struct meshlink_handle *mesh, const char *);
-extern submesh_t *lookup_submesh(struct meshlink_handle *mesh, const char *);
-extern submesh_t *lookup_or_create_submesh(struct meshlink_handle *mesh, const char *);
-extern bool submesh_allows_node(const submesh_t *submesh, const struct node_t *node);
+extern submesh_t *create_submesh(struct meshlink_handle *mesh, const char *) __attribute__((__warn_unused_result__));
+extern submesh_t *lookup_submesh(struct meshlink_handle *mesh, const char *) __attribute__((__warn_unused_result__));
+extern submesh_t *lookup_or_create_submesh(struct meshlink_handle *mesh, const char *) __attribute__((__warn_unused_result__));
+extern bool submesh_allows_node(const submesh_t *submesh, const struct node_t *node) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index 371a327df08d3286dd75dd4047ead817426d7fa0..6c01e6ae84262b68347dc370449d6cdabda57fab 100644 (file)
@@ -45,6 +45,6 @@ extern const char *winerror(int);
 #define sockinuse(x) ((x) == EADDRINUSE)
 #endif
 
 #define sockinuse(x) ((x) == EADDRINUSE)
 #endif
 
-extern unsigned int bitfield_to_int(const void *bitfield, size_t size);
+extern unsigned int bitfield_to_int(const void *bitfield, size_t size) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index fcd5192c0d1a49ea23f261d262303879ac19317a..03d5620a53c8ed09e0bd0358d0357e155ee1c38d 100644 (file)
@@ -1,6 +1,6 @@
 #ifndef MESHLINK_XOSHIRO_H
 #define MESHLINK_XOSHIRO_H
 
 #ifndef MESHLINK_XOSHIRO_H
 #define MESHLINK_XOSHIRO_H
 
-extern uint64_t xoshiro(uint64_t s[4]);
+extern uint64_t xoshiro(uint64_t s[4]) __attribute__((__warn_unused_result__));
 
 #endif
 
 #endif
index 4d13928af5b490f97edf594a999fab5f97b4cea3..02453efda08450d9df411ac4d1805f53c2a81bf1 100644 (file)
@@ -72,7 +72,7 @@ static void test_case_mesh_add_address_01(void **state) {
 */
 static bool test_steps_mesh_add_address_01(void) {
        char *node = "foo";
 */
 static bool test_steps_mesh_add_address_01(void) {
        char *node = "foo";
-       meshlink_destroy("add_conf.1");
+       assert(meshlink_destroy("add_conf.1"));
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("add_conf.1", node, "chat", DEV_CLASS_STATIONARY);
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("add_conf.1", node, "chat", DEV_CLASS_STATIONARY);
@@ -100,7 +100,7 @@ static bool test_steps_mesh_add_address_01(void) {
 
        // Clean up
        meshlink_close(mesh);
 
        // Clean up
        meshlink_close(mesh);
-       meshlink_destroy("add_conf.1");
+       assert(meshlink_destroy("add_conf.1"));
        return true;
 }
 
        return true;
 }
 
@@ -141,7 +141,7 @@ static void test_case_mesh_add_address_03(void **state) {
     meshlink_add_address API returns false by reporting error successfully.
 */
 static bool test_steps_mesh_add_address_03(void) {
     meshlink_add_address API returns false by reporting error successfully.
 */
 static bool test_steps_mesh_add_address_03(void) {
-       meshlink_destroy("add_conf.3");
+       assert(meshlink_destroy("add_conf.3"));
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("add_conf.3", "foo", "chat", DEV_CLASS_STATIONARY);
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("add_conf.3", "foo", "chat", DEV_CLASS_STATIONARY);
@@ -151,7 +151,7 @@ static bool test_steps_mesh_add_address_03(void) {
        assert_int_equal(result, false);
 
        meshlink_close(mesh);
        assert_int_equal(result, false);
 
        meshlink_close(mesh);
-       meshlink_destroy("add_conf.3");
+       assert(meshlink_destroy("add_conf.3"));
        return true;
 }
 
        return true;
 }
 
index c78690952045f79cddb3223277a593d7c9c7f97a..894d3d3f36ce0a5243ab65f5a09079f60b46b496 100644 (file)
@@ -65,7 +65,7 @@ void test_case_mesh_add_ex_address_01(void **state) {
     meshlink_add_external_address API adds the new address given to it's confbase
 */
 bool test_steps_mesh_add_ex_address_01(void) {
     meshlink_add_external_address API adds the new address given to it's confbase
 */
 bool test_steps_mesh_add_ex_address_01(void) {
-       meshlink_destroy("addex_conf.1");
+       assert(meshlink_destroy("addex_conf.1"));
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("addex_conf.1", "foo", "test", DEV_CLASS_STATIONARY);
 
        // Create node instance
        meshlink_handle_t *mesh = meshlink_open("addex_conf.1", "foo", "test", DEV_CLASS_STATIONARY);
@@ -94,7 +94,7 @@ bool test_steps_mesh_add_ex_address_01(void) {
        assert_int_equal(found, true);
 
        meshlink_close(mesh);
        assert_int_equal(found, true);
 
        meshlink_close(mesh);
-       meshlink_destroy("addex_conf.1");
+       assert(meshlink_destroy("addex_conf.1"));
        return true;
 }
 
        return true;
 }
 
index d8b7e490f916a79df7447539444cb07269684f55..f9c27717f16d84a4c905b1a9ecccfc108ccf2020 100644 (file)
@@ -101,8 +101,8 @@ bool test_steps_mesh_autoconnect(void) {
        char *invite = NULL;
        meshlink_node_t *node = NULL;
 
        char *invite = NULL;
        meshlink_node_t *node = NULL;
 
-       meshlink_destroy("m1n1");
-       meshlink_destroy("m1n2");
+       assert(meshlink_destroy("m1n1"));
+       assert(meshlink_destroy("m1n2"));
 
        // Open two new meshlink instance.
        mesh1 = meshlink_open("m1n1", "m1n1", "autoconnect", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        mesh1 = meshlink_open("m1n1", "m1n1", "autoconnect", DEV_CLASS_BACKBONE);
@@ -129,7 +129,7 @@ bool test_steps_mesh_autoconnect(void) {
        assert(wait_sync_flag(&test_autoconnect_m1n1_reachable, 30));
 
        node = meshlink_get_node(mesh2, "m1n1");
        assert(wait_sync_flag(&test_autoconnect_m1n1_reachable, 30));
 
        node = meshlink_get_node(mesh2, "m1n1");
-       meshlink_blacklist(mesh2, node);
+       assert(meshlink_blacklist(mesh2, node));
        set_sync_flag(&test_autoconnect_blacklisted, true);
 
        assert(wait_sync_flag(&test_autoconnect_successful, 60));
        set_sync_flag(&test_autoconnect_blacklisted, true);
 
        assert(wait_sync_flag(&test_autoconnect_successful, 60));
@@ -140,8 +140,8 @@ bool test_steps_mesh_autoconnect(void) {
        meshlink_close(mesh2);
        fprintf(stderr, "Meshlink node2 closed\n");
 
        meshlink_close(mesh2);
        fprintf(stderr, "Meshlink node2 closed\n");
 
-       meshlink_destroy("m1n1");
-       meshlink_destroy("m1n2");
+       assert(meshlink_destroy("m1n1"));
+       assert(meshlink_destroy("m1n2"));
        fprintf(stderr, "Meshlink nodes destroyed\n");
 
        return true;
        fprintf(stderr, "Meshlink nodes destroyed\n");
 
        return true;
index 1990893068c35b17d97e52912300901c50d52826..8f9a118cafa43ca0f9be5d211c2d4be650c0a266 100644 (file)
@@ -99,8 +99,8 @@ static void status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reach
     but when enabled foo node should not receive data
 */
 bool test_steps_mesh_blacklist_01(void) {
     but when enabled foo node should not receive data
 */
 bool test_steps_mesh_blacklist_01(void) {
-       meshlink_destroy("blacklist_conf.1");
-       meshlink_destroy("blacklist_conf.2");
+       assert(meshlink_destroy("blacklist_conf.1"));
+       assert(meshlink_destroy("blacklist_conf.2"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("blacklist_conf.1", "foo", "blacklist", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("blacklist_conf.1", "foo", "blacklist", DEV_CLASS_BACKBONE);
@@ -136,7 +136,7 @@ bool test_steps_mesh_blacklist_01(void) {
        sleep(1);
        assert(received);
 
        sleep(1);
        assert(received);
 
-       meshlink_blacklist(mesh1, bar);
+       assert(meshlink_blacklist(mesh1, bar));
 
        received = false;
        assert(meshlink_send(mesh2, foo, "test", 5));
 
        received = false;
        assert(meshlink_send(mesh2, foo, "test", 5));
@@ -146,8 +146,8 @@ bool test_steps_mesh_blacklist_01(void) {
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("blacklist_conf.1");
-       meshlink_destroy("blacklist_conf.2");
+       assert(meshlink_destroy("blacklist_conf.1"));
+       assert(meshlink_destroy("blacklist_conf.2"));
        return true;
 }
 
        return true;
 }
 
@@ -166,7 +166,7 @@ void test_case_mesh_blacklist_02(void **state) {
     meshlink_blacklist API handles the invalid parameter when called by giving proper error number.
 */
 bool test_steps_mesh_blacklist_02(void) {
     meshlink_blacklist API handles the invalid parameter when called by giving proper error number.
 */
 bool test_steps_mesh_blacklist_02(void) {
-       meshlink_destroy("blacklist_conf.3");
+       assert(meshlink_destroy("blacklist_conf.3"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("blacklist_conf.3", "foo", "blacklist", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("blacklist_conf.3", "foo", "blacklist", DEV_CLASS_BACKBONE);
@@ -176,12 +176,12 @@ bool test_steps_mesh_blacklist_02(void) {
        assert(node);
 
        // Passing NULL as mesh handle and node handle being some valid node handle
        assert(node);
 
        // Passing NULL as mesh handle and node handle being some valid node handle
-       meshlink_blacklist(NULL, node);
+       assert(!meshlink_blacklist(NULL, node));
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
        meshlink_close(mesh);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
        meshlink_close(mesh);
-       meshlink_destroy("blacklist_conf.3");
+       assert(meshlink_destroy("blacklist_conf.3"));
        return true;
 }
 
        return true;
 }
 
@@ -200,19 +200,19 @@ void test_case_mesh_blacklist_03(void **state) {
     meshlink_blacklist API handles the invalid parameter when called by giving proper error number.
 */
 bool test_steps_mesh_blacklist_03(void) {
     meshlink_blacklist API handles the invalid parameter when called by giving proper error number.
 */
 bool test_steps_mesh_blacklist_03(void) {
-       meshlink_destroy("blacklist_conf.4");
+       assert(meshlink_destroy("blacklist_conf.4"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("blacklist_conf.4", "foo", "blacklist", DEV_CLASS_BACKBONE);
        assert(mesh != NULL);
 
        // Passing NULL as node handle and mesh handle being some valid mesh handle value
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("blacklist_conf.4", "foo", "blacklist", DEV_CLASS_BACKBONE);
        assert(mesh != NULL);
 
        // Passing NULL as node handle and mesh handle being some valid mesh handle value
-       meshlink_blacklist(mesh, NULL);
+       assert(!meshlink_blacklist(mesh, NULL));
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
        meshlink_close(mesh);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
        meshlink_close(mesh);
-       meshlink_destroy("blacklist_conf.4");
+       assert(meshlink_destroy("blacklist_conf.4"));
        return true;
 }
 
        return true;
 }
 
index 333f3a990a79be3de8dab0e3a9b37e092efe1b16..568a475b0682264da910deb3cbc10c695e3461f6 100644 (file)
@@ -66,9 +66,9 @@ static int setup_test(void **state) {
        netns_create_topology(test_channel_disconnection_state);
        fprintf(stderr, "\nCreated topology\n");
 
        netns_create_topology(test_channel_disconnection_state);
        fprintf(stderr, "\nCreated topology\n");
 
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
        channel_discon_case_ping = false;
        channel_discon_network_failure_01 = false;
        channel_discon_network_failure_02 = false;
        channel_discon_case_ping = false;
        channel_discon_network_failure_01 = false;
        channel_discon_network_failure_02 = false;
@@ -81,9 +81,9 @@ static int setup_test(void **state) {
 static int teardown_test(void **state) {
        (void)state;
 
 static int teardown_test(void **state) {
        (void)state;
 
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
        netns_destroy_topology(test_channel_disconnection_state);
 
        return EXIT_SUCCESS;
        netns_destroy_topology(test_channel_disconnection_state);
 
        return EXIT_SUCCESS;
index 1f6e3a029d1e6af3dc4e0705249e8bddb65e605f..9f2c9c93cb7267eb6ca1381f5bc66ba8a2620236 100644 (file)
@@ -56,8 +56,8 @@ static void test_case_mesh_channel_close_01(void **state) {
 
 /* Test Steps for meshlink_channel_close Test Case # 1*/
 static bool test_steps_mesh_channel_close_01(void) {
 
 /* Test Steps for meshlink_channel_close Test Case # 1*/
 static bool test_steps_mesh_channel_close_01(void) {
-       meshlink_destroy("chan_close_conf.3");
-       meshlink_destroy("chan_close_conf.4");
+       assert(meshlink_destroy("chan_close_conf.3"));
+       assert(meshlink_destroy("chan_close_conf.4"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("chan_close_conf.3", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("chan_close_conf.3", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -100,8 +100,8 @@ static bool test_steps_mesh_channel_close_01(void) {
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("chan_close_conf.3");
-       meshlink_destroy("chan_close_conf.4");
+       assert(meshlink_destroy("chan_close_conf.3"));
+       assert(meshlink_destroy("chan_close_conf.4"));
        return true;
 }
 
        return true;
 }
 
@@ -113,7 +113,7 @@ static void test_case_mesh_channel_close_02(void **state) {
 
 /* Test Steps for meshlink_channel_close Test Case # 2*/
 static bool test_steps_mesh_channel_close_02(void) {
 
 /* Test Steps for meshlink_channel_close Test Case # 2*/
 static bool test_steps_mesh_channel_close_02(void) {
-       meshlink_destroy("chan_close_conf.5");
+       assert(meshlink_destroy("chan_close_conf.5"));
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh = meshlink_open("chan_close_conf.5", "foo", "channels", DEV_CLASS_BACKBONE);
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh = meshlink_open("chan_close_conf.5", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -129,7 +129,7 @@ static bool test_steps_mesh_channel_close_02(void) {
        // Clean up.
 
        meshlink_close(mesh);
        // Clean up.
 
        meshlink_close(mesh);
-       meshlink_destroy("chan_close_conf.5");
+       assert(meshlink_destroy("chan_close_conf.5"));
        return true;
 }
 
        return true;
 }
 
index 9f539cffb05b512a815fbaf33794354cb6683345..74c3a3e66b3012afb56e019fee2e7429731d6fff 100644 (file)
@@ -164,7 +164,7 @@ static bool test_steps_channel_ex_01(void) {
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
 
        return true;
 }
 
        return true;
 }
@@ -217,7 +217,7 @@ static bool test_steps_channel_ex_02(void) {
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
        return true;
 }
 
        return true;
 }
 
@@ -269,7 +269,7 @@ static bool test_steps_channel_ex_03(void) {
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
        return true;
 }
 
        return true;
 }
 
@@ -321,7 +321,7 @@ static bool test_steps_channel_ex_04(void) {
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
        assert_int_equal(ret, true);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
        return true;
 }
 
        return true;
 }
 
@@ -361,7 +361,7 @@ static bool test_steps_channel_ex_05(void) {
        assert(channel == NULL);
 
        meshlink_close(mesh_handle);
        assert(channel == NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
        return true;
 }
 
        return true;
 }
 
@@ -399,7 +399,7 @@ static bool test_steps_channel_ex_06(void) {
        assert_int_equal(channel, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(channel, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelexconf");
+       assert(meshlink_destroy("channelexconf"));
        return true;
 }
 
        return true;
 }
 
index 9ae6dfdfb358f403f081f49102938dc50ffddd7b..5bb268396027beabc0fa7037d0a3b057eec037a8 100644 (file)
@@ -96,7 +96,7 @@ static bool test_steps_channel_get_flags_01(void) {
        assert_int_equal(flags, MESHLINK_CHANNEL_TCP);
 
        meshlink_close(mesh_handle);
        assert_int_equal(flags, MESHLINK_CHANNEL_TCP);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getflagsconf");
+       assert(meshlink_destroy("getflagsconf"));
 
        return true;
 }
 
        return true;
 }
@@ -145,7 +145,7 @@ static bool test_steps_channel_get_flags_02(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getflagsconf");
+       assert(meshlink_destroy("getflagsconf"));
        return true;
 }
 
        return true;
 }
 
@@ -181,7 +181,7 @@ static bool test_steps_channel_get_flags_03(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getflagsconf");
+       assert(meshlink_destroy("getflagsconf"));
        return true;
 }
 
        return true;
 }
 
index 89c69ba91595c02838c2361736ae5e577f64677e..9792aec561750ee44490372cc632a3203d781ebe 100644 (file)
@@ -78,8 +78,8 @@ static void test_case_mesh_channel_open_01(void **state) {
     meshlink_channel_open should open a channel by returning a channel handler
 */
 static bool test_steps_mesh_channel_open_01(void) {
     meshlink_channel_open should open a channel by returning a channel handler
 */
 static bool test_steps_mesh_channel_open_01(void) {
-       meshlink_destroy("channels_conf.1");
-       meshlink_destroy("channels_conf.2");
+       assert(meshlink_destroy("channels_conf.1"));
+       assert(meshlink_destroy("channels_conf.2"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("channels_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("channels_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -111,8 +111,8 @@ static bool test_steps_mesh_channel_open_01(void) {
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("channels_conf.1");
-       meshlink_destroy("channels_conf.2");
+       assert(meshlink_destroy("channels_conf.1"));
+       assert(meshlink_destroy("channels_conf.2"));
        return true;
 }
 
        return true;
 }
 
@@ -132,8 +132,8 @@ static void test_case_mesh_channel_open_02(void **state) {
 
 /* Test Steps for meshlink_channel_open Test Case # 2*/
 static bool test_steps_mesh_channel_open_02(void) {
 
 /* Test Steps for meshlink_channel_open Test Case # 2*/
 static bool test_steps_mesh_channel_open_02(void) {
-       meshlink_destroy("channels_conf.3");
-       meshlink_destroy("channels_conf.4");
+       assert(meshlink_destroy("channels_conf.3"));
+       assert(meshlink_destroy("channels_conf.4"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("channels_conf.3", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("channels_conf.3", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -166,8 +166,8 @@ static bool test_steps_mesh_channel_open_02(void) {
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
        // Clean up.
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("channels_conf.3");
-       meshlink_destroy("channels_conf.4");
+       assert(meshlink_destroy("channels_conf.3"));
+       assert(meshlink_destroy("channels_conf.4"));
        return true;
 }
 
        return true;
 }
 
@@ -188,7 +188,7 @@ static void test_case_mesh_channel_open_03(void **state) {
     when called by giving proper error number.
 */
 static bool test_steps_mesh_channel_open_03(void) {
     when called by giving proper error number.
 */
 static bool test_steps_mesh_channel_open_03(void) {
-       meshlink_destroy("channels_conf.5");
+       assert(meshlink_destroy("channels_conf.5"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("channels_conf.5", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("channels_conf.5", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -202,7 +202,7 @@ static bool test_steps_mesh_channel_open_03(void) {
 
        // Clean up.
        meshlink_close(mesh);
 
        // Clean up.
        meshlink_close(mesh);
-       meshlink_destroy("channels_conf.5");
+       assert(meshlink_destroy("channels_conf.5"));
        return true;
 }
 
        return true;
 }
 
@@ -223,7 +223,7 @@ static void test_case_mesh_channel_open_04(void **state) {
     when called by giving proper error number.
 */
 static bool test_steps_mesh_channel_open_04(void) {
     when called by giving proper error number.
 */
 static bool test_steps_mesh_channel_open_04(void) {
-       meshlink_destroy("channels_conf.7");
+       assert(meshlink_destroy("channels_conf.7"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("channels_conf.7", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh = meshlink_open("channels_conf.7", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -237,7 +237,7 @@ static bool test_steps_mesh_channel_open_04(void) {
 
        // Clean up.
        meshlink_close(mesh);
 
        // Clean up.
        meshlink_close(mesh);
-       meshlink_destroy("channels_conf.7");
+       assert(meshlink_destroy("channels_conf.7"));
        return true;
 }
 
        return true;
 }
 
index f302e2b5f1efd3b18a0af73b2a42d3429676e458..d818a0c7efac8c7589558c4db47d36b932bb0fc0 100644 (file)
@@ -142,8 +142,8 @@ static void poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t
 /* Test Steps for meshlink_channel_send Test Case # 1*/
 static bool test_steps_mesh_channel_send_01(void) {
        struct timespec timeout = {0};
 /* Test Steps for meshlink_channel_send Test Case # 1*/
 static bool test_steps_mesh_channel_send_01(void) {
        struct timespec timeout = {0};
-       meshlink_destroy("chan_send_conf.1");
-       meshlink_destroy("chan_send_conf.2");
+       assert(meshlink_destroy("chan_send_conf.1"));
+       assert(meshlink_destroy("chan_send_conf.2"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -216,8 +216,8 @@ static bool test_steps_mesh_channel_send_01(void) {
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("chan_send_conf.1");
-       meshlink_destroy("chan_send_conf.2");
+       assert(meshlink_destroy("chan_send_conf.1"));
+       assert(meshlink_destroy("chan_send_conf.2"));
 
        return true;
 }
 
        return true;
 }
@@ -230,7 +230,7 @@ static void test_case_mesh_channel_send_02(void **state) {
 /* Test Steps for meshlink_channel_send Test Case # 2*/
 static bool test_steps_mesh_channel_send_02(void) {
        struct timespec timeout = {0};
 /* Test Steps for meshlink_channel_send Test Case # 2*/
 static bool test_steps_mesh_channel_send_02(void) {
        struct timespec timeout = {0};
-       meshlink_destroy("chan_send_conf.5");
+       assert(meshlink_destroy("chan_send_conf.5"));
 
        // Open new meshlink instance.
 
 
        // Open new meshlink instance.
 
@@ -265,7 +265,7 @@ static bool test_steps_mesh_channel_send_02(void) {
        // Clean up.
 
        meshlink_close(mesh1);
        // Clean up.
 
        meshlink_close(mesh1);
-       meshlink_destroy("chan_send_conf.5");
+       assert(meshlink_destroy("chan_send_conf.5"));
 
        return true;
 }
 
        return true;
 }
@@ -277,7 +277,7 @@ static void test_case_mesh_channel_send_03(void **state) {
 
 /* Test Steps for meshlink_channel_send Test Case # 3*/
 static bool test_steps_mesh_channel_send_03(void) {
 
 /* Test Steps for meshlink_channel_send Test Case # 3*/
 static bool test_steps_mesh_channel_send_03(void) {
-       meshlink_destroy("chan_send_conf.7");
+       assert(meshlink_destroy("chan_send_conf.7"));
        // Open new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.7", "foo", "channels", DEV_CLASS_BACKBONE);
        // Open new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.7", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -295,7 +295,7 @@ static bool test_steps_mesh_channel_send_03(void) {
        // Clean up.
 
        meshlink_close(mesh1);
        // Clean up.
 
        meshlink_close(mesh1);
-       meshlink_destroy("chan_send_conf.7");
+       assert(meshlink_destroy("chan_send_conf.7"));
 
        return true;
 }
 
        return true;
 }
@@ -308,7 +308,7 @@ static void test_case_mesh_channel_send_04(void **state) {
 /* Test Steps for meshlink_channel_send Test Case # 4*/
 static bool test_steps_mesh_channel_send_04(void) {
        struct timespec timeout = {0};
 /* Test Steps for meshlink_channel_send Test Case # 4*/
 static bool test_steps_mesh_channel_send_04(void) {
        struct timespec timeout = {0};
-       meshlink_destroy("chan_send_conf.9");
+       assert(meshlink_destroy("chan_send_conf.9"));
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.9", "foo", "channels", DEV_CLASS_BACKBONE);
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_send_conf.9", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -342,7 +342,7 @@ static bool test_steps_mesh_channel_send_04(void) {
        // Clean up.
 
        meshlink_close(mesh1);
        // Clean up.
 
        meshlink_close(mesh1);
-       meshlink_destroy("chan_send_conf.9");
+       assert(meshlink_destroy("chan_send_conf.9"));
 
        return true;
 }
 
        return true;
 }
index 9972b63ac9223c42131867cacbf7e277fe70bc2c..fa345b31f5e1e8891332275e6dcc333b5471af20 100644 (file)
@@ -138,8 +138,8 @@ static void test_case_set_channel_accept_cb_01(void **state) {
 static bool test_steps_set_channel_accept_cb_01(void) {
        /* deleting the confbase if already exists */
        struct timespec timeout = {0};
 static bool test_steps_set_channel_accept_cb_01(void) {
        /* deleting the confbase if already exists */
        struct timespec timeout = {0};
-       meshlink_destroy("acceptconf1");
-       meshlink_destroy("acceptconf2");
+       assert(meshlink_destroy("acceptconf1"));
+       assert(meshlink_destroy("acceptconf2"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instances */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instances */
@@ -225,8 +225,8 @@ static bool test_steps_set_channel_accept_cb_01(void) {
        /* closing channel, meshes and destroying confbase */
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        /* closing channel, meshes and destroying confbase */
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("acceptconf1");
-       meshlink_destroy("acceptconf2");
+       assert(meshlink_destroy("acceptconf1"));
+       assert(meshlink_destroy("acceptconf2"));
 
        return true;
 }
 
        return true;
 }
index 39579e850710c0db21cc179afd9a030dffd0175d..5ad8f03d6c2d99de657cdc3d27f16b6f4438bfff 100644 (file)
@@ -114,8 +114,8 @@ static void test_case_channel_set_poll_cb_01(void **state) {
 static bool test_steps_channel_set_poll_cb_01(void) {
        /* deleting the confbase if already exists */
        struct timespec timeout = {0};
 static bool test_steps_channel_set_poll_cb_01(void) {
        /* deleting the confbase if already exists */
        struct timespec timeout = {0};
-       meshlink_destroy("pollconf1");
-       meshlink_destroy("pollconf2");
+       assert(meshlink_destroy("pollconf1"));
+       assert(meshlink_destroy("pollconf2"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instances */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instances */
@@ -170,8 +170,8 @@ static bool test_steps_channel_set_poll_cb_01(void) {
        /* closing channel, meshes and destroying confbase */
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        /* closing channel, meshes and destroying confbase */
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("pollconf1");
-       meshlink_destroy("pollconf2");
+       assert(meshlink_destroy("pollconf1"));
+       assert(meshlink_destroy("pollconf2"));
 
        return true;
 }
 
        return true;
 }
@@ -212,7 +212,7 @@ static bool test_steps_channel_set_poll_cb_02(void) {
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_handle);
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelpollconf3");
+       assert(meshlink_destroy("channelpollconf3"));
        return true;
 }
 
        return true;
 }
 
@@ -245,7 +245,7 @@ static bool test_steps_channel_set_poll_cb_03(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelpollconf4");
+       assert(meshlink_destroy("channelpollconf4"));
        return true;
 }
 
        return true;
 }
 
index 1f904cec779ce10b233ae5b084533b443c6b5780..697812e54224c1d0e9d0385ec6a43f4ce8dd7401 100644 (file)
@@ -122,7 +122,7 @@ static void test_case_set_channel_receive_cb_01(void **state) {
 */
 static bool test_steps_set_channel_receive_cb_01(void) {
        struct timespec timeout = {0};
 */
 static bool test_steps_set_channel_receive_cb_01(void) {
        struct timespec timeout = {0};
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -160,7 +160,7 @@ static bool test_steps_set_channel_receive_cb_01(void) {
        pthread_mutex_unlock(& lock_receive);
 
        meshlink_close(mesh_handle);
        pthread_mutex_unlock(& lock_receive);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
 
        return true;
 }
 
        return true;
 }
@@ -179,7 +179,7 @@ static void test_case_set_channel_receive_cb_02(void **state) {
     meshlink_channel_set_receive_cb returning proper meshlink_errno.
 */
 static bool test_steps_set_channel_receive_cb_02(void) {
     meshlink_channel_set_receive_cb returning proper meshlink_errno.
 */
 static bool test_steps_set_channel_receive_cb_02(void) {
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -202,7 +202,7 @@ static bool test_steps_set_channel_receive_cb_02(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
 
        return true;
 }
 
        return true;
 }
@@ -221,7 +221,7 @@ static void test_case_set_channel_receive_cb_03(void **state) {
     meshlink_channel_set_receive_cb returning proper meshlink_errno.
 */
 static bool test_steps_set_channel_receive_cb_03(void) {
     meshlink_channel_set_receive_cb returning proper meshlink_errno.
 */
 static bool test_steps_set_channel_receive_cb_03(void) {
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -239,7 +239,7 @@ static bool test_steps_set_channel_receive_cb_03(void) {
 
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
        meshlink_close(mesh_handle);
 
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelreceiveconf");
+       assert(meshlink_destroy("channelreceiveconf"));
        return true;
 }
 
        return true;
 }
 
index 434afc916d8010f67aa593d11f1f93965c3d7f61..c8f6ef43de94f1c1c2e7ce9d4330907912508706 100644 (file)
@@ -146,8 +146,8 @@ static void test_case_mesh_channel_shutdown_01(void **state) {
 */
 static bool test_steps_mesh_channel_shutdown_01(void) {
        struct timespec timeout = {0};
 */
 static bool test_steps_mesh_channel_shutdown_01(void) {
        struct timespec timeout = {0};
-       meshlink_destroy("chan_shutdown_conf.1");
-       meshlink_destroy("chan_shutdown_conf.2");
+       assert(meshlink_destroy("chan_shutdown_conf.1"));
+       assert(meshlink_destroy("chan_shutdown_conf.2"));
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_shutdown_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
        // Open two new meshlink instance.
 
        meshlink_handle_t *mesh1 = meshlink_open("chan_shutdown_conf.1", "foo", "channels", DEV_CLASS_BACKBONE);
@@ -245,8 +245,8 @@ static bool test_steps_mesh_channel_shutdown_01(void) {
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("chan_shutdown_conf.1");
-       meshlink_destroy("chan_shutdown_conf.2");
+       assert(meshlink_destroy("chan_shutdown_conf.1"));
+       assert(meshlink_destroy("chan_shutdown_conf.2"));
 
        return true;
 }
 
        return true;
 }
@@ -266,7 +266,7 @@ static void test_case_mesh_channel_shutdown_02(void **state) {
     meshlink_channel_shutdown API should report proper error handling
 */
 static bool test_steps_mesh_channel_shutdown_02(void) {
     meshlink_channel_shutdown API should report proper error handling
 */
 static bool test_steps_mesh_channel_shutdown_02(void) {
-       meshlink_destroy("channelshutdownconf.3");
+       assert(meshlink_destroy("channelshutdownconf.3"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -290,7 +290,7 @@ static bool test_steps_mesh_channel_shutdown_02(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelshutdownconf.3");
+       assert(meshlink_destroy("channelshutdownconf.3"));
 
        return true;
 }
 
        return true;
 }
@@ -310,7 +310,7 @@ static void test_case_mesh_channel_shutdown_03(void **state) {
     meshlink_channel_shutdown API should report proper error handling
 */
 static bool test_steps_mesh_channel_shutdown_03(void) {
     meshlink_channel_shutdown API should report proper error handling
 */
 static bool test_steps_mesh_channel_shutdown_03(void) {
-       meshlink_destroy("channelshutdownconf.4");
+       assert(meshlink_destroy("channelshutdownconf.4"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -327,7 +327,7 @@ static bool test_steps_mesh_channel_shutdown_03(void) {
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("channelshutdownconf.4");
+       assert(meshlink_destroy("channelshutdownconf.4"));
 
        return true;
 }
 
        return true;
 }
index 37ddd020e9c8f6fe9f4edffded3a84054b416b57..508e784be6593ad0eb02cdd885f7d3aa763b23d7 100644 (file)
@@ -97,9 +97,9 @@ void status_cb1(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable)
     but when enabled foo node should not receive data from foz
 */
 static bool test_steps_mesh_default_blacklist_01(void) {
     but when enabled foo node should not receive data from foz
 */
 static bool test_steps_mesh_default_blacklist_01(void) {
-       meshlink_destroy("def_blacklist_conf.1");
-       meshlink_destroy("def_blacklist_conf.2");
-       meshlink_destroy("def_blacklist_conf.3");
+       assert(meshlink_destroy("def_blacklist_conf.1"));
+       assert(meshlink_destroy("def_blacklist_conf.2"));
+       assert(meshlink_destroy("def_blacklist_conf.3"));
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("def_blacklist_conf.1", "foo", "blacklist", DEV_CLASS_BACKBONE);
 
        // Open two new meshlink instance.
        meshlink_handle_t *mesh1 = meshlink_open("def_blacklist_conf.1", "foo", "blacklist", DEV_CLASS_BACKBONE);
@@ -165,9 +165,9 @@ static bool test_steps_mesh_default_blacklist_01(void) {
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        meshlink_close(mesh3);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        meshlink_close(mesh3);
-       meshlink_destroy("def_blacklist_conf.1");
-       meshlink_destroy("def_blacklist_conf.2");
-       meshlink_destroy("def_blacklist_conf.3");
+       assert(meshlink_destroy("def_blacklist_conf.1"));
+       assert(meshlink_destroy("def_blacklist_conf.2"));
+       assert(meshlink_destroy("def_blacklist_conf.3"));
 
        return true;
 }
 
        return true;
 }
index db94a0024ddf4c604694885255858338c52827ec..0281f0b5a95b48f0bac0f7509b58a10bbee37284 100644 (file)
@@ -65,7 +65,7 @@ static void test_case_export_01(void **state) {
     API returns a NULL terminated string containing meta data of NUT.
 */
 static bool test_export_01(void) {
     API returns a NULL terminated string containing meta data of NUT.
 */
 static bool test_export_01(void) {
-       meshlink_destroy("exportconf");
+       assert(meshlink_destroy("exportconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -77,7 +77,7 @@ static bool test_export_01(void) {
        assert_int_not_equal(expo, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_not_equal(expo, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("exportconf");
+       assert(meshlink_destroy("exportconf"));
 
        return true;
 }
 
        return true;
 }
index 9f298a2c243fe487b02ecd8feaccfd763c4a19ff..6fd409bb27e82d009147bbdaf841655d2d668dab 100644 (file)
@@ -75,8 +75,8 @@ static void test_case_get_all_nodes_01(void **state) {
     Obtaining list of nodes in the mesh at the given instance
 */
 static bool test_get_all_nodes_01(void) {
     Obtaining list of nodes in the mesh at the given instance
 */
 static bool test_get_all_nodes_01(void) {
-       meshlink_destroy("getnodeconf1");
-       meshlink_destroy("getnodeconf2");
+       assert(meshlink_destroy("getnodeconf1"));
+       assert(meshlink_destroy("getnodeconf2"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance for NUT */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance for NUT */
@@ -108,8 +108,8 @@ static bool test_get_all_nodes_01(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("getnodeconf1");
-       meshlink_destroy("getnodeconf2");
+       assert(meshlink_destroy("getnodeconf1"));
+       assert(meshlink_destroy("getnodeconf2"));
 
        return true;
 }
 
        return true;
 }
@@ -162,7 +162,7 @@ static bool test_get_all_nodes_03(void) {
        assert_int_equal(nodes, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(nodes, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getallnodesconf");
+       assert(meshlink_destroy("getallnodesconf"));
 
        return true;
 }
 
        return true;
 }
index 3c1498eba871425db0dfc28b4bff2586f82c2e44..f3c73a923b1fe678053648bfe182c6a75c899d5e 100644 (file)
@@ -213,7 +213,7 @@ static bool test_steps_mesh_get_node_by_dev_class_02(void) {
        meshlink_node_t **nodes;
        size_t nnodes = 0;
 
        meshlink_node_t **nodes;
        size_t nnodes = 0;
 
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
@@ -233,7 +233,7 @@ static bool test_steps_mesh_get_node_by_dev_class_02(void) {
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_nut);
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_nut);
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
        return true;
 }
 
        return true;
 }
 
@@ -252,7 +252,7 @@ static void test_case_mesh_get_node_dev_class_01(void **state) {
     meshlink_get_node_dev_class API should return DEV_CLASS_STATIONARY device class
 */
 static bool test_steps_mesh_get_node_dev_class_01(void) {
     meshlink_get_node_dev_class API should return DEV_CLASS_STATIONARY device class
 */
 static bool test_steps_mesh_get_node_dev_class_01(void) {
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
@@ -267,7 +267,7 @@ static bool test_steps_mesh_get_node_dev_class_01(void) {
        assert_int_equal(dev_class, DEV_CLASS_STATIONARY);
 
        meshlink_close(mesh_nut);
        assert_int_equal(dev_class, DEV_CLASS_STATIONARY);
 
        meshlink_close(mesh_nut);
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
        return true;
 }
 
        return true;
 }
 
@@ -287,7 +287,7 @@ static void test_case_mesh_get_node_dev_class_02(void **state) {
     meshlink_errno.
 */
 static bool test_steps_mesh_get_node_dev_class_02(void) {
     meshlink_errno.
 */
 static bool test_steps_mesh_get_node_dev_class_02(void) {
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
 
        /* Create meshlink instance for NUT */
        meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
@@ -307,7 +307,7 @@ static bool test_steps_mesh_get_node_dev_class_02(void) {
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_nut);
        assert_int_not_equal(meshlink_errno, 0);
 
        meshlink_close(mesh_nut);
-       meshlink_destroy("getnodeconf.1");
+       assert(meshlink_destroy("getnodeconf.1"));
        return true;
 }
 
        return true;
 }
 
@@ -315,11 +315,11 @@ static int black_box_setup_test_case(void **state) {
        (void)state;
 
        fprintf(stderr, "Destroying confbases\n");
        (void)state;
 
        fprintf(stderr, "Destroying confbases\n");
-       meshlink_destroy("getnodeconf.1");
-       meshlink_destroy("getnodeconf.2");
-       meshlink_destroy("getnodeconf.3");
-       meshlink_destroy("getnodeconf.4");
-       meshlink_destroy("getnodeconf.5");
+       assert(meshlink_destroy("getnodeconf.1"));
+       assert(meshlink_destroy("getnodeconf.2"));
+       assert(meshlink_destroy("getnodeconf.3"));
+       assert(meshlink_destroy("getnodeconf.4"));
+       assert(meshlink_destroy("getnodeconf.5"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_errno = MESHLINK_OK;
 
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_errno = MESHLINK_OK;
 
index 2c5cea461a11aa3d393ad7d6cdcf28098c0dade0..02cb4d6fafbfe4f5c3566b880fe715809c394c51 100644 (file)
@@ -79,7 +79,7 @@ static bool test_steps_mesh_get_address_01(void) {
 
        free(addr);
        meshlink_close(mesh);
 
        free(addr);
        meshlink_close(mesh);
-       meshlink_destroy("getex_conf");
+       assert(meshlink_destroy("getex_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -128,7 +128,7 @@ static bool test_steps_mesh_get_address_03(void) {
 
        free(addr);
        meshlink_close(mesh);
 
        free(addr);
        meshlink_close(mesh);
-       meshlink_destroy("getex_conf");
+       assert(meshlink_destroy("getex_conf"));
        return true;
 }
 
        return true;
 }
 
index 59321f0d26ca2d78c8934377873ab835c7026224..3435f6eeaa5bf7ad2b52e7a4ad9eb4169df93641 100644 (file)
@@ -85,7 +85,7 @@ static bool test_get_fingerprint_cb_01(void) {
        assert_int_not_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_not_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getfingerprintconf");
+       assert(meshlink_destroy("getfingerprintconf"));
 
        return true;
 }
 
        return true;
 }
@@ -126,7 +126,7 @@ static bool test_get_fingerprint_cb_02(void) {
        assert_int_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getfingerprintconf");
+       assert(meshlink_destroy("getfingerprintconf"));
 
        return true;
 }
 
        return true;
 }
@@ -158,7 +158,7 @@ static bool test_get_fingerprint_cb_03(void) {
        assert_int_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(fp, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getfingerprintconf");
+       assert(meshlink_destroy("getfingerprintconf"));
 
        return true;
 }
 
        return true;
 }
index c46caa5c1e191fd011c07922ab8d892bcf2b2c49..a13b4756000a91a10de08b22a8ea3dd1a32123ff 100644 (file)
@@ -81,8 +81,8 @@ static void test_case_mesh_get_node_01(void **state) {
 */
 static bool test_steps_mesh_get_node_01(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 */
 static bool test_steps_mesh_get_node_01(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
-       meshlink_destroy("getnode1");
-       meshlink_destroy("getnode2");
+       assert(meshlink_destroy("getnode1"));
+       assert(meshlink_destroy("getnode2"));
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("getnode1", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("getnode1", "nut", "test", DEV_CLASS_STATIONARY);
@@ -111,8 +111,8 @@ static bool test_steps_mesh_get_node_01(void) {
        // Cleanup
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        // Cleanup
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("getnode1");
-       meshlink_destroy("getnode2");
+       assert(meshlink_destroy("getnode1"));
+       assert(meshlink_destroy("getnode2"));
        return true;
 }
 
        return true;
 }
 
@@ -158,7 +158,7 @@ static bool test_steps_mesh_get_node_03(void) {
        assert_int_equal(get_node, NULL);
 
        meshlink_close(mesh);
        assert_int_equal(get_node, NULL);
 
        meshlink_close(mesh);
-       meshlink_destroy("node_conf.3");
+       assert(meshlink_destroy("node_conf.3"));
        return true;
 }
 
        return true;
 }
 
@@ -187,7 +187,7 @@ static bool test_steps_mesh_get_node_04(void) {
        assert_int_equal(get_node, NULL);
 
        meshlink_close(mesh);
        assert_int_equal(get_node, NULL);
 
        meshlink_close(mesh);
-       meshlink_destroy("node_conf");
+       assert(meshlink_destroy("node_conf"));
        return true;
 }
 
        return true;
 }
 
index 9b55984436d6a7f43cf5c48b6b3c65b5dc58c8e4..71f7cb44cb305973ffac69ebd97f5d8a3f6f87f0 100644 (file)
@@ -72,7 +72,7 @@ static bool test_steps_mesh_get_port_01(void) {
        assert_int_not_equal(port, -1);
 
        meshlink_close(mesh);
        assert_int_not_equal(port, -1);
 
        meshlink_close(mesh);
-       meshlink_destroy("port_conf");
+       assert(meshlink_destroy("port_conf"));
        return true;
 }
 
        return true;
 }
 
index 52f909e7646eb706667d65dce081758b2bbebf46..3368a42fa554b229087d6b40d892cd07cba4900f 100644 (file)
@@ -75,7 +75,7 @@ static bool test_steps_mesh_get_self_01(void) {
        }
 
        meshlink_close(mesh);
        }
 
        meshlink_close(mesh);
-       meshlink_destroy("self_conf");
+       assert(meshlink_destroy("self_conf"));
        return true;
 
 }
        return true;
 
 }
index d79c48897160c2cd16b2369f6af842bfe72cf76a..61be45188595ff63b9e51ad29ce33239c626ab9e 100644 (file)
@@ -65,8 +65,8 @@ void test_case_hint_address_01(void **state) {
 }
 /* Test Steps for meshlink_hint_address Test Case # 1 - Valid case */
 bool test_steps_hint_address_01(void) {
 }
 /* Test Steps for meshlink_hint_address Test Case # 1 - Valid case */
 bool test_steps_hint_address_01(void) {
-       meshlink_destroy("hintconf1");
-       meshlink_destroy("hintconf2");
+       assert(meshlink_destroy("hintconf1"));
+       assert(meshlink_destroy("hintconf2"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance for the nodes
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance for the nodes
@@ -123,8 +123,8 @@ bool test_steps_hint_address_01(void) {
        free(buff);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        free(buff);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("hintconf1");
-       meshlink_destroy("hintconf2");
+       assert(meshlink_destroy("hintconf1"));
+       assert(meshlink_destroy("hintconf2"));
 
        return true;
 }
 
        return true;
 }
index 53107a28c6582e45bf18375830600d242546310b..fb1b559a0e16a0f00a2c0656ee96d2a60cc1f395 100644 (file)
@@ -87,8 +87,8 @@ static void test_case_import_01(void **state) {
 */
 static bool test_import_01(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 */
 static bool test_import_01(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "test", DEV_CLASS_STATIONARY);
@@ -110,8 +110,8 @@ static bool test_import_01(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
        return imp1 && imp2;
 }
 
        return imp1 && imp2;
 }
 
@@ -130,8 +130,8 @@ static void test_case_import_02(void **state) {
 */
 static bool test_import_02(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 */
 static bool test_import_02(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "test", DEV_CLASS_STATIONARY);
@@ -153,8 +153,8 @@ static bool test_import_02(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
        return true;
 }
 
        return true;
 }
 
@@ -175,8 +175,8 @@ static void test_case_import_03(void **state) {
 static bool test_import_03(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
 static bool test_import_03(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
 
        /* Opening NUT and bar nodes */
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
 
        /* Opening NUT and bar nodes */
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
@@ -199,8 +199,8 @@ static bool test_import_03(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
        return true;
 }
 
        return true;
 }
 
@@ -220,8 +220,8 @@ static void test_case_import_04(void **state) {
 */
 static bool test_import_04(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 */
 static bool test_import_04(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
@@ -244,8 +244,8 @@ static bool test_import_04(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
        return true;
 }
 
        return true;
 }
 
@@ -265,8 +265,8 @@ static void test_case_import_05(void **state) {
 */
 static bool test_import_05(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 */
 static bool test_import_05(void) {
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
 
        /* Opening NUT and bar nodes */
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
 
        /* Opening NUT and bar nodes */
        meshlink_handle_t *mesh1 = meshlink_open("importconf1", "nut", "chat", DEV_CLASS_STATIONARY);
@@ -293,8 +293,8 @@ static bool test_import_05(void) {
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
 
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("importconf1");
-       meshlink_destroy("importconf2");
+       assert(meshlink_destroy("importconf1"));
+       assert(meshlink_destroy("importconf2"));
        return true;
 }
 
        return true;
 }
 
index e95f278b8886e763cb641dd7c5dc58560f72d787..929b002ab3241fa663259960b6b00101d1509761 100644 (file)
@@ -78,7 +78,7 @@ static void test_case_invite_01(void **state) {
     Generates an invitation
 */
 static bool test_invite_01(void) {
     Generates an invitation
 */
 static bool test_invite_01(void) {
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
@@ -91,7 +91,7 @@ static bool test_invite_01(void) {
 
        free(invitation);
        meshlink_close(mesh_handle);
 
        free(invitation);
        meshlink_close(mesh_handle);
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
        return true;
 }
 
        return true;
 }
 
@@ -127,7 +127,7 @@ static void test_case_invite_03(void **state) {
     Reports appropriate error by returning NULL
 */
 static bool test_invite_03(void) {
     Reports appropriate error by returning NULL
 */
 static bool test_invite_03(void) {
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
@@ -140,7 +140,7 @@ static bool test_invite_03(void) {
        assert_int_equal(invitation, NULL);
 
        meshlink_close(mesh_handle);
        assert_int_equal(invitation, NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
        return true;
 }
 
        return true;
 }
 
@@ -159,7 +159,7 @@ static void test_case_invite_04(void **state) {
     Newly added address should be there in the invitation.
 */
 static bool test_invite_04(void) {
     Newly added address should be there in the invitation.
 */
 static bool test_invite_04(void) {
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        // Create meshlink instance
@@ -168,12 +168,12 @@ static bool test_invite_04(void) {
        meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        char *hostname1 = "127.1.1.1";
        meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        char *hostname1 = "127.1.1.1";
-       meshlink_add_address(mesh_handle, hostname1);
+       assert(meshlink_add_address(mesh_handle, hostname1));
        char *invitation = meshlink_invite(mesh_handle, NULL, "foo");
        assert_int_not_equal(strstr(invitation, hostname1), NULL);
 
        char *hostname2 = "127.1.2.3";
        char *invitation = meshlink_invite(mesh_handle, NULL, "foo");
        assert_int_not_equal(strstr(invitation, hostname1), NULL);
 
        char *hostname2 = "127.1.2.3";
-       meshlink_add_address(mesh_handle, hostname2);
+       assert(meshlink_add_address(mesh_handle, hostname2));
        invitation = meshlink_invite(mesh_handle, NULL, "bar");
 
        // Verify we have both the added addresses
        invitation = meshlink_invite(mesh_handle, NULL, "bar");
 
        // Verify we have both the added addresses
@@ -181,7 +181,7 @@ static bool test_invite_04(void) {
        assert_int_not_equal(strstr(invitation, hostname2), NULL);
 
        meshlink_close(mesh_handle);
        assert_int_not_equal(strstr(invitation, hostname2), NULL);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("inviteconf");
+       assert(meshlink_destroy("inviteconf"));
 
        return true;
 }
 
        return true;
 }
index 56866fe52a7e15e8958a3e9040270b1803cb63f2..865528574f6c8bdec4f16087cb0ad76eb4e38a8a 100644 (file)
@@ -86,8 +86,8 @@ static void test_case_meshlink_join_01(void **state) {
     NUT joins relay using the invitation generated.
 */
 static bool test_meshlink_join_01(void) {
     NUT joins relay using the invitation generated.
 */
 static bool test_meshlink_join_01(void) {
-       meshlink_destroy("join_conf.1");
-       meshlink_destroy("join_conf.2");
+       assert(meshlink_destroy("join_conf.1"));
+       assert(meshlink_destroy("join_conf.2"));
 
        // Create node instances
        meshlink_handle_t *mesh1 = meshlink_open("join_conf.1", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Create node instances
        meshlink_handle_t *mesh1 = meshlink_open("join_conf.1", "nut", "test", DEV_CLASS_STATIONARY);
@@ -101,7 +101,7 @@ static bool test_meshlink_join_01(void) {
        meshlink_set_node_status_cb(mesh1, status_callback);
 
        // Inviting nut
        meshlink_set_node_status_cb(mesh1, status_callback);
 
        // Inviting nut
-       meshlink_start(mesh2);
+       assert(meshlink_start(mesh2));
        char *invitation = meshlink_invite(mesh2, NULL, "nut");
        assert(invitation);
 
        char *invitation = meshlink_invite(mesh2, NULL, "nut");
        assert(invitation);
 
@@ -116,8 +116,8 @@ static bool test_meshlink_join_01(void) {
        free(invitation);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        free(invitation);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("join_conf.1");
-       meshlink_destroy("join_conf.2");
+       assert(meshlink_destroy("join_conf.1"));
+       assert(meshlink_destroy("join_conf.2"));
 
        return true;
 }
 
        return true;
 }
@@ -136,7 +136,7 @@ static void test_case_meshlink_join_02(void **state) {
     report error accordingly when NULL is passed as mesh handle argument
 */
 static bool test_meshlink_join_02(void) {
     report error accordingly when NULL is passed as mesh handle argument
 */
 static bool test_meshlink_join_02(void) {
-       meshlink_destroy("join_conf.3");
+       assert(meshlink_destroy("join_conf.3"));
 
        // Create node instances
        meshlink_handle_t *mesh1 = meshlink_open("join_conf.3", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Create node instances
        meshlink_handle_t *mesh1 = meshlink_open("join_conf.3", "nut", "test", DEV_CLASS_STATIONARY);
@@ -151,7 +151,7 @@ static bool test_meshlink_join_02(void) {
 
        free(invitation);
        meshlink_close(mesh1);
 
        free(invitation);
        meshlink_close(mesh1);
-       meshlink_destroy("join_conf.3");
+       assert(meshlink_destroy("join_conf.3"));
 
        return true;
 }
 
        return true;
 }
@@ -171,7 +171,7 @@ static void test_case_meshlink_join_03(void **state) {
     Report error accordingly when NULL is passed as invite argument
 */
 static bool test_meshlink_join_03(void) {
     Report error accordingly when NULL is passed as invite argument
 */
 static bool test_meshlink_join_03(void) {
-       meshlink_destroy("joinconf.4");
+       assert(meshlink_destroy("joinconf.4"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 
        /* Create meshlink instance */
@@ -184,7 +184,7 @@ static bool test_meshlink_join_03(void) {
        assert_int_equal(ret, false);
 
        meshlink_close(mesh_handle);
        assert_int_equal(ret, false);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("joinconf.4");
+       assert(meshlink_destroy("joinconf.4"));
        return true;
 }
 
        return true;
 }
 
index 695d5e69607e50701ce0455d86da2374ffaa0f11..8987d7c54d6885d479bcc33e1f63fcd52064ce02 100644 (file)
@@ -70,7 +70,7 @@ static void test_case_key_rotation_01(void **state) {
 */
 static bool test_key_rotation_01(void) {
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 */
 static bool test_key_rotation_01(void) {
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
 
        // Open a new meshlink instance.
 
 
        // Open a new meshlink instance.
 
@@ -91,7 +91,7 @@ static bool test_key_rotation_01(void) {
        // Cleanup
 
        meshlink_close(mesh);
        // Cleanup
 
        meshlink_close(mesh);
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
 
        return true;
 }
 
        return true;
 }
@@ -113,7 +113,7 @@ static void test_case_key_rotation_02(void **state) {
 */
 static bool test_key_rotation_02(void) {
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 */
 static bool test_key_rotation_02(void) {
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
 
        // Open a new meshlink instance.
 
 
        // Open a new meshlink instance.
 
@@ -145,7 +145,7 @@ static bool test_key_rotation_02(void) {
        // Cleanup
 
        meshlink_close(mesh);
        // Cleanup
 
        meshlink_close(mesh);
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
 
        return true;
 }
 
        return true;
 }
@@ -166,7 +166,7 @@ static void test_case_key_rotation_03(void **state) {
     been changed to new by key rotate API.
 */
 static bool test_key_rotation_03(void) {
     been changed to new by key rotate API.
 */
 static bool test_key_rotation_03(void) {
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        // Open a new meshlink instance.
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        // Open a new meshlink instance.
@@ -188,7 +188,7 @@ static bool test_key_rotation_03(void) {
 
        // Cleanup
 
 
        // Cleanup
 
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
 
        return true;
 }
 
        return true;
 }
@@ -224,7 +224,7 @@ static bool test_key_rotation_04(void) {
        bool join_status;
        char *invitations_directory_path = "encrypted_conf/current/invitations/";
 
        bool join_status;
        char *invitations_directory_path = "encrypted_conf/current/invitations/";
 
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        // Open a new meshlink instance.
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        // Open a new meshlink instance.
@@ -310,9 +310,9 @@ static bool test_key_rotation_04(void) {
        meshlink_close(mesh);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        meshlink_close(mesh);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("encrypted_conf");
-       meshlink_destroy("encrypted_conf.1");
-       meshlink_destroy("encrypted_conf.2");
+       assert(meshlink_destroy("encrypted_conf"));
+       assert(meshlink_destroy("encrypted_conf.1"));
+       assert(meshlink_destroy("encrypted_conf.2"));
 
        return true;
 }
 
        return true;
 }
@@ -360,7 +360,7 @@ static bool test_key_rotation_05(void) {
        pid_t pid;
        int status;
        meshlink_handle_t *mesh;
        pid_t pid;
        int status;
        meshlink_handle_t *mesh;
-       meshlink_destroy("encrypted_conf");
+       assert(meshlink_destroy("encrypted_conf"));
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        assert(signal(SIGINT, SIG_DFL) != SIG_ERR);
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
 
        assert(signal(SIGINT, SIG_DFL) != SIG_ERR);
@@ -376,7 +376,7 @@ static bool test_key_rotation_05(void) {
 
        for(break_stage = 1; break_stage <= 3; break_stage += 1) {
                fprintf(stderr, "Debugging stage %d\n", break_stage);
 
        for(break_stage = 1; break_stage <= 3; break_stage += 1) {
                fprintf(stderr, "Debugging stage %d\n", break_stage);
-               meshlink_destroy("encrypted_conf");
+               assert(meshlink_destroy("encrypted_conf"));
 
                assert(pipe(pipefd) != -1);
 
 
                assert(pipe(pipefd) != -1);
 
@@ -397,7 +397,7 @@ static bool test_key_rotation_05(void) {
 
                        assert(write(pipefd[1], invitation, strlen(invitation) + 1) != -1);
 
 
                        assert(write(pipefd[1], invitation, strlen(invitation) + 1) != -1);
 
-                       meshlink_encrypted_key_rotate(mesh, "newkey", 6);
+                       assert(meshlink_encrypted_key_rotate(mesh, "newkey", 6));
                        raise(SIGABRT);
                }
 
                        raise(SIGABRT);
                }
 
@@ -441,7 +441,7 @@ static bool test_key_rotation_05(void) {
 
                assert(meshlink_start(mesh));
 
 
                assert(meshlink_start(mesh));
 
-               meshlink_destroy("encrypted_conf.1");
+               assert(meshlink_destroy("encrypted_conf.1"));
 
                meshlink_handle_t *mesh2 = meshlink_open("encrypted_conf.1", "bar", "bar", DEV_CLASS_BACKBONE);
                assert(mesh2);
 
                meshlink_handle_t *mesh2 = meshlink_open("encrypted_conf.1", "bar", "bar", DEV_CLASS_BACKBONE);
                assert(mesh2);
@@ -461,8 +461,8 @@ static bool test_key_rotation_05(void) {
 
        // Cleanup
 
 
        // Cleanup
 
-       meshlink_destroy("encrypted_conf");
-       meshlink_destroy("encrypted_conf.1");
+       assert(meshlink_destroy("encrypted_conf"));
+       assert(meshlink_destroy("encrypted_conf.1"));
        devtool_keyrotate_probe = nop_stage;
        return true;
 }
        devtool_keyrotate_probe = nop_stage;
        return true;
 }
index cdfba7b09742f92df211fec1e18bcae23f170b6f..40bd26c70103cd974a386b3c4531525289c55dc0 100644 (file)
@@ -91,7 +91,7 @@ static bool test_steps_mesh_open_01(void) {
        assert_int_not_equal(mesh, NULL);
 
        meshlink_close(mesh);
        assert_int_not_equal(mesh, NULL);
 
        meshlink_close(mesh);
-       meshlink_destroy("open_conf");
+       assert(meshlink_destroy("open_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -134,7 +134,7 @@ static bool test_steps_mesh_open_03(void) {
        meshlink_handle_t *mesh = meshlink_open("openconf", NULL, "test", DEV_CLASS_STATIONARY);
        assert_int_equal(mesh, NULL);
 
        meshlink_handle_t *mesh = meshlink_open("openconf", NULL, "test", DEV_CLASS_STATIONARY);
        assert_int_equal(mesh, NULL);
 
-       meshlink_destroy("open_conf");
+       assert(meshlink_destroy("open_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -156,7 +156,7 @@ static bool test_steps_mesh_open_04(void) {
        meshlink_handle_t *mesh = meshlink_open("openconf", "foo", NULL, DEV_CLASS_STATIONARY);
        assert_int_equal(mesh, NULL);
 
        meshlink_handle_t *mesh = meshlink_open("openconf", "foo", NULL, DEV_CLASS_STATIONARY);
        assert_int_equal(mesh, NULL);
 
-       meshlink_destroy("open_conf");
+       assert(meshlink_destroy("open_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -178,7 +178,7 @@ static bool test_steps_mesh_open_05(void) {
        meshlink_handle_t *mesh = meshlink_open("openconf", "foo", "test", -1);
        assert_int_equal(mesh, NULL);
 
        meshlink_handle_t *mesh = meshlink_open("openconf", "foo", "test", -1);
        assert_int_equal(mesh, NULL);
 
-       meshlink_destroy("open_conf");
+       assert(meshlink_destroy("open_conf"));
        return true;
 }
 
        return true;
 }
 
index 204132d7303adf7b39c416bf6b809db0863148ec..58675964e3df93ecd9989e0e3f9130ef9bd22e35 100644 (file)
@@ -81,7 +81,7 @@ static bool test_steps_mesh_pmtu_01(void) {
        assert_int_not_equal(pmtu, -1);
 
        meshlink_close(mesh);
        assert_int_not_equal(pmtu, -1);
 
        meshlink_close(mesh);
-       meshlink_destroy("pmtu_conf");
+       assert(meshlink_destroy("pmtu_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -111,7 +111,7 @@ static bool test_steps_mesh_pmtu_02(void) {
        assert_int_equal(pmtu, -1);
 
        meshlink_close(mesh);
        assert_int_equal(pmtu, -1);
 
        meshlink_close(mesh);
-       meshlink_destroy("pmtu_conf");
+       assert(meshlink_destroy("pmtu_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -139,7 +139,7 @@ static bool test_steps_mesh_pmtu_03(void) {
        assert_int_equal(pmtu, -1);
 
        meshlink_close(mesh);
        assert_int_equal(pmtu, -1);
 
        meshlink_close(mesh);
-       meshlink_destroy("pmtu_conf");
+       assert(meshlink_destroy("pmtu_conf"));
        return true;
 }
 
        return true;
 }
 
index 45d86ed23fe59951b4cc13563c7be453e77214bb..5cce98c0b4e805b296b8b70132b331efe64d9081 100644 (file)
@@ -143,7 +143,7 @@ void test_case_mesh_random_port_bindings_01(void **state) {
 */
 bool test_steps_mesh_random_port_bindings_01(void) {
        meshlink_handle_t *relay = NULL;
 */
 bool test_steps_mesh_random_port_bindings_01(void) {
        meshlink_handle_t *relay = NULL;
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
@@ -171,7 +171,7 @@ bool test_steps_mesh_random_port_bindings_01(void) {
        ipv6_fd = -1;
 
        meshlink_close(relay);
        ipv6_fd = -1;
 
        meshlink_close(relay);
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
 
        return true;
 }
 
        return true;
 }
@@ -193,7 +193,7 @@ void test_case_mesh_random_port_bindings_02(void **state) {
 */
 bool test_steps_mesh_random_port_bindings_02(void) {
        meshlink_handle_t *relay = NULL;
 */
 bool test_steps_mesh_random_port_bindings_02(void) {
        meshlink_handle_t *relay = NULL;
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
@@ -220,7 +220,7 @@ bool test_steps_mesh_random_port_bindings_02(void) {
        ipv6_fd = -1;
 
        meshlink_close(relay);
        ipv6_fd = -1;
 
        meshlink_close(relay);
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -244,7 +244,7 @@ void test_case_mesh_random_port_bindings_03(void **state) {
 bool test_steps_mesh_random_port_bindings_03(void) {
        int port, new_port;
        meshlink_handle_t *relay = NULL;
 bool test_steps_mesh_random_port_bindings_03(void) {
        int port, new_port;
        meshlink_handle_t *relay = NULL;
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
 
        meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_message);
 
@@ -282,7 +282,7 @@ bool test_steps_mesh_random_port_bindings_03(void) {
        ipv6_fd = -1;
 
        meshlink_close(relay);
        ipv6_fd = -1;
 
        meshlink_close(relay);
-       meshlink_destroy("relay_conf");
+       assert(meshlink_destroy("relay_conf"));
        return true;
 }
 
        return true;
 }
 
index 3fa760694878b20c5b07d23bf7c8fc06f862851a..168915adf262baf5b64b48c5cdf9be9e9e721346 100644 (file)
@@ -69,9 +69,9 @@ static int setup_test(void **state) {
        set_sync_flag(&test_random_port_binding_peer_closed, false);
        set_sync_flag(&test_random_port_binding_nut_closed, false);
 
        set_sync_flag(&test_random_port_binding_peer_closed, false);
        set_sync_flag(&test_random_port_binding_nut_closed, false);
 
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
 
        return EXIT_SUCCESS;
 }
 
        return EXIT_SUCCESS;
 }
@@ -79,9 +79,9 @@ static int setup_test(void **state) {
 static int teardown_test(void **state) {
        (void)state;
 
 static int teardown_test(void **state) {
        (void)state;
 
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
        netns_destroy_topology(test_random_port_bindings_state);
 
        return EXIT_SUCCESS;
        netns_destroy_topology(test_random_port_bindings_state);
 
        return EXIT_SUCCESS;
@@ -138,7 +138,7 @@ static void *relay_node(void *arg) {
 
        //system("ifconfig");
 
 
        //system("ifconfig");
 
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("relay"));
 
        relay = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(relay);
 
        relay = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(relay);
@@ -156,7 +156,7 @@ static void *relay_node(void *arg) {
        if(localnode == true) {
                assert(wait_sync_flag(&test_random_port_binding_make_switch, 300));
                meshlink_close(relay);
        if(localnode == true) {
                assert(wait_sync_flag(&test_random_port_binding_make_switch, 300));
                meshlink_close(relay);
-               meshlink_destroy("relay");
+               assert(meshlink_destroy("relay"));
 
 
                set_sync_flag(&test_random_port_binding_relay_closed, true);
 
 
                set_sync_flag(&test_random_port_binding_relay_closed, true);
@@ -167,7 +167,7 @@ static void *relay_node(void *arg) {
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(relay);
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(relay);
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("relay"));
 
 
        set_sync_flag(&test_random_port_binding_relay_closed, true);
 
 
        set_sync_flag(&test_random_port_binding_relay_closed, true);
@@ -180,7 +180,7 @@ static void *peer_node(void *arg) {
 
        fprintf(stderr, "\n\x1b[32mPeer Thread Started\x1b[0m\n");
 
 
        fprintf(stderr, "\n\x1b[32mPeer Thread Started\x1b[0m\n");
 
-       meshlink_destroy("peer");
+       assert(meshlink_destroy("peer"));
 
        peer = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(peer);
 
        peer = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(peer);
@@ -209,7 +209,7 @@ static void *peer_node(void *arg) {
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(peer);
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(peer);
-       meshlink_destroy("peer");
+       assert(meshlink_destroy("peer"));
 
        set_sync_flag(&test_random_port_binding_peer_closed, true);
 
 
        set_sync_flag(&test_random_port_binding_peer_closed, true);
 
@@ -221,7 +221,7 @@ static void *nut_node(void *arg) {
 
        fprintf(stderr, "\n\x1b[32mNut Thread Started\x1b[0m\n");
 
 
        fprintf(stderr, "\n\x1b[32mNut Thread Started\x1b[0m\n");
 
-       meshlink_destroy("nut");
+       assert(meshlink_destroy("nut"));
 
        nut_instance = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(nut_instance);
 
        nut_instance = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(nut_instance);
@@ -254,7 +254,7 @@ static void *nut_node(void *arg) {
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(nut_instance);
        assert(wait_sync_flag(&test_random_port_binding_node_connected, 300));
 
        meshlink_close(nut_instance);
-       meshlink_destroy("nut");
+       assert(meshlink_destroy("nut"));
 
        set_sync_flag(&test_random_port_binding_nut_closed, true);
 
 
        set_sync_flag(&test_random_port_binding_nut_closed, true);
 
index e94f9bfa637aed21ae2d51a478fff191e1263865..044234b3acb0bfdc06aed36ee8aa9d6f1ed271ec 100644 (file)
@@ -121,7 +121,7 @@ static bool test_set_rec_cb_01(void) {
        pthread_mutex_unlock(&lock);
 
        meshlink_close(mesh_handle);
        pthread_mutex_unlock(&lock);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("set_receive_cb_conf");
+       assert(meshlink_destroy("set_receive_cb_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -189,7 +189,7 @@ static bool test_set_rec_cb_03(void) {
        pthread_mutex_unlock(&lock);
 
        meshlink_close(mesh_handle);
        pthread_mutex_unlock(&lock);
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("set_receive_cb_conf");
+       assert(meshlink_destroy("set_receive_cb_conf"));
        return true;
 }
 
        return true;
 }
 
index 743636af9a59b395fc2ef3ab217fa6a16a9d491c..1cf47fce436faf81fbd87c87b4bfee87380333df 100644 (file)
@@ -99,7 +99,7 @@ static bool test_steps_mesh_send_01(void) {
        assert_int_equal(receive_data, true);
 
        meshlink_close(mesh);
        assert_int_equal(receive_data, true);
 
        meshlink_close(mesh);
-       meshlink_destroy("send_conf");
+       assert(meshlink_destroy("send_conf"));
        return result;
 }
 
        return result;
 }
 
@@ -130,7 +130,7 @@ static bool test_steps_mesh_send_02(void) {
        assert_int_equal(ret, false);
 
        meshlink_close(mesh);
        assert_int_equal(ret, false);
 
        meshlink_close(mesh);
-       meshlink_destroy("send_conf");
+       assert(meshlink_destroy("send_conf"));
        return true;
 }
 
        return true;
 }
 
@@ -159,7 +159,7 @@ static bool test_steps_mesh_send_03(void) {
        assert_int_equal(ret, false);
 
        meshlink_close(mesh);
        assert_int_equal(ret, false);
 
        meshlink_close(mesh);
-       meshlink_destroy("send_conf");
+       assert(meshlink_destroy("send_conf"));
        return true;
 }
 
        return true;
 }
 
index 45e75542a80165065e3b19c203475a8c1646ac6b..6eac8577009e864a1480b985b8f245a2422ab82d 100644 (file)
@@ -75,8 +75,8 @@ static void test_case_set_connection_try_cb_01(void **state) {
     After closing bar node it should invoke 3 connection try callbacks in span of about 30 seconds.
 */
 static bool test_set_connection_try_cb_01(void) {
     After closing bar node it should invoke 3 connection try callbacks in span of about 30 seconds.
 */
 static bool test_set_connection_try_cb_01(void) {
-       meshlink_destroy("meshlink_conf.1");
-       meshlink_destroy("meshlink_conf.2");
+       assert(meshlink_destroy("meshlink_conf.1"));
+       assert(meshlink_destroy("meshlink_conf.2"));
 
        // Opening foo and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("meshlink_conf.1", "foo", "test", DEV_CLASS_STATIONARY);
 
        // Opening foo and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("meshlink_conf.1", "foo", "test", DEV_CLASS_STATIONARY);
@@ -95,8 +95,8 @@ static bool test_set_connection_try_cb_01(void) {
        assert(exp1 != NULL);
        char *exp2 = meshlink_export(mesh2);
        assert(exp2 != NULL);
        assert(exp1 != NULL);
        char *exp2 = meshlink_export(mesh2);
        assert(exp2 != NULL);
-       meshlink_import(mesh1, exp2);
-       meshlink_import(mesh2, exp1);
+       assert(meshlink_import(mesh1, exp2));
+       assert(meshlink_import(mesh2, exp1));
        free(exp1);
        free(exp2);
 
        free(exp1);
        free(exp2);
 
@@ -129,8 +129,8 @@ static bool test_set_connection_try_cb_01(void) {
        assert_in_range(attempt_time_stop - attempt_time_start, 25, 45);
 
        // Cleanup
        assert_in_range(attempt_time_stop - attempt_time_start, 25, 45);
 
        // Cleanup
-       meshlink_destroy("meshlink_conf.1");
-       meshlink_destroy("meshlink_conf.2");
+       assert(meshlink_destroy("meshlink_conf.1"));
+       assert(meshlink_destroy("meshlink_conf.2"));
 
        return true;
 }
 
        return true;
 }
index 9a287023fe98c0359b33dcd56fd81453551b44d8..da49558432dbb1972eaa82849ff6364a4479441b 100644 (file)
@@ -80,7 +80,7 @@ static void test_case_set_log_cb_01(void **state) {
     log callback should be invoked when NUT joins with relay.
 */
 static bool test_set_log_cb_01(void) {
     log callback should be invoked when NUT joins with relay.
 */
 static bool test_set_log_cb_01(void) {
-       meshlink_destroy("logconf");
+       assert(meshlink_destroy("logconf"));
 
        // Create meshlink instance for NUT
 
 
        // Create meshlink instance for NUT
 
@@ -104,7 +104,7 @@ static bool test_set_log_cb_01(void) {
        // closing meshes and destroying confbase
 
        meshlink_close(mesh);
        // closing meshes and destroying confbase
 
        meshlink_close(mesh);
-       meshlink_destroy("logconf");
+       assert(meshlink_destroy("logconf"));
 
        return true;
 }
 
        return true;
 }
index ca3a2f38c47cdecb79b71364f4ff05520a02664d..e514e57f11328d4cf82bc0b96768a47547c40703 100644 (file)
@@ -95,7 +95,7 @@ static bool test_set_port_01(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("setportconf");
+       assert(meshlink_destroy("setportconf"));
        return true;
 }
 
        return true;
 }
 
@@ -153,7 +153,7 @@ static bool test_set_port_03(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("getportconf");
+       assert(meshlink_destroy("getportconf"));
 
        return false;
 }
 
        return false;
 }
index 758807146bdc78c74f7a4cdf3e3d9e56a34ddcec..68ae35218cf9a3251c326569a7ab40a0df917c2c 100644 (file)
@@ -119,7 +119,7 @@ static bool test_sign_01(void) {
 
        // Clean up
        meshlink_close(mesh_handle);
 
        // Clean up
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        return ret;
 }
 
        return ret;
 }
@@ -188,7 +188,7 @@ static bool test_sign_03(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as data arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as data arg\n");
@@ -234,7 +234,7 @@ static bool test_sign_04(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing 0 as size of data arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing 0 as size of data arg\n");
@@ -279,7 +279,7 @@ static bool test_sign_05(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as sign arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as sign arg\n");
@@ -323,7 +323,7 @@ static bool test_sign_06(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as signsize arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as signsize arg\n");
@@ -369,7 +369,7 @@ static bool test_sign_07(void) {
 
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
 
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
-       meshlink_destroy("signconf");
+       assert(meshlink_destroy("signconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing signsize < MESHLINK_SIGLEN arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing signsize < MESHLINK_SIGLEN arg\n");
index 7e6a8e8c1597bf922a5ae20ad069e00f35c549ba..be29b3303bcdb7ccc2add802f3f0f6af2c4762ea 100644 (file)
@@ -75,7 +75,7 @@ static bool test_steps_mesh_start_01(void) {
 
        // Clean up
        meshlink_close(mesh);
 
        // Clean up
        meshlink_close(mesh);
-       meshlink_destroy("start_conf");
+       assert(meshlink_destroy("start_conf"));
 
        if(!result) {
                fprintf(stderr, "meshlink_start status1: %s\n", meshlink_strerror(meshlink_errno));
 
        if(!result) {
                fprintf(stderr, "meshlink_start status1: %s\n", meshlink_strerror(meshlink_errno));
@@ -100,7 +100,7 @@ static void test_case_mesh_start_02(void **state) {
 */
 static bool test_steps_mesh_start_02(void) {
        bool result = false;
 */
 static bool test_steps_mesh_start_02(void) {
        bool result = false;
-       meshlink_destroy("start_conf");
+       assert(meshlink_destroy("start_conf"));
        meshlink_handle_t *mesh = meshlink_open("start_conf", "foo", "test", DEV_CLASS_STATIONARY);
        assert(mesh);
 
        meshlink_handle_t *mesh = meshlink_open("start_conf", "foo", "test", DEV_CLASS_STATIONARY);
        assert(mesh);
 
@@ -112,7 +112,7 @@ static bool test_steps_mesh_start_02(void) {
        // Clean up
 
        meshlink_close(mesh);
        // Clean up
 
        meshlink_close(mesh);
-       meshlink_destroy("start_conf");
+       assert(meshlink_destroy("start_conf"));
        return true;
 }
 
        return true;
 }
 
index f60542b5cfdfb87dc5f36549ab4bb0ebe86b8e17..fedf3e618503339e38da9341a8704d9073990323 100644 (file)
@@ -85,8 +85,8 @@ static void test_case_set_status_cb_01(void **state) {
     status callback should be invoked when NUT connects/disconnects with 'relay' node.
 */
 static bool test_set_status_cb_01(void) {
     status callback should be invoked when NUT connects/disconnects with 'relay' node.
 */
 static bool test_set_status_cb_01(void) {
-       meshlink_destroy("set_status_cb_conf.1");
-       meshlink_destroy("set_status_cb_conf.2");
+       assert(meshlink_destroy("set_status_cb_conf.1"));
+       assert(meshlink_destroy("set_status_cb_conf.2"));
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("set_status_cb_conf.1", "nut", "test", DEV_CLASS_STATIONARY);
 
        // Opening NUT and bar nodes
        meshlink_handle_t *mesh1 = meshlink_open("set_status_cb_conf.1", "nut", "test", DEV_CLASS_STATIONARY);
@@ -104,8 +104,8 @@ static bool test_set_status_cb_01(void) {
        assert(exp1 != NULL);
        char *exp2 = meshlink_export(mesh2);
        assert(exp2 != NULL);
        assert(exp1 != NULL);
        char *exp2 = meshlink_export(mesh2);
        assert(exp2 != NULL);
-       meshlink_import(mesh1, exp2);
-       meshlink_import(mesh2, exp1);
+       assert(meshlink_import(mesh1, exp2));
+       assert(meshlink_import(mesh2, exp1));
 
        assert(meshlink_start(mesh1));
        assert(meshlink_start(mesh2));
 
        assert(meshlink_start(mesh1));
        assert(meshlink_start(mesh2));
@@ -123,8 +123,8 @@ static bool test_set_status_cb_01(void) {
        free(exp1);
        free(exp2);
        meshlink_close(mesh1);
        free(exp1);
        free(exp2);
        meshlink_close(mesh1);
-       meshlink_destroy("set_status_cb_conf.1");
-       meshlink_destroy("set_status_cb_conf.2");
+       assert(meshlink_destroy("set_status_cb_conf.1"));
+       assert(meshlink_destroy("set_status_cb_conf.2"));
 
        return true;
 }
 
        return true;
 }
@@ -146,7 +146,7 @@ static bool test_set_status_cb_02(void) {
 
        // Create meshlink instance
 
 
        // Create meshlink instance
 
-       meshlink_destroy("set_status_cb_conf.3");
+       assert(meshlink_destroy("set_status_cb_conf.3"));
        meshlink_handle_t *mesh_handle = meshlink_open("set_status_cb_conf.3", "nut", "node_sim", 1);
        assert(mesh_handle);
 
        meshlink_handle_t *mesh_handle = meshlink_open("set_status_cb_conf.3", "nut", "node_sim", 1);
        assert(mesh_handle);
 
@@ -159,7 +159,7 @@ static bool test_set_status_cb_02(void) {
        // Clean up
 
        meshlink_close(mesh_handle);
        // Clean up
 
        meshlink_close(mesh_handle);
-       meshlink_destroy("set_status_cb_conf.3");
+       assert(meshlink_destroy("set_status_cb_conf.3"));
        return true;
 }
 
        return true;
 }
 
index 96a27059b717a1ce8feed47b0bdebdda1e9bde2f..f811e169770f7326e081cee7cba647b9306153ff 100644 (file)
@@ -113,7 +113,7 @@ bool test_verify_01(void) {
        assert(source);
        ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
        assert(source);
        ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify FAILED to verify data\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify FAILED to verify data\n");
@@ -158,7 +158,7 @@ bool test_verify_02(void) {
        assert(source != NULL);
        bool ret = meshlink_verify(NULL, source, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
        assert(source != NULL);
        bool ret = meshlink_verify(NULL, source, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
@@ -200,7 +200,7 @@ bool test_verify_03(void) {
        assert(ret);
        ret = meshlink_verify(mesh_handle, NULL, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
        assert(ret);
        ret = meshlink_verify(mesh_handle, NULL, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh_handle);
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as node_handle arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as node_handle arg\n");
@@ -228,7 +228,7 @@ void test_case_verify_04(void **state) {
     Reports error accordingly by returning false
 */
 bool test_verify_04(void) {
     Reports error accordingly by returning false
 */
 bool test_verify_04(void) {
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
        assert(mesh_handle);
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
        assert(mesh_handle);
@@ -245,7 +245,7 @@ bool test_verify_04(void) {
        ret = meshlink_verify(mesh_handle, source, NULL, strlen(data) + 1, sig, ssize);
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
        ret = meshlink_verify(mesh_handle, source, NULL, strlen(data) + 1, sig, ssize);
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as data arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as data arg\n");
@@ -291,7 +291,7 @@ bool test_verify_05(void) {
        ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, NULL, ssize);
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
        ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, NULL, ssize);
        meshlink_stop(mesh_handle);
        meshlink_close(mesh_handle);
-       meshlink_destroy("verifyconf");
+       assert(meshlink_destroy("verifyconf"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully NULL as sign arg\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully NULL as sign arg\n");
@@ -321,8 +321,8 @@ void test_case_verify_06(void **state) {
 */
 bool test_verify_06(void) {
        /* deleting the confbase if already exists */
 */
 bool test_verify_06(void) {
        /* deleting the confbase if already exists */
-       meshlink_destroy("verifyconf1");
-       meshlink_destroy("verifyconf2");
+       assert(meshlink_destroy("verifyconf1"));
+       assert(meshlink_destroy("verifyconf2"));
        /* Set up logging for Meshlink */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_handle_t *mesh1 = meshlink_open("verifyconf1", "nut", "chat", DEV_CLASS_STATIONARY);
        /* Set up logging for Meshlink */
        meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
        meshlink_handle_t *mesh1 = meshlink_open("verifyconf1", "nut", "chat", DEV_CLASS_STATIONARY);
@@ -349,8 +349,8 @@ bool test_verify_06(void) {
        ret = meshlink_verify(mesh_handle, source_nut, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
        ret = meshlink_verify(mesh_handle, source_nut, data, strlen(data) + 1, sig, ssize);
        meshlink_close(mesh1);
        meshlink_close(mesh2);
-       meshlink_destroy("verifyconf1");
-       meshlink_destroy("verifyconf2");
+       assert(meshlink_destroy("verifyconf1"));
+       assert(meshlink_destroy("verifyconf2"));
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully returned 'false' when a wrong source node used to verify the data\n");
 
        if(!ret) {
                PRINT_TEST_CASE_MSG("meshlink_verify successfully returned 'false' when a wrong source node used to verify the data\n");
index 0a9dd3182c2241aeeadff45dc3b0dcb30e50c8e8..68283a96f0fca27b699dc3af4ce2477c81e2ae55 100644 (file)
@@ -113,8 +113,8 @@ static bool test_steps_mesh_whitelist_01(void) {
 
        // Open two new meshlink instance.
 
 
        // Open two new meshlink instance.
 
-       meshlink_destroy("whitelist_conf.1");
-       meshlink_destroy("whitelist_conf.2");
+       assert(meshlink_destroy("whitelist_conf.1"));
+       assert(meshlink_destroy("whitelist_conf.2"));
        meshlink_handle_t *mesh1 = meshlink_open("whitelist_conf.1", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh1);
        meshlink_set_log_cb(mesh1, MESHLINK_DEBUG, meshlink_callback_logger);
        meshlink_handle_t *mesh1 = meshlink_open("whitelist_conf.1", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh1);
        meshlink_set_log_cb(mesh1, MESHLINK_DEBUG, meshlink_callback_logger);
@@ -170,7 +170,7 @@ static bool test_steps_mesh_whitelist_01(void) {
        pthread_mutex_unlock(& lock_receive);
 
 
        pthread_mutex_unlock(& lock_receive);
 
 
-       meshlink_blacklist(mesh1, foo);
+       assert(meshlink_blacklist(mesh1, foo));
 
        rec_stat = false;
        assert(meshlink_send(mesh1, bar, "test", 5));
 
        rec_stat = false;
        assert(meshlink_send(mesh1, bar, "test", 5));
@@ -183,7 +183,7 @@ static bool test_steps_mesh_whitelist_01(void) {
        }
 
        pthread_mutex_unlock(& lock_receive);
        }
 
        pthread_mutex_unlock(& lock_receive);
-       meshlink_whitelist(mesh1, foo);
+       assert(meshlink_whitelist(mesh1, foo));
 
        rec_stat = false;
        bool result = meshlink_send(mesh2, foo, "test", 5);
 
        rec_stat = false;
        bool result = meshlink_send(mesh2, foo, "test", 5);
@@ -200,8 +200,8 @@ static bool test_steps_mesh_whitelist_01(void) {
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("whitelist_conf.1");
-       meshlink_destroy("whitelist_conf.2");
+       assert(meshlink_destroy("whitelist_conf.1"));
+       assert(meshlink_destroy("whitelist_conf.2"));
 
        return result;
 }
 
        return result;
 }
@@ -224,8 +224,8 @@ static bool test_steps_mesh_whitelist_02(void) {
 
        // Open two new meshlink instance.
 
 
        // Open two new meshlink instance.
 
-       meshlink_destroy("whitelist_conf.3");
-       meshlink_destroy("whitelist_conf.4");
+       assert(meshlink_destroy("whitelist_conf.3"));
+       assert(meshlink_destroy("whitelist_conf.4"));
        meshlink_handle_t *mesh1 = meshlink_open("whitelist_conf.3", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh1);
        meshlink_handle_t *mesh2 = meshlink_open("whitelist_conf.4", "bar", "test", DEV_CLASS_BACKBONE);
        meshlink_handle_t *mesh1 = meshlink_open("whitelist_conf.3", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh1);
        meshlink_handle_t *mesh2 = meshlink_open("whitelist_conf.4", "bar", "test", DEV_CLASS_BACKBONE);
@@ -266,19 +266,19 @@ static bool test_steps_mesh_whitelist_02(void) {
 
        assert(meshlink_send(mesh1, bar, "test", 5));
 
 
        assert(meshlink_send(mesh1, bar, "test", 5));
 
-       meshlink_blacklist(mesh1, foo);
+       assert(meshlink_blacklist(mesh1, foo));
 
        // Passing NULL as mesh handle but with valid node handle 'foo'
 
 
        // Passing NULL as mesh handle but with valid node handle 'foo'
 
-       meshlink_whitelist(NULL, foo);
+       assert(!meshlink_whitelist(NULL, foo));
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
 
        meshlink_close(mesh2);
        meshlink_close(mesh1);
-       meshlink_destroy("whitelist_conf.3");
-       meshlink_destroy("whitelist_conf.4");
+       assert(meshlink_destroy("whitelist_conf.3"));
+       assert(meshlink_destroy("whitelist_conf.4"));
 
        return true;
 }
 
        return true;
 }
@@ -299,20 +299,20 @@ static void test_case_mesh_whitelist_03(void **state) {
 static bool test_steps_mesh_whitelist_03(void) {
        // Open meshlink instance.
 
 static bool test_steps_mesh_whitelist_03(void) {
        // Open meshlink instance.
 
-       meshlink_destroy("whitelist_conf");
+       assert(meshlink_destroy("whitelist_conf"));
        meshlink_handle_t *mesh = meshlink_open("whitelist_conf", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh);
 
        // Start instance
        assert(meshlink_start(mesh));
 
        meshlink_handle_t *mesh = meshlink_open("whitelist_conf", "foo", "test", DEV_CLASS_BACKBONE);
        assert(mesh);
 
        // Start instance
        assert(meshlink_start(mesh));
 
-       meshlink_whitelist(mesh, NULL);
+       assert(!meshlink_whitelist(mesh, NULL));
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
 
        meshlink_close(mesh);
        assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
 
        // Clean up.
 
        meshlink_close(mesh);
-       meshlink_destroy("whitelist_conf");
+       assert(meshlink_destroy("whitelist_conf"));
        return true;
 }
 
        return true;
 }
 
index d7463e761e36c139bd03ecf48e6d892d720a2a97..1d7408957ef90a20c052170c54fd4eef3377ac27 100644 (file)
@@ -77,9 +77,9 @@ static int setup_test(void **state) {
        ping_channel_enable_07 = false;
        memset(node_pmtu, 0, sizeof(node_pmtu));
        set_sync_flag(&test_pmtu_nut_closed, false);
        ping_channel_enable_07 = false;
        memset(node_pmtu, 0, sizeof(node_pmtu));
        set_sync_flag(&test_pmtu_nut_closed, false);
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
 
        return EXIT_SUCCESS;
 }
 
        return EXIT_SUCCESS;
 }
@@ -87,9 +87,9 @@ static int setup_test(void **state) {
 static int teardown_test(void **state) {
        (void)state;
 
 static int teardown_test(void **state) {
        (void)state;
 
-       meshlink_destroy("nut");
-       meshlink_destroy("peer");
-       meshlink_destroy("relay");
+       assert(meshlink_destroy("nut"));
+       assert(meshlink_destroy("peer"));
+       assert(meshlink_destroy("relay"));
        netns_destroy_topology(test_pmtu_state);
 
        return EXIT_SUCCESS;
        netns_destroy_topology(test_pmtu_state);
 
        return EXIT_SUCCESS;
index 7c17340533f8341365570c436a8e8bd2c4655b58..9e04a8bba2d5d93b62f93869932bd8d85a5612f1 100644 (file)
@@ -179,7 +179,7 @@ void *test_channel_blacklist_disonnection_nut_01(void *arg) {
 
        fprintf(stderr, "Node blacklisted\n");
        set_sync_flag(&channels_closed, false);
 
        fprintf(stderr, "Node blacklisted\n");
        set_sync_flag(&channels_closed, false);
-       meshlink_blacklist(mesh, peer_node);
+       assert(meshlink_blacklist(mesh, peer_node));
 
        sleep(10);
 
 
        sleep(10);
 
@@ -209,7 +209,7 @@ void *test_channel_blacklist_disonnection_nut_01(void *arg) {
 
        set_sync_flag(&peer_reachable, false);
 
 
        set_sync_flag(&peer_reachable, false);
 
-       meshlink_whitelist(mesh, peer_node);
+       assert(meshlink_whitelist(mesh, peer_node));
        fprintf(stderr, "Node whitelisted\n");
 
        wait_sync_flag(&peer_reachable, 70);
        fprintf(stderr, "Node whitelisted\n");
 
        wait_sync_flag(&peer_reachable, 70);
index 43e2a7f57185f5b407bce2640d73c9a8d7ca10ec..a6c293ad26a9198ad6e081968db0c1fab5cae554 100644 (file)
@@ -36,7 +36,7 @@ void *test_channel_blacklist_disonnection_relay_01(void *arg) {
        mesh = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(mesh);
 
        mesh = meshlink_open(mesh_arg->node_name, mesh_arg->confbase, mesh_arg->app_name, mesh_arg->dev_class);
        assert(mesh);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_channel_blacklist_disonnection_relay_01_running) {
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_channel_blacklist_disonnection_relay_01_running) {
index 52646399340c58a801469bada04f80b29a339042..9579f0123a4413a66ebfecf0a52155587991ebec 100644 (file)
@@ -152,7 +152,7 @@ int main(int argc, char *argv[]) {
        // Restarting the node instance
 
        meshlink_stop(mesh);
        // Restarting the node instance
 
        meshlink_stop(mesh);
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        assert(wait_sync_flag(&peer_reachable, 60));
        send_event(NODE_RESTARTED);
 
        assert(wait_sync_flag(&peer_reachable, 60));
        send_event(NODE_RESTARTED);
index c4fd1e4c366b869ba1e004f45376466b93c95e26..8e5e66ec9eb14e7e0b397f476a29ed05e70a4456 100644 (file)
@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) {
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
index c4fd1e4c366b869ba1e004f45376466b93c95e26..8e5e66ec9eb14e7e0b397f476a29ed05e70a4456 100644 (file)
@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) {
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
index c4fd1e4c366b869ba1e004f45376466b93c95e26..8e5e66ec9eb14e7e0b397f476a29ed05e70a4456 100644 (file)
@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) {
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
index 52646399340c58a801469bada04f80b29a339042..9579f0123a4413a66ebfecf0a52155587991ebec 100644 (file)
@@ -152,7 +152,7 @@ int main(int argc, char *argv[]) {
        // Restarting the node instance
 
        meshlink_stop(mesh);
        // Restarting the node instance
 
        meshlink_stop(mesh);
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        assert(wait_sync_flag(&peer_reachable, 60));
        send_event(NODE_RESTARTED);
 
        assert(wait_sync_flag(&peer_reachable, 60));
        send_event(NODE_RESTARTED);
index c4fd1e4c366b869ba1e004f45376466b93c95e26..8e5e66ec9eb14e7e0b397f476a29ed05e70a4456 100644 (file)
@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) {
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
        assert(mesh);
        meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        while(test_running) {
index 77ff2b801d0c9d77e3d40b7029edb49da45e7dbf..5cf624f22eaf18c7b61eada479b6d52b41402f12 100644 (file)
@@ -128,6 +128,6 @@ int main(int argc, char *argv[]) {
        assert(mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, NULL, 0));
 
        execute_close();
        assert(mesh_event_sock_send(client_id, META_RECONN_SUCCESSFUL, NULL, 0));
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
        return 0;
 }
        return 0;
 }
index 8b242038ed0acd90c40b1f1df4f9747a15fa6922..5dd8807ec65dcfad14540c92c74144ea1fbe514f 100644 (file)
@@ -60,5 +60,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 3c6c548c36873bd73571de5f49c0c1ab830dd972..cde644c8c6c387b85c7884767413a411ec2735ca 100644 (file)
@@ -56,5 +56,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index d56124ddd3c2c9530bb6ad764f7053064ea2e35c..c197c58c75baee0ba42a19708edf1aad38807940 100644 (file)
@@ -112,7 +112,7 @@ int main(int argc, char *argv[]) {
        assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, NULL, 0));
 
        execute_close();
        assert(mesh_event_sock_send(client_id, META_CONN_SUCCESSFUL, NULL, 0));
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 
        return 0;
 }
 
        return 0;
 }
index 429ca3331325d746135eb9c538e1ab697c20ee7c..91ac601eb80707bab9c495120de65055d9337927 100644 (file)
@@ -66,5 +66,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 20fd8373551309d1e797c478b78db9568a8313c3..57ea254d2efd39eadb0278cb041e3f80693840af 100644 (file)
@@ -62,5 +62,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index cdffb6eac2dd729d5bde008e26bd1f3107d298f9..4038d24619402a6ace60cf719caed0c4d9d7633f 100644 (file)
@@ -125,7 +125,7 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 
        return 0;
 }
 
        return 0;
 }
index 429ca3331325d746135eb9c538e1ab697c20ee7c..91ac601eb80707bab9c495120de65055d9337927 100644 (file)
@@ -66,5 +66,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index f24037d9404bb2682237d730a9b5dd2f071cf0ae..a6f917725cc220db948ad67df803bd18308dc87b 100644 (file)
@@ -62,5 +62,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index e16dee39fec86ed6702f3ba35139cd4f36fe58a2..e2085720a1c3e5d23d70e20cbdaae1f03f04cd8c 100644 (file)
@@ -126,5 +126,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index ef0cfcbbdba166a950c3224c3d1cf840615a421d..b003e0615eb4b0a9d3d19c1853a0908b1a49a6d2 100644 (file)
@@ -66,5 +66,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 3e4299dc6091460a6959ff2a7a0c655981cddf18..37bb11d6669d0b89625e9771a85fde339a6aaa75 100644 (file)
@@ -59,5 +59,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index b6d90c936b5f8ece28481e3b5c8c261fd4c5cd59..1581cebb8f3e525b8896f12032bfd0f0fee1f7f7 100644 (file)
@@ -143,5 +143,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 429ca3331325d746135eb9c538e1ab697c20ee7c..91ac601eb80707bab9c495120de65055d9337927 100644 (file)
@@ -66,5 +66,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 3e4299dc6091460a6959ff2a7a0c655981cddf18..37bb11d6669d0b89625e9771a85fde339a6aaa75 100644 (file)
@@ -59,5 +59,5 @@ int main(int argc, char *argv[]) {
        }
 
        execute_close();
        }
 
        execute_close();
-       meshlink_destroy(argv[1]);
+       assert(meshlink_destroy(argv[1]));
 }
 }
index 936720b22dbc3506f7ac2ffe6aaf8a654964956b..6e745b75521aff3d2211dd70bda53fa8e5c0647e 100644 (file)
@@ -286,7 +286,7 @@ void *node_sim_pmtu_nut_01(void *arg) {
 
                        if(time_stamp >= send_time) {
                                send_time = time_stamp + 10;
 
                        if(time_stamp >= send_time) {
                                send_time = time_stamp + 10;
-                               meshlink_channel_send(mesh, channel, "ping", 5);
+                               assert(meshlink_channel_send(mesh, channel, "ping", 5) == 5);
                        }
                }
        }
                        }
                }
        }
index 0eff6da671066d90fe6ee1076b34727550f92f61..7823f4b9d9c362bd7bf59828686e3cc6f8e0e9ce 100644 (file)
@@ -50,7 +50,7 @@ void *node_sim_pmtu_relay_01(void *arg) {
        //meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
        meshlink_enable_discovery(mesh, false);
 
        //meshlink_set_log_cb(mesh, MESHLINK_DEBUG, meshlink_callback_logger);
        meshlink_enable_discovery(mesh, false);
 
-       meshlink_start(mesh);
+       assert(meshlink_start(mesh));
        //send_event(NODE_STARTED);
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
        //send_event(NODE_STARTED);
 
        /* All test steps executed - wait for signals to stop/start or close the mesh */
index 0b30963df1c58b775af44aecc70a4e6d636ed88c..8e47d7e3fdf7217979fd1044dd4ca657353b237c 100644 (file)
@@ -263,11 +263,11 @@ int main(int argc, char *argv[]) {
        }
 
        channel_data_recieved.flag = false;
        }
 
        channel_data_recieved.flag = false;
-       meshlink_blacklist(mesh, app1_node1);
+       assert(meshlink_blacklist(mesh, app1_node1));
 
        sleep(2);
 
 
        sleep(2);
 
-       meshlink_channel_send(mesh, ch_app1node1, "test", 5);
+       assert(meshlink_channel_send(mesh, ch_app1node1, "test", 5) == 5);
 
        wait_sync_flag(&channel_data_recieved, 30);
 
 
        wait_sync_flag(&channel_data_recieved, 30);
 
@@ -277,11 +277,11 @@ int main(int argc, char *argv[]) {
        }
 
        channel_data_recieved.flag = false;
        }
 
        channel_data_recieved.flag = false;
-       meshlink_whitelist(mesh, app1_node1);
+       assert(meshlink_whitelist(mesh, app1_node1));
 
        sleep(2);
 
 
        sleep(2);
 
-       meshlink_channel_send(mesh, ch_app1node1, "Channel Message", strlen("Channel Message"));
+       assert(meshlink_channel_send(mesh, ch_app1node1, "Channel Message", strlen("Channel Message")) == strlen("Channel Message"));
 
        assert(wait_sync_flag(&channel_data_recieved, 60));
 
 
        assert(wait_sync_flag(&channel_data_recieved, 60));
 
index 369ac4eed5b9295c880594e6815a424eb59a0187..d4644a42c00943a1d9e57d91c4975f02fb192940 100644 (file)
@@ -34,7 +34,7 @@ static void a_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, c
 static void b_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
        // Send one message back, then close the channel.
        if(len) {
 static void b_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
        // Send one message back, then close the channel.
        if(len) {
-               meshlink_channel_send(mesh, channel, data, len);
+               assert(meshlink_channel_send(mesh, channel, data, len) == (ssize_t)len);
        }
 
        meshlink_channel_close(mesh, channel);
        }
 
        meshlink_channel_close(mesh, channel);
@@ -138,8 +138,7 @@ int main() {
        struct sync_flag channel_closed = {.flag = false};
        channel->priv = &channel_closed;
 
        struct sync_flag channel_closed = {.flag = false};
        channel->priv = &channel_closed;
 
-       meshlink_channel_send(a, channel, "Hello", 5);
-
+       assert(meshlink_channel_send(a, channel, "Hello", 5) == 5);
        assert(wait_sync_flag(&channel_closed, 20));
        assert(b_responded);
        assert(b_closed);
        assert(wait_sync_flag(&channel_closed, 20));
        assert(b_responded);
        assert(b_closed);
index 8a2ddd808f3f662cb63eb39b2ed2552dd4d49d68..9168168c8db54ab237d0ed0c992c582e7e2cee24 100644 (file)
@@ -45,7 +45,7 @@ static void bar_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool r
 static void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
        // Echo the data back.
        if(len) {
 static void bar_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len) {
        // Echo the data back.
        if(len) {
-               meshlink_channel_send(mesh, channel, data, len);
+               assert(meshlink_channel_send(mesh, channel, data, len) == (ssize_t)len);
        } else {
                meshlink_channel_close(mesh, channel);
        }
        } else {
                meshlink_channel_close(mesh, channel);
        }
@@ -96,7 +96,7 @@ static int main1(int rfd, int wfd) {
 
        meshlink_enable_discovery(mesh, false);
 
 
        meshlink_enable_discovery(mesh, false);
 
-       meshlink_add_address(mesh, "localhost");
+       assert(meshlink_add_address(mesh, "localhost"));
 
        char *data = meshlink_export(mesh);
        assert(data);
 
        char *data = meshlink_export(mesh);
        assert(data);
@@ -152,7 +152,7 @@ static int main2(int rfd, int wfd) {
 
        meshlink_enable_discovery(mesh, false);
 
 
        meshlink_enable_discovery(mesh, false);
 
-       meshlink_add_address(mesh, "localhost");
+       assert(meshlink_add_address(mesh, "localhost"));
 
        char *data = meshlink_export(mesh);
        assert(data);
 
        char *data = meshlink_export(mesh);
        assert(data);
index bcf8cec1be8946dc2408a4651b795f4bf2b7f1ad..c765456abff08e3de1b9c8a5151182e59c6ddd4d 100644 (file)
@@ -68,7 +68,7 @@ int main(int argc, char *argv[]) {
 
        // Restart a to ensure it gets to flush the channel send queue.
 
 
        // Restart a to ensure it gets to flush the channel send queue.
 
-       meshlink_start(mesh_a);
+       assert(meshlink_start(mesh_a));
 
        assert_after(!meshlink_channel_get_sendq(mesh_a, channel), 30);
        assert(meshlink_channel_send(mesh_a, channel, buf, 512) == 512);
 
        assert_after(!meshlink_channel_get_sendq(mesh_a, channel), 30);
        assert(meshlink_channel_send(mesh_a, channel, buf, 512) == 512);
index 5dd4f428a199ffe348128e2dd75ecc9da4dd29a6..5424ae66639bf3e4929a86763a0d216339704610 100644 (file)
@@ -32,7 +32,7 @@ static void b_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, c
        fwrite(data, 1, len, stdout);
        printf("\n");
        // Echo the data back.
        fwrite(data, 1, len, stdout);
        printf("\n");
        // Echo the data back.
-       meshlink_channel_send(mesh, channel, data, len);
+       assert(meshlink_channel_send(mesh, channel, data, len) == (ssize_t)len);
 }
 
 static bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
 }
 
 static bool reject_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
index 28155711ca2f984fd1dcbd98831c450ee222fb02..db2ce72a0db80540d0c8ac5aadf26b41db581465 100644 (file)
@@ -15,7 +15,7 @@ static struct sync_flag duplicate_detected;
 
 static void handle_duplicate(meshlink_handle_t *mesh, meshlink_node_t *node) {
        set_sync_flag(&duplicate_detected, true);
 
 static void handle_duplicate(meshlink_handle_t *mesh, meshlink_node_t *node) {
        set_sync_flag(&duplicate_detected, true);
-       meshlink_blacklist(mesh, node);
+       assert(meshlink_blacklist(mesh, node));
 }
 
 int main() {
 }
 
 int main() {
@@ -34,7 +34,7 @@ int main() {
                mesh[i] = meshlink_open(dirname, name[i], "duplicate", DEV_CLASS_BACKBONE);
                assert(mesh[i]);
 
                mesh[i] = meshlink_open(dirname, name[i], "duplicate", DEV_CLASS_BACKBONE);
                assert(mesh[i]);
 
-               meshlink_add_address(mesh[i], "localhost");
+               assert(meshlink_add_address(mesh[i], "localhost"));
                meshlink_enable_discovery(mesh[i], false);
 
                meshlink_set_node_duplicate_cb(mesh[i], handle_duplicate);
                meshlink_enable_discovery(mesh[i], false);
 
                meshlink_set_node_duplicate_cb(mesh[i], handle_duplicate);
index 133cbcbe98e30084afbac38f12ab833473a97185..8bc41c1b3c06fad7ac11b7fba4956f41abfe5dac 100644 (file)
@@ -43,8 +43,8 @@ int main() {
 
        // Import and export both side's data
 
 
        // Import and export both side's data
 
-       meshlink_add_address(mesh1, "localhost");
-       meshlink_add_address(mesh2, "localhost");
+       assert(meshlink_add_address(mesh1, "localhost"));
+       assert(meshlink_add_address(mesh2, "localhost"));
 
        char *data = meshlink_export(mesh1);
        assert(data);
 
        char *data = meshlink_export(mesh1);
        assert(data);
index 49b5981ba85a2fec312980ff505ee143259ad13f..1dd6c26da654bc525bef2b446e7b5fb25e4eafce 100644 (file)
@@ -50,7 +50,7 @@ int main() {
 
        meshlink_set_node_status_cb(mesh1, status_cb);
 
 
        meshlink_set_node_status_cb(mesh1, status_cb);
 
-       meshlink_add_address(mesh1, "localhost");
+       assert(meshlink_add_address(mesh1, "localhost"));
        char *baz_url = meshlink_invite(mesh1, NULL, "baz");
        assert(baz_url);
 
        char *baz_url = meshlink_invite(mesh1, NULL, "baz");
        assert(baz_url);
 
index 9fa7de33ea37e2f467de4473d071434fe8073c1d..a183b3da92493d09e299989f843b160ec2bb93b9 100644 (file)
@@ -65,7 +65,7 @@ int main() {
                assert(mesh[i]);
                free(path);
 
                assert(mesh[i]);
                free(path);
 
-               meshlink_add_address(mesh[i], "localhost");
+               assert(meshlink_add_address(mesh[i], "localhost"));
 
                data[i] = meshlink_export(mesh[i]);
                assert(data[i]);
 
                data[i] = meshlink_export(mesh[i]);
                assert(data[i]);
index 283b280a08085c951e09f557a5f48d1a82cf4e94..57312988e1b174885eeff1a08c8f53483bb06dd0 100644 (file)
@@ -65,7 +65,7 @@ int main() {
                assert(mesh[i]);
                free(path);
 
                assert(mesh[i]);
                free(path);
 
-               meshlink_add_address(mesh[i], "localhost");
+               assert(meshlink_add_address(mesh[i], "localhost"));
 
                data[i] = meshlink_export(mesh[i]);
                assert(data[i]);
 
                data[i] = meshlink_export(mesh[i]);
                assert(data[i]);
index c11894b7f82a467c7181d7d2ff508a7713752224..28e3d62fd90e133a23dfc3440dbc1f3905c9e68b 100644 (file)
@@ -49,8 +49,8 @@ bool wait_sync_flag(struct sync_flag *s, int seconds) {
 void link_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
        // Import and export both side's data
 
 void link_meshlink_pair(meshlink_handle_t *a, meshlink_handle_t *b) {
        // Import and export both side's data
 
-       meshlink_add_address(a, "localhost");
-       meshlink_add_address(b, "localhost");
+       assert(meshlink_add_address(a, "localhost"));
+       assert(meshlink_add_address(b, "localhost"));
 
        char *data = meshlink_export(a);
        assert(data);
 
        char *data = meshlink_export(a);
        assert(data);