]> git.meshlink.io Git - meshlink/blobdiff - src/meshlink.c
Merge branch 'mesh_topology_output' into roles
[meshlink] / src / meshlink.c
index 6396163dc4d6938a230f2039132cd8ce2dbc044a..1d52724e26d6e31b52255bbb2ae8976e4edbb770 100644 (file)
@@ -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
@@ -1840,8 +1846,8 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
  * 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, size_t *nmemb) {
-       if(!mesh || !nmemb) {
+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;
        }
@@ -1850,34 +1856,50 @@ meshlink_edge_t **meshlink_get_all_edges_state(meshlink_handle_t *mesh, size_t *
        
        meshlink_edge_t **result = NULL;
        meshlink_edge_t *copy = NULL;
+       int result_size = 0;
 
-       // mesh->edges->count is the max size
-       *nmemb = mesh->edges->count;
+       result_size = mesh->edges->count;
 
-       result = xzalloc(*nmemb * sizeof (meshlink_edge_t*));
+       // 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)) {
-                               *nmemb--;
+                               result_size--;
                                continue;
                        }
-                       // copy the edge so it can't be mutated
-                       copy = xzalloc(sizeof *copy);
+                       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;
-                       //TODO fix conversion from sockaddr_t to sockaddr_storage
-                       //copy->address = e->address.ss;
+                       copy->address = e->address.storage;
                        copy->options = e->options;
                        copy->weight = e->weight;
                        *p++ = copy;
                }
                // shrink result to the actual amount of memory used
-               result = realloc(result, *nmemb * sizeof (meshlink_edge_t*));
+               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;
        }
 
@@ -1894,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
+};