Add braces to all if statements.

1 files changed, 112 insertions, 56 deletions

diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index d4944aed..d689e817 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -80,8 +80,9 @@ static int realloc_connection(TCP_Server *TCP_server, uint32_t num)
     TCP_Secure_Connection *new_connections = realloc(TCP_server->accepted_connection_array,
             num * sizeof(TCP_Secure_Connection));
 
-    if (new_connections == NULL)
+    if (new_connections == NULL) {
         return -1;
+    }
 
     if (num > TCP_server->size_accepted_connections) {
         uint32_t old_size = TCP_server->size_accepted_connections;
@@ -120,8 +121,9 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
     }
 
     if (TCP_server->size_accepted_connections == TCP_server->num_accepted_connections) {
-        if (realloc_connection(TCP_server, TCP_server->size_accepted_connections + 4) == -1)
+        if (realloc_connection(TCP_server, TCP_server->size_accepted_connections + 4) == -1) {
             return -1;
+        }
 
         index = TCP_server->num_accepted_connections;
     } else {
@@ -140,8 +142,9 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
         return -1;
     }
 
-    if (!bs_list_add(&TCP_server->accepted_key_list, con->public_key, index))
+    if (!bs_list_add(&TCP_server->accepted_key_list, con->public_key, index)) {
         return -1;
+    }
 
     memcpy(&TCP_server->accepted_connection_array[index], con, sizeof(TCP_Secure_Connection));
     TCP_server->accepted_connection_array[index].status = TCP_STATUS_CONFIRMED;
@@ -160,20 +163,24 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
  */
 static int del_accepted(TCP_Server *TCP_server, int index)
 {
-    if ((uint32_t)index >= TCP_server->size_accepted_connections)
+    if ((uint32_t)index >= TCP_server->size_accepted_connections) {
         return -1;
+    }
 
-    if (TCP_server->accepted_connection_array[index].status == TCP_STATUS_NO_STATUS)
+    if (TCP_server->accepted_connection_array[index].status == TCP_STATUS_NO_STATUS) {
         return -1;
+    }
 
-    if (!bs_list_remove(&TCP_server->accepted_key_list, TCP_server->accepted_connection_array[index].public_key, index))
+    if (!bs_list_remove(&TCP_server->accepted_key_list, TCP_server->accepted_connection_array[index].public_key, index)) {
         return -1;
+    }
 
     sodium_memzero(&TCP_server->accepted_connection_array[index], sizeof(TCP_Secure_Connection));
     --TCP_server->num_accepted_connections;
 
-    if (TCP_server->num_accepted_connections == 0)
+    if (TCP_server->num_accepted_connections == 0) {
         realloc_connection(TCP_server, 0);
+    }
 
     return 0;
 }
@@ -259,30 +266,35 @@ int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length,
     if (*next_packet_length == 0) {
         uint16_t len = read_TCP_length(sock);
 
-        if (len == (uint16_t)~0)
+        if (len == (uint16_t)~0) {
             return -1;
+        }
 
-        if (len == 0)
+        if (len == 0) {
             return 0;
+        }
 
         *next_packet_length = len;
     }
 
-    if (max_len + crypto_box_MACBYTES < *next_packet_length)
+    if (max_len + crypto_box_MACBYTES < *next_packet_length) {
         return -1;
+    }
 
     uint8_t data_encrypted[*next_packet_length];
     int len_packet = read_TCP_packet(sock, data_encrypted, *next_packet_length);
 
-    if (len_packet != *next_packet_length)
+    if (len_packet != *next_packet_length) {
         return 0;
+    }
 
     *next_packet_length = 0;
 
     int len = decrypt_data_symmetric(shared_key, recv_nonce, data_encrypted, len_packet, data);
 
-    if (len + crypto_box_MACBYTES != len_packet)
+    if (len + crypto_box_MACBYTES != len_packet) {
         return -1;
+    }
 
     increment_nonce(recv_nonce);
 
@@ -301,8 +313,9 @@ static int send_pending_data_nonpriority(TCP_Secure_Connection *con)
     uint16_t left = con->last_packet_length - con->last_packet_sent;
     int len = send(con->sock, con->last_packet + con->last_packet_sent, left, MSG_NOSIGNAL);
 
-    if (len <= 0)
+    if (len <= 0) {
         return -1;
+    }
 
     if (len == left) {
         con->last_packet_length = 0;
@@ -388,8 +401,9 @@ static _Bool add_priority(TCP_Secure_Connection *con, const uint8_t *packet, uin
 static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
         _Bool priority)
 {
-    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
+    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE) {
         return -1;
+    }
 
     _Bool sendpriority = 1;
 
@@ -407,8 +421,9 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
     memcpy(packet, &c_length, sizeof(uint16_t));
     int len = encrypt_data_symmetric(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
 
-    if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
+    if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t))) {
         return -1;
+    }
 
     if (priority) {
         len = sendpriority ? send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL) : 0;
@@ -428,13 +443,15 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
 
     len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
 
-    if (len <= 0)
+    if (len <= 0) {
         return 0;
+    }
 
     increment_nonce(con->sent_nonce);
 
-    if ((unsigned int)len == sizeof(packet))
+    if ((unsigned int)len == sizeof(packet)) {
         return 1;
+    }
 
     memcpy(con->last_packet, packet, sizeof(packet));
     con->last_packet_length = sizeof(packet);
@@ -459,8 +476,9 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
  */
 static int kill_accepted(TCP_Server *TCP_server, int index)
 {
-    if ((uint32_t)index >= TCP_server->size_accepted_connections)
+    if ((uint32_t)index >= TCP_server->size_accepted_connections) {
         return -1;
+    }
 
     uint32_t i;
 
@@ -470,8 +488,9 @@ static int kill_accepted(TCP_Server *TCP_server, int index)
 
     sock_t sock = TCP_server->accepted_connection_array[index].sock;
 
-    if (del_accepted(TCP_server, index) != 0)
+    if (del_accepted(TCP_server, index) != 0) {
         return -1;
+    }
 
     kill_sock(sock);
     return 0;
@@ -483,11 +502,13 @@ static int kill_accepted(TCP_Server *TCP_server, int index)
 static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
                                 const uint8_t *self_secret_key)
 {
-    if (length != TCP_CLIENT_HANDSHAKE_SIZE)
+    if (length != TCP_CLIENT_HANDSHAKE_SIZE) {
         return -1;
+    }
 
-    if (con->status != TCP_STATUS_CONNECTED)
+    if (con->status != TCP_STATUS_CONNECTED) {
         return -1;
+    }
 
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
     encrypt_precompute(data, self_secret_key, shared_key);
@@ -495,8 +516,9 @@ static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data,
     int len = decrypt_data_symmetric(shared_key, data + crypto_box_PUBLICKEYBYTES,
                                      data + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES, plain);
 
-    if (len != TCP_HANDSHAKE_PLAIN_SIZE)
+    if (len != TCP_HANDSHAKE_PLAIN_SIZE) {
         return -1;
+    }
 
     memcpy(con->public_key, data, crypto_box_PUBLICKEYBYTES);
     uint8_t temp_secret_key[crypto_box_SECRETKEYBYTES];
@@ -512,11 +534,13 @@ static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data,
     len = encrypt_data_symmetric(shared_key, response, resp_plain, TCP_HANDSHAKE_PLAIN_SIZE,
                                  response + crypto_box_NONCEBYTES);
 
-    if (len != TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES)
+    if (len != TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES) {
         return -1;
+    }
 
-    if (TCP_SERVER_HANDSHAKE_SIZE != send(con->sock, response, TCP_SERVER_HANDSHAKE_SIZE, MSG_NOSIGNAL))
+    if (TCP_SERVER_HANDSHAKE_SIZE != send(con->sock, response, TCP_SERVER_HANDSHAKE_SIZE, MSG_NOSIGNAL)) {
         return -1;
+    }
 
     encrypt_precompute(plain, temp_secret_key, con->shared_key);
     con->status = TCP_STATUS_UNCONFIRMED;
@@ -584,8 +608,9 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
 
     /* If person tries to cennect to himself we deny the request*/
     if (public_key_cmp(con->public_key, public_key) == 0) {
-        if (send_routing_response(con, 0, public_key) == -1)
+        if (send_routing_response(con, 0, public_key) == -1) {
             return -1;
+        }
 
         return 0;
     }
@@ -605,19 +630,22 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
     }
 
     if (index == (uint32_t)~0) {
-        if (send_routing_response(con, 0, public_key) == -1)
+        if (send_routing_response(con, 0, public_key) == -1) {
             return -1;
+        }
 
         return 0;
     }
 
     int ret = send_routing_response(con, index + NUM_RESERVED_PORTS, public_key);
 
-    if (ret == 0)
+    if (ret == 0) {
         return 0;
+    }
 
-    if (ret == -1)
+    if (ret == -1) {
         return -1;
+    }
 
     con->connections[index].status = 1;
     memcpy(con->connections[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
@@ -657,8 +685,9 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
 static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *public_key, const uint8_t *data,
                                uint16_t length)
 {
-    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH)
+    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH) {
         return -1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[con_id];
 
@@ -683,8 +712,9 @@ static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const ui
  */
 static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *con, uint8_t con_number)
 {
-    if (con_number >= NUM_CLIENT_CONNECTIONS)
+    if (con_number >= NUM_CLIENT_CONNECTIONS) {
         return -1;
+    }
 
     if (con->connections[con_number].status) {
         uint32_t index = con->connections[con_number].index;
@@ -692,8 +722,9 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
 
         if (con->connections[con_number].status == 2) {
 
-            if (index >= TCP_server->size_accepted_connections)
+            if (index >= TCP_server->size_accepted_connections) {
                 return -1;
+            }
 
             TCP_server->accepted_connection_array[index].connections[other_id].other_id = 0;
             TCP_server->accepted_connection_array[index].connections[other_id].index = 0;
@@ -716,20 +747,23 @@ static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data,
     TCP_Server *TCP_server = object;
     uint32_t index = dest.ip.ip6.uint32[0];
 
-    if (index >= TCP_server->size_accepted_connections)
+    if (index >= TCP_server->size_accepted_connections) {
         return 1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[index];
 
-    if (con->identifier != dest.ip.ip6.uint64[1])
+    if (con->identifier != dest.ip.ip6.uint64[1]) {
         return 1;
+    }
 
     uint8_t packet[1 + length];
     memcpy(packet + 1, data, length);
     packet[0] = TCP_PACKET_ONION_RESPONSE;
 
-    if (write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0) != 1)
+    if (write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0) != 1) {
         return 1;
+    }
 
     return 0;
 }
@@ -739,36 +773,41 @@ static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data,
  */
 static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *data, uint16_t length)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[con_id];
 
     switch (data[0]) {
         case TCP_PACKET_ROUTING_REQUEST: {
-            if (length != 1 + crypto_box_PUBLICKEYBYTES)
+            if (length != 1 + crypto_box_PUBLICKEYBYTES) {
                 return -1;
+            }
 
             return handle_TCP_routing_req(TCP_server, con_id, data + 1);
         }
 
         case TCP_PACKET_CONNECTION_NOTIFICATION: {
-            if (length != 2)
+            if (length != 2) {
                 return -1;
+            }
 
             break;
         }
 
         case TCP_PACKET_DISCONNECT_NOTIFICATION: {
-            if (length != 2)
+            if (length != 2) {
                 return -1;
+            }
 
             return rm_connection_index(TCP_server, con, data[1] - NUM_RESERVED_PORTS);
         }
 
         case TCP_PACKET_PING: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint8_t response[1 + sizeof(uint64_t)];
             response[0] = TCP_PACKET_PONG;
@@ -778,8 +817,9 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
         }
 
         case TCP_PACKET_PONG: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
@@ -796,8 +836,9 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
         }
 
         case TCP_PACKET_OOB_SEND: {
-            if (length <= 1 + crypto_box_PUBLICKEYBYTES)
+            if (length <= 1 + crypto_box_PUBLICKEYBYTES) {
                 return -1;
+            }
 
             return handle_TCP_oob_send(TCP_server, con_id, data + 1, data + 1 + crypto_box_PUBLICKEYBYTES,
                                        length - (1 + crypto_box_PUBLICKEYBYTES));
@@ -805,8 +846,9 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
 
         case TCP_PACKET_ONION_REQUEST: {
             if (TCP_server->onion) {
-                if (length <= 1 + crypto_box_NONCEBYTES + ONION_SEND_BASE * 2)
+                if (length <= 1 + crypto_box_NONCEBYTES + ONION_SEND_BASE * 2) {
                     return -1;
+                }
 
                 IP_Port source;
                 source.port = 0;  // dummy initialise
@@ -826,19 +868,23 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
         }
 
         default: {
-            if (data[0] < NUM_RESERVED_PORTS)
+            if (data[0] < NUM_RESERVED_PORTS) {
                 return -1;
+            }
 
             uint8_t c_id = data[0] - NUM_RESERVED_PORTS;
 
-            if (c_id >= NUM_CLIENT_CONNECTIONS)
+            if (c_id >= NUM_CLIENT_CONNECTIONS) {
                 return -1;
+            }
 
-            if (con->connections[c_id].status == 0)
+            if (con->connections[c_id].status == 0) {
                 return -1;
+            }
 
-            if (con->connections[c_id].status != 2)
+            if (con->connections[c_id].status != 2) {
                 return 0;
+            }
 
             uint32_t index = con->connections[c_id].index;
             uint8_t other_c_id = con->connections[c_id].other_id + NUM_RESERVED_PORTS;
@@ -847,8 +893,9 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
             new_data[0] = other_c_id;
             int ret = write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[index], new_data, length, 0);
 
-            if (ret == -1)
+            if (ret == -1) {
                 return -1;
+            }
 
             return 0;
         }
@@ -883,8 +930,9 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
  */
 static int accept_connection(TCP_Server *TCP_server, sock_t sock)
 {
-    if (!sock_valid(sock))
+    if (!sock_valid(sock)) {
         return -1;
+    }
 
     if (!set_socket_nonblock(sock)) {
         kill_sock(sock);
@@ -900,8 +948,9 @@ static int accept_connection(TCP_Server *TCP_server, sock_t sock)
 
     TCP_Secure_Connection *conn = &TCP_server->incomming_connection_queue[index];
 
-    if (conn->status != TCP_STATUS_NO_STATUS)
+    if (conn->status != TCP_STATUS_NO_STATUS) {
         kill_TCP_connection(conn);
+    }
 
     conn->status = TCP_STATUS_CONNECTED;
     conn->sock = sock;
@@ -942,8 +991,9 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
 TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *secret_key,
                            Onion *onion)
 {
-    if (num_sockets == 0 || ports == NULL)
+    if (num_sockets == 0 || ports == NULL) {
         return NULL;
+    }
 
     if (networking_at_startup() != 0) {
         return NULL;
@@ -951,8 +1001,9 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
 
     TCP_Server *temp = calloc(1, sizeof(TCP_Server));
 
-    if (temp == NULL)
+    if (temp == NULL) {
         return NULL;
+    }
 
     temp->socks_listening = calloc(num_sockets, sizeof(sock_t));
 
@@ -1040,8 +1091,9 @@ static void do_TCP_accept_new(TCP_Server *TCP_server)
 
 static int do_incoming(TCP_Server *TCP_server, uint32_t i)
 {
-    if (TCP_server->incomming_connection_queue[i].status != TCP_STATUS_CONNECTED)
+    if (TCP_server->incomming_connection_queue[i].status != TCP_STATUS_CONNECTED) {
         return -1;
+    }
 
     int ret = read_connection_handshake(&TCP_server->incomming_connection_queue[i], TCP_server->secret_key);
 
@@ -1052,8 +1104,9 @@ static int do_incoming(TCP_Server *TCP_server, uint32_t i)
         TCP_Secure_Connection *conn_old = &TCP_server->incomming_connection_queue[i];
         TCP_Secure_Connection *conn_new = &TCP_server->unconfirmed_connection_queue[index_new];
 
-        if (conn_new->status != TCP_STATUS_NO_STATUS)
+        if (conn_new->status != TCP_STATUS_NO_STATUS) {
             kill_TCP_connection(conn_new);
+        }
 
         memcpy(conn_new, conn_old, sizeof(TCP_Secure_Connection));
         sodium_memzero(conn_old, sizeof(TCP_Secure_Connection));
@@ -1069,8 +1122,9 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
 {
     TCP_Secure_Connection *conn = &TCP_server->unconfirmed_connection_queue[i];
 
-    if (conn->status != TCP_STATUS_UNCONFIRMED)
+    if (conn->status != TCP_STATUS_UNCONFIRMED) {
         return -1;
+    }
 
     uint8_t packet[MAX_PACKET_SIZE];
     int len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key, conn->recv_nonce,
@@ -1139,16 +1193,18 @@ static void do_TCP_confirmed(TCP_Server *TCP_server)
     for (i = 0; i < TCP_server->size_accepted_connections; ++i) {
         TCP_Secure_Connection *conn = &TCP_server->accepted_connection_array[i];
 
-        if (conn->status != TCP_STATUS_CONFIRMED)
+        if (conn->status != TCP_STATUS_CONFIRMED) {
             continue;
+        }
 
         if (is_timeout(conn->last_pinged, TCP_PING_FREQUENCY)) {
             uint8_t ping[1 + sizeof(uint64_t)];
             ping[0] = TCP_PACKET_PING;
             uint64_t ping_id = random_64b();
 
-            if (!ping_id)
+            if (!ping_id) {
                 ++ping_id;
+            }
 
             memcpy(ping + 1, &ping_id, sizeof(uint64_t));
             int ret = write_packet_TCP_secure_connection(conn, ping, sizeof(ping), 1);