Fix all -Wall -W compiler warnings.

[tinc] / src / meta.c

diff --git a/src/meta.c b/src/meta.c
index 09c063d..ee55ecd 100644 (file)
--- a/src/meta.c
+++ b/src/meta.c
@@ -1,6 +1,6 @@
 /*
     meta.c -- handle the meta communication
-    Copyright (C) 2000-2016 Guus Sliepen <guus@tinc-vpn.org>,
+    Copyright (C) 2000-2017 Guus Sliepen <guus@tinc-vpn.org>,
                   2000-2005 Ivo Timmermans
                   2006      Scott Lamb <slamb@slamb.org>
 
@@ -38,16 +38,12 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
        int outlen;
        int result;
 
-       if(!c) {
-               logger(LOG_ERR, "send_meta() called with NULL pointer!");
-               abort();
-       }
-
        ifdebug(META) logger(LOG_DEBUG, "Sending %d bytes of metadata to %s (%s)", length,
-                          c->name, c->hostname);
+                            c->name, c->hostname);
 
-       if(!c->outbuflen)
+       if(!c->outbuflen) {
                c->last_flushed_time = now;
+       }
 
        /* Find room in connection's buffer */
        if(length + c->outbuflen > c->outbufsize) {
@@ -63,7 +59,7 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
        /* Add our data to buffer */
        if(c->status.encryptout) {
                /* Check encryption limits */
-               if(length > c->outbudget) {
+               if((uint64_t)length > c->outbudget) {
                        ifdebug(META) logger(LOG_ERR, "Byte limit exceeded for encryption to %s (%s)", c->name, c->hostname);
                        return false;
                } else {
@@ -71,15 +67,17 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
                }
 
                result = EVP_EncryptUpdate(c->outctx, (unsigned char *)c->outbuf + c->outbufstart + c->outbuflen,
-                               &outlen, (unsigned char *)buffer, length);
+                                          &outlen, (unsigned char *)buffer, length);
+
                if(!result || outlen < length) {
                        logger(LOG_ERR, "Error while encrypting metadata to %s (%s): %s",
-                                       c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
+                              c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
                        return false;
                } else if(outlen > length) {
                        logger(LOG_EMERG, "Encrypted data too long! Heap corrupted!");
                        abort();
                }
+
                c->outbuflen += outlen;
        } else {
                memcpy(c->outbuf + c->outbufstart + c->outbuflen, buffer, length);
@@ -91,25 +89,26 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
 
 bool flush_meta(connection_t *c) {
        int result;
-       
+
        ifdebug(META) logger(LOG_DEBUG, "Flushing %d bytes to %s (%s)",
-                        c->outbuflen, c->name, c->hostname);
+                            c->outbuflen, c->name, c->hostname);
 
        while(c->outbuflen) {
                result = send(c->socket, c->outbuf + c->outbufstart, c->outbuflen, 0);
+
                if(result <= 0) {
                        if(!errno || errno == EPIPE) {
                                ifdebug(CONNECTIONS) logger(LOG_NOTICE, "Connection closed by %s (%s)",
-                                                  c->name, c->hostname);
+                                                           c->name, c->hostname);
                        } else if(errno == EINTR) {
                                continue;
                        } else if(sockwouldblock(sockerrno)) {
-                               ifdebug(CONNECTIONS) logger(LOG_DEBUG, "Flushing %d bytes to %s (%s) would block",
-                                               c->outbuflen, c->name, c->hostname);
+                               ifdebug(META) logger(LOG_DEBUG, "Flushing %d bytes to %s (%s) would block",
+                                                    c->outbuflen, c->name, c->hostname);
                                return true;
                        } else {
                                logger(LOG_ERR, "Flushing meta data to %s (%s) failed: %s", c->name,
-                                          c->hostname, sockstrerror(sockerrno));
+                                      c->hostname, sockstrerror(sockerrno));
                        }
 
                        return false;
@@ -130,8 +129,9 @@ void broadcast_meta(connection_t *from, const char *buffer, int length) {
        for(node = connection_tree->head; node; node = node->next) {
                c = node->data;
 
-               if(c != from && c->status.active)
+               if(c != from && c->status.active) {
                        send_meta(c, buffer, length);
+               }
        }
 }
 
@@ -155,12 +155,12 @@ bool receive_meta(connection_t *c) {
        if(lenin <= 0) {
                if(!lenin || !errno) {
                        ifdebug(CONNECTIONS) logger(LOG_NOTICE, "Connection closed by %s (%s)",
-                                          c->name, c->hostname);
-               } else if(sockwouldblock(sockerrno))
+                                                   c->name, c->hostname);
+               } else if(sockwouldblock(sockerrno)) {
                        return true;
-               else
+               } else
                        logger(LOG_ERR, "Metadata socket read error for %s (%s): %s",
-                                  c->name, c->hostname, sockstrerror(sockerrno));
+                              c->name, c->hostname, sockstrerror(sockerrno));
 
                return false;
        }
@@ -174,9 +174,12 @@ bool receive_meta(connection_t *c) {
                /* Is it proxy metadata? */
 
                if(c->allow_request == PROXY) {
-                       reqlen = receive_proxy_meta(c, oldlen, lenin);
-                       if(reqlen < 0)
+                       reqlen = receive_proxy_meta(c);
+
+                       if(reqlen < 0) {
                                return false;
+                       }
+
                        goto consume;
                }
 
@@ -184,7 +187,7 @@ bool receive_meta(connection_t *c) {
 
                if(c->status.decryptin && !decrypted) {
                        /* Check decryption limits */
-                       if(lenin > c->inbudget) {
+                       if((uint64_t)lenin > c->inbudget) {
                                ifdebug(META) logger(LOG_ERR, "Byte limit exceeded for decryption from %s (%s)", c->name, c->hostname);
                                return false;
                        } else {
@@ -192,11 +195,13 @@ bool receive_meta(connection_t *c) {
                        }
 
                        result = EVP_DecryptUpdate(c->inctx, (unsigned char *)inbuf, &lenout, (unsigned char *)c->buffer + oldlen, lenin);
+
                        if(!result || lenout != lenin) {
                                logger(LOG_ERR, "Error while decrypting metadata from %s (%s): %s",
-                                               c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
+                                      c->name, c->hostname, ERR_error_string(ERR_get_error(), NULL));
                                return false;
                        }
+
                        memcpy(c->buffer + oldlen, inbuf, lenin);
                        decrypted = true;
                }
@@ -219,17 +224,19 @@ bool receive_meta(connection_t *c) {
 
                        for(i = oldlen; i < c->buflen; i++) {
                                if(c->buffer[i] == '\n') {
-                                       c->buffer[i] = '\0';    /* replace end-of-line by end-of-string so we can use sscanf */
+                                       c->buffer[i] = '\0';    /* replace end-of-line by end-of-string so we can use sscanf */
                                        c->reqlen = reqlen = i + 1;
                                        break;
                                }
                        }
 
-                       if(reqlen && !receive_request(c))
+                       if(reqlen && !receive_request(c)) {
                                return false;
+                       }
                }
 
 consume:
+
                if(reqlen) {
                        c->buflen -= reqlen;
                        lenin -= reqlen - oldlen;
@@ -243,7 +250,7 @@ consume:
 
        if(c->buflen >= MAXBUFSIZE) {
                logger(LOG_ERR, "Metadata read buffer overflow for %s (%s)",
-                          c->name, c->hostname);
+                      c->name, c->hostname);
                return false;
        }