Fix a bunch of compiler warnings and remove suppressions.

17 files changed, 98 insertions, 89 deletions

diff --git a/toxcore/BUILD.bazel b/toxcore/BUILD.bazel
index d6c3693e..3dfa1648 100644
--- a/toxcore/BUILD.bazel
+++ b/toxcore/BUILD.bazel
@@ -48,6 +48,7 @@ cc_library(
     name = "logger",
     srcs = ["logger.c"],
     hdrs = ["logger.h"],
+    deps = [":ccompat"],
 )
 
 cc_library(
@@ -100,9 +101,6 @@ cc_library(
         "LAN_discovery.h",
         "ping.h",
     ],
-    copts = [
-        "-Wno-parentheses",
-    ],
     visibility = ["//c-toxcore/other/bootstrap_daemon:__pkg__"],
     deps = [
         ":crypto_core",
@@ -205,9 +203,6 @@ cc_library(
         "tox.h",
         "tox_api.c",
     ],
-    copts = [
-        "-Wno-parentheses",
-    ],
     visibility = ["//c-toxcore:__subpackages__"],
     deps = [
         ":group",
@@ -221,9 +216,6 @@ cc_library(
         "*.c",
         "*.h",
     ]),
-    copts = [
-        "-Wno-parentheses",
-    ],
     linkopts = ["-lpthread"],
     visibility = ["//c-toxcore/other:__pkg__"],
     deps = [
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 10ea659e..4acfa161 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -615,8 +615,8 @@ static uint32_t index_of_node_pk(const Node_format *array, uint32_t size, const
 static uint32_t index_of_client_ip_port(const Client_data *array, uint32_t size, const IP_Port *ip_port)
 {
     for (uint32_t i = 0; i < size; ++i) {
-        if (ip_port->ip.family == TOX_AF_INET  && ipport_equal(&array[i].assoc4.ip_port, ip_port) ||
-                ip_port->ip.family == TOX_AF_INET6 && ipport_equal(&array[i].assoc6.ip_port, ip_port)) {
+        if ((ip_port->ip.family == TOX_AF_INET && ipport_equal(&array[i].assoc4.ip_port, ip_port)) ||
+                (ip_port->ip.family == TOX_AF_INET6 && ipport_equal(&array[i].assoc6.ip_port, ip_port))) {
             return i;
         }
     }
@@ -1084,18 +1084,20 @@ static bool ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_key, IP_P
         ret = true;
     }
 
-    unsigned int *const num = &dht->num_to_bootstrap;
-    const uint32_t index = index_of_node_pk(dht->to_bootstrap, *num, public_key);
-    const bool in_close_list = is_pk_in_close_list(dht, public_key, ip_port);
+    {
+        unsigned int *const num = &dht->num_to_bootstrap;
+        const uint32_t index = index_of_node_pk(dht->to_bootstrap, *num, public_key);
+        const bool in_close_list = is_pk_in_close_list(dht, public_key, ip_port);
 
-    if (ret && index == UINT32_MAX && !in_close_list) {
-        if (*num < MAX_CLOSE_TO_BOOTSTRAP_NODES) {
-            memcpy(dht->to_bootstrap[*num].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
-            dht->to_bootstrap[*num].ip_port = ip_port;
-            ++*num;
-        } else {
-            // TODO(irungentoo): ipv6 vs v4
-            add_to_list(dht->to_bootstrap, MAX_CLOSE_TO_BOOTSTRAP_NODES, public_key, ip_port, dht->self_public_key);
+        if (ret && index == UINT32_MAX && !in_close_list) {
+            if (*num < MAX_CLOSE_TO_BOOTSTRAP_NODES) {
+                memcpy(dht->to_bootstrap[*num].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+                dht->to_bootstrap[*num].ip_port = ip_port;
+                ++*num;
+            } else {
+                // TODO(irungentoo): ipv6 vs v4
+                add_to_list(dht->to_bootstrap, MAX_CLOSE_TO_BOOTSTRAP_NODES, public_key, ip_port, dht->self_public_key);
+            }
         }
     }
 
@@ -1655,8 +1657,8 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
 
         IPPTsPng *assocs[ASSOC_COUNT] = { &client->assoc6, &client->assoc4 };
 
-        for (size_t i = 0; i < ASSOC_COUNT; i++) {
-            IPPTsPng *assoc = assocs[i];
+        for (size_t j = 0; j < ASSOC_COUNT; j++) {
+            IPPTsPng *assoc = assocs[j];
 
             if (!is_timeout(assoc->timestamp, KILL_NODE_TIMEOUT)) {
                 sort = 0;
@@ -1677,7 +1679,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
                 ++sort;
 
                 /* Timed out should be at beginning, if they are not, sort the list. */
-                if (sort > 1 && sort < (((i + 1) * 2) - 1)) {
+                if (sort > 1 && sort < (((j + 1) * 2) - 1)) {
                     sort_ok = true;
                 }
             }
@@ -2237,14 +2239,17 @@ static void do_NAT(DHT *dht)
 /*----------------------------------------------------------------------------------*/
 /*-----------------------END OF NAT PUNCHING FUNCTIONS------------------------------*/
 
+#define DHT_HARDENING 0
 #define HARDREQ_DATA_SIZE 384 /* Attempt to prevent amplification/other attacks*/
 
-#define CHECK_TYPE_ROUTE_REQ 0
-#define CHECK_TYPE_ROUTE_RES 1
-#define CHECK_TYPE_GETNODE_REQ 2
-#define CHECK_TYPE_GETNODE_RES 3
-#define CHECK_TYPE_TEST_REQ 4
-#define CHECK_TYPE_TEST_RES 5
+enum {
+    CHECK_TYPE_ROUTE_REQ = 0,
+    CHECK_TYPE_ROUTE_RES = 1,
+    CHECK_TYPE_GETNODE_REQ = 2,
+    CHECK_TYPE_GETNODE_RES = 3,
+    CHECK_TYPE_TEST_REQ = 4,
+    CHECK_TYPE_TEST_RES = 5,
+};
 
 #if DHT_HARDENING
 static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8_t *contents, uint16_t length)
@@ -2350,7 +2355,6 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 
 /* Interval in seconds between hardening checks */
 #define HARDENING_INTERVAL 120
-#define HARDEN_TIMEOUT 1200
 
 /* Handle a received hardening packet */
 static int handle_hardening(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
@@ -2429,6 +2433,8 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
 }
 
 #if DHT_HARDENING
+#define HARDEN_TIMEOUT 1200
+
 /* Return a random node from all the nodes we are connected to.
  * TODO(irungentoo): improve this function.
  */
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index f5883060..70b71fea 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -156,9 +156,9 @@ static void fetch_broadcast_info(uint16_t port)
      * a larger array, not done (640kB and 16 interfaces shall be
      * enough, for everybody!)
      */
-    int i, n = ifconf.ifc_len / sizeof(struct ifreq);
+    int n = ifconf.ifc_len / sizeof(struct ifreq);
 
-    for (i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
         /* there are interfaces with are incapable of broadcast */
         if (ioctl(sock, SIOCGIFBRDADDR, &i_faces[i]) < 0) {
             continue;
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 5542ee1b..2bebae92 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -33,7 +33,6 @@
 
 #include <assert.h>
 
-static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata);
 static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
                                 uint32_t length, uint8_t congestion_control);
 
@@ -949,7 +948,7 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
     }
 }
 
-void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata)
+static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata)
 {
     check_friend_connectionstatus(m, friendnumber, status, userdata);
     m->friendlist[friendnumber].status = status;
@@ -1825,13 +1824,13 @@ static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint
     return 1;
 }
 
-void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
+void custom_lossy_packet_registerhandler(Messenger *m, void (*lossy_packethandler)(Messenger *m,
         uint32_t friendnumber, const uint8_t *data, size_t len, void *object))
 {
-    m->lossy_packethandler = packet_handler_callback;
+    m->lossy_packethandler = lossy_packethandler;
 }
 
-int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*packet_handler_callback)(Messenger *m,
+int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*function)(Messenger *m,
                           uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object), void *object)
 {
     if (friend_not_valid(m, friendnumber)) {
@@ -1846,8 +1845,7 @@ int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int
         return -1;
     }
 
-    m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].function =
-        packet_handler_callback;
+    m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].function = function;
     m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].object = object;
     return 0;
 }
@@ -1907,10 +1905,10 @@ static int handle_custom_lossless_packet(void *object, int friend_num, const uin
     return 1;
 }
 
-void custom_lossless_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
+void custom_lossless_packet_registerhandler(Messenger *m, void (*lossless_packethandler)(Messenger *m,
         uint32_t friendnumber, const uint8_t *data, size_t len, void *object))
 {
-    m->lossless_packethandler = packet_handler_callback;
+    m->lossless_packethandler = lossless_packethandler;
 }
 
 int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
@@ -2765,7 +2763,7 @@ struct SAVED_FRIEND {
     uint64_t last_seen_time;
 };
 
-static uint32_t friend_size()
+static uint32_t friend_size(void)
 {
     uint32_t data = 0;
     const struct SAVED_FRIEND *const temp = nullptr;
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 956f8ac5..402eb916 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -37,7 +37,7 @@
 /* This cannot be bigger than 256 */
 #define MAX_CONCURRENT_FILE_PIPES 256
 
-#if MAX_CONCURRENT_FILE_PIPES > UINT8_MAX + 1
+#if !defined(__SPLINT__) && MAX_CONCURRENT_FILE_PIPES > UINT8_MAX + 1
 #error "uint8_t cannot represent all file transfer numbers"
 #endif
 
@@ -74,13 +74,13 @@ enum {
 #define PACKET_LOSSY_AV_RESERVED 8 /* Number of lossy packet types at start of range reserved for A/V. */
 
 typedef struct {
-    uint8_t ipv6enabled;
-    uint8_t udp_disabled;
+    bool ipv6enabled;
+    bool udp_disabled;
     TCP_Proxy_Info proxy_info;
     uint16_t port_range[2];
     uint16_t tcp_server_port;
 
-    uint8_t hole_punching_enabled;
+    bool hole_punching_enabled;
     bool local_discovery_enabled;
 
     logger_cb *log_callback;
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index e3f55a73..a6c32f9c 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -110,9 +110,9 @@ void tcp_con_set_custom_object(TCP_Client_Connection *con, void *object)
 {
     con->custom_object = object;
 }
-void tcp_con_set_custom_uint(TCP_Client_Connection *con, uint32_t uint)
+void tcp_con_set_custom_uint(TCP_Client_Connection *con, uint32_t value)
 {
-    con->custom_uint = uint;
+    con->custom_uint = value;
 }
 
 /* return 1 on success
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index ae73b804..4541fce0 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -98,9 +98,11 @@ size_t tcp_server_listen_count(const TCP_Server *tcp_server)
 
 /* This is needed to compile on Android below API 21
  */
+#ifdef TCP_SERVER_USE_EPOLL
 #ifndef EPOLLRDHUP
 #define EPOLLRDHUP 0x2000
 #endif
+#endif
 
 /* Set the size of the connection list to numfriends.
  *
diff --git a/toxcore/ccompat.h b/toxcore/ccompat.h
index 90db8bc6..1ceb5a5a 100644
--- a/toxcore/ccompat.h
+++ b/toxcore/ccompat.h
@@ -13,7 +13,7 @@
 // "function") is used. Note the semantic difference: alloca'd memory does not
 // get freed at the end of the declaration's scope. Do not use VLA() in loops or
 // you may run out of stack space.
-#if !defined(_MSC_VER) && __STDC_VERSION__ >= 199901L
+#if !defined(_MSC_VER) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 // C99 VLAs.
 #define VLA(type, name, size) type name[size]
 #define SIZEOF_VLA sizeof
@@ -42,4 +42,10 @@
 #define nullptr NULL
 #endif
 
+#ifdef __GNUC__
+#define GNU_PRINTF __attribute__((__format__(__printf__, 6, 7)))
+#else
+#define GNU_PRINTF
+#endif
+
 #endif /* CCOMPAT_H */
diff --git a/toxcore/crypto_core.c b/toxcore/crypto_core.c
index d5333e67..26589219 100644
--- a/toxcore/crypto_core.c
+++ b/toxcore/crypto_core.c
@@ -219,7 +219,7 @@ void increment_nonce(uint8_t *nonce)
 
 static uint32_t host_to_network(uint32_t x)
 {
-#if BYTE_ORDER == LITTLE_ENDIAN
+#if !defined(BYTE_ORDER) || BYTE_ORDER == LITTLE_ENDIAN
     return
         ((x >> 24) & 0x000000FF) | // move byte 3 to byte 0
         ((x >> 8)  & 0x0000FF00) | // move byte 2 to byte 1
diff --git a/toxcore/logger.h b/toxcore/logger.h
index 8c8a639b..b3a8f7dc 100644
--- a/toxcore/logger.h
+++ b/toxcore/logger.h
@@ -26,6 +26,8 @@
 
 #include <stdint.h>
 
+#include "ccompat.h"
+
 #ifndef MIN_LOGGER_LEVEL
 #define MIN_LOGGER_LEVEL LOG_INFO
 #endif
@@ -59,8 +61,8 @@ void logger_callback_log(Logger *log, logger_cb *function, void *context, void *
 /**
  * Main write function. If logging disabled does nothing.
  */
-void logger_write(Logger *log, LOGGER_LEVEL level, const char *file, int line, const char *func, const char *format,
-                  ...);
+void logger_write(
+    Logger *log, LOGGER_LEVEL level, const char *file, int line, const char *func, const char *format, ...) GNU_PRINTF;
 
 
 #define LOGGER_WRITE(log, level, ...) \
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index fbdbaab8..65c81d92 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -1542,8 +1542,6 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const
             return -1;
         }
 
-        // else { /* TODO(irungentoo): ? */ }
-
         set_buffer_end(&conn->recv_array, num);
     } else if (real_data[0] >= CRYPTO_RESERVED_PACKETS && real_data[0] < PACKET_ID_LOSSY_RANGE_START) {
         Packet_Data dt;
diff --git a/toxcore/network.c b/toxcore/network.c
index 99768829..6090b6e3 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -25,7 +25,10 @@
 #include "config.h"
 #endif
 
+#ifdef __APPLE__
 #define _DARWIN_C_SOURCE
+#endif
+
 #ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE 600
 #endif
@@ -185,14 +188,14 @@ const IP6 IP6_BROADCAST = {
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
 };
 
-IP4 get_ip4_loopback()
+IP4 get_ip4_loopback(void)
 {
     IP4 loopback;
     loopback.uint32 = htonl(INADDR_LOOPBACK);
     return loopback;
 }
 
-IP6 get_ip6_loopback()
+IP6 get_ip6_loopback(void)
 {
     IP6 loopback;
     get_ip6(&loopback, &in6addr_loopback);
@@ -374,18 +377,18 @@ static void loglogdata(Logger *log, const char *message, const uint8_t *buffer,
     char ip_str[IP_NTOA_LEN];
 
     if (res < 0) { /* Windows doesn't necessarily know %zu */
-        LOGGER_TRACE(log, "[%2u] %s %3hu%c %s:%hu (%u: %s) | %04x%04x",
-                     buffer[0], message, (buflen < 999 ? (uint16_t)buflen : 999), 'E',
+        LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, (buflen < 999 ? buflen : 999), 'E',
                      ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), errno,
                      strerror(errno), data_0(buflen, buffer), data_1(buflen, buffer));
     } else if ((res > 0) && ((size_t)res <= buflen)) {
-        LOGGER_TRACE(log, "[%2u] %s %3zu%c %s:%hu (%u: %s) | %04x%04x",
-                     buffer[0], message, (res < 999 ? (size_t)res : 999), ((size_t)res < buflen ? '<' : '='),
+        LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, (res < 999 ? res : 999), ((size_t)res < buflen ? '<' : '='),
                      ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), 0, "OK",
                      data_0(buflen, buffer), data_1(buflen, buffer));
     } else { /* empty or overwrite */
-        LOGGER_TRACE(log, "[%2u] %s %zu%c%zu %s:%hu (%u: %s) | %04x%04x",
-                     buffer[0], message, (size_t)res, (!res ? '!' : '>'), buflen,
+        LOGGER_TRACE(log, "[%2u] %s %u%c%u %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, res, (!res ? '!' : '>'), buflen,
                      ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), 0, "OK",
                      data_0(buflen, buffer), data_1(buflen, buffer));
     }
@@ -951,7 +954,7 @@ void ip_reset(IP *ip)
 }
 
 /* nulls out ip, sets family according to flag */
-void ip_init(IP *ip, uint8_t ipv6enabled)
+void ip_init(IP *ip, bool ipv6enabled)
 {
     if (!ip) {
         return;
@@ -1298,7 +1301,7 @@ int32_t net_getipport(const char *node, IP_Port **res, int tox_type)
     const size_t MAX_COUNT = MIN(SIZE_MAX, INT32_MAX) / sizeof(IP_Port);
     int type = make_socktype(tox_type);
     struct addrinfo *cur;
-    int32_t count = 0;
+    size_t count = 0;
 
     for (cur = infos; count < MAX_COUNT && cur != nullptr; cur = cur->ai_next) {
         if (cur->ai_socktype && type > 0 && cur->ai_socktype != type) {
diff --git a/toxcore/network.h b/toxcore/network.h
index 8b5af47c..405721b2 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -33,6 +33,7 @@
 #include "ccompat.h"
 #include "logger.h"
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -187,7 +188,7 @@ size_t net_unpack_u64(const uint8_t *bytes, uint64_t *v);
 #define SIZE_PORT 2
 #define SIZE_IPPORT (SIZE_IP + SIZE_PORT)
 
-#define TOX_ENABLE_IPV6_DEFAULT 1
+#define TOX_ENABLE_IPV6_DEFAULT true
 
 /* addr_resolve return values */
 #define TOX_ADDR_RESOLVE_INET  1
@@ -260,7 +261,7 @@ int ipport_equal(const IP_Port *a, const IP_Port *b);
 /* nulls out ip */
 void ip_reset(IP *ip);
 /* nulls out ip, sets family according to flag */
-void ip_init(IP *ip, uint8_t ipv6enabled);
+void ip_init(IP *ip, bool ipv6enabled);
 /* checks if ip is valid */
 int ip_isset(const IP *ip);
 /* checks if ip is valid */
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index e6743559..c4eb3fc1 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -1351,14 +1351,14 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
  * return -1 on failure.
  * return 0 on success.
  */
-int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_relay_node_callback)(void *object,
+int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*callback)(void *object,
                            uint32_t number, IP_Port ip_port, const uint8_t *public_key), void *object, uint32_t number)
 {
     if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
     }
 
-    onion_c->friends_list[friend_num].tcp_relay_node_callback = tcp_relay_node_callback;
+    onion_c->friends_list[friend_num].tcp_relay_node_callback = callback;
     onion_c->friends_list[friend_num].tcp_relay_node_callback_object = object;
     onion_c->friends_list[friend_num].tcp_relay_node_callback_number = number;
     return 0;
diff --git a/toxcore/tox.api.h b/toxcore/tox.api.h
index 493307e9..fc5d5593 100644
--- a/toxcore/tox.api.h
+++ b/toxcore/tox.api.h
@@ -188,19 +188,19 @@ const VERSION_PATCH                = 0;
  * features, but can't break the API.
  */
 #define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)              \
-  (TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (            \
+  ((TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (           \
     /* 1.x.x, 2.x.x, etc. with matching major version. */               \
     TOX_VERSION_MINOR > MINOR ||                                        \
-    TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH            \
-  ) || (TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                      \
+    (TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH)          \
+  )) || ((TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                    \
     /* 0.x.x makes minor behave like major above. */                    \
-    (TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (          \
+    ((TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (         \
       TOX_VERSION_PATCH >= PATCH                                        \
-    ) || (TOX_VERSION_MINOR == 0 && MINOR == 0) && (                    \
+    )) || ((TOX_VERSION_MINOR == 0 && MINOR == 0) && (                  \
       /* 0.0.x and 0.0.y are only compatible if x == y. */              \
       TOX_VERSION_PATCH == PATCH                                        \
-    )                                                                   \
-  )
+    ))                                                                  \
+  ))
 
 static namespace version {
 
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 747411f1..caaaedba 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -82,7 +82,7 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
 {
     Messenger_Options m_options = {0};
 
-    bool load_savedata_sk = 0, load_savedata_tox = 0;
+    bool load_savedata_sk = false, load_savedata_tox = false;
 
     if (options == nullptr) {
         m_options.ipv6enabled = TOX_ENABLE_IPV6_DEFAULT;
@@ -100,7 +100,7 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
                 return nullptr;
             }
 
-            load_savedata_sk = 1;
+            load_savedata_sk = true;
         } else if (tox_options_get_savedata_type(options) == TOX_SAVEDATA_TYPE_TOX_SAVE) {
             if (tox_options_get_savedata_length(options) < TOX_ENC_SAVE_MAGIC_LENGTH) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
@@ -112,7 +112,7 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
                 return nullptr;
             }
 
-            load_savedata_tox = 1;
+            load_savedata_tox = true;
         }
 
         m_options.ipv6enabled = tox_options_get_ipv6_enabled(options);
@@ -156,7 +156,7 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
                 m_options.proxy_info.ip_port.ip.family = TOX_AF_UNSPEC;
             }
 
-            if (!addr_resolve_or_parse_ip(tox_options_get_proxy_host(options), &m_options.proxy_info.ip_port.ip, nullptr)) {
+            if (addr_resolve_or_parse_ip(tox_options_get_proxy_host(options), &m_options.proxy_info.ip_port.ip, nullptr) == 0) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST);
                 // TODO(irungentoo): TOX_ERR_NEW_PROXY_NOT_FOUND if domain.
                 return nullptr;
@@ -457,7 +457,8 @@ void tox_self_set_status(Tox *tox, TOX_USER_STATUS status)
 TOX_USER_STATUS tox_self_get_status(const Tox *tox)
 {
     const Messenger *m = tox;
-    return (TOX_USER_STATUS)m_get_self_userstatus(m);
+    const uint8_t status = m_get_self_userstatus(m);
+    return (TOX_USER_STATUS)status;
 }
 
 static void set_friend_error(int32_t ret, TOX_ERR_FRIEND_ADD *error)
diff --git a/toxcore/tox.h b/toxcore/tox.h
index f2e746c8..cf5b2c28 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -191,19 +191,19 @@ uint32_t tox_version_patch(void);
  * features, but can't break the API.
  */
 #define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)              \
-  (TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (            \
+  ((TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (           \
     /* 1.x.x, 2.x.x, etc. with matching major version. */               \
     TOX_VERSION_MINOR > MINOR ||                                        \
-    TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH            \
-  ) || (TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                      \
+    (TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH)          \
+  )) || ((TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                    \
     /* 0.x.x makes minor behave like major above. */                    \
-    (TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (          \
+    ((TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (         \
       TOX_VERSION_PATCH >= PATCH                                        \
-    ) || (TOX_VERSION_MINOR == 0 && MINOR == 0) && (                    \
+    )) || ((TOX_VERSION_MINOR == 0 && MINOR == 0) && (                  \
       /* 0.0.x and 0.0.y are only compatible if x == y. */              \
       TOX_VERSION_PATCH == PATCH                                        \
-    )                                                                   \
-  )
+    ))                                                                  \
+  ))
 
 /**
  * Return whether the compiled library version is compatible with the passed