asserts added to make sure devclass is valid

diff --git a/src/meshlink.c b/src/meshlink.c
index 3661f064c4ef6a89279503525ac5275ea7863f88..bf1eb92bcdf0719ac99eb1780b4e5bbc4d173854 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -1713,7 +1713,7 @@ static void __attribute__((destructor)) meshlink_exit(void) {
 }
 
 
-/// Device class
+/// 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

diff --git a/src/meshlink_internal.h b/src/meshlink_internal.h
index c1f3659da0d2fdf73563017952124daf27d9a2be..2a8b7ebf601b87aab7d5d25df4dc448a6f4020c0 100644 (file)
--- a/src/meshlink_internal.h
+++ b/src/meshlink_internal.h
@@ -158,7 +158,7 @@ extern void meshlink_send_from_queue(event_loop_t* el,meshlink_handle_t *mesh);
 extern meshlink_log_level_t global_log_level;
 extern meshlink_log_cb_t global_log_cb;
 
-/// Device class
+/// Device class traits
 typedef struct {
        unsigned int min_connects;
        unsigned int max_connects;

diff --git a/src/net.c b/src/net.c
index 654a7813cee55fca752d9092458a9a0cd6bc9091..6528fab9833fd82c364b752bf9308bae4c5c7424 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -31,6 +31,7 @@
 #include "protocol.h"
 #include "xalloc.h"
 
+#include <assert.h>
 
 static const int min(int a, int b) {
        return a < b ? a : b;
@@ -185,6 +186,102 @@ static int node_compare_devclass_desc(const void *a, const void *b)
 }
 
 
+/*
+
+
+autoconnect()
+{
+       timeout = 5
+
+       // find the best one for initial connect
+
+       if cur < min
+               newcon =
+                       first from nodes
+                               where dclass <= my.dclass and !connection and (timestamp - last_retry) > retry_timeout
+                               order by dclass asc, last_connection desc
+               if newcon
+                       timeout = 0
+                       goto connect
+
+
+       // find better nodes to connect to: in case we have less than min connections within [BACKBONE, i] and there are nodes which we are not connected to within the range
+
+       if min <= cur < max
+               j = 0
+               for i = BACKBONE to my.dclass
+                       j += count(from connections where node.dclass = i)
+                       if j < min
+                               newcon =
+                                       first from nodes
+                                               where dclass = i and !connection and (timestamp - last_retry) > retry_timeout
+                                               order by last_connection desc
+                               if newcon
+                                       goto connect
+                       else
+                               break
+
+
+       // heal partitions
+
+       if min <= cur < max
+               newcon =
+                       first from nodes
+                               where dclass <= my.dclass and !reachable and (timestamp - last_retry) > retry_timeout
+                               order by dclass asc, last_connection desc
+               if newcon
+                       goto connect
+
+
+       // connect
+
+connect:
+       if newcon
+               connect newcon
+
+
+       // disconnect outgoing connections in case we have more than min connections within [BACKBONE, i] and there are nodes which we are connected to within the range [i, PORTABLE]
+
+       if min < cur <= max
+               j = 0
+               for i = BACKBONE to my.dclass
+                       j += count(from connections where node.dclass = i)
+                       if min < j
+                               delcon =
+                                       first from nodes
+                                               where dclass >= i and outgoing_connection
+                                               order by dclass desc
+                               if disconnect
+                                       goto disconnect
+                               else
+                                       break
+
+
+       // disconnect connections in case we have more than enough connections
+
+       if max < cur
+               delcon =
+                       first from nodes
+                               where outgoing_connection
+                               order by dclass desc
+               goto disconnect
+
+       // disconnect
+
+disconnect
+       if delcon
+               disconnect delcon
+
+
+       // next iteration
+       next (timeout, autoconnect)
+
+}
+
+
+ */
+
+
 static void periodic_handler(event_loop_t *loop, void *data) {
        meshlink_handle_t *mesh = loop->data;
 
@@ -242,6 +339,8 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
                // get min_connects and max_connects
 
+               assert(mesh->devclass >= 0 && mesh->devclass <= _DEV_CLASS_MAX);
+
                int min_connects = dev_class_traits[mesh->devclass].min_connects;
                int max_connects = dev_class_traits[mesh->devclass].max_connects;
 

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index 82254593e36aa0a5982ad447dae801c5baa76f89..d359b9b638c9aae8e9699201317bc5d470bb285f 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -36,7 +36,9 @@
 #include "utils.h"
 #include "xalloc.h"
 #include "ed25519/sha512.h"
-    
+
+#include <assert.h>
+
 extern bool node_write_devclass(meshlink_handle_t *mesh, node_t *n);
 
 static bool send_proxyrequest(meshlink_handle_t *mesh, connection_t *c) {
@@ -444,6 +446,8 @@ bool ack_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 
        /* Create an edge_t for this connection */
 
+       assert(devclass >= 0 && devclass <= _DEV_CLASS_MAX);
+
        c->edge = new_edge();
        c->edge->from = mesh->self;
        c->edge->to = n;