Add braces to all if statements.

1 files changed, 234 insertions, 117 deletions

diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index 717737ad..c6528c97 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -40,14 +40,16 @@
  */
 int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *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 -1;
+    }
 
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (public_key_cmp(public_key, onion_c->path_nodes_bs[i].public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->path_nodes_bs[i].public_key) == 0) {
             return -1;
+        }
     }
 
     onion_c->path_nodes_bs[onion_c->path_nodes_index_bs % MAX_PATH_NODES].ip_port = ip_port;
@@ -57,8 +59,9 @@ int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t
     uint16_t last = onion_c->path_nodes_index_bs;
     ++onion_c->path_nodes_index_bs;
 
-    if (onion_c->path_nodes_index_bs < last)
+    if (onion_c->path_nodes_index_bs < last) {
         onion_c->path_nodes_index_bs = MAX_PATH_NODES + 1;
+    }
 
     return 0;
 }
@@ -70,14 +73,16 @@ int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t
  */
 static int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *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 -1;
+    }
 
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (public_key_cmp(public_key, onion_c->path_nodes[i].public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->path_nodes[i].public_key) == 0) {
             return -1;
+        }
     }
 
     onion_c->path_nodes[onion_c->path_nodes_index % MAX_PATH_NODES].ip_port = ip_port;
@@ -87,8 +92,9 @@ static int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uin
     uint16_t last = onion_c->path_nodes_index;
     ++onion_c->path_nodes_index;
 
-    if (onion_c->path_nodes_index < last)
+    if (onion_c->path_nodes_index < last) {
         onion_c->path_nodes_index = MAX_PATH_NODES + 1;
+    }
 
     return 0;
 }
@@ -101,16 +107,19 @@ uint16_t onion_backup_nodes(const Onion_Client *onion_c, Node_format *nodes, uin
 {
     unsigned int i;
 
-    if (!max_num)
+    if (!max_num) {
         return 0;
+    }
 
     unsigned int num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
-    if (num_nodes < max_num)
+    if (num_nodes < max_num) {
         max_num = num_nodes;
+    }
 
     for (i = 0; i < max_num; ++i) {
         nodes[i] = onion_c->path_nodes[(onion_c->path_nodes_index - (1 + i)) % num_nodes];
@@ -127,15 +136,17 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
 {
     unsigned int i;
 
-    if (!max_num)
+    if (!max_num) {
         return 0;
+    }
 
     unsigned int num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
 
     //if (DHT_non_lan_connected(onion_c->dht)) {
     if (DHT_isconnected(onion_c->dht)) {
-        if (num_nodes == 0)
+        if (num_nodes == 0) {
             return 0;
+        }
 
         for (i = 0; i < max_num; ++i) {
             nodes[i] = onion_c->path_nodes[rand() % num_nodes];
@@ -158,8 +169,9 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
             unsigned int num_nodes_bs = (onion_c->path_nodes_index_bs < MAX_PATH_NODES) ? onion_c->path_nodes_index_bs :
                                         MAX_PATH_NODES;
 
-            if (num_nodes_bs == 0)
+            if (num_nodes_bs == 0) {
                 return 0;
+            }
 
             nodes[0].ip_port.ip.family = TCP_FAMILY;
             nodes[0].ip_port.ip.ip4.uint32 = random_tcp;
@@ -229,14 +241,16 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
     if (path_timed_out(onion_paths, pathnum)) {
         Node_format nodes[ONION_PATH_LENGTH];
 
-        if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH)
+        if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH) {
             return -1;
+        }
 
         int n = is_path_used(onion_paths, nodes);
 
         if (n == -1) {
-            if (create_onion_path(onion_c->dht, &onion_paths->paths[pathnum], nodes) == -1)
+            if (create_onion_path(onion_c->dht, &onion_paths->paths[pathnum], nodes) == -1) {
                 return -1;
+            }
 
             onion_paths->last_path_success[pathnum] = unix_time() + ONION_PATH_FIRST_TIMEOUT - ONION_PATH_TIMEOUT;
             onion_paths->path_creation_time[pathnum] = unix_time();
@@ -262,8 +276,9 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
 /* Does path with path_num exist. */
 static _Bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
 {
-    if (path_timed_out(onion_paths, path_num))
+    if (path_timed_out(onion_paths, path_num)) {
         return 0;
+    }
 
     return onion_paths->paths[path_num % NUMBER_ONION_PATHS].path_num == path_num;
 }
@@ -273,8 +288,9 @@ static _Bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
  */
 static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t path_num)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
     Onion_Client_Paths *onion_paths;
 
@@ -316,19 +332,22 @@ static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Pa
         uint8_t packet[ONION_MAX_PACKET_SIZE];
         int len = create_onion_packet(packet, sizeof(packet), path, dest, data, length);
 
-        if (len == -1)
+        if (len == -1) {
             return -1;
+        }
 
-        if (sendpacket(onion_c->net, path->ip_port1, packet, len) != len)
+        if (sendpacket(onion_c->net, path->ip_port1, packet, len) != len) {
             return -1;
+        }
 
         return 0;
     } else if (path->ip_port1.ip.family == TCP_FAMILY) {
         uint8_t packet[ONION_MAX_PACKET_SIZE];
         int len = create_onion_packet_tcp(packet, sizeof(packet), path, dest, data, length);
 
-        if (len == -1)
+        if (len == -1) {
             return -1;
+        }
 
         return send_tcp_onion_request(onion_c->c, path->ip_port1.ip.ip4.uint32, packet, len);
     } else {
@@ -361,8 +380,9 @@ static int new_sendback(Onion_Client *onion_c, uint32_t num, const uint8_t *publ
     memcpy(data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port), &path_num, sizeof(uint32_t));
     *sendback = ping_array_add(&onion_c->announce_ping_array, data, sizeof(data));
 
-    if (*sendback == 0)
+    if (*sendback == 0) {
         return -1;
+    }
 
     return 0;
 }
@@ -384,8 +404,9 @@ static uint32_t check_sendback(Onion_Client *onion_c, const uint8_t *sendback, u
     memcpy(&sback, sendback, sizeof(uint64_t));
     uint8_t data[sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port) + sizeof(uint32_t)];
 
-    if (ping_array_check(data, sizeof(data), &onion_c->announce_ping_array, sback) != sizeof(data))
+    if (ping_array_check(data, sizeof(data), &onion_c->announce_ping_array, sback) != sizeof(data)) {
         return ~0;
+    }
 
     memcpy(ret_pubkey, data + sizeof(uint32_t), crypto_box_PUBLICKEYBYTES);
     memcpy(ret_ip_port, data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES, sizeof(IP_Port));
@@ -399,27 +420,32 @@ static uint32_t check_sendback(Onion_Client *onion_c, const uint8_t *sendback, u
 static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_Port dest, const uint8_t *dest_pubkey,
                                         const uint8_t *ping_id, uint32_t pathnum)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
     uint64_t sendback;
     Onion_Path path;
 
     if (num == 0) {
-        if (random_path(onion_c, &onion_c->onion_paths_self, pathnum, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_self, pathnum, &path) == -1) {
             return -1;
+        }
     } else {
-        if (random_path(onion_c, &onion_c->onion_paths_friends, pathnum, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_friends, pathnum, &path) == -1) {
             return -1;
+        }
     }
 
-    if (new_sendback(onion_c, num, dest_pubkey, dest, path.path_num, &sendback) == -1)
+    if (new_sendback(onion_c, num, dest_pubkey, dest, path.path_num, &sendback) == -1) {
         return -1;
+    }
 
     uint8_t zero_ping_id[ONION_PING_ID_SIZE] = {0};
 
-    if (ping_id == NULL)
+    if (ping_id == NULL) {
         ping_id = zero_ping_id;
+    }
 
     uint8_t request[ONION_ANNOUNCE_REQUEST_SIZE];
     int len;
@@ -450,22 +476,27 @@ static int cmp_entry(const void *a, const void *b)
     int t1 = is_timeout(entry1.timestamp, ONION_NODE_TIMEOUT);
     int t2 = is_timeout(entry2.timestamp, ONION_NODE_TIMEOUT);
 
-    if (t1 && t2)
+    if (t1 && t2) {
         return 0;
+    }
 
-    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;
 }
@@ -473,8 +504,9 @@ static int cmp_entry(const void *a, const void *b)
 static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t *public_key, IP_Port ip_port,
                               uint8_t is_stored, const uint8_t *pingid_or_key, uint32_t path_num)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
     Onion_Node *list_nodes = NULL;
     uint8_t *reference_id = NULL;
@@ -490,8 +522,9 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
         }
 
     } else {
-        if (is_stored >= 2)
+        if (is_stored >= 2) {
             return -1;
+        }
 
         list_nodes = onion_c->friends_list[num - 1].clients_list;
         reference_id = onion_c->friends_list[num - 1].real_public_key;
@@ -517,8 +550,9 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
         }
     }
 
-    if (index == -1)
+    if (index == -1) {
         return 0;
+    }
 
     memcpy(list_nodes[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
     list_nodes[index].ip_port = ip_port;
@@ -535,8 +569,9 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
     list_nodes[index].is_stored = is_stored;
     list_nodes[index].timestamp = unix_time();
 
-    if (!stored)
+    if (!stored) {
         list_nodes[index].last_pinged = 0;
+    }
 
     list_nodes[index].path_used = set_path_timeouts(onion_c, num, path_num);
     return 0;
@@ -547,9 +582,11 @@ static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, co
     unsigned int i;
 
     for (i = 0; i < MAX_STORED_PINGED_NODES; ++i) {
-        if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME))
-            if (public_key_cmp(last_pinged[i].public_key, public_key) == 0)
+        if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME)) {
+            if (public_key_cmp(last_pinged[i].public_key, public_key) == 0) {
                 return 0;
+            }
+        }
     }
 
     memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].public_key, public_key, crypto_box_PUBLICKEYBYTES);
@@ -561,11 +598,13 @@ static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, co
 static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_format *nodes, uint16_t num_nodes,
                              IP_Port source)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
     Onion_Node *list_nodes = NULL;
     uint8_t *reference_id = NULL;
@@ -593,9 +632,11 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
 
     for (i = 0; i < num_nodes; ++i) {
 
-        if (!lan_ips_accepted)
-            if (LAN_ip(nodes[i].ip_port.ip) == 0)
+        if (!lan_ips_accepted) {
+            if (LAN_ip(nodes[i].ip_port.ip) == 0) {
                 continue;
+            }
+        }
 
         if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)
                 || id_closest(reference_id, list_nodes[0].public_key, nodes[i].public_key) == 2
@@ -622,8 +663,9 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
 {
     Onion_Client *onion_c = object;
 
-    if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE)
+    if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE) {
         return 1;
+    }
 
     uint16_t len_nodes = length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE;
 
@@ -632,8 +674,9 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
     uint32_t path_num;
     uint32_t num = check_sendback(onion_c, packet + 1, public_key, &ip_port, &path_num);
 
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return 1;
+    }
 
     uint8_t plain[1 + ONION_PING_ID_SIZE + len_nodes];
     int len = -1;
@@ -643,8 +686,9 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
                            packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,
                            length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);
     } else {
-        if (onion_c->friends_list[num - 1].status == 0)
+        if (onion_c->friends_list[num - 1].status == 0) {
             return 1;
+        }
 
         len = decrypt_data(public_key, onion_c->friends_list[num - 1].temp_secret_key,
                            packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
@@ -652,21 +696,25 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
                            length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);
     }
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != sizeof(plain)) {
         return 1;
+    }
 
-    if (client_add_to_list(onion_c, num, public_key, ip_port, plain[0], plain + 1, path_num) == -1)
+    if (client_add_to_list(onion_c, num, public_key, ip_port, plain[0], plain + 1, path_num) == -1) {
         return 1;
+    }
 
     if (len_nodes != 0) {
         Node_format nodes[MAX_SENT_NODES];
         int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, plain + 1 + ONION_PING_ID_SIZE, len_nodes, 0);
 
-        if (num_nodes <= 0)
+        if (num_nodes <= 0) {
             return 1;
+        }
 
-        if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1)
+        if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1) {
             return 1;
+        }
     }
 
     //TODO: LAN vs non LAN ips?, if we are connected only to LAN, are we offline?
@@ -680,29 +728,34 @@ static int handle_data_response(void *object, IP_Port source, const uint8_t *pac
 {
     Onion_Client *onion_c = object;
 
-    if (length <= (ONION_DATA_RESPONSE_MIN_SIZE + DATA_IN_RESPONSE_MIN_SIZE))
+    if (length <= (ONION_DATA_RESPONSE_MIN_SIZE + DATA_IN_RESPONSE_MIN_SIZE)) {
         return 1;
+    }
 
-    if (length > MAX_DATA_REQUEST_SIZE)
+    if (length > MAX_DATA_REQUEST_SIZE) {
         return 1;
+    }
 
     uint8_t temp_plain[length - ONION_DATA_RESPONSE_MIN_SIZE];
     int len = decrypt_data(packet + 1 + crypto_box_NONCEBYTES, onion_c->temp_secret_key, packet + 1,
                            packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
                            length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES), temp_plain);
 
-    if ((uint32_t)len != sizeof(temp_plain))
+    if ((uint32_t)len != sizeof(temp_plain)) {
         return 1;
+    }
 
     uint8_t plain[sizeof(temp_plain) - DATA_IN_RESPONSE_MIN_SIZE];
     len = decrypt_data(temp_plain, onion_c->c->self_secret_key, packet + 1, temp_plain + crypto_box_PUBLICKEYBYTES,
                        sizeof(temp_plain) - crypto_box_PUBLICKEYBYTES, plain);
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != sizeof(plain)) {
         return 1;
+    }
 
-    if (!onion_c->Onion_Data_Handlers[plain[0]].function)
+    if (!onion_c->Onion_Data_Handlers[plain[0]].function) {
         return 1;
+    }
 
     return onion_c->Onion_Data_Handlers[plain[0]].function(onion_c->Onion_Data_Handlers[plain[0]].object, temp_plain, plain,
             sizeof(plain));
@@ -714,29 +767,34 @@ static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, con
 {
     Onion_Client *onion_c = object;
 
-    if (length < DHTPK_DATA_MIN_LENGTH)
+    if (length < DHTPK_DATA_MIN_LENGTH) {
         return 1;
+    }
 
-    if (length > DHTPK_DATA_MAX_LENGTH)
+    if (length > DHTPK_DATA_MAX_LENGTH) {
         return 1;
+    }
 
     int friend_num = onion_friend_num(onion_c, source_pubkey);
 
-    if (friend_num == -1)
+    if (friend_num == -1) {
         return 1;
+    }
 
     uint64_t no_replay;
     memcpy(&no_replay, data + 1, sizeof(uint64_t));
     net_to_host((uint8_t *) &no_replay, sizeof(no_replay));
 
-    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay)
+    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay) {
         return 1;
+    }
 
     onion_c->friends_list[friend_num].last_noreplay = no_replay;
 
-    if (onion_c->friends_list[friend_num].dht_pk_callback)
+    if (onion_c->friends_list[friend_num].dht_pk_callback) {
         onion_c->friends_list[friend_num].dht_pk_callback(onion_c->friends_list[friend_num].dht_pk_callback_object,
                 onion_c->friends_list[friend_num].dht_pk_callback_number, data + 1 + sizeof(uint64_t));
+    }
 
     onion_set_friend_DHT_pubkey(onion_c, friend_num, data + 1 + sizeof(uint64_t));
     onion_c->friends_list[friend_num].last_seen = unix_time();
@@ -748,8 +806,9 @@ static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, con
         int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, data + 1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES,
                                      len_nodes, 1);
 
-        if (num_nodes <= 0)
+        if (num_nodes <= 0) {
             return 1;
+        }
 
         int i;
 
@@ -773,8 +832,9 @@ static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, con
 
 static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return 1;
+    }
 
     IP_Port ip_port = {{0}};
     ip_port.ip.family = TCP_FAMILY;
@@ -798,21 +858,25 @@ static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length,
  */
 int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (length + DATA_IN_RESPONSE_MIN_SIZE > MAX_DATA_REQUEST_SIZE)
+    if (length + DATA_IN_RESPONSE_MIN_SIZE > MAX_DATA_REQUEST_SIZE) {
         return -1;
+    }
 
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     unsigned int i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0;
     Onion_Node *list_nodes = onion_c->friends_list[friend_num].clients_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT))
+        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT)) {
             continue;
+        }
 
         ++num_nodes;
 
@@ -822,8 +886,9 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data,
         }
     }
 
-    if (num_good < (num_nodes / 4) + 1)
+    if (num_good < (num_nodes / 4) + 1) {
         return -1;
+    }
 
     uint8_t nonce[crypto_box_NONCEBYTES];
     random_nonce(nonce);
@@ -833,26 +898,30 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data,
     int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key, onion_c->c->self_secret_key, nonce, data,
                            length, packet + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES != sizeof(packet))
+    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES != sizeof(packet)) {
         return -1;
+    }
 
     unsigned int good = 0;
 
     for (i = 0; i < num_good; ++i) {
         Onion_Path path;
 
-        if (random_path(onion_c, &onion_c->onion_paths_friends, ~0, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_friends, ~0, &path) == -1) {
             continue;
+        }
 
         uint8_t o_packet[ONION_MAX_PACKET_SIZE];
         len = create_data_request(o_packet, sizeof(o_packet), onion_c->friends_list[friend_num].real_public_key,
                                   list_nodes[good_nodes[i]].data_public_key, nonce, packet, sizeof(packet));
 
-        if (len == -1)
+        if (len == -1) {
             continue;
+        }
 
-        if (send_onion_packet_tcp_udp(onion_c, &path, list_nodes[good_nodes[i]].ip_port, o_packet, len) == 0)
+        if (send_onion_packet_tcp_udp(onion_c, &path, list_nodes[good_nodes[i]].ip_port, o_packet, len) == 0) {
             ++good;
+        }
     }
 
     return good;
@@ -867,11 +936,13 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data,
  */
 static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (!onion_c->friends_list[friend_num].know_dht_public_key)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key) {
         return -1;
+    }
 
     uint8_t nonce[crypto_box_NONCEBYTES];
     new_nonce(nonce);
@@ -882,15 +953,17 @@ static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uin
     int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key, onion_c->c->self_secret_key, nonce, data,
                            length, temp + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
 
-    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES != sizeof(temp))
+    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES != sizeof(temp)) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
     len = create_request(onion_c->dht->self_public_key, onion_c->dht->self_secret_key, packet,
                          onion_c->friends_list[friend_num].dht_public_key, temp, sizeof(temp), CRYPTO_PACKET_DHTPK);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return route_tofriend(onion_c->dht, onion_c->friends_list[friend_num].dht_public_key, packet, len);
 }
@@ -900,22 +973,26 @@ static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_
 {
     Onion_Client *onion_c = object;
 
-    if (length < DHTPK_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
+    if (length < DHTPK_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES) {
         return 1;
+    }
 
-    if (length > DHTPK_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
+    if (length > DHTPK_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES) {
         return 1;
+    }
 
     uint8_t plain[DHTPK_DATA_MAX_LENGTH];
     int len = decrypt_data(packet, onion_c->c->self_secret_key, packet + crypto_box_PUBLICKEYBYTES,
                            packet + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
                            length - (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES), plain);
 
-    if (len != length - (DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES))
+    if (len != length - (DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)) {
         return 1;
+    }
 
-    if (public_key_cmp(source_pubkey, plain + 1 + sizeof(uint64_t)) != 0)
+    if (public_key_cmp(source_pubkey, plain + 1 + sizeof(uint64_t)) != 0) {
         return 1;
+    }
 
     return handle_dhtpk_announce(onion_c, packet, plain, len);
 }
@@ -930,8 +1007,9 @@ static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_
  */
 static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8_t onion_dht_both)
 {
-    if (friend_num >= onion_c->num_friends)
+    if (friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     uint8_t data[DHTPK_DATA_MAX_LENGTH];
     data[0] = ONION_DATA_DHTPK;
@@ -949,23 +1027,28 @@ static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8
         nodes_len = pack_nodes(data + DHTPK_DATA_MIN_LENGTH, DHTPK_DATA_MAX_LENGTH - DHTPK_DATA_MIN_LENGTH, nodes,
                                num_nodes);
 
-        if (nodes_len <= 0)
+        if (nodes_len <= 0) {
             return -1;
+        }
     }
 
     int num1 = -1, num2 = -1;
 
-    if (onion_dht_both != 1)
+    if (onion_dht_both != 1) {
         num1 = send_onion_data(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
+    }
 
-    if (onion_dht_both != 0)
+    if (onion_dht_both != 0) {
         num2 = send_dht_dhtpk(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
+    }
 
-    if (num1 == -1)
+    if (num1 == -1) {
         return num2;
+    }
 
-    if (num2 == -1)
+    if (num2 == -1) {
         return num1;
+    }
 
     return num1 + num2;
 }
@@ -980,11 +1063,13 @@ int onion_friend_num(const Onion_Client *onion_c, const uint8_t *public_key)
     unsigned int i;
 
     for (i = 0; i < onion_c->num_friends; ++i) {
-        if (onion_c->friends_list[i].status == 0)
+        if (onion_c->friends_list[i].status == 0) {
             continue;
+        }
 
-        if (public_key_cmp(public_key, onion_c->friends_list[i].real_public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->friends_list[i].real_public_key) == 0) {
             return i;
+        }
     }
 
     return -1;
@@ -1005,8 +1090,9 @@ static int realloc_onion_friends(Onion_Client *onion_c, uint32_t num)
 
     Onion_Friend *newonion_friends = realloc(onion_c->friends_list, num * sizeof(Onion_Friend));
 
-    if (newonion_friends == NULL)
+    if (newonion_friends == NULL) {
         return -1;
+    }
 
     onion_c->friends_list = newonion_friends;
     return 0;
@@ -1021,8 +1107,9 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
 {
     int num = onion_friend_num(onion_c, public_key);
 
-    if (num != -1)
+    if (num != -1) {
         return num;
+    }
 
     unsigned int i, index = ~0;
 
@@ -1034,8 +1121,9 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
     }
 
     if (index == (uint32_t)~0) {
-        if (realloc_onion_friends(onion_c, onion_c->num_friends + 1) == -1)
+        if (realloc_onion_friends(onion_c, onion_c->num_friends + 1) == -1) {
             return -1;
+        }
 
         index = onion_c->num_friends;
         memset(&(onion_c->friends_list[onion_c->num_friends]), 0, sizeof(Onion_Friend));
@@ -1055,8 +1143,9 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
  */
 int onion_delfriend(Onion_Client *onion_c, int friend_num)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     //if (onion_c->friends_list[friend_num].know_dht_public_key)
     //    DHT_delfriend(onion_c->dht, onion_c->friends_list[friend_num].dht_public_key, 0);
@@ -1065,8 +1154,9 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
     unsigned int i;
 
     for (i = onion_c->num_friends; i != 0; --i) {
-        if (onion_c->friends_list[i - 1].status != 0)
+        if (onion_c->friends_list[i - 1].status != 0) {
             break;
+        }
     }
 
     if (onion_c->num_friends != i) {
@@ -1088,8 +1178,9 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
 int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_relay_node_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)
+    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_object = object;
@@ -1108,8 +1199,9 @@ int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_rela
 int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function)(void *data, int32_t number,
                           const uint8_t *dht_public_key), void *object, uint32_t number)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     onion_c->friends_list[friend_num].dht_pk_callback = function;
     onion_c->friends_list[friend_num].dht_pk_callback_object = object;
@@ -1124,11 +1216,13 @@ int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function
  */
 int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (onion_c->friends_list[friend_num].status == 0)
+    if (onion_c->friends_list[friend_num].status == 0) {
         return -1;
+    }
 
     if (onion_c->friends_list[friend_num].know_dht_public_key) {
         if (public_key_cmp(dht_key, onion_c->friends_list[friend_num].dht_public_key) == 0) {
@@ -1152,14 +1246,17 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
  */
 unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return 0;
+    }
 
-    if (onion_c->friends_list[friend_num].status == 0)
+    if (onion_c->friends_list[friend_num].status == 0) {
         return 0;
+    }
 
-    if (!onion_c->friends_list[friend_num].know_dht_public_key)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key) {
         return 0;
+    }
 
     memcpy(dht_key, onion_c->friends_list[friend_num].dht_public_key, crypto_box_PUBLICKEYBYTES);
     return 1;
@@ -1176,8 +1273,9 @@ int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_p
 {
     uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
 
-    if (onion_getfriend_DHT_pubkey(onion_c, friend_num, dht_public_key) == 0)
+    if (onion_getfriend_DHT_pubkey(onion_c, friend_num, dht_public_key) == 0) {
         return -1;
+    }
 
     return DHT_getfriendip(onion_c->dht, dht_public_key, ip_port);
 }
@@ -1194,11 +1292,13 @@ int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_p
  */
 int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_online)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (is_online == 0 && onion_c->friends_list[friend_num].is_online == 1)
+    if (is_online == 0 && onion_c->friends_list[friend_num].is_online == 1) {
         onion_c->friends_list[friend_num].last_seen = unix_time();
+    }
 
     onion_c->friends_list[friend_num].is_online = is_online;
 
@@ -1244,24 +1344,28 @@ static void populate_path_nodes_tcp(Onion_Client *onion_c)
 
 static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
 {
-    if (friendnum >= onion_c->num_friends)
+    if (friendnum >= onion_c->num_friends) {
         return;
+    }
 
-    if (onion_c->friends_list[friendnum].status == 0)
+    if (onion_c->friends_list[friendnum].status == 0) {
         return;
+    }
 
     unsigned int interval = ANNOUNCE_FRIEND;
 
-    if (onion_c->friends_list[friendnum].run_count < RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING)
+    if (onion_c->friends_list[friendnum].run_count < RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING) {
         interval = ANNOUNCE_FRIEND_BEGINNING;
+    }
 
     unsigned int i, count = 0;
     Onion_Node *list_nodes = onion_c->friends_list[friendnum].clients_list;
 
     if (!onion_c->friends_list[friendnum].is_online) {
         for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-            if (is_timeout(list_nodes[i].timestamp, FRIEND_ONION_NODE_TIMEOUT))
+            if (is_timeout(list_nodes[i].timestamp, FRIEND_ONION_NODE_TIMEOUT)) {
                 continue;
+            }
 
             ++count;
 
@@ -1283,8 +1387,9 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
 
             unsigned int n = num_nodes;
 
-            if (num_nodes > (MAX_ONION_CLIENTS / 2))
+            if (num_nodes > (MAX_ONION_CLIENTS / 2)) {
                 n = (MAX_ONION_CLIENTS / 2);
+            }
 
             if (num_nodes != 0) {
                 unsigned int j;
@@ -1302,13 +1407,17 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
         }
 
         /* send packets to friend telling them our DHT public key. */
-        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_onion_sent, ONION_DHTPK_SEND_INTERVAL))
-            if (send_dhtpk_announce(onion_c, friendnum, 0) >= 1)
+        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_onion_sent, ONION_DHTPK_SEND_INTERVAL)) {
+            if (send_dhtpk_announce(onion_c, friendnum, 0) >= 1) {
                 onion_c->friends_list[friendnum].last_dht_pk_onion_sent = unix_time();
+            }
+        }
 
-        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_dht_sent, DHT_DHTPK_SEND_INTERVAL))
-            if (send_dhtpk_announce(onion_c, friendnum, 1) >= 1)
+        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_dht_sent, DHT_DHTPK_SEND_INTERVAL)) {
+            if (send_dhtpk_announce(onion_c, friendnum, 1) >= 1) {
                 onion_c->friends_list[friendnum].last_dht_pk_dht_sent = unix_time();
+            }
+        }
 
     }
 }
@@ -1330,8 +1439,9 @@ static void do_announce(Onion_Client *onion_c)
     Onion_Node *list_nodes = onion_c->clients_announce_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) {
-        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT))
+        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT)) {
             continue;
+        }
 
         ++count;
 
@@ -1385,11 +1495,13 @@ static int onion_isconnected(const Onion_Client *onion_c)
 {
     unsigned int i, num = 0, announced = 0;
 
-    if (is_timeout(onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT))
+    if (is_timeout(onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT)) {
         return 0;
+    }
 
-    if (onion_c->path_nodes_index == 0)
+    if (onion_c->path_nodes_index == 0) {
         return 0;
+    }
 
     for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) {
         if (!is_timeout(onion_c->clients_announce_list[i].timestamp, ONION_NODE_TIMEOUT)) {
@@ -1410,8 +1522,9 @@ static int onion_isconnected(const Onion_Client *onion_c)
     /* Consider ourselves online if we are announced to half or more nodes
       we are connected to */
     if (num && announced) {
-        if ((num / 2) <= announced && (pnodes / 2) <= num)
+        if ((num / 2) <= announced && (pnodes / 2) <= num) {
             return 1;
+        }
     }
 
     return 0;
@@ -1440,8 +1553,9 @@ void do_onion_client(Onion_Client *onion_c)
 {
     unsigned int i;
 
-    if (onion_c->last_run == unix_time())
+    if (onion_c->last_run == unix_time()) {
         return;
+    }
 
     if (is_timeout(onion_c->first_run, ONION_CONNECTION_SECONDS)) {
         populate_path_nodes(onion_c);
@@ -1485,13 +1599,15 @@ void do_onion_client(Onion_Client *onion_c)
 
 Onion_Client *new_onion_client(Net_Crypto *c)
 {
-    if (c == NULL)
+    if (c == NULL) {
         return NULL;
+    }
 
     Onion_Client *onion_c = calloc(1, sizeof(Onion_Client));
 
-    if (onion_c == NULL)
+    if (onion_c == NULL) {
         return NULL;
+    }
 
     if (ping_array_init(&onion_c->announce_ping_array, ANNOUNCE_ARRAY_SIZE, ANNOUNCE_TIMEOUT) != 0) {
         free(onion_c);
@@ -1514,8 +1630,9 @@ Onion_Client *new_onion_client(Net_Crypto *c)
 
 void kill_onion_client(Onion_Client *onion_c)
 {
-    if (onion_c == NULL)
+    if (onion_c == NULL) {
         return;
+    }
 
     ping_array_free_all(&onion_c->announce_ping_array);
     realloc_onion_friends(onion_c, 0);