Fix compiling with -Wall -W.

diff --git a/src/buffer.c b/src/buffer.c
index 1cc3986cb42e48e3f7d31ea5d6248a68c6c11575..ccef7279bc15e2722de77a4bbaf3a4ec879e2309 100644 (file)
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1,6 +1,6 @@
 /*
     buffer.c -- buffer management
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
 #include "buffer.h"
 #include "xalloc.h"
 
-void buffer_compact(buffer_t *buffer, int maxsize) {
+void buffer_compact(buffer_t *buffer, size_t maxsize) {
        if(buffer->len >= maxsize || buffer->offset / 7 > buffer->len / 8) {
                memmove(buffer->data, buffer->data + buffer->offset, buffer->len - buffer->offset);
                buffer->len -= buffer->offset;
@@ -32,7 +32,7 @@ void buffer_compact(buffer_t *buffer, int maxsize) {
 
 // Make sure we can add size bytes to the buffer, and return a pointer to the start of those bytes.
 
-char *buffer_prepare(buffer_t *buffer, int size) {
+char *buffer_prepare(buffer_t *buffer, size_t size) {
        if(!buffer->data) {
                buffer->maxlen = size;
                buffer->data = xmalloc(size);
@@ -58,13 +58,13 @@ char *buffer_prepare(buffer_t *buffer, int size) {
 
 // Copy data into the buffer.
 
-void buffer_add(buffer_t *buffer, const char *data, int size) {
+void buffer_add(buffer_t *buffer, const char *data, size_t size) {
        memcpy(buffer_prepare(buffer, size), data, size);
 }
 
 // Remove given number of bytes from the buffer, return a pointer to the start of them.
 
-static char *buffer_consume(buffer_t *buffer, int size) {
+static char *buffer_consume(buffer_t *buffer, size_t size) {
        char *start = buffer->data + buffer->offset;
 
        buffer->offset += size;
@@ -85,14 +85,14 @@ char *buffer_readline(buffer_t *buffer) {
        if(!newline)
                return NULL;
 
-       int len = newline + 1 - (buffer->data + buffer->offset);
+       size_t len = newline + 1 - (buffer->data + buffer->offset);
        *newline = 0;
        return buffer_consume(buffer, len);
 }
 
 // Check if we have enough bytes in the buffer, and if so, return a pointer to the start of them.
 
-char *buffer_read(buffer_t *buffer, int size) {
+char *buffer_read(buffer_t *buffer, size_t size) {
        if(buffer->len - buffer->offset < size)
                return NULL;
 

diff --git a/src/buffer.h b/src/buffer.h
index 493d3293c593ca3c9035ae8f72ce1b25b73eff99..ba6647ed0c095119247617e714fdb01b090266b9 100644 (file)
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -22,16 +22,16 @@
 
 typedef struct buffer_t {
        char *data;
-       int maxlen;
-       int len;
-       int offset;
+       size_t maxlen;
+       size_t len;
+       size_t offset;
 } buffer_t;
 
-extern void buffer_compact(buffer_t *buffer, int maxsize);
-extern char *buffer_prepare(buffer_t *buffer, int size);
-extern void buffer_add(buffer_t *buffer, const char *data, int size);
+extern void buffer_compact(buffer_t *buffer, size_t maxsize);
+extern char *buffer_prepare(buffer_t *buffer, size_t size);
+extern void buffer_add(buffer_t *buffer, const char *data, size_t size);
 extern char *buffer_readline(buffer_t *buffer);
-extern char *buffer_read(buffer_t *buffer, int size);
+extern char *buffer_read(buffer_t *buffer, size_t size);
 extern void buffer_clear(buffer_t *buffer);
 
 #endif

diff --git a/src/devtools.c b/src/devtools.c
index c1578e65532eceb6d2e5f8c543c24719b9797507..a8fc56b8b98d8abd50c73bd1c3372eed54660958 100644 (file)
--- a/src/devtools.c
+++ b/src/devtools.c
@@ -42,19 +42,19 @@ devtool_edge_t *devtool_get_all_edges(meshlink_handle_t *mesh, devtool_edge_t *e
        pthread_mutex_lock(&(mesh->mesh_mutex));
 
        devtool_edge_t *result = NULL;
-       int result_size = 0;
+       unsigned int result_size = 0;
 
        result_size = mesh->edges->count / 2;
 
        // if result is smaller than edges, we have to dealloc all the excess devtool_edge_t
-       if(result_size > *nmemb)
+       if((size_t)result_size > *nmemb)
                result = realloc(edges, result_size * sizeof(*result));
        else
                result = edges;
 
        if(result) {
                devtool_edge_t *p = result;
-               int n = 0;
+               unsigned int n = 0;
 
                for splay_each(edge_t, e, mesh->edges) {
                        // skip edges that do not represent a two-directional connection

diff --git a/src/discovery.c b/src/discovery.c
index 0ef1001da471901f766f2206d93c356fc515cc3b..5b83862d767c1a48f8d2bd28a3b4349583049601 100644 (file)
--- a/src/discovery.c
+++ b/src/discovery.c
@@ -28,6 +28,8 @@ static void generate_rand_string(char *buffer, size_t size) {
 }
 
 static void discovery_entry_group_callback(CattaServer *server, CattaSEntryGroup *group, CattaEntryGroupState state, void *userdata) {
+       (void)server;
+       (void)group;
        meshlink_handle_t *mesh = userdata;
 
        // asserts
@@ -128,6 +130,7 @@ done:
 }
 
 static void discovery_server_callback(CattaServer *server, CattaServerState state, void *userdata) {
+       (void)server;
        meshlink_handle_t *mesh = userdata;
 
        // asserts
@@ -193,6 +196,8 @@ static void discovery_server_callback(CattaServer *server, CattaServerState stat
 }
 
 static void discovery_resolve_callback(CattaSServiceResolver *resolver, CattaIfIndex interface_, CattaProtocol protocol, CattaResolverEvent event, const char *name, const char *type, const char *domain, const char *host_name, const CattaAddress *address, uint16_t port, CattaStringList *txt, CattaLookupResultFlags flags, void *userdata) {
+       (void)interface_;
+       (void)protocol;
        meshlink_handle_t *mesh = userdata;
 
        // asserts
@@ -306,6 +311,8 @@ static void discovery_resolve_callback(CattaSServiceResolver *resolver, CattaIfI
 }
 
 static void discovery_browse_callback(CattaSServiceBrowser *browser, CattaIfIndex interface_, CattaProtocol protocol, CattaBrowserEvent event, const char *name, const char *type, const char *domain, CattaLookupResultFlags flags, void *userdata) {
+       (void)browser;
+       (void)flags;
        meshlink_handle_t *mesh = userdata;
 
        // asserts

diff --git a/src/ed25519/ecdsa.c b/src/ed25519/ecdsa.c
index a63dedab0597c16c59500fdc31a357af7c431b84..2606a21e2e161e26240cd40eb15f02f3e9003751 100644 (file)
--- a/src/ed25519/ecdsa.c
+++ b/src/ed25519/ecdsa.c
@@ -1,6 +1,6 @@
 /*
     ecdsa.c -- ECDSA key handling
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -79,6 +79,7 @@ ecdsa_t *ecdsa_read_pem_private_key(FILE *fp) {
 }
 
 size_t ecdsa_size(ecdsa_t *ecdsa) {
+       (void)ecdsa;
        return 64;
 }
 

diff --git a/src/event.c b/src/event.c
index 6ca44d4898aa8d8110d728a2316a89d44fc39505..54d696582f237711f796c7abdad2eee809029276 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -1,6 +1,6 @@
 /*
     event.c -- I/O, timeout and signal event handling
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -133,6 +133,8 @@ static int signal_compare(const signal_t *a, const signal_t *b) {
 }
 
 static void signalio_handler(event_loop_t *loop, void *data, int flags) {
+       (void)data;
+       (void)flags;
        unsigned char signum;
        if(read(loop->pipefd[0], &signum, 1) != 1)
                return;

diff --git a/src/list.h b/src/list.h
index 254fbffdefaecb9f8d0c1680d58f90a25e818a4b..186e0ad616c26b21184a2ebe2a64b165d92a6b1f 100644 (file)
--- a/src/list.h
+++ b/src/list.h
@@ -35,7 +35,7 @@ typedef void (*list_action_node_t)(const list_node_t *);
 typedef struct list_t {
        list_node_t *head;
        list_node_t *tail;
-       int count;
+       unsigned int count;
 
        /* Callbacks */
 

diff --git a/src/logger.c b/src/logger.c
index f77252bd64e3a79731667f5bed193196029434f7..97fddecd3dbd7482180b277a253917abab6036f9 100644 (file)
--- a/src/logger.c
+++ b/src/logger.c
@@ -1,6 +1,6 @@
 /*
     logger.c -- logging code
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -40,7 +40,7 @@ void logger(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *for
        int len = vsnprintf(message, sizeof(message), format, ap);
        va_end(ap);
 
-       if(len > 0 && len < sizeof(message) && message[len - 1] == '\n')
+       if(len > 0 && (size_t)len < sizeof(message) && message[len - 1] == '\n')
                message[len - 1] = 0;
 
        if(mesh)

diff --git a/src/meshlink.c b/src/meshlink.c
index e70ac5f624589023139dc54fda2ba797dd391940..094d4983fb5318f86e79c68eba884579f55d7a22 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -310,7 +310,7 @@ static char *get_line(const char **data) {
 
        static char line[1024];
        const char *end = strchr(*data, '\n');
-       size_t len = end ? end - *data : strlen(*data);
+       size_t len = end ? (size_t)(end - *data) : strlen(*data);
        if(len >= sizeof(line)) {
                logger(NULL, MESHLINK_ERROR, "Maximum line length exceeded!\n");
                return NULL;
@@ -553,6 +553,7 @@ static bool finalize_join(meshlink_handle_t *mesh) {
 }
 
 static bool invitation_send(void *handle, uint8_t type, const void *data, size_t len) {
+       (void)type;
        meshlink_handle_t *mesh = handle;
        while(len) {
                int result = send(mesh->sock, data, len, 0);
@@ -611,7 +612,7 @@ static bool recvline(meshlink_handle_t *mesh, size_t len) {
                mesh->blen += result;
        }
 
-       if(newline - mesh->buffer >= len)
+       if((size_t)(newline - mesh->buffer) >= len)
                return false;
 
        len = newline - mesh->buffer;
@@ -633,7 +634,7 @@ static bool sendline(int fd, char *format, ...) {
        blen = vsnprintf(buffer, sizeof(buffer), format, ap);
        va_end(ap);
 
-       if(blen < 1 || blen >= sizeof(buffer))
+       if(blen < 1 || (size_t)blen >= sizeof(buffer))
                return false;
 
        buffer[blen] = '\n';
@@ -666,7 +667,7 @@ static const char *errstr[] = {
 };
 
 const char *meshlink_strerror(meshlink_errno_t err) {
-       if(err < 0 || err >= sizeof(errstr) / sizeof(*errstr))
+       if((int)err < 0 || err >= sizeof(errstr) / sizeof(*errstr))
                return "Invalid error code";
        return errstr[err];
 }
@@ -726,6 +727,7 @@ static bool ecdsa_keygen(meshlink_handle_t *mesh) {
 }
 
 static struct timeval idle(event_loop_t *loop, void *data) {
+       (void)loop;
        meshlink_handle_t *mesh = data;
        struct timeval t, tmin = {3600, 0};
        for splay_each(node_t, n, mesh->nodes) {
@@ -872,7 +874,7 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name, const c
                        usingname = true;
        }
 
-       if(devclass < 0 || devclass > _DEV_CLASS_MAX) {
+       if((int)devclass < 0 || devclass > _DEV_CLASS_MAX) {
                logger(NULL, MESHLINK_ERROR, "Invalid devclass given!\n");
                meshlink_errno = MESHLINK_EINVAL;
                return NULL;
@@ -1227,6 +1229,7 @@ bool meshlink_send(meshlink_handle_t *mesh, meshlink_node_t *destination, const
 }
 
 void meshlink_send_from_queue(event_loop_t *loop, meshlink_handle_t *mesh) {
+       (void)loop;
        vpn_packet_t *packet = meshlink_queue_pop(&mesh->outpacketqueue);
        if(!packet)
                return;
@@ -2100,6 +2103,7 @@ void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const
 }
 
 static bool channel_pre_accept(struct utcp *utcp, uint16_t port) {
+       (void)port;
        node_t *n = utcp->priv;
        meshlink_handle_t *mesh = n->mesh;
        return mesh->channel_accept_cb;
@@ -2137,7 +2141,7 @@ static void channel_accept(struct utcp_connection *utcp_connection, uint16_t por
 static ssize_t channel_send(struct utcp *utcp, const void *data, size_t len) {
        node_t *n = utcp->priv;
        meshlink_handle_t *mesh = n->mesh;
-       return meshlink_send(mesh, (meshlink_node_t *)n, data, len) ? len : -1;
+       return meshlink_send(mesh, (meshlink_node_t *)n, data, len) ? (ssize_t)len : -1;
 }
 
 void meshlink_set_channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_receive_cb_t cb) {
@@ -2150,6 +2154,7 @@ void meshlink_set_channel_receive_cb(meshlink_handle_t *mesh, meshlink_channel_t
 }
 
 static void channel_receive(meshlink_handle_t *mesh, meshlink_node_t *source, const void *data, size_t len) {
+       (void)mesh;
        node_t *n = (node_t *)source;
        if(!n->utcp)
                abort();
@@ -2167,6 +2172,7 @@ static void channel_poll(struct utcp_connection *connection, size_t len) {
 }
 
 void meshlink_set_channel_poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_poll_cb_t cb) {
+       (void)mesh;
        channel->poll_cb = cb;
        utcp_set_poll_cb(channel->c, cb ? channel_poll : NULL);
 }
@@ -2188,6 +2194,9 @@ void meshlink_set_channel_accept_cb(meshlink_handle_t *mesh, meshlink_channel_ac
 }
 
 meshlink_channel_t *meshlink_channel_open_ex(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t port, meshlink_channel_receive_cb_t cb, const void *data, size_t len, uint32_t flags) {
+       if(data || len)
+               abort(); // TODO: handle non-NULL data
+
        if(!mesh || !node) {
                meshlink_errno = MESHLINK_EINVAL;
                return NULL;

diff --git a/src/meta.c b/src/meta.c
index 2d30840314d802be9b50ace3c2d77570c1efdc80..fe213643e2db018a790883eaa720ee5cdc761bb6 100644 (file)
--- a/src/meta.c
+++ b/src/meta.c
@@ -1,6 +1,6 @@
 /*
     meta.c -- handle the meta communication
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>,
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>,
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -29,6 +29,7 @@
 #include "xalloc.h"
 
 bool send_meta_sptps(void *handle, uint8_t type, const void *buffer, size_t length) {
+       (void)type;
        connection_t *c = handle;
        meshlink_handle_t *mesh = c->mesh;
 
@@ -89,11 +90,7 @@ bool receive_meta_sptps(void *handle, uint8_t type, const void *data, uint16_t l
        /* Are we receiving a TCPpacket? */
 
        if(c->tcplen) {
-               if(length != c->tcplen)
-                       return false;
-               receive_tcppacket(mesh, c, request, length);
-               c->tcplen = 0;
-               return true;
+               abort(); // TODO: get rid of tcplen altogether
        }
 
        /* Change newline to null byte, just like non-SPTPS requests */

diff --git a/src/net.c b/src/net.c
index c0ed984964ae000c34aa65088b8583a2af3f4889..69462d5c56f1ee73e9796ab972d201f55957fd70 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -1,6 +1,6 @@
 /*
     net.c -- most of the network code
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -34,7 +34,7 @@
 #include <assert.h>
 
 #if !defined(min)
-static const int min(int a, int b) {
+static inline int min(int a, int b) {
        return a < b ? a : b;
 }
 #endif
@@ -344,7 +344,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
                // get cur_connects
 
-               int cur_connects = 0;
+               unsigned int cur_connects = 0;
 
                for list_each(connection_t, c, mesh->connections) {
                        if(c->status.active)
@@ -358,8 +358,8 @@ static void periodic_handler(event_loop_t *loop, void *data) {
 
                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;
+               unsigned int min_connects = dev_class_traits[mesh->devclass].min_connects;
+               unsigned int max_connects = dev_class_traits[mesh->devclass].max_connects;
 
                logger(mesh, MESHLINK_DEBUG, "* min_connects = %d", min_connects);
                logger(mesh, MESHLINK_DEBUG, "* max_connects = %d", max_connects);
@@ -393,7 +393,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                if(!connect_to && min_connects <= cur_connects && cur_connects < max_connects) {
                        unsigned int connects = 0;
 
-                       for(int devclass = 0; devclass <= mesh->devclass; ++devclass) {
+                       for(unsigned int devclass = 0; devclass <= mesh->devclass; ++devclass) {
                                for list_each(connection_t, c, mesh->connections) {
                                        if(c->status.active && c->node && c->node->devclass == devclass)
                                                connects += 1;
@@ -476,7 +476,7 @@ static void periodic_handler(event_loop_t *loop, void *data) {
                if(min_connects < cur_connects /*&& cur_connects <= max_connects*/) {
                        unsigned int connects = 0;
 
-                       for(int devclass = 0; devclass <= mesh->devclass; ++devclass) {
+                       for(unsigned int devclass = 0; devclass <= mesh->devclass; ++devclass) {
                                for list_each(connection_t, c, mesh->connections) {
                                        if(c->status.active && c->node && c->node->devclass == devclass)
                                                connects += 1;

diff --git a/src/net.h b/src/net.h
index fa34dcf7eaa2faf6f87fcfdfb46c8508bc138e7e..afefa17b683e9031c443de3f9b39fda67624965d 100644 (file)
--- a/src/net.h
+++ b/src/net.h
@@ -91,7 +91,6 @@ extern int setup_vpn_in_socket(struct meshlink_handle *mesh, const sockaddr_t *)
 extern bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len);
 extern bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len);
 extern void send_packet(struct meshlink_handle *mesh, struct node_t *, struct vpn_packet_t *);
-extern void receive_tcppacket(struct meshlink_handle *mesh, struct connection_t *, const char *, int);
 extern void broadcast_packet(struct meshlink_handle *mesh, const struct node_t *, struct vpn_packet_t *);
 extern char *get_name(struct meshlink_handle *mesh);
 extern void load_all_nodes(struct meshlink_handle *mesh);

diff --git a/src/net_packet.c b/src/net_packet.c
index 0ab5b7fa69e4d38a5d6d8c6ef1e8506ce860612c..96f16d57a34b636823bcbf0eef019d4c81223e81 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -1,6 +1,6 @@
 /*
     net_packet.c -- Handles in- and outgoing VPN packets
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -195,14 +195,6 @@ static void mtu_probe_h(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet
        }
 }
 
-static uint16_t compress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
-       abort();
-}
-
-static uint16_t uncompress_packet(uint8_t *dest, const uint8_t *source, uint16_t len, int level) {
-       abort();
-}
-
 /* VPN packet I/O */
 
 static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *packet) {
@@ -219,6 +211,7 @@ static void receive_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *pac
 }
 
 static bool try_mac(meshlink_handle_t *mesh, node_t *n, const vpn_packet_t *inpkt) {
+       (void)mesh;
        return sptps_verify_datagram(&n->sptps, inpkt->data, inpkt->len);
 }
 
@@ -234,19 +227,6 @@ static void receive_udppacket(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *
        sptps_receive_data(&n->sptps, inpkt->data, inpkt->len);
 }
 
-void receive_tcppacket(meshlink_handle_t *mesh, connection_t *c, const char *buffer, int len) {
-       vpn_packet_t outpkt;
-
-       if(len > sizeof(outpkt).data)
-               return;
-
-       outpkt.len = len;
-       outpkt.tcp = true;
-       memcpy(outpkt.data, buffer, len);
-
-       receive_packet(mesh, c->node, &outpkt);
-}
-
 static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *origpkt) {
        if(!n->status.validkey) {
                logger(mesh, MESHLINK_INFO, "No valid key known yet for %s", n->name);
@@ -269,17 +249,9 @@ static void send_sptps_packet(meshlink_handle_t *mesh, node_t *n, vpn_packet_t *
                return;
        }
 
-       vpn_packet_t outpkt;
-
        if(n->outcompression) {
-               int len = compress_packet(outpkt.data, origpkt->data, origpkt->len, n->outcompression);
-               if(len < 0)
-                       logger(mesh, MESHLINK_ERROR, "Error while compressing packet to %s", n->name);
-               else if(len < origpkt->len) {
-                       outpkt.len = len;
-                       origpkt = &outpkt;
-                       type |= PKT_COMPRESSED;
-               }
+               logger(mesh, MESHLINK_ERROR, "Error while compressing packet to %s", n->name);
+               return;
        }
 
        sptps_send_record(&n->sptps, type, origpkt->data, origpkt->len);
@@ -463,18 +435,13 @@ bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t
        }
 
        if(type & PKT_COMPRESSED) {
-               uint16_t ulen = uncompress_packet(inpkt.data, (const uint8_t *)data, len, from->incompression);
-               if(ulen < 0)
-                       return false;
-               else
-                       inpkt.len = ulen;
-               if(inpkt.len > MAXSIZE)
-                       abort();
-       } else {
-               memcpy(inpkt.data, data, len);
-               inpkt.len = len;
+               logger(mesh, MESHLINK_ERROR, "Error while decompressing packet from %s", from->name);
+               return false;
        }
 
+       memcpy(inpkt.data, data, len); // TODO: get rid of memcpy
+       inpkt.len = len;
+
        receive_packet(mesh, from, &inpkt);
        return true;
 }
@@ -548,11 +515,12 @@ static node_t *try_harder(meshlink_handle_t *mesh, const sockaddr_t *from, const
 }
 
 void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
+       (void)flags;
        meshlink_handle_t *mesh = loop->data;
        listen_socket_t *ls = data;
        vpn_packet_t pkt;
        char *hostname;
-       sockaddr_t from = {{0}};
+       sockaddr_t from = {};
        socklen_t fromlen = sizeof(from);
        node_t *n;
        int len;

diff --git a/src/net_setup.c b/src/net_setup.c
index 96be9df37d87b6be2610436cf845e5c1ec32b2cb..37644c44ab6226237d9ce944f447cc57426bd884 100644 (file)
--- a/src/net_setup.c
+++ b/src/net_setup.c
@@ -1,6 +1,6 @@
 /*
     net_setup.c -- Setup.
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -136,7 +136,7 @@ bool node_read_devclass(meshlink_handle_t *mesh, node_t *n) {
                free(p);
        }
 
-       if(n->devclass < 0 || n->devclass > _DEV_CLASS_MAX)
+       if((int)n->devclass < 0 || n->devclass > _DEV_CLASS_MAX)
                n->devclass = _DEV_CLASS_MAX;
 
 exit:
@@ -146,7 +146,7 @@ exit:
 
 bool node_write_devclass(meshlink_handle_t *mesh, node_t *n) {
 
-       if(n->devclass < 0 || n->devclass > _DEV_CLASS_MAX)
+       if((int)n->devclass < 0 || n->devclass > _DEV_CLASS_MAX)
                return false;
 
        bool result = false;
@@ -252,7 +252,7 @@ static bool add_listen_address(meshlink_handle_t *mesh, char *address, bool bind
                        *address = 0;
        }
 
-       struct addrinfo *ai, hint = {0};
+       struct addrinfo *ai, hint = {};
        hint.ai_family = addressfamily;
        hint.ai_socktype = SOCK_STREAM;
        hint.ai_protocol = IPPROTO_TCP;

diff --git a/src/net_socket.c b/src/net_socket.c
index a74db196973c910ae54dc31d1740ee8c55c43363..97c42fc2ba2d8a19d0ccaed1b08e8e244ad37296 100644 (file)
--- a/src/net_socket.c
+++ b/src/net_socket.c
@@ -1,6 +1,6 @@
 /*
     net_socket.c -- Handle various kinds of sockets.
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -311,13 +311,14 @@ static void handle_meta_write(meshlink_handle_t *mesh, connection_t *c) {
 
        ssize_t outlen = send(c->socket, c->outbuf.data + c->outbuf.offset, c->outbuf.len - c->outbuf.offset, MSG_NOSIGNAL);
        if(outlen <= 0) {
-               if(!errno || errno == EPIPE)
+               if(!errno || errno == EPIPE) {
                        logger(mesh, MESHLINK_INFO, "Connection closed by %s", c->name);
-               else if(sockwouldblock(sockerrno)) {
-                       logger(mesh, MESHLINK_DEBUG, "Sending %d bytes to %s would block", c->outbuf.len - c->outbuf.offset, c->name);
+               } else if(sockwouldblock(sockerrno)) {
+                       logger(mesh, MESHLINK_DEBUG, "Sending %lu bytes to %s would block", (unsigned long)(c->outbuf.len - c->outbuf.offset), c->name);
                        return;
-               } else
-                       logger(mesh, MESHLINK_ERROR, "Could not send %d bytes of data to %s: %s", c->outbuf.len - c->outbuf.offset, c->name, strerror(errno));
+               } else {
+                       logger(mesh, MESHLINK_ERROR, "Could not send %lu bytes of data to %s: %s", (unsigned long)(c->outbuf.len - c->outbuf.offset), c->name, strerror(errno));
+               }
 
                terminate_connection(mesh, c, c->status.active);
                return;
@@ -564,6 +565,7 @@ void setup_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
   new connection
 */
 void handle_new_meta_connection(event_loop_t *loop, void *data, int flags) {
+       (void)flags;
        meshlink_handle_t *mesh = loop->data;
        listen_socket_t *l = data;
        connection_t *c;

diff --git a/src/netutl.c b/src/netutl.c
index 983ad91485de40a5a6692a8c1613b16452a76e50..75950f05c865ee01700d06417dc5a2b0ea09279d 100644 (file)
--- a/src/netutl.c
+++ b/src/netutl.c
@@ -1,6 +1,6 @@
 /*
     netutl.c -- some supporting network utility code
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@ bool hostnames = false;
   Return NULL on failure.
 */
 struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) {
-       struct addrinfo *ai, hint = {0};
+       struct addrinfo *ai, hint = {};
        int err;
 
        hint.ai_family = addressfamily;
@@ -49,8 +49,8 @@ struct addrinfo *str2addrinfo(const char *address, const char *service, int sock
 }
 
 sockaddr_t str2sockaddr(const char *address, const char *port) {
-       struct addrinfo *ai, hint = {0};
-       sockaddr_t result = {{0}};
+       struct addrinfo *ai, hint = {};
+       sockaddr_t result = {};
        int err;
 
        hint.ai_family = AF_UNSPEC;

diff --git a/src/protocol.c b/src/protocol.c
index fb0aa9ca12b0ff26b2e467d2815ac48810bcc71e..08226f670200226fb9ca466be52bdc00c0a7e13f 100644 (file)
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -1,6 +1,6 @@
 /*
     protocol.c -- handle the meta-protocol, basic functions
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -158,6 +158,7 @@ static void free_past_request(past_request_t *r) {
 }
 
 static void age_past_requests(event_loop_t *loop, void *data) {
+       (void)data;
        meshlink_handle_t *mesh = loop->data;
        int left = 0, deleted = 0;
 
@@ -178,7 +179,7 @@ static void age_past_requests(event_loop_t *loop, void *data) {
 }
 
 bool seen_request(meshlink_handle_t *mesh, const char *request) {
-       past_request_t *new, p = {NULL};
+       past_request_t *new, p = {};
 
        p.request = request;
 

diff --git a/src/protocol.h b/src/protocol.h
index 0070cd0298627ba64c639669faf83a0d3f7bcbe6..48bdd864df83cc8120cf56cbd24e262b477616c3 100644 (file)
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -83,17 +83,12 @@ extern bool seen_request(struct meshlink_handle *mesh, const char *);
 
 extern bool send_id(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_ack(struct meshlink_handle *mesh, struct connection_t *);
-extern bool send_status(struct meshlink_handle *mesh, struct connection_t *, int, const char *);
-extern bool send_error(struct meshlink_handle *mesh, struct connection_t *, int, const  char *);
-extern bool send_termreq(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_ping(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_pong(struct meshlink_handle *mesh, struct connection_t *);
 extern bool send_add_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *);
 extern bool send_del_edge(struct meshlink_handle *mesh, struct connection_t *, const struct edge_t *);
 extern void send_key_changed(struct meshlink_handle *mesh);
 extern bool send_req_key(struct meshlink_handle *mesh, struct node_t *);
-extern bool send_ans_key(struct meshlink_handle *mesh, struct node_t *);
-extern bool send_tcppacket(struct meshlink_handle *mesh, struct connection_t *, const struct vpn_packet_t *);
 
 /* Request handlers  */
 

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index ca042e12606a70e38b6c3e1907140b26a6faf972..69507b7750a66459296847ab09882ca80d426f75 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -1,6 +1,6 @@
 /*
     protocol_auth.c -- handle the meta-protocol, authentication
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -138,6 +138,7 @@ bool send_id(meshlink_handle_t *mesh, connection_t *c) {
 }
 
 static bool finalize_invitation(meshlink_handle_t *mesh, connection_t *c, const void *data, uint16_t len) {
+       (void)len;
        if(strchr(data, '\n')) {
                logger(mesh, MESHLINK_ERROR, "Received invalid key from invited node %s!\n", c->name);
                return false;

diff --git a/src/protocol_key.c b/src/protocol_key.c
index 6384eb3979d9d92154e963913a4763693f13dd1b..5f1be34efd847ab9cfe4e26af7a4084d6168d1b8 100644 (file)
--- a/src/protocol_key.c
+++ b/src/protocol_key.c
@@ -1,6 +1,6 @@
 /*
     protocol_key.c -- handle the meta-protocol, key exchange
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -68,6 +68,7 @@ bool key_changed_h(meshlink_handle_t *mesh, connection_t *c, const char *request
 }
 
 static bool send_initial_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
+       (void)type;
        node_t *to = handle;
        meshlink_handle_t *mesh = to->mesh;
        to->sptps.send_data = send_sptps_data;
@@ -99,6 +100,7 @@ bool send_req_key(meshlink_handle_t *mesh, node_t *to) {
 /* REQ_KEY is overloaded to allow arbitrary requests to be routed between two nodes. */
 
 static bool req_key_ext_h(meshlink_handle_t *mesh, connection_t *c, const char *request, node_t *from, int reqno) {
+       (void)c;
        switch(reqno) {
        case REQ_PUBKEY: {
                char *pubkey = ecdsa_get_base64_public_key(mesh->self->connection->ecdsa);
@@ -219,8 +221,8 @@ bool req_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
                if(reqno)
                        return req_key_ext_h(mesh, c, request, from, reqno);
 
-               /* No, just send our key back */
-               send_ans_key(mesh, from);
+               /* This should never happen. Ignore it, unless it came directly from the connected peer, in which case we disconnect. */
+               return from->connection != c;
        } else {
                if(!to->status.reachable) {
                        logger(mesh, MESHLINK_WARNING, "Got %s from %s destination %s which is not reachable",
@@ -235,6 +237,8 @@ bool req_key_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 }
 
 bool send_ans_key(meshlink_handle_t *mesh, node_t *to) {
+       (void)mesh;
+       (void)to;
        abort();
 }
 

diff --git a/src/protocol_misc.c b/src/protocol_misc.c
index 8948bb2e6082d42cdc8fc18faedc879cd64ba044..5ec01d9253405e82849779905f02b66a42bf0ee0 100644 (file)
--- a/src/protocol_misc.c
+++ b/src/protocol_misc.c
@@ -1,6 +1,6 @@
 /*
     protocol_misc.c -- handle the meta-protocol, miscellaneous functions
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -33,13 +33,6 @@ int maxoutbufsize = 0;
 
 /* Status and error notification routines */
 
-bool send_status(meshlink_handle_t *mesh, connection_t *c, int statusno, const char *statusstring) {
-       if(!statusstring)
-               statusstring = "Status";
-
-       return send_request(mesh, c, "%d %d %s", STATUS, statusno, statusstring);
-}
-
 bool status_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        int statusno;
        char statusstring[MAX_STRING_SIZE];
@@ -54,13 +47,6 @@ bool status_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        return true;
 }
 
-bool send_error(meshlink_handle_t *mesh, connection_t *c, int err, const char *errstring) {
-       if(!errstring)
-               errstring = "Error";
-
-       return send_request(mesh, c, "%d %d %s", ERROR, err, errstring);
-}
-
 bool error_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        int err;
        char errorstring[MAX_STRING_SIZE];
@@ -75,11 +61,10 @@ bool error_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        return false;
 }
 
-bool send_termreq(meshlink_handle_t *mesh, connection_t *c) {
-       return send_request(mesh, c, "%d", TERMREQ);
-}
-
 bool termreq_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
+       (void)mesh;
+       (void)c;
+       (void)request;
        return false;
 }
 
@@ -91,6 +76,7 @@ bool send_ping(meshlink_handle_t *mesh, connection_t *c) {
 }
 
 bool ping_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
+       (void)request;
        return send_pong(mesh, c);
 }
 
@@ -99,6 +85,8 @@ bool send_pong(meshlink_handle_t *mesh, connection_t *c) {
 }
 
 bool pong_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
+       (void)mesh;
+       (void)request;
        c->status.pinged = false;
 
        /* Succesful connection, reset timeout if this is an outgoing connection. */
@@ -117,19 +105,6 @@ bool pong_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
 
 /* Sending and receiving packets via TCP */
 
-bool send_tcppacket(meshlink_handle_t *mesh, connection_t *c, const vpn_packet_t *packet) {
-       /* If there already is a lot of data in the outbuf buffer, discard this packet.
-          We use a very simple Random Early Drop algorithm. */
-
-       if(2.0 * c->outbuf.len / (float)maxoutbufsize - 1 > (float)rand() / (float)RAND_MAX)
-               return true;
-
-       if(!send_request(mesh, c, "%d %hd", PACKET, packet->len))
-               return false;
-
-       return send_meta(mesh, c, (char *)packet->data, packet->len);
-}
-
 bool tcppacket_h(meshlink_handle_t *mesh, connection_t *c, const char *request) {
        short int len;
 
@@ -138,9 +113,6 @@ bool tcppacket_h(meshlink_handle_t *mesh, connection_t *c, const char *request)
                return false;
        }
 
-       /* Set reqlen to len, this will tell receive_meta() that a tcppacket is coming. */
-
-       c->tcplen = len;
-
-       return true;
+       // This should never happen with MeshLink.
+       return false;
 }

diff --git a/src/splay_tree.c b/src/splay_tree.c
index d84948ed64aaa9f0ae7e27963ca200b509d9c320..b9130d6bd784108605a6b6c2bdd2f18b792a59a7 100644 (file)
--- a/src/splay_tree.c
+++ b/src/splay_tree.c
@@ -1,6 +1,6 @@
 /*
     splay_tree.c -- splay tree and linked list convenience
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -25,7 +25,7 @@
 /* Splay operation */
 
 static splay_node_t *splay_top_down(splay_tree_t *tree, const void *data, int *result) {
-       splay_node_t left = {NULL}, right = {NULL};
+       splay_node_t left = {}, right = {};
        splay_node_t *leftbottom = &left, *rightbottom = &right, *child, *grandchild;
        splay_node_t *root = tree->root;
        int c;

diff --git a/src/splay_tree.h b/src/splay_tree.h
index f1ff7db9d201a47924014c75bfb20ec9f4808d95..b6727908053adc5352af8997904927f9a5d98cc8 100644 (file)
--- a/src/splay_tree.h
+++ b/src/splay_tree.h
@@ -57,7 +57,7 @@ typedef struct splay_tree_t {
        splay_compare_t compare;
        splay_action_t delete;
 
-       int count;
+       unsigned int count;
 
 } splay_tree_t;
 

diff --git a/src/sptps.c b/src/sptps.c
index 50958ec64737743329664d376c1ee009469532ee..01fb438f2e3469fc6c186b3201db66e96d1a82c9 100644 (file)
--- a/src/sptps.c
+++ b/src/sptps.c
@@ -1,6 +1,6 @@
 /*
     sptps.c -- Simple Peer-to-Peer Security
-    Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
+    Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -50,9 +50,15 @@ unsigned int sptps_replaywin = 32;
 */
 
 void sptps_log_quiet(sptps_t *s, int s_errno, const char *format, va_list ap) {
+       (void)s;
+       (void)s_errno;
+       (void)format;
+       (void)ap;
 }
 
 void sptps_log_stderr(sptps_t *s, int s_errno, const char *format, va_list ap) {
+       (void)s;
+       (void)s_errno;
        vfprintf(stderr, format, ap);
        fputc('\n', stderr);
 }
@@ -227,6 +233,7 @@ static bool send_ack(sptps_t *s) {
 
 // Receive an ACKnowledgement record.
 static bool receive_ack(sptps_t *s, const char *data, uint16_t len) {
+       (void)data;
        if(len)
                return error(s, EIO, "Invalid ACK record length");
 
@@ -335,6 +342,7 @@ static bool receive_handshake(sptps_t *s, const char *data, uint16_t len) {
                // We receive a secondary KEX request, first respond by sending our own.
                if(!send_kex(s))
                        return false;
+               // fallthrough
        case SPTPS_KEX:
                // We have sent our KEX request, we expect our peer to sent one as well.
                if(!receive_kex(s, data, len))
@@ -439,7 +447,7 @@ static bool sptps_receive_data_datagram(sptps_t *s, const void *vdata, size_t le
                                        return error(s, EIO, "Received late or replayed packet, seqno %d, last received %d\n", seqno, s->inseqno);
                        } else {
                                // We missed some packets. Mark them in the bitmap as being late.
-                               for(int i = s->inseqno; i < seqno; i++)
+                               for(uint32_t i = s->inseqno; i < seqno; i++)
                                        s->late[(i / 8) % s->replaywin] |= 1 << i % 8;
                        }
                }

diff --git a/src/utcp b/src/utcp
index 1d8aa0d5a55bb871ce56bca355ade80b08a7c1e5..558c6d183e2a580b811c5603dd48c33b01a3dc7e 160000 (submodule)
--- a/src/utcp
+++ b/src/utcp
@@ -1 +1 @@
-Subproject commit 1d8aa0d5a55bb871ce56bca355ade80b08a7c1e5
+Subproject commit 558c6d183e2a580b811c5603dd48c33b01a3dc7e