Merge branch 'mesh_topology_output' into roles

[meshlink] / src / meshlink.c

diff --git a/src/meshlink.c b/src/meshlink.c
index d028d4289e0257886bd70035d7253c022d434299..1d52724e26d6e31b52255bbb2ae8976e4edbb770 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -742,11 +742,11 @@ static bool meshlink_setup(meshlink_handle_t *mesh) {
        return true;
 }
 
-meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const char* appname, dclass_t dclass) {
-       return meshlink_open_with_size(confbase, name, appname, dclass, sizeof(meshlink_handle_t));
+meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const char* appname, dev_class_t devclass) {
+       return meshlink_open_with_size(confbase, name, appname, devclass, sizeof(meshlink_handle_t));
 }
 
-meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *name, const char* appname, dclass_t dclass, size_t size) {
+meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *name, const char* appname, dev_class_t devclass, size_t size) {
 
        // Validate arguments provided by the application
        bool usingname = false;
@@ -778,10 +778,16 @@ meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *nam
                } else { usingname = true;}
        }
 
+       if(devclass < 0 || devclass > _DEV_CLASS_MAX) {
+               logger(NULL, MESHLINK_ERROR, "Invalid devclass given!\n");
+               meshlink_errno = MESHLINK_EINVAL;
+               return NULL;
+       }
+
        meshlink_handle_t *mesh = xzalloc(size);
        mesh->confbase = xstrdup(confbase);
        mesh->appname = xstrdup(appname);
-       mesh->dclass = dclass;
+       mesh->devclass = devclass;
        if (usingname) mesh->name = xstrdup(name);
 
        // initialize mutex
@@ -1042,8 +1048,10 @@ void meshlink_send_from_queue(event_loop_t* el,meshlink_handle_t *mesh) {
 
        outpacketqueue_t* p = meshlink_queue_pop(&mesh->outpacketqueue);
        if(!p)
+       {
                pthread_mutex_unlock(&(mesh->mesh_mutex));
                return;
+       }
 
        if (sizeof(meshlink_packethdr_t) + p->len > MAXSIZE) {
                pthread_mutex_unlock(&(mesh->mesh_mutex));
@@ -1812,7 +1820,7 @@ void meshlink_whitelist(meshlink_handle_t *mesh, meshlink_node_t *node) {
 /* Hint that a hostname may be found at an address
  * See header file for detailed comment.
  */
-extern void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const struct sockaddr *addr) {
+void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const struct sockaddr *addr) {
        if(!mesh || !node || !addr)
                return;
        
@@ -1834,6 +1842,72 @@ extern void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node
        // @TODO do we want to fire off a connection attempt right away?
 }
 
+/* Return an array of edges in the current network graph.
+ * Data captures the current state and will not be updated.
+ * Caller must deallocate data when done.
+ */
+meshlink_edge_t **meshlink_get_all_edges_state(meshlink_handle_t *mesh, meshlink_edge_t **edges, size_t *nmemb) {
+       if(!mesh || !nmemb || (*nmemb && !edges)) {
+               meshlink_errno = MESHLINK_EINVAL;
+               return NULL;
+       }
+
+       pthread_mutex_lock(&(mesh->mesh_mutex));
+       
+       meshlink_edge_t **result = NULL;
+       meshlink_edge_t *copy = NULL;
+       int result_size = 0;
+
+       result_size = mesh->edges->count;
+
+       // if result is smaller than edges, we have to dealloc all the excess meshlink_edge_t
+       if(result_size > *nmemb) {
+               result = realloc(edges, result_size * sizeof (meshlink_edge_t*));
+       } else {
+               result = edges;
+       }
+
+       if(result) {
+               meshlink_edge_t **p = result;
+               int n = 0;
+               for splay_each(edge_t, e, mesh->edges) {
+                       // skip edges that do not represent a two-directional connection
+                       if((!e->reverse) || (e->reverse->to != e->from)) {
+                               result_size--;
+                               continue;
+                       }
+                       n++;
+                       // the first *nmemb members of result can be re-used
+                       if(n > *nmemb) {
+                               copy = xzalloc(sizeof *copy);
+                       }
+                       else {
+                               copy = *p;
+                       }
+                       copy->from = (meshlink_node_t*)e->from;
+                       copy->to = (meshlink_node_t*)e->to;
+                       copy->address = e->address.storage;
+                       copy->options = e->options;
+                       copy->weight = e->weight;
+                       *p++ = copy;
+               }
+               // shrink result to the actual amount of memory used
+               for(int i = *nmemb; i > result_size; i--) {
+                       free(result[i - 1]);
+               }
+               result = realloc(result, result_size * sizeof (meshlink_edge_t*));
+               *nmemb = result_size;
+       } else {
+               *nmemb = 0;
+               free(result);
+               meshlink_errno = MESHLINK_ENOMEM;
+       }
+
+       pthread_mutex_unlock(&(mesh->mesh_mutex));
+
+       return result;
+}
+
 static void __attribute__((constructor)) meshlink_init(void) {
        crypto_init();
 }
@@ -1842,19 +1916,11 @@ static void __attribute__((destructor)) meshlink_exit(void) {
        crypto_exit();
 }
 
-int weight_from_dclass(dclass_t dclass)
-{
-       switch(dclass)
-       {
-       case BACKBONE:
-               return 1;
-
-       case STATIONARY:
-               return 3;
-
-       case PORTABLE:
-               return 6;
-       }
 
-       return 9;
-}
+/// Device class traits
+dev_class_traits_t dev_class_traits[_DEV_CLASS_MAX +1] = {
+       { .min_connects = 3, .max_connects = 10000, .edge_weight = 1 }, // DEV_CLASS_BACKBONE
+       { .min_connects = 3, .max_connects = 100, .edge_weight = 3 },   // DEV_CLASS_STATIONARY
+       { .min_connects = 3, .max_connects = 3, .edge_weight = 6 },             // DEV_CLASS_PORTABLE
+       { .min_connects = 1, .max_connects = 1, .edge_weight = 9 },             // DEV_CLASS_UNKNOWN
+};