Add meshlink_get_node_reachability().

This function returns the current state of a node's reachability, as
well as the last time the node became reachable and the last time it
became unreachable.

diff --git a/src/meshlink++.h b/src/meshlink++.h
index 3599cc55f44c7b59a64f66eab4aece32479ba6ff..6374a86d3b3725920c4b464da91afb6dbfaa744c 100644 (file)
--- a/src/meshlink++.h
+++ b/src/meshlink++.h
@@ -388,6 +388,20 @@ public:
                return (node *)meshlink_get_node(handle, name);
        }
 
+       /// Get a node's reachability status.
+       /** This function returns the current reachability of a given node, and the times of the last state changes.
+        *  If a given state change never happened, the time returned will be 0.
+        *
+        *  @param node              A pointer to a meshlink::node describing the node.
+        *  @param last_reachable    A pointer to a time_t variable that will be filled in with the last time the node became reachable.
+        *  @param last_unreachable  A pointer to a time_t variable that will be filled in with the last time the node became unreachable.
+        *
+        *  @return                  This function returns true if the node is currently reachable, false otherwise.
+        */
+       bool get_node_reachability(node *node, time_t *last_reachable = NULL, time_t *last_unreachable = NULL) {
+               return meshlink_get_node_reachability(handle, node, last_reachable, last_unreachable);
+       }
+
        /// Get a handle for a specific submesh.
        /** This function returns a handle for the submesh with the given name.
         *

diff --git a/src/meshlink.c b/src/meshlink.c
index 30b386846a7322e261a1b0f4888331773352fe0c..2d4c2e1f2beb1c218eebd5343be2f6aa75cb8644 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -2143,6 +2143,31 @@ meshlink_submesh_t *meshlink_get_node_submesh(meshlink_handle_t *mesh, meshlink_
        return s;
 }
 
+bool meshlink_get_node_reachability(struct meshlink_handle *mesh, struct meshlink_node *node, time_t *last_reachable, time_t *last_unreachable) {
+       if(!mesh || !node) {
+               meshlink_errno = MESHLINK_EINVAL;
+               return NULL;
+       }
+
+       node_t *n = (node_t *)node;
+       bool reachable;
+
+       pthread_mutex_lock(&mesh->mutex);
+       reachable = n->status.reachable;
+
+       if(last_reachable) {
+               *last_reachable = n->last_reachable;
+       }
+
+       if(last_unreachable) {
+               *last_unreachable = n->last_unreachable;
+       }
+
+       pthread_mutex_unlock(&mesh->mutex);
+
+       return reachable;
+}
+
 bool meshlink_sign(meshlink_handle_t *mesh, const void *data, size_t len, void *signature, size_t *siglen) {
        if(!mesh || !data || !len || !signature || !siglen) {
                meshlink_errno = MESHLINK_EINVAL;

diff --git a/src/meshlink.h b/src/meshlink.h
index e3a7ca942ae3b30de27a8ce18deaa646def9f08e..e0f1bae7b09d6413d9b809ef514cbe5f75143348 100644 (file)
--- a/src/meshlink.h
+++ b/src/meshlink.h
@@ -758,6 +758,22 @@ extern dev_class_t meshlink_get_node_dev_class(struct meshlink_handle *mesh, str
  */
 extern struct meshlink_submesh *meshlink_get_node_submesh(struct meshlink_handle *mesh, struct meshlink_node *node) __attribute__((__warn_unused_result__));
 
+/// Get a node's reachability status.
+/** This function returns the current reachability of a given node, and the times of the last state changes.
+ *  If a given state change never happened, the time returned will be 0.
+ *
+ *  \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.
+ *  @param last_reachable    A pointer to a time_t variable that will be filled in with the last time the node became reachable.
+ *                           Pass NULL to not have anything written.
+ *  @param last_unreachable  A pointer to a time_t variable that will be filled in with the last time the node became unreachable.
+ *                           Pass NULL to not have anything written.
+ *
+ *  @return                  This function returns true if the node is currently reachable, false otherwise.
+ */
+extern bool meshlink_get_node_reachability(struct meshlink_handle *mesh, struct meshlink_node *node, time_t *last_reachable, time_t *last_unreachable);
+
 /// 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.
  *

diff --git a/src/meshlink.sym b/src/meshlink.sym
index b0ad2e52e38bb8107e837750305bc76d1bcd40d0..9c3d9065dd940965e7f0f3d9061bdf6c8b6d1c4e 100644 (file)
--- a/src/meshlink.sym
+++ b/src/meshlink.sym
@@ -39,6 +39,7 @@ meshlink_get_fingerprint
 meshlink_get_local_address_for_family
 meshlink_get_node
 meshlink_get_node_dev_class
+meshlink_get_node_reachability
 meshlink_get_node_submesh
 meshlink_get_pmtu
 meshlink_get_port

diff --git a/test/basic.c b/test/basic.c
index e0f77c5773d24d46904c9a3243956a77edb64cf0..46f86960cab377bb97f7517191560ec9c3258eb6 100644 (file)
--- a/test/basic.c
+++ b/test/basic.c
@@ -37,11 +37,19 @@ int main() {
        assert(self);
        assert(!strcmp(self->name, "foo"));
 
+       // Check that we are reachable.
+
+       assert(meshlink_get_node_reachability(mesh, self, NULL, NULL));
+
        // Start and stop the mesh.
 
        assert(meshlink_start(mesh));
        meshlink_stop(mesh);
 
+       // Check that we are still reachable.
+
+       assert(meshlink_get_node_reachability(mesh, self, NULL, NULL));
+
        // Make sure we can start and stop the mesh again.
 
        assert(meshlink_start(mesh));

diff --git a/test/import-export.c b/test/import-export.c
index 8bc41c1b3c06fad7ac11b7fba4956f41abfe5dac..bffe0fc49cabfd9aae8b8022b723106c43122a63 100644 (file)
--- a/test/import-export.c
+++ b/test/import-export.c
@@ -58,6 +58,16 @@ int main() {
        assert(meshlink_import(mesh1, data));
        free(data);
 
+       // Check that foo knows bar, but that it is not reachable.
+
+       time_t last_reachable;
+       time_t last_unreachable;
+       meshlink_node_t *bar = meshlink_get_node(mesh1, "bar");
+       assert(bar);
+       assert(!meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
+       assert(!last_reachable);
+       assert(!last_unreachable);
+
        // Start both instances
 
        meshlink_set_node_status_cb(mesh1, status_cb);
@@ -80,6 +90,24 @@ int main() {
 
        assert(pmtu);
 
+       // Check that we now have reachability information
+
+       assert(meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
+       assert(last_reachable);
+       assert(!last_unreachable);
+
+       // Stop the meshes.
+
+       meshlink_stop(mesh1);
+       meshlink_stop(mesh2);
+
+       // Check that bar is no longer reachable
+
+       assert(!meshlink_get_node_reachability(mesh1, bar, &last_reachable, &last_unreachable));
+       assert(last_reachable);
+       assert(last_unreachable);
+       assert(last_reachable <= last_unreachable);
+
        // Clean up.
 
        meshlink_close(mesh2);