Add braces to all if statements.

1 files changed, 275 insertions, 141 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 98859856..538cd220 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -81,11 +81,13 @@ int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2)
         distance1 = pk[i] ^ pk1[i];
         distance2 = pk[i] ^ pk2[i];
 
-        if (distance1 < distance2)
+        if (distance1 < distance2) {
             return 1;
+        }
 
-        if (distance1 > distance2)
+        if (distance1 > distance2) {
             return 2;
+        }
     }
 
     return 0;
@@ -98,12 +100,14 @@ static unsigned int bit_by_bit_cmp(const uint8_t *pk1, const uint8_t *pk2)
     unsigned int i, j = 0;
 
     for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) {
-        if (pk1[i] == pk2[i])
+        if (pk1[i] == pk2[i]) {
             continue;
+        }
 
         for (j = 0; j < 8; ++j) {
-            if ((pk1[i] & (1 << (7 - j))) != (pk2[i] & (1 << (7 - j))))
+            if ((pk1[i] & (1 << (7 - j))) != (pk2[i] & (1 << (7 - j)))) {
                 break;
+            }
         }
 
         break;
@@ -179,10 +183,11 @@ void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *publi
 
 void to_net_family(IP *ip)
 {
-    if (ip->family == AF_INET)
+    if (ip->family == AF_INET) {
         ip->family = TOX_AF_INET;
-    else if (ip->family == AF_INET6)
+    } else if (ip->family == AF_INET6) {
         ip->family = TOX_AF_INET6;
+    }
 }
 
 int to_host_family(IP *ip)
@@ -253,8 +258,9 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_
         if (ipv6 == 0) {
             uint32_t size = PACKED_NODE_SIZE_IP4;
 
-            if (packed_length + size > length)
+            if (packed_length + size > length) {
                 return -1;
+            }
 
             data[packed_length] = net_family;
             memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip4, SIZE_IP4);
@@ -264,8 +270,9 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_
         } else if (ipv6 == 1) {
             uint32_t size = PACKED_NODE_SIZE_IP6;
 
-            if (packed_length + size > length)
+            if (packed_length + size > length) {
                 return -1;
+            }
 
             data[packed_length] = net_family;
             memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip6, SIZE_IP6);
@@ -300,8 +307,9 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
             ipv6 = 0;
             host_family = AF_INET;
         } else if (data[len_processed] == TOX_TCP_INET) {
-            if (!tcp_enabled)
+            if (!tcp_enabled) {
                 return -1;
+            }
 
             ipv6 = 0;
             host_family = TCP_INET;
@@ -309,8 +317,9 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
             ipv6 = 1;
             host_family = AF_INET6;
         } else if (data[len_processed] == TOX_TCP_INET6) {
-            if (!tcp_enabled)
+            if (!tcp_enabled) {
                 return -1;
+            }
 
             ipv6 = 1;
             host_family = TCP_INET6;
@@ -321,8 +330,9 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
         if (ipv6 == 0) {
             uint32_t size = PACKED_NODE_SIZE_IP4;
 
-            if (len_processed + size > length)
+            if (len_processed + size > length) {
                 return -1;
+            }
 
             nodes[num].ip_port.ip.family = host_family;
             memcpy(&nodes[num].ip_port.ip.ip4, data + len_processed + 1, SIZE_IP4);
@@ -333,8 +343,9 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
         } else if (ipv6 == 1) {
             uint32_t size = PACKED_NODE_SIZE_IP6;
 
-            if (len_processed + size > length)
+            if (len_processed + size > length) {
                 return -1;
+            }
 
             nodes[num].ip_port.ip.family = host_family;
             memcpy(&nodes[num].ip_port.ip.ip6, data + len_processed + 1, SIZE_IP6);
@@ -347,8 +358,9 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
         }
     }
 
-    if (processed_data_len)
+    if (processed_data_len) {
         *processed_data_len = len_processed;
+    }
 
     return num;
 }
@@ -369,7 +381,7 @@ static int client_or_ip_port_in_list(Logger *log, Client_data *list, uint16_t le
     uint64_t temp_time = unix_time();
 
     /* if public_key is in list, find it and maybe overwrite ip_port */
-    for (i = 0; i < length; ++i)
+    for (i = 0; i < length; ++i) {
         if (id_equal(list[i].public_key, public_key)) {
             /* Refresh the client timestamp. */
             if (ip_port.ip.family == AF_INET) {
@@ -380,8 +392,9 @@ static int client_or_ip_port_in_list(Logger *log, Client_data *list, uint16_t le
                                  ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
                 }
 
-                if (LAN_ip(list[i].assoc4.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0)
+                if (LAN_ip(list[i].assoc4.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0) {
                     return 1;
+                }
 
                 list[i].assoc4.ip_port = ip_port;
                 list[i].assoc4.timestamp = temp_time;
@@ -393,8 +406,9 @@ static int client_or_ip_port_in_list(Logger *log, Client_data *list, uint16_t le
                                  ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
                 }
 
-                if (LAN_ip(list[i].assoc6.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0)
+                if (LAN_ip(list[i].assoc6.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0) {
                     return 1;
+                }
 
                 list[i].assoc6.ip_port = ip_port;
                 list[i].assoc6.timestamp = temp_time;
@@ -402,6 +416,7 @@ static int client_or_ip_port_in_list(Logger *log, Client_data *list, uint16_t le
 
             return 1;
         }
+    }
 
     /* public_key not in list yet: see if we can find an identical ip_port, in
      * that case we kill the old public_key by overwriting it with the new one
@@ -445,8 +460,9 @@ static int client_in_nodelist(const Node_format *list, uint16_t length, const ui
     uint32_t i;
 
     for (i = 0; i < length; ++i) {
-        if (id_equal(list[i].public_key, public_key))
+        if (id_equal(list[i].public_key, public_key)) {
             return 1;
+        }
     }
 
     return 0;
@@ -460,8 +476,9 @@ static int friend_number(const DHT *dht, const uint8_t *public_key)
     uint32_t i;
 
     for (i = 0; i < dht->num_friends; ++i) {
-        if (id_equal(dht->friends_list[i].public_key, public_key))
+        if (id_equal(dht->friends_list[i].public_key, public_key)) {
             return i;
+        }
     }
 
     return -1;
@@ -484,8 +501,9 @@ _Bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *p
             memcpy(nodes_list[i].public_key, pk, crypto_box_PUBLICKEYBYTES);
             nodes_list[i].ip_port = ip_port;
 
-            if (i != (length - 1))
+            if (i != (length - 1)) {
                 add_to_list(nodes_list, length, pk_bak, ip_port_bak, cmp_pk);
+            }
 
             return 1;
         }
@@ -513,8 +531,9 @@ static void get_close_nodes_inner(const uint8_t *public_key, Node_format *nodes_
                                   sa_family_t sa_family, const Client_data *client_list, uint32_t client_list_length,
                                   uint32_t *num_nodes_ptr, uint8_t is_LAN, uint8_t want_good)
 {
-    if ((sa_family != AF_INET) && (sa_family != AF_INET6) && (sa_family != 0))
+    if ((sa_family != AF_INET) && (sa_family != AF_INET6) && (sa_family != 0)) {
         return;
+    }
 
     uint32_t num_nodes = *num_nodes_ptr;
     uint32_t i;
@@ -523,8 +542,9 @@ static void get_close_nodes_inner(const uint8_t *public_key, Node_format *nodes_
         const Client_data *client = &client_list[i];
 
         /* node already in list? */
-        if (client_in_nodelist(nodes_list, MAX_SENT_NODES, client->public_key))
+        if (client_in_nodelist(nodes_list, MAX_SENT_NODES, client->public_key)) {
             continue;
+        }
 
         const IPPTsPng *ipptp = NULL;
 
@@ -541,16 +561,19 @@ static void get_close_nodes_inner(const uint8_t *public_key, Node_format *nodes_
         }
 
         /* node not in a good condition? */
-        if (is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT))
+        if (is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT)) {
             continue;
+        }
 
         /* don't send LAN ips to non LAN peers */
-        if (LAN_ip(ipptp->ip_port.ip) == 0 && !is_LAN)
+        if (LAN_ip(ipptp->ip_port.ip) == 0 && !is_LAN) {
             continue;
+        }
 
         if (LAN_ip(ipptp->ip_port.ip) != 0 && want_good && hardening_correct(&ipptp->hardening) != HARDENING_ALL_OK
-                && !id_equal(public_key, client->public_key))
+                && !id_equal(public_key, client->public_key)) {
             continue;
+        }
 
         if (num_nodes < MAX_SENT_NODES) {
             memcpy(nodes_list[num_nodes].public_key,
@@ -588,10 +611,11 @@ static int get_somewhat_close_nodes(const DHT *dht, const uint8_t *public_key, N
                                   dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
                                   &num_nodes, is_LAN, want_good);
     */
-    for (i = 0; i < dht->num_friends; ++i)
+    for (i = 0; i < dht->num_friends; ++i) {
         get_close_nodes_inner(public_key, nodes_list, sa_family,
                               dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
                               &num_nodes, is_LAN, 0);
+    }
 
     return num_nodes;
 }
@@ -665,14 +689,17 @@ static int cmp_dht_entry(const void *a, const void *b)
     int t1 = is_timeout(entry1.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry1.assoc6.timestamp, BAD_NODE_TIMEOUT);
     int t2 = is_timeout(entry2.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry2.assoc6.timestamp, BAD_NODE_TIMEOUT);
 
-    if (t1 && t2)
+    if (t1 && t2) {
         return 0;
+    }
 
-    if (t1)
+    if (t1) {
         return -1;
+    }
 
-    if (t2)
+    if (t2) {
         return 1;
+    }
 
     t1 = hardening_correct(&entry1.assoc4.hardening) != HARDENING_ALL_OK
          && hardening_correct(&entry1.assoc6.hardening) != HARDENING_ALL_OK;
@@ -680,20 +707,24 @@ static int cmp_dht_entry(const void *a, const void *b)
          && hardening_correct(&entry2.assoc6.hardening) != HARDENING_ALL_OK;
 
     if (t1 != t2) {
-        if (t1)
+        if (t1) {
             return -1;
+        }
 
-        if (t2)
+        if (t2) {
             return 1;
+        }
     }
 
     int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
 
-    if (close == 1)
+    if (close == 1) {
         return 1;
+    }
 
-    if (close == 2)
+    if (close == 2) {
         return -1;
+    }
 
     return 0;
 }
@@ -738,8 +769,9 @@ static int replace_all(   Client_data    *list,
                           IP_Port         ip_port,
                           const uint8_t  *comp_public_key )
 {
-    if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6))
+    if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6)) {
         return 0;
+    }
 
     if (store_node_ok(&list[1], public_key, comp_public_key) || store_node_ok(&list[0], public_key, comp_public_key)) {
         sort_client_list(list, length, comp_public_key);
@@ -787,8 +819,9 @@ static int add_to_close(DHT *dht, const uint8_t *public_key, IP_Port ip_port, _B
 
     unsigned int index = bit_by_bit_cmp(public_key, dht->self_public_key);
 
-    if (index > LCLIENT_LENGTH)
+    if (index > LCLIENT_LENGTH) {
         index = LCLIENT_LENGTH - 1;
+    }
 
     for (i = 0; i < LCLIENT_NODES; ++i) {
         Client_data *client = &dht->close_clientlist[(index * LCLIENT_NODES) + i];
@@ -929,10 +962,12 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
      * to replace the first ip by the second.
      */
     if (!client_or_ip_port_in_list(dht->log, dht->close_clientlist, LCLIENT_LIST, public_key, ip_port)) {
-        if (add_to_close(dht, public_key, ip_port, 0))
+        if (add_to_close(dht, public_key, ip_port, 0)) {
             used++;
-    } else
+        }
+    } else {
         used++;
+    }
 
     DHT_Friend *friend_foundip = 0;
 
@@ -965,9 +1000,10 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
         uint32_t j;
 
         for (j = 0; j < friend_foundip->lock_count; ++j) {
-            if (friend_foundip->callbacks[j].ip_callback)
+            if (friend_foundip->callbacks[j].ip_callback) {
                 friend_foundip->callbacks[j].ip_callback(friend_foundip->callbacks[j].data, friend_foundip->callbacks[j].number,
                         ip_port);
+            }
         }
     }
 
@@ -1060,8 +1096,9 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const
                     const Node_format *sendback_node)
 {
     /* Check if packet is going to be sent to ourself. */
-    if (id_equal(public_key, dht->self_public_key))
+    if (id_equal(public_key, dht->self_public_key)) {
         return -1;
+    }
 
     uint8_t plain_message[sizeof(Node_format) * 2] = {0};
 
@@ -1079,8 +1116,9 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const
         ping_id = ping_array_add(&dht->dht_ping_array, plain_message, sizeof(receiver));
     }
 
-    if (ping_id == 0)
+    if (ping_id == 0) {
         return -1;
+    }
 
     uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(ping_id)];
     uint8_t encrypt[sizeof(plain) + crypto_box_MACBYTES];
@@ -1101,8 +1139,9 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const
                                       sizeof(plain),
                                       encrypt );
 
-    if (len != sizeof(encrypt))
+    if (len != sizeof(encrypt)) {
         return -1;
+    }
 
     data[0] = NET_PACKET_GET_NODES;
     memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES);
@@ -1117,11 +1156,13 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
                           const uint8_t *sendback_data, uint16_t length, const uint8_t *shared_encryption_key)
 {
     /* Check if packet is going to be sent to ourself. */
-    if (id_equal(public_key, dht->self_public_key))
+    if (id_equal(public_key, dht->self_public_key)) {
         return -1;
+    }
 
-    if (length != sizeof(uint64_t))
+    if (length != sizeof(uint64_t)) {
         return -1;
+    }
 
     size_t Node_format_size = sizeof(Node_format);
     uint8_t data[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES
@@ -1140,8 +1181,9 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
     if (num_nodes) {
         nodes_length = pack_nodes(plain + 1, Node_format_size * MAX_SENT_NODES, nodes_list, num_nodes);
 
-        if (nodes_length <= 0)
+        if (nodes_length <= 0) {
             return -1;
+        }
     }
 
     plain[0] = num_nodes;
@@ -1152,8 +1194,9 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
                                       1 + nodes_length + length,
                                       encrypt );
 
-    if (len != 1 + nodes_length + length + crypto_box_MACBYTES)
+    if (len != 1 + nodes_length + length + crypto_box_MACBYTES) {
         return -1;
+    }
 
     data[0] = NET_PACKET_SEND_NODES_IPV6;
     memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES);
@@ -1166,14 +1209,16 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
 static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
     if (length != (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + sizeof(
-                       uint64_t) + crypto_box_MACBYTES))
+                       uint64_t) + crypto_box_MACBYTES)) {
         return 1;
+    }
 
     DHT *dht = object;
 
     /* Check if packet is from ourself. */
-    if (id_equal(packet + 1, dht->self_public_key))
+    if (id_equal(packet + 1, dht->self_public_key)) {
         return 1;
+    }
 
     uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(uint64_t)];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -1185,8 +1230,9 @@ static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet,
                                       crypto_box_PUBLICKEYBYTES + sizeof(uint64_t) + crypto_box_MACBYTES,
                                       plain );
 
-    if (len != crypto_box_PUBLICKEYBYTES + sizeof(uint64_t))
+    if (len != crypto_box_PUBLICKEYBYTES + sizeof(uint64_t)) {
         return 1;
+    }
 
     sendnodes_ipv6(dht, source, packet + 1, plain, plain + crypto_box_PUBLICKEYBYTES, sizeof(uint64_t), shared_key);
 
@@ -1212,8 +1258,9 @@ static uint8_t sent_getnode_to_node(DHT *dht, const uint8_t *public_key, IP_Port
     Node_format test;
     memcpy(&test, data, sizeof(Node_format));
 
-    if (!ipport_equal(&test.ip_port, &node_ip_port) || public_key_cmp(test.public_key, public_key) != 0)
+    if (!ipport_equal(&test.ip_port, &node_ip_port) || public_key_cmp(test.public_key, public_key) != 0) {
         return 0;
+    }
 
     return 1;
 }
@@ -1228,16 +1275,19 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa
     DHT *dht = object;
     uint32_t cid_size = 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + 1 + sizeof(uint64_t) + crypto_box_MACBYTES;
 
-    if (length < cid_size) /* too short */
+    if (length < cid_size) { /* too short */
         return 1;
+    }
 
     uint32_t data_size = length - cid_size;
 
-    if (data_size == 0)
+    if (data_size == 0) {
         return 1;
+    }
 
-    if (data_size > sizeof(Node_format) * MAX_SENT_NODES) /* invalid length */
+    if (data_size > sizeof(Node_format) * MAX_SENT_NODES) { /* invalid length */
         return 1;
+    }
 
     uint8_t plain[1 + data_size + sizeof(uint64_t)];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -1249,31 +1299,37 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa
                   1 + data_size + sizeof(uint64_t) + crypto_box_MACBYTES,
                   plain);
 
-    if ((unsigned int)len != sizeof(plain))
+    if ((unsigned int)len != sizeof(plain)) {
         return 1;
+    }
 
-    if (plain[0] > size_plain_nodes)
+    if (plain[0] > size_plain_nodes) {
         return 1;
+    }
 
     Node_format sendback_node;
 
     uint64_t ping_id;
     memcpy(&ping_id, plain + 1 + data_size, sizeof(ping_id));
 
-    if (!sent_getnode_to_node(dht, packet + 1, source, ping_id, &sendback_node))
+    if (!sent_getnode_to_node(dht, packet + 1, source, ping_id, &sendback_node)) {
         return 1;
+    }
 
     uint16_t length_nodes = 0;
     int num_nodes = unpack_nodes(plain_nodes, plain[0], &length_nodes, plain + 1, data_size, 0);
 
-    if (length_nodes != data_size)
+    if (length_nodes != data_size) {
         return 1;
+    }
 
-    if (num_nodes != plain[0])
+    if (num_nodes != plain[0]) {
         return 1;
+    }
 
-    if (num_nodes < 0)
+    if (num_nodes < 0) {
         return 1;
+    }
 
     /* store the address the *request* was sent to */
     addto_lists(dht, source, packet + 1);
@@ -1290,11 +1346,13 @@ static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *pa
     Node_format plain_nodes[MAX_SENT_NODES];
     uint32_t num_nodes;
 
-    if (handle_sendnodes_core(object, source, packet, length, plain_nodes, MAX_SENT_NODES, &num_nodes))
+    if (handle_sendnodes_core(object, source, packet, length, plain_nodes, MAX_SENT_NODES, &num_nodes)) {
         return 1;
+    }
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
     uint32_t i;
 
@@ -1322,8 +1380,9 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
     if (friend_num != -1) { /* Is friend already in DHT? */
         DHT_Friend *friend = &dht->friends_list[friend_num];
 
-        if (friend->lock_count == DHT_FRIEND_MAX_LOCKS)
+        if (friend->lock_count == DHT_FRIEND_MAX_LOCKS) {
             return -1;
+        }
 
         lock_num = friend->lock_count;
         ++friend->lock_count;
@@ -1331,8 +1390,9 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
         friend->callbacks[lock_num].data = data;
         friend->callbacks[lock_num].number = number;
 
-        if (lock_count)
+        if (lock_count) {
             *lock_count = lock_num + 1;
+        }
 
         return 0;
     }
@@ -1340,8 +1400,9 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
     DHT_Friend *temp;
     temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
 
-    if (temp == NULL)
+    if (temp == NULL) {
         return -1;
+    }
 
     dht->friends_list = temp;
     DHT_Friend *friend = &dht->friends_list[dht->num_friends];
@@ -1357,8 +1418,9 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
     friend->callbacks[lock_num].data = data;
     friend->callbacks[lock_num].number = number;
 
-    if (lock_count)
+    if (lock_count) {
         *lock_count = lock_num + 1;
+    }
 
     friend->num_to_bootstrap = get_close_nodes(dht, friend->public_key, friend->to_bootstrap, 0, 1, 0);
 
@@ -1402,8 +1464,9 @@ int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count)
 
     temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
 
-    if (temp == NULL)
+    if (temp == NULL) {
         return -1;
+    }
 
     dht->friends_list = temp;
     return 0;
@@ -1427,11 +1490,12 @@ int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port)
                     IPPTsPng *assoc = NULL;
                     uint32_t a;
 
-                    for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4)
+                    for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4) {
                         if (!is_timeout(assoc->timestamp, BAD_NODE_TIMEOUT)) {
                             *ip_port = assoc->ip_port;
                             return 1;
                         }
+                    }
                 }
             }
 
@@ -1462,7 +1526,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
         IPPTsPng *assoc;
         uint32_t a;
 
-        for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4)
+        for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4) {
             if (!is_timeout(assoc->timestamp, KILL_NODE_TIMEOUT)) {
                 sort = 0;
                 not_kill++;
@@ -1486,6 +1550,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
                     sort_ok = 1;
                 }
             }
+        }
     }
 
     if (sortable && sort_ok) {
@@ -1559,9 +1624,11 @@ static void do_Close(DHT *dht)
             Client_data *client = &dht->close_clientlist[i];
             IPPTsPng *assoc;
 
-            for (a = 0, assoc = &client->assoc4; a < 2; a++, assoc = &client->assoc6)
-                if (assoc->timestamp)
+            for (a = 0, assoc = &client->assoc4; a < 2; a++, assoc = &client->assoc6) {
+                if (assoc->timestamp) {
                     assoc->timestamp = badonly;
+                }
+            }
         }
     }
 }
@@ -1610,8 +1677,9 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
         }
 
         return 1;
-    } else
+    } else {
         return 0;
+    }
 }
 
 /* Send the given packet to node with public_key
@@ -1626,12 +1694,13 @@ int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packe
         if (id_equal(public_key, dht->close_clientlist[i].public_key)) {
             const Client_data *client = &dht->close_clientlist[i];
 
-            if (ip_isset(&client->assoc6.ip_port.ip))
+            if (ip_isset(&client->assoc6.ip_port.ip)) {
                 return sendpacket(dht->net, client->assoc6.ip_port, packet, length);
-            else if (ip_isset(&client->assoc4.ip_port.ip))
+            } else if (ip_isset(&client->assoc4.ip_port.ip)) {
                 return sendpacket(dht->net, client->assoc4.ip_port, packet, length);
-            else
+            } else {
                 break;
+            }
         }
     }
 
@@ -1647,8 +1716,9 @@ int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packe
  */
 static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_num)
 {
-    if (friend_num >= dht->num_friends)
+    if (friend_num >= dht->num_friends) {
         return -1;
+    }
 
     DHT_Friend *friend = &dht->friends_list[friend_num];
     Client_data *client;
@@ -1672,9 +1742,12 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
             ++num_ipv6s;
         }
 
-        if (id_equal(client->public_key, friend->public_key))
-            if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) || !is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT))
+        if (id_equal(client->public_key, friend->public_key)) {
+            if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)
+                    || !is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT)) {
                 return 0; /* direct connectivity */
+            }
+        }
     }
 
 #ifdef FRIEND_IPLIST_PAD
@@ -1717,8 +1790,9 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
 {
     int num = friend_number(dht, friend_id);
 
-    if (num == -1)
+    if (num == -1) {
         return 0;
+    }
 
     uint32_t i, sent = 0;
     uint8_t friend_sent[MAX_FRIEND_CLIENTS] = {0};
@@ -1726,8 +1800,9 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
     IP_Port ip_list[MAX_FRIEND_CLIENTS];
     int ip_num = friend_iplist(dht, ip_list, num);
 
-    if (ip_num < (MAX_FRIEND_CLIENTS / 4))
+    if (ip_num < (MAX_FRIEND_CLIENTS / 4)) {
         return 0; /* Reason for that? */
+    }
 
     DHT_Friend *friend = &dht->friends_list[num];
     Client_data *client;
@@ -1736,18 +1811,20 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
      * is *usually* good(tm) (bites us in the behind in this case though) */
     uint32_t a;
 
-    for (a = 0; a < 2; a++)
+    for (a = 0; a < 2; a++) {
         for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-            if (friend_sent[i])/* Send one packet per client.*/
+            if (friend_sent[i]) {/* Send one packet per client.*/
                 continue;
+            }
 
             client = &friend->client_list[i];
             IPPTsPng *assoc = NULL;
 
-            if (!a)
+            if (!a) {
                 assoc = &client->assoc4;
-            else
+            } else {
                 assoc = &client->assoc6;
+            }
 
             /* If ip is not zero and node is good. */
             if (ip_isset(&assoc->ret_ip_port.ip) &&
@@ -1760,6 +1837,7 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
                 }
             }
         }
+    }
 
     return sent;
 }
@@ -1772,8 +1850,9 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
 {
     int num = friend_number(dht, friend_id);
 
-    if (num == -1)
+    if (num == -1) {
         return 0;
+    }
 
     DHT_Friend *friend = &dht->friends_list[num];
     Client_data *client;
@@ -1786,15 +1865,16 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
      * is *usually* good(tm) (bites us in the behind in this case though) */
     uint32_t a;
 
-    for (a = 0; a < 2; a++)
+    for (a = 0; a < 2; a++) {
         for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
             client = &friend->client_list[i];
             IPPTsPng *assoc = NULL;
 
-            if (!a)
+            if (!a) {
                 assoc = &client->assoc4;
-            else
+            } else {
                 assoc = &client->assoc6;
+            }
 
             /* If ip is not zero and node is good. */
             if (ip_isset(&assoc->ret_ip_port.ip) && !is_timeout(assoc->ret_timestamp, BAD_NODE_TIMEOUT)) {
@@ -1802,14 +1882,17 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
                 ++n;
             }
         }
+    }
 
-    if (n < 1)
+    if (n < 1) {
         return 0;
+    }
 
     int retval = sendpacket(dht->net, ip_list[rand() % n], packet, length);
 
-    if ((unsigned int)retval == length)
+    if ((unsigned int)retval == length) {
         return 1;
+    }
 
     return 0;
 }
@@ -1830,16 +1913,19 @@ static int send_NATping(DHT *dht, const uint8_t *public_key, uint64_t ping_id, u
     int len = create_request(dht->self_public_key, dht->self_secret_key, packet, public_key, data,
                              sizeof(uint64_t) + 1, CRYPTO_PACKET_NAT_PING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
-    if (type == 0) /* If packet is request use many people to route it. */
+    if (type == 0) { /* If packet is request use many people to route it. */
         num = route_tofriend(dht, public_key, packet, len);
-    else if (type == 1) /* If packet is response use only one person to route it */
+    } else if (type == 1) { /* If packet is response use only one person to route it */
         num = routeone_tofriend(dht, public_key, packet, len);
+    }
 
-    if (num == 0)
+    if (num == 0) {
         return -1;
+    }
 
     return num;
 }
@@ -1848,8 +1934,9 @@ static int send_NATping(DHT *dht, const uint8_t *public_key, uint64_t ping_id, u
 static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
                           uint16_t length)
 {
-    if (length != sizeof(uint64_t) + 1)
+    if (length != sizeof(uint64_t) + 1) {
         return 1;
+    }
 
     DHT *dht = object;
     uint64_t ping_id;
@@ -1857,8 +1944,9 @@ static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pu
 
     int friendnumber = friend_number(dht, source_pubkey);
 
-    if (friendnumber == -1)
+    if (friendnumber == -1) {
         return 1;
+    }
 
     DHT_Friend *friend = &dht->friends_list[friendnumber];
 
@@ -1889,20 +1977,23 @@ static IP NAT_commonip(IP_Port *ip_portlist, uint16_t len, uint16_t min_num)
     IP zero;
     ip_reset(&zero);
 
-    if (len > MAX_FRIEND_CLIENTS)
+    if (len > MAX_FRIEND_CLIENTS) {
         return zero;
+    }
 
     uint32_t i, j;
     uint16_t numbers[MAX_FRIEND_CLIENTS] = {0};
 
     for (i = 0; i < len; ++i) {
         for (j = 0; j < len; ++j) {
-            if (ip_equal(&ip_portlist[i].ip, &ip_portlist[j].ip))
+            if (ip_equal(&ip_portlist[i].ip, &ip_portlist[j].ip)) {
                 ++numbers[i];
+            }
         }
 
-        if (numbers[i] >= min_num)
+        if (numbers[i] >= min_num) {
             return ip_portlist[i].ip;
+        }
     }
 
     return zero;
@@ -1931,16 +2022,18 @@ static uint16_t NAT_getports(uint16_t *portlist, IP_Port *ip_portlist, uint16_t
 
 static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports, uint16_t friend_num)
 {
-    if (numports > MAX_FRIEND_CLIENTS || numports == 0)
+    if (numports > MAX_FRIEND_CLIENTS || numports == 0) {
         return;
+    }
 
     uint32_t i;
     uint32_t top = dht->friends_list[friend_num].nat.punching_index + MAX_PUNCHING_PORTS;
     uint16_t firstport = port_list[0];
 
     for (i = 0; i < numports; ++i) {
-        if (firstport != port_list[i])
+        if (firstport != port_list[i]) {
             break;
+        }
     }
 
     if (i == numports) { /* If all ports are the same, only try that one port. */
@@ -1988,8 +2081,9 @@ static void do_NAT(DHT *dht)
         int num = friend_iplist(dht, ip_list, i);
 
         /* If already connected or friend is not online don't try to hole punch. */
-        if (num < MAX_FRIEND_CLIENTS / 2)
+        if (num < MAX_FRIEND_CLIENTS / 2) {
             continue;
+        }
 
         if (dht->friends_list[i].nat.NATping_timestamp + PUNCH_INTERVAL < temp_time) {
             send_NATping(dht, dht->friends_list[i].public_key, dht->friends_list[i].nat.NATping_id, NAT_PING_REQUEST);
@@ -2002,8 +2096,9 @@ static void do_NAT(DHT *dht)
 
             IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS / 2);
 
-            if (!ip_isset(&ip))
+            if (!ip_isset(&ip)) {
                 continue;
+            }
 
             uint16_t port_list[MAX_FRIEND_CLIENTS];
             uint16_t numports = NAT_getports(port_list, ip_list, num, ip);
@@ -2029,8 +2124,9 @@ static void do_NAT(DHT *dht)
 
 static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8_t *contents, uint16_t length)
 {
-    if (length > HARDREQ_DATA_SIZE - 1)
+    if (length > HARDREQ_DATA_SIZE - 1) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
     uint8_t data[HARDREQ_DATA_SIZE] = {0};
@@ -2039,8 +2135,9 @@ static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8
     int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->public_key, data,
                              sizeof(data), CRYPTO_PACKET_HARDENING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return sendpacket(dht->net, sendto->ip_port, packet, len);
 }
@@ -2058,8 +2155,9 @@ static int send_hardening_getnode_req(DHT *dht, Node_format *dest, Node_format *
 static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto, const uint8_t *queried_client_id,
                                       const uint8_t *nodes_data, uint16_t nodes_data_length)
 {
-    if (!ip_isset(&sendto->ip_port.ip))
+    if (!ip_isset(&sendto->ip_port.ip)) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
     uint8_t data[1 + crypto_box_PUBLICKEYBYTES + nodes_data_length];
@@ -2069,8 +2167,9 @@ static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto,
     int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->public_key, data,
                              sizeof(data), CRYPTO_PACKET_HARDENING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return sendpacket(dht->net, sendto->ip_port, packet, len);
 }
@@ -2081,13 +2180,15 @@ static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *public_key, sa_
     uint32_t i;
 
     for (i = 0; i < LCLIENT_LIST; ++i) {
-        if (public_key_cmp(dht->close_clientlist[i].public_key, public_key) != 0)
+        if (public_key_cmp(dht->close_clientlist[i].public_key, public_key) != 0) {
             continue;
+        }
 
-        if (sa_family == AF_INET)
+        if (sa_family == AF_INET) {
             return &dht->close_clientlist[i].assoc4;
-        else if (sa_family == AF_INET6)
+        } else if (sa_family == AF_INET6) {
             return &dht->close_clientlist[i].assoc6;
+        }
     }
 
     return NULL;
@@ -2136,26 +2237,30 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
 
     switch (packet[0]) {
         case CHECK_TYPE_GETNODE_REQ: {
-            if (length != HARDREQ_DATA_SIZE)
+            if (length != HARDREQ_DATA_SIZE) {
                 return 1;
+            }
 
             Node_format node, tocheck_node;
             node.ip_port = source;
             memcpy(node.public_key, source_pubkey, crypto_box_PUBLICKEYBYTES);
             memcpy(&tocheck_node, packet + 1, sizeof(Node_format));
 
-            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.public_key, packet + 1 + sizeof(Node_format), &node) == -1)
+            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.public_key, packet + 1 + sizeof(Node_format), &node) == -1) {
                 return 1;
+            }
 
             return 0;
         }
 
         case CHECK_TYPE_GETNODE_RES: {
-            if (length <= crypto_box_PUBLICKEYBYTES + 1)
+            if (length <= crypto_box_PUBLICKEYBYTES + 1) {
                 return 1;
+            }
 
-            if (length > 1 + crypto_box_PUBLICKEYBYTES + sizeof(Node_format) * MAX_SENT_NODES)
+            if (length > 1 + crypto_box_PUBLICKEYBYTES + sizeof(Node_format) * MAX_SENT_NODES) {
                 return 1;
+            }
 
             uint16_t length_nodes = length - 1 - crypto_box_PUBLICKEYBYTES;
             Node_format nodes[MAX_SENT_NODES];
@@ -2163,23 +2268,28 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
 
             /* TODO: MAX_SENT_NODES nodes should be returned at all times
              (right now we have a small network size so it could cause problems for testing and etc..) */
-            if (num_nodes <= 0)
+            if (num_nodes <= 0) {
                 return 1;
+            }
 
             /* NOTE: This should work for now but should be changed to something better. */
-            if (have_nodes_closelist(dht, nodes, num_nodes) < (uint32_t)((num_nodes + 2) / 2))
+            if (have_nodes_closelist(dht, nodes, num_nodes) < (uint32_t)((num_nodes + 2) / 2)) {
                 return 1;
+            }
 
             IPPTsPng *temp = get_closelist_IPPTsPng(dht, packet + 1, nodes[0].ip_port.ip.family);
 
-            if (temp == NULL)
+            if (temp == NULL) {
                 return 1;
+            }
 
-            if (is_timeout(temp->hardening.send_nodes_timestamp, HARDENING_INTERVAL))
+            if (is_timeout(temp->hardening.send_nodes_timestamp, HARDENING_INTERVAL)) {
                 return 1;
+            }
 
-            if (public_key_cmp(temp->hardening.send_nodes_pingedid, source_pubkey) != 0)
+            if (public_key_cmp(temp->hardening.send_nodes_pingedid, source_pubkey) != 0) {
                 return 1;
+            }
 
             /* If Nodes look good and the request checks out */
             temp->hardening.send_nodes_ok = 1;
@@ -2207,10 +2317,11 @@ Node_format random_node(DHT *dht, sa_family_t sa_family)
     memset(nodes_list, 0, sizeof(nodes_list));
     uint32_t num_nodes = get_close_nodes(dht, id, nodes_list, sa_family, 1, 0);
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return nodes_list[0];
-    else
+    } else {
         return nodes_list[rand() % num_nodes];
+    }
 }
 
 /* Put up to max_num nodes in nodes from the closelist.
@@ -2219,8 +2330,9 @@ Node_format random_node(DHT *dht, sa_family_t sa_family)
  */
 uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes, uint16_t max_num)
 {
-    if (max_num == 0)
+    if (max_num == 0) {
         return 0;
+    }
 
     uint16_t count = 0;
 
@@ -2229,14 +2341,16 @@ uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes,
     for (i = length; i != 0; --i) {
         IPPTsPng *assoc = NULL;
 
-        if (!is_timeout(list[i - 1].assoc4.timestamp, BAD_NODE_TIMEOUT))
+        if (!is_timeout(list[i - 1].assoc4.timestamp, BAD_NODE_TIMEOUT)) {
             assoc = &list[i - 1].assoc4;
+        }
 
         if (!is_timeout(list[i - 1].assoc6.timestamp, BAD_NODE_TIMEOUT)) {
-            if (assoc == NULL)
+            if (assoc == NULL) {
                 assoc = &list[i - 1].assoc6;
-            else if (rand() % 2)
+            } else if (rand() % 2) {
                 assoc = &list[i - 1].assoc6;
+            }
         }
 
         if (assoc != NULL) {
@@ -2244,8 +2358,9 @@ uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes,
             nodes[count].ip_port = assoc->ip_port;
             ++count;
 
-            if (count >= max_num)
+            if (count >= max_num) {
                 return count;
+            }
         }
     }
 
@@ -2258,8 +2373,9 @@ uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes,
  */
 uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
 {
-    if (max_num == 0)
+    if (max_num == 0) {
         return 0;
+    }
 
     uint16_t count = 0;
     unsigned int i, r = rand();
@@ -2268,8 +2384,9 @@ uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
         count += list_nodes(dht->friends_list[(i + r) % DHT_FAKE_FRIEND_NUMBER].client_list, MAX_FRIEND_CLIENTS, nodes + count,
                             max_num - count);
 
-        if (count >= max_num)
+        if (count >= max_num) {
             break;
+        }
     }
 
     return count;
@@ -2301,18 +2418,21 @@ void do_hardening(DHT *dht)
             sa_family = AF_INET6;
         }
 
-        if (is_timeout(cur_iptspng->timestamp, BAD_NODE_TIMEOUT))
+        if (is_timeout(cur_iptspng->timestamp, BAD_NODE_TIMEOUT)) {
             continue;
+        }
 
         if (cur_iptspng->hardening.send_nodes_ok == 0) {
             if (is_timeout(cur_iptspng->hardening.send_nodes_timestamp, HARDENING_INTERVAL)) {
                 Node_format rand_node = random_node(dht, sa_family);
 
-                if (!ipport_isset(&rand_node.ip_port))
+                if (!ipport_isset(&rand_node.ip_port)) {
                     continue;
+                }
 
-                if (id_equal(public_key, rand_node.public_key))
+                if (id_equal(public_key, rand_node.public_key)) {
                     continue;
+                }
 
                 Node_format to_test;
                 to_test.ip_port = cur_iptspng->ip_port;
@@ -2348,8 +2468,9 @@ static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *pack
 
     if (packet[0] == NET_PACKET_CRYPTO) {
         if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
-                length > MAX_CRYPTO_REQUEST_SIZE + crypto_box_MACBYTES)
+                length > MAX_CRYPTO_REQUEST_SIZE + crypto_box_MACBYTES) {
             return 1;
+        }
 
         if (public_key_cmp(packet + 1, dht->self_public_key) == 0) { // Check if request is for us.
             uint8_t public_key[crypto_box_PUBLICKEYBYTES];
@@ -2357,10 +2478,13 @@ static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *pack
             uint8_t number;
             int len = handle_request(dht->self_public_key, dht->self_secret_key, public_key, data, &number, packet, length);
 
-            if (len == -1 || len == 0)
+            if (len == -1 || len == 0) {
                 return 1;
+            }
 
-            if (!dht->cryptopackethandlers[number].function) return 1;
+            if (!dht->cryptopackethandlers[number].function) {
+                return 1;
+            }
 
             return dht->cryptopackethandlers[number].function(dht->cryptopackethandlers[number].object, source, public_key,
                     data, len);
@@ -2368,8 +2492,9 @@ static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *pack
         } else { /* If request is not for us, try routing it. */
             int retval = route_packet(dht, packet + 1, packet, length);
 
-            if ((unsigned int)retval == length)
+            if ((unsigned int)retval == length) {
                 return 0;
+            }
         }
     }
 
@@ -2383,13 +2508,15 @@ DHT *new_DHT(Logger *log, Networking_Core *net)
     /* init time */
     unix_time_update();
 
-    if (net == NULL)
+    if (net == NULL) {
         return NULL;
+    }
 
     DHT *dht = calloc(1, sizeof(DHT));
 
-    if (dht == NULL)
+    if (dht == NULL) {
         return NULL;
+    }
 
     dht->log = log;
     dht->net = net;
@@ -2571,11 +2698,13 @@ void DHT_save(DHT *dht, uint8_t *data)
 /* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set */
 int DHT_connect_after_load(DHT *dht)
 {
-    if (dht == NULL)
+    if (dht == NULL) {
         return -1;
+    }
 
-    if (!dht->loaded_nodes_list)
+    if (!dht->loaded_nodes_list) {
         return -1;
+    }
 
     /* DHT is connected, stop. */
     if (DHT_non_lan_connected(dht)) {
@@ -2602,8 +2731,9 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
 
     switch (type) {
         case DHT_STATE_TYPE_NODES:
-            if (length == 0)
+            if (length == 0) {
                 break;
+            }
 
             {
                 free(dht->loaded_nodes_list);
@@ -2647,9 +2777,10 @@ int DHT_load(DHT *dht, const uint8_t *data, uint32_t length)
         uint32_t data32;
         lendian_to_host32(&data32, data);
 
-        if (data32 == DHT_STATE_COOKIE_GLOBAL)
+        if (data32 == DHT_STATE_COOKIE_GLOBAL) {
             return load_state(dht_load_state_callback, dht, data + cookie_len,
                               length - cookie_len, DHT_STATE_COOKIE_TYPE);
+        }
     }
 
     return -1;
@@ -2667,8 +2798,9 @@ int DHT_isconnected(const DHT *dht)
         const Client_data *client = &dht->close_clientlist[i];
 
         if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) ||
-                !is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT))
+                !is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)) {
             return 1;
+        }
     }
 
     return 0;
@@ -2685,11 +2817,13 @@ int DHT_non_lan_connected(const DHT *dht)
     for (i = 0; i < LCLIENT_LIST; ++i) {
         const Client_data *client = &dht->close_clientlist[i];
 
-        if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc4.ip_port.ip) == -1)
+        if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc4.ip_port.ip) == -1) {
             return 1;
+        }
 
-        if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc6.ip_port.ip) == -1)
+        if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc6.ip_port.ip) == -1) {
             return 1;
+        }
 
     }