introduction of dclass and use as source for weight of edges

diff --git a/examples/chat.c b/examples/chat.c
index cd0144e01b7630dac6bcf9125177545a230a0732..3eaa5c7e3b3fe5ef093b7955d0db011cf15591f0 100644 (file)
--- a/examples/chat.c
+++ b/examples/chat.c
@@ -195,7 +195,7 @@ int main(int argc, char *argv[]) {
 
        meshlink_set_log_cb(NULL, MESHLINK_INFO, log_message);
 
-       meshlink_handle_t *mesh = meshlink_open(confbase, nick, "chat");
+       meshlink_handle_t *mesh = meshlink_open(confbase, nick, "chat", STATIONARY);
        if(!mesh) {
                fprintf(stderr, "Could not open MeshLink: %s\n", meshlink_strerror(meshlink_errno));
                return 1;

diff --git a/examples/chatpp.cc b/examples/chatpp.cc
index c94cf2bb3d2aea82b1df805a126736708ad809be..e500ad2733547b63fcd29ef46293061baafc5767 100644 (file)
--- a/examples/chatpp.cc
+++ b/examples/chatpp.cc
@@ -187,7 +187,7 @@ int main(int argc, char *argv[]) {
        if(argc > 2)
                nick = argv[2];
 
-       ChatMesh* mesh = meshlink::open<ChatMesh>(confbase, nick, "chatpp");
+       ChatMesh* mesh = meshlink::open<ChatMesh>(confbase, nick, "chatpp", STATIONARY);
 
        if(!mesh) {
                fprintf(stderr, "Could not open MeshLink: %s\n", meshlink::strerror());

diff --git a/examples/manynodes.c b/examples/manynodes.c
index fa583f606a960b3ec71eb149b19c56ef9095b68c..ecc8b458e3abdb9e775ec80df94b0b2920ec0ae7 100644 (file)
--- a/examples/manynodes.c
+++ b/examples/manynodes.c
@@ -229,7 +229,7 @@ int main(int argc, char *argv[]) {
                snprintf(nodename, sizeof nodename, "%snode%d", namesprefix,i);
                snprintf(filename, sizeof filename, "%s/%s", basebase, nodename);
                bool itsnew = access(filename, R_OK);
-               mesh[i] = meshlink_open(filename, nodename, "manynodes");
+               mesh[i] = meshlink_open(filename, nodename, "manynodes", STATIONARY);
                if(itsnew)
                        meshlink_add_address(mesh[i], "localhost");
                if(!mesh[i]) {

diff --git a/examples/meshlinkapp.c b/examples/meshlinkapp.c
index 85cdf6feab2ccbadba61532fcc49680dfc06e5a5..6c56165c2dbdd8d6554c3f4aed0108ce4df2fc0c 100644 (file)
--- a/examples/meshlinkapp.c
+++ b/examples/meshlinkapp.c
@@ -14,7 +14,7 @@ int main(int argc , char **argv){
 
        meshlink_handle_t* myhandle;
 
-       myhandle = meshlink_open(confbase, name, "meshlinkapp");
+       myhandle = meshlink_open(confbase, name, "meshlinkapp", STATIONARY);
 
        //Register callback function for incoming data
        meshlink_set_receive_cb(myhandle, (meshlink_receive_cb_t)handle_recv_data);

diff --git a/src/connection.h b/src/connection.h
index 5c11217593906d8dc3f1d93a00d56ad6b357777e..c3c219be4d0ae0bce1463453f0ca11c88e3da1a8 100644 (file)
--- a/src/connection.h
+++ b/src/connection.h
@@ -64,8 +64,6 @@ typedef struct connection_t {
        int socket;                     /* socket used for this connection */
        uint32_t options;               /* options for this connection */
        connection_status_t status;     /* status info */
-       int estimated_weight;           /* estimation for the weight of the edge for this connection */
-       struct timeval start;           /* time this connection was started, used for above estimation */
        struct outgoing_t *outgoing;    /* used to keep track of outgoing connections */
 
        struct meshlink_handle *mesh;   /* the mesh this connection belongs to */

diff --git a/src/meshlink++.h b/src/meshlink++.h
index 9500852bbf2c05f59715f3d36f16916aaebe82e4..8271ab2f4cbfb4814009a81d2f9b61a7c8381f68 100644 (file)
--- a/src/meshlink++.h
+++ b/src/meshlink++.h
@@ -382,12 +382,13 @@ namespace meshlink {
         *  @param confbase The directory in which MeshLink will store its configuration files.
         *  @param name     The name which this instance of the application will use in the mesh.
         *  @param appname  The application name which will be used in the mesh.
+        *  @param dclass   The device class which will be used in the mesh.
         *
         *  @return         This function will return a pointer to a meshlink::mesh if MeshLink has succesfully set up its configuration files, NULL otherwise.
         */
        template<class MESH>
-       static MESH* open(const char *confbase, const char *name, const char* appname) {
-               void* mp = (void *)meshlink_open_with_size(confbase, name, appname, sizeof(MESH));
+       static MESH* open(const char *confbase, const char *name, const char* appname, dclass_t dclass) {
+               void* mp = (void *)meshlink_open_with_size(confbase, name, appname, dclass, sizeof(MESH));
                return new (mp) MESH;
        }
 

diff --git a/src/meshlink.c b/src/meshlink.c
index b8fb5055a41ed82a9ae740492f72cf0ab7e2b6b1..0ecab432912b4dc9c384700aea5043ac9160169c 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) {
-       return meshlink_open_with_size(confbase, name, appname, sizeof(meshlink_handle_t));
+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_with_size(const char *confbase, const char *name, const char* appname, size_t size) {
+meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *name, const char* appname, dclass_t dclass, size_t size) {
 
        // Validate arguments provided by the application
        bool usingname = false;
@@ -779,6 +779,7 @@ meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *nam
        meshlink_handle_t *mesh = xzalloc(size);
        mesh->confbase = xstrdup(confbase);
        mesh->appname = xstrdup(appname);
+       mesh->dclass = dclass;
        if (usingname) mesh->name = xstrdup(name);
        pthread_mutex_init ( &(mesh->nodes_mutex), NULL);
        mesh->threadstarted = false;
@@ -934,6 +935,7 @@ void meshlink_close(meshlink_handle_t *mesh) {
        ecdsa_free(mesh->invitation_key);
 
        free(mesh->name);
+       free(mesh->appname);
        free(mesh->confbase);
 
        memset(mesh, 0, sizeof *mesh);
@@ -1721,3 +1723,10 @@ static void __attribute__((constructor)) meshlink_init(void) {
 static void __attribute__((destructor)) meshlink_exit(void) {
        crypto_exit();
 }
+
+int weight_from_dclass(dclass_t dclass)
+{
+       if(dclass == PORTABLE)
+               return 3;
+       return 1;
+}

diff --git a/src/meshlink.h b/src/meshlink.h
index 2ae5f5bb8517693080dc349b47aff9badd73527a..30c118e7dfa8890a5d6290afa4538e6ab36aebd2 100644 (file)
--- a/src/meshlink.h
+++ b/src/meshlink.h
@@ -65,6 +65,12 @@ typedef enum {
        MESHLINK_EPEER, ///< A peer caused an error
 } meshlink_errno_t;
 
+// Device class
+typedef enum {
+       STATIONARY = 1,
+       PORTABLE = 2
+} dclass_t;
+
 /// A variable holding the last encountered error from MeshLink.
 /** This is a thread local variable that contains the error code of the most recent error
  *  encountered by a MeshLink API function called in the current thread.
@@ -123,14 +129,15 @@ extern const char *meshlink_strerror(meshlink_errno_t err);
  *                  After the function returns, the application is free to overwrite or free @a name @a.
  *  @param appname  The application name which will be used in the mesh.
  *                  After the function returns, the application is free to overwrite or free @a name @a.
+ *  @param dclass   The device class which will be used in the mesh.
  *
  *  @return         A pointer to a meshlink_handle_t which represents this instance of MeshLink, or NULL in case of an error.
  *                  The pointer is valid until meshlink_close() is called.
  */
-extern meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const char* appname);
+extern meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const char* appname, dclass_t dclass);
 
 /// is used by the C++ wrapper to allocate more memory behind the handle
-extern meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *name, const char* appname, size_t size);
+extern meshlink_handle_t *meshlink_open_with_size(const char *confbase, const char *name, const char* appname, dclass_t dclass, size_t size);
 
 /// Start MeshLink.
 /** This function causes MeshLink to open network sockets, make outgoing connections, and

diff --git a/src/meshlink_internal.h b/src/meshlink_internal.h
index 73c75b89a8ed1546ab7e04d26ebca8e40ff7817a..63a71dc048dc0f81d693908dab280a396fbf9499 100644 (file)
--- a/src/meshlink_internal.h
+++ b/src/meshlink_internal.h
@@ -63,12 +63,12 @@ typedef struct outpacketqueue {
 /// A handle for an instance of MeshLink.
 struct meshlink_handle {
        char *name;
+       char *appname;
+       dclass_t dclass;
        void *priv;
 
        char *confbase;
 
-       char *appname;
-
        meshlink_receive_cb_t receive_cb;
        meshlink_node_status_cb_t node_status_cb;
        meshlink_log_cb_t log_cb;
@@ -158,5 +158,6 @@ 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;
 
+extern int weight_from_dclass(dclass_t dclass);
 
 #endif // MESHLINK_INTERNAL_H

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index 85a0fbe16237bfad1c01e9fb9553f39815b44a68..b05b04b1c1317bfe20c1e47b87aef6682b59ecde 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -124,8 +124,7 @@ static bool send_proxyrequest(meshlink_handle_t *mesh, connection_t *c) {
 }
 
 bool send_id(meshlink_handle_t *mesh, connection_t *c) {
-       gettimeofday(&c->start, NULL);
-
+       
        int minor = mesh->self->connection->protocol_minor;
 
        if(mesh->proxytype && c->outgoing)
@@ -353,22 +352,13 @@ bool id_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 }
 
 bool send_ack(meshlink_handle_t *mesh, connection_t *c) {
-       /* ACK message contains rest of the information the other end needs
-          to create node_t and edge_t structures. */
-
-       struct timeval now;
-
-       /* Estimate weight */
-
-       gettimeofday(&now, NULL);
-       c->estimated_weight = (now.tv_sec - c->start.tv_sec) * 1000 + (now.tv_usec - c->start.tv_usec) / 1000;
 
        /* Check some options */
 
        if(mesh->self->options & OPTION_PMTU_DISCOVERY)
                c->options |= OPTION_PMTU_DISCOVERY;
 
-       return send_request(mesh, c, "%d %s %d %x", ACK, mesh->myport, c->estimated_weight, (c->options & 0xffffff) | (PROT_MINOR << 24));
+       return send_request(mesh, c, "%d %s %d %x", ACK, mesh->myport, mesh->dclass, (c->options & 0xffffff) | (PROT_MINOR << 24));
 }
 
 static void send_everything(meshlink_handle_t *mesh, connection_t *c) {
@@ -383,11 +373,11 @@ static void send_everything(meshlink_handle_t *mesh, connection_t *c) {
 bool ack_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        char hisport[MAX_STRING_SIZE];
        char *hisaddress;
-       int weight;
+       int dclass;
        uint32_t options;
        node_t *n;
 
-       if(sscanf(request, "%*d " MAX_STRING " %d %x", hisport, &weight, &options) != 3) {
+       if(sscanf(request, "%*d " MAX_STRING " %d %x", hisport, &dclass, &options) != 3) {
                logger(mesh, MESHLINK_ERROR, "Got bad %s from %s (%s)", "ACK", c->name,
                           c->hostname);
                return false;
@@ -449,7 +439,7 @@ bool ack_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        sockaddr2str(&c->address, &hisaddress, NULL);
        c->edge->address = str2sockaddr(hisaddress, hisport);
        free(hisaddress);
-       c->edge->weight = (weight + c->estimated_weight) / 2;
+       c->edge->weight = weight_from_dclass(dclass);
        c->edge->connection = c;
        c->edge->options = c->options;