Add a monolith_test that includes all toxcore sources.

This requires that every symbol, even if static (file-scope), is unique.
The idea is that we can easily run "whole" program static analysis on
programs that include monolith.h ("whole" is in quotes, as we don't
include dependencies like libsodium in this static analysis).

8 files changed, 107 insertions, 107 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 5ef24564..30e0b816 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -798,13 +798,13 @@ int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *node
 typedef struct {
     const uint8_t *base_public_key;
     Client_data entry;
-} Cmp_data;
+} DHT_Cmp_data;
 
 static int cmp_dht_entry(const void *a, const void *b)
 {
-    Cmp_data cmp1, cmp2;
-    memcpy(&cmp1, a, sizeof(Cmp_data));
-    memcpy(&cmp2, b, sizeof(Cmp_data));
+    DHT_Cmp_data cmp1, cmp2;
+    memcpy(&cmp1, a, sizeof(DHT_Cmp_data));
+    memcpy(&cmp2, b, sizeof(DHT_Cmp_data));
     Client_data entry1 = cmp1.entry;
     Client_data entry2 = cmp2.entry;
     const uint8_t *cmp_public_key = cmp1.base_public_key;
@@ -871,14 +871,14 @@ static void sort_client_list(Client_data *list, unsigned int length, const uint8
 {
     // Pass comp_public_key to qsort with each Client_data entry, so the
     // comparison function can use it as the base of comparison.
-    VLA(Cmp_data, cmp_list, length);
+    VLA(DHT_Cmp_data, cmp_list, length);
 
     for (uint32_t i = 0; i < length; i++) {
         cmp_list[i].base_public_key = comp_public_key;
         cmp_list[i].entry = list[i];
     }
 
-    qsort(cmp_list, length, sizeof(Cmp_data), cmp_dht_entry);
+    qsort(cmp_list, length, sizeof(DHT_Cmp_data), cmp_dht_entry);
 
     for (uint32_t i = 0; i < length; i++) {
         list[i] = cmp_list[i].entry;
@@ -2736,7 +2736,7 @@ uint32_t DHT_size(const DHT *dht)
     return size32 + sizesubhead + (packed_node_size(AF_INET) * numv4) + (packed_node_size(AF_INET6) * numv6);
 }
 
-static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
+static uint8_t *DHT_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
 {
     host_to_lendian32(data, len);
     data += sizeof(uint32_t);
@@ -2757,7 +2757,7 @@ void DHT_save(DHT *dht, uint8_t *data)
     uint8_t *old_data = data;
 
     /* get right offset. we write the actual header later. */
-    data = z_state_save_subheader(data, 0, 0);
+    data = DHT_save_subheader(data, 0, 0);
 
     Node_format clients[MAX_SAVED_DHT_NODES];
 
@@ -2793,7 +2793,7 @@ void DHT_save(DHT *dht, uint8_t *data)
         }
     }
 
-    z_state_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
+    DHT_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
 }
 
 /* Bootstrap from this number of nodes every time DHT_connect_after_load() is called */
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 5dda5b30..7f21d367 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -166,10 +166,10 @@ static int send_offline_packet(Messenger *m, int friendcon_id)
                              sizeof(packet), 0) != -1;
 }
 
-static int handle_status(void *object, int i, uint8_t status, void *userdata);
-static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata);
-static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
-                                      void *userdata);
+static int m_handle_status(void *object, int i, uint8_t status, void *userdata);
+static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata);
+static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
+                                        void *userdata);
 
 static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t status)
 {
@@ -198,8 +198,8 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta
             m->friendlist[i].userstatus = USERSTATUS_NONE;
             m->friendlist[i].is_typing = 0;
             m->friendlist[i].message_id = 0;
-            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
-                                        &handle_custom_lossy_packet, m, i);
+            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &m_handle_status, &m_handle_packet,
+                                        &m_handle_custom_lossy_packet, m, i);
 
             if (m->numfriends == i) {
                 ++m->numfriends;
@@ -1757,8 +1757,8 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length, 0);
 }
 
-static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
-                                      void *userdata)
+static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
+                                        void *userdata)
 {
     Messenger *m = (Messenger *)object;
 
@@ -2080,7 +2080,7 @@ static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t,
     }
 }
 
-static int handle_status(void *object, int i, uint8_t status, void *userdata)
+static int m_handle_status(void *object, int i, uint8_t status, void *userdata)
 {
     Messenger *m = (Messenger *)object;
 
@@ -2095,7 +2095,7 @@ static int handle_status(void *object, int i, uint8_t status, void *userdata)
     return 0;
 }
 
-static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata)
+static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata)
 {
     if (len == 0) {
         return -1;
@@ -2902,7 +2902,7 @@ uint32_t messenger_size(const Messenger *m)
              + sizesubhead;
 }
 
-static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
+static uint8_t *messenger_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
 {
     host_to_lendian32(data, len);
     data += sizeof(uint32_t);
@@ -2928,69 +2928,69 @@ void messenger_save(const Messenger *m, uint8_t *data)
     assert(sizeof(get_nospam(&m->fr)) == sizeof(uint32_t));
     len = size32 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE;
     type = MESSENGER_STATE_TYPE_NOSPAMKEYS;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     *(uint32_t *)data = get_nospam(&(m->fr));
     save_keys(m->net_crypto, data + size32);
     data += len;
 
     len = saved_friendslist_size(m);
     type = MESSENGER_STATE_TYPE_FRIENDS;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     friends_list_save(m, data);
     data += len;
 
     len = m->name_length;
     type = MESSENGER_STATE_TYPE_NAME;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     memcpy(data, m->name, len);
     data += len;
 
     len = m->statusmessage_length;
     type = MESSENGER_STATE_TYPE_STATUSMESSAGE;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     memcpy(data, m->statusmessage, len);
     data += len;
 
     len = 1;
     type = MESSENGER_STATE_TYPE_STATUS;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     *data = m->userstatus;
     data += len;
 
     len = DHT_size(m->dht);
     type = MESSENGER_STATE_TYPE_DHT;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     DHT_save(m->dht, data);
     data += len;
 
     Node_format relays[NUM_SAVED_TCP_RELAYS];
     type = MESSENGER_STATE_TYPE_TCP_RELAY;
     uint8_t *temp_data = data;
-    data = z_state_save_subheader(temp_data, 0, type);
+    data = messenger_save_subheader(temp_data, 0, type);
     unsigned int num = copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS);
     int l = pack_nodes(data, NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6), relays, num);
 
     if (l > 0) {
         len = l;
-        data = z_state_save_subheader(temp_data, len, type);
+        data = messenger_save_subheader(temp_data, len, type);
         data += len;
     }
 
     Node_format nodes[NUM_SAVED_PATH_NODES];
     type = MESSENGER_STATE_TYPE_PATH_NODE;
     temp_data = data;
-    data = z_state_save_subheader(data, 0, type);
+    data = messenger_save_subheader(data, 0, type);
     memset(nodes, 0, sizeof(nodes));
     num = onion_backup_nodes(m->onion_c, nodes, NUM_SAVED_PATH_NODES);
     l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6), nodes, num);
 
     if (l > 0) {
         len = l;
-        data = z_state_save_subheader(temp_data, len, type);
+        data = messenger_save_subheader(temp_data, len, type);
         data += len;
     }
 
-    z_state_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
+    messenger_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
 }
 
 static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index 3e6de14a..e584b265 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -244,7 +244,7 @@ static int handle_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *data
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data_nonpriority(TCP_Client_Connection *con)
+static int client_send_pending_data_nonpriority(TCP_Client_Connection *con)
 {
     if (con->last_packet_length == 0) {
         return 0;
@@ -270,10 +270,10 @@ static int send_pending_data_nonpriority(TCP_Client_Connection *con)
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data(TCP_Client_Connection *con)
+static int client_send_pending_data(TCP_Client_Connection *con)
 {
     /* finish sending current non-priority packet */
-    if (send_pending_data_nonpriority(con) == -1) {
+    if (client_send_pending_data_nonpriority(con) == -1) {
         return -1;
     }
 
@@ -309,7 +309,7 @@ static int send_pending_data(TCP_Client_Connection *con)
 /* return 0 on failure (only if malloc fails)
  * return 1 on success
  */
-static bool add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
+static bool client_add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
 {
     TCP_Priority_List *p = con->priority_queue_end;
     TCP_Priority_List *new_list = (TCP_Priority_List *)malloc(sizeof(TCP_Priority_List) + size);
@@ -348,7 +348,7 @@ static void wipe_priority_list(TCP_Client_Connection *con)
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
+static int write_packet_TCP_client_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
         bool priority)
 {
     if (length + CRYPTO_MAC_SIZE > MAX_PACKET_SIZE) {
@@ -357,7 +357,7 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
 
     bool sendpriority = 1;
 
-    if (send_pending_data(con) == -1) {
+    if (client_send_pending_data(con) == -1) {
         if (priority) {
             sendpriority = 0;
         } else {
@@ -388,7 +388,7 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
             return 1;
         }
 
-        return add_priority(con, packet, SIZEOF_VLA(packet), len);
+        return client_add_priority(con, packet, SIZEOF_VLA(packet), len);
     }
 
     len = send(con->sock, (const char *)packet, SIZEOF_VLA(packet), MSG_NOSIGNAL);
@@ -418,7 +418,7 @@ int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key)
     uint8_t packet[1 + CRYPTO_PUBLIC_KEY_SIZE];
     packet[0] = TCP_PACKET_ROUTING_REQUEST;
     memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
+    return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
@@ -435,8 +435,8 @@ void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(v
     con->status_callback_object = object;
 }
 
-static int send_ping_response(TCP_Client_Connection *con);
-static int send_ping_request(TCP_Client_Connection *con);
+static int tcp_send_ping_response(TCP_Client_Connection *con);
+static int tcp_send_ping_request(TCP_Client_Connection *con);
 
 /* return 1 on success.
  * return 0 if could not send packet.
@@ -452,14 +452,14 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, u
         return -1;
     }
 
-    if (send_ping_response(con) == 0 || send_ping_request(con) == 0) {
+    if (tcp_send_ping_response(con) == 0 || tcp_send_ping_request(con) == 0) {
         return 0;
     }
 
     VLA(uint8_t, packet, 1 + length);
     packet[0] = con_id + NUM_RESERVED_PORTS;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 /* return 1 on success.
@@ -476,7 +476,7 @@ int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const
     packet[0] = TCP_PACKET_OOB_SEND;
     memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, data, length);
-    return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 
@@ -519,19 +519,19 @@ void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
+static int client_send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
 {
     uint8_t packet[1 + 1];
     packet[0] = TCP_PACKET_DISCONNECT_NOTIFICATION;
     packet[1] = id;
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
+    return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_request(TCP_Client_Connection *con)
+static int tcp_send_ping_request(TCP_Client_Connection *con)
 {
     if (!con->ping_request_id) {
         return 1;
@@ -542,7 +542,7 @@ static int send_ping_request(TCP_Client_Connection *con)
     memcpy(packet + 1, &con->ping_request_id, sizeof(uint64_t));
     int ret;
 
-    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+    if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
         con->ping_request_id = 0;
     }
 
@@ -553,7 +553,7 @@ static int send_ping_request(TCP_Client_Connection *con)
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_response(TCP_Client_Connection *con)
+static int tcp_send_ping_response(TCP_Client_Connection *con)
 {
     if (!con->ping_response_id) {
         return 1;
@@ -564,7 +564,7 @@ static int send_ping_response(TCP_Client_Connection *con)
     memcpy(packet + 1, &con->ping_response_id, sizeof(uint64_t));
     int ret;
 
-    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+    if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
         con->ping_response_id = 0;
     }
 
@@ -583,7 +583,7 @@ int send_disconnect_request(TCP_Client_Connection *con, uint8_t con_id)
 
     con->connections[con_id].status = 0;
     con->connections[con_id].number = 0;
-    return send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
+    return client_send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
 }
 
 /* return 1 on success.
@@ -595,7 +595,7 @@ int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t
     VLA(uint8_t, packet, 1 + length);
     packet[0] = TCP_PACKET_ONION_REQUEST;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
@@ -692,7 +692,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
 /* return 0 on success
  * return -1 on failure
  */
-static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length, void *userdata)
+static int handle_TCP_client_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length, void *userdata)
 {
     if (length <= 1) {
         return -1;
@@ -787,7 +787,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
             conn->ping_response_id = ping_id;
-            send_ping_response(conn);
+            tcp_send_ping_response(conn);
             return 0;
         }
 
@@ -847,9 +847,9 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
 
 static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
 {
-    send_pending_data(conn);
-    send_ping_response(conn);
-    send_ping_request(conn);
+    client_send_pending_data(conn);
+    tcp_send_ping_response(conn);
+    tcp_send_ping_request(conn);
 
     uint8_t packet[MAX_PACKET_SIZE];
     int len;
@@ -862,7 +862,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
         }
 
         conn->ping_request_id = conn->ping_id = ping_id;
-        send_ping_request(conn);
+        tcp_send_ping_request(conn);
         conn->last_pinged = unix_time();
     }
 
@@ -878,7 +878,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
             break;
         }
 
-        if (handle_TCP_packet(conn, packet, len, userdata) == -1) {
+        if (handle_TCP_client_packet(conn, packet, len, userdata) == -1) {
             conn->status = TCP_CLIENT_DISCONNECTED;
             break;
         }
@@ -898,7 +898,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_HTTP_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = proxy_http_read_connection_response(TCP_connection);
 
             if (ret == -1) {
@@ -914,7 +914,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = socks5_read_handshake_response(TCP_connection);
 
             if (ret == -1) {
@@ -930,7 +930,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = proxy_socks5_read_connection_response(TCP_connection);
 
             if (ret == -1) {
@@ -946,7 +946,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
     }
 
     if (TCP_connection->status == TCP_CLIENT_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             TCP_connection->status = TCP_CLIENT_UNCONFIRMED;
         }
     }
diff --git a/toxcore/TCP_connection.c b/toxcore/TCP_connection.c
index 18c1e76e..b9c75afe 100644
--- a/toxcore/TCP_connection.c
+++ b/toxcore/TCP_connection.c
@@ -973,8 +973,8 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
     return 0;
 }
 
-static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length,
-                             void *userdata)
+static int tcp_conn_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data,
+                                  uint16_t length, void *userdata)
 {
     if (length == 0) {
         return -1;
@@ -1003,8 +1003,8 @@ static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_i
     return 0;
 }
 
-static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
-                            void *userdata)
+static int tcp_conn_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
+                                 void *userdata)
 {
     if (length == 0) {
         return -1;
@@ -1026,7 +1026,7 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
     if (con_to && tcp_connection_in_conn(con_to, tcp_connections_number)) {
-        return tcp_data_callback(object, connections_number, 0, data, length, userdata);
+        return tcp_conn_data_callback(object, connections_number, 0, data, length, userdata);
     }
 
     if (tcp_c->tcp_oob_callback) {
@@ -1067,8 +1067,8 @@ static int tcp_relay_set_callbacks(TCP_Connections *tcp_c, int tcp_connections_n
     onion_response_handler(con, &tcp_onion_callback, tcp_c);
     routing_response_handler(con, &tcp_response_callback, con);
     routing_status_handler(con, &tcp_status_callback, con);
-    routing_data_handler(con, &tcp_data_callback, con);
-    oob_data_handler(con, &tcp_oob_callback, con);
+    routing_data_handler(con, &tcp_conn_data_callback, con);
+    oob_data_handler(con, &tcp_conn_oob_callback, con);
 
     return 0;
 }
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index d2b08206..3f2e554f 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -45,9 +45,9 @@ struct TCP_Server {
 
     uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t secret_key[CRYPTO_SECRET_KEY_SIZE];
-    TCP_Secure_Connection incomming_connection_queue[MAX_INCOMMING_CONNECTIONS];
-    uint16_t incomming_connection_queue_index;
-    TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMMING_CONNECTIONS];
+    TCP_Secure_Connection incoming_connection_queue[MAX_INCOMING_CONNECTIONS];
+    uint16_t incoming_connection_queue_index;
+    TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMING_CONNECTIONS];
     uint16_t unconfirmed_connection_queue_index;
 
     TCP_Secure_Connection *accepted_connection_array;
@@ -477,7 +477,7 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
 
 /* Kill a TCP_Secure_Connection
  */
-static void kill_TCP_connection(TCP_Secure_Connection *con)
+static void kill_TCP_secure_connection(TCP_Secure_Connection *con)
 {
     kill_sock(con->sock);
     crypto_memzero(con, sizeof(TCP_Secure_Connection));
@@ -927,7 +927,7 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
     int index = add_accepted(TCP_server, con);
 
     if (index == -1) {
-        kill_TCP_connection(con);
+        kill_TCP_secure_connection(con);
         return -1;
     }
 
@@ -960,19 +960,19 @@ static int accept_connection(TCP_Server *TCP_server, Socket sock)
         return -1;
     }
 
-    uint16_t index = TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
+    uint16_t index = TCP_server->incoming_connection_queue_index % MAX_INCOMING_CONNECTIONS;
 
-    TCP_Secure_Connection *conn = &TCP_server->incomming_connection_queue[index];
+    TCP_Secure_Connection *conn = &TCP_server->incoming_connection_queue[index];
 
     if (conn->status != TCP_STATUS_NO_STATUS) {
-        kill_TCP_connection(conn);
+        kill_TCP_secure_connection(conn);
     }
 
     conn->status = TCP_STATUS_CONNECTED;
     conn->sock = sock;
     conn->next_packet_length = 0;
 
-    ++TCP_server->incomming_connection_queue_index;
+    ++TCP_server->incoming_connection_queue_index;
     return index;
 }
 
@@ -1107,21 +1107,21 @@ 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->incoming_connection_queue[i].status != TCP_STATUS_CONNECTED) {
         return -1;
     }
 
-    int ret = read_connection_handshake(&TCP_server->incomming_connection_queue[i], TCP_server->secret_key);
+    int ret = read_connection_handshake(&TCP_server->incoming_connection_queue[i], TCP_server->secret_key);
 
     if (ret == -1) {
-        kill_TCP_connection(&TCP_server->incomming_connection_queue[i]);
+        kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[i]);
     } else if (ret == 1) {
-        int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
-        TCP_Secure_Connection *conn_old = &TCP_server->incomming_connection_queue[i];
+        int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMING_CONNECTIONS;
+        TCP_Secure_Connection *conn_old = &TCP_server->incoming_connection_queue[i];
         TCP_Secure_Connection *conn_new = &TCP_server->unconfirmed_connection_queue[index_new];
 
         if (conn_new->status != TCP_STATUS_NO_STATUS) {
-            kill_TCP_connection(conn_new);
+            kill_TCP_secure_connection(conn_new);
         }
 
         memcpy(conn_new, conn_old, sizeof(TCP_Secure_Connection));
@@ -1151,7 +1151,7 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
     }
 
     if (len == -1) {
-        kill_TCP_connection(conn);
+        kill_TCP_secure_connection(conn);
         return -1;
     }
 
@@ -1179,11 +1179,11 @@ static void do_confirmed_recv(TCP_Server *TCP_server, uint32_t i)
     }
 }
 
-static void do_TCP_incomming(TCP_Server *TCP_server)
+static void do_TCP_incoming(TCP_Server *TCP_server)
 {
     uint32_t i;
 
-    for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
+    for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
         do_incoming(TCP_server, i);
     }
 }
@@ -1192,7 +1192,7 @@ static void do_TCP_unconfirmed(TCP_Server *TCP_server)
 {
     uint32_t i;
 
-    for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
+    for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
         do_unconfirmed(TCP_server, i);
     }
 }
@@ -1276,12 +1276,12 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                     }
 
                     case TCP_SOCKET_INCOMING: {
-                        kill_TCP_connection(&TCP_server->incomming_connection_queue[index]);
+                        kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index]);
                         break;
                     }
 
                     case TCP_SOCKET_UNCONFIRMED: {
-                        kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index]);
+                        kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index]);
                         break;
                     }
 
@@ -1324,7 +1324,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                         };
 
                         if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new, &ev) == -1) {
-                            kill_TCP_connection(&TCP_server->incomming_connection_queue[index_new]);
+                            kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index_new]);
                             continue;
                         }
                     }
@@ -1340,7 +1340,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                         events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_UNCONFIRMED << 32) | ((uint64_t)index_new << 40);
 
                         if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
-                            kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
+                            kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
                             break;
                         }
                     }
@@ -1386,7 +1386,7 @@ void do_TCP_server(TCP_Server *TCP_server)
 
 #else
     do_TCP_accept_new(TCP_server);
-    do_TCP_incomming(TCP_server);
+    do_TCP_incoming(TCP_server);
     do_TCP_unconfirmed(TCP_server);
 #endif
 
diff --git a/toxcore/TCP_server.h b/toxcore/TCP_server.h
index 7c1db65e..ddb204c2 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -36,9 +36,9 @@
 #define MSG_NOSIGNAL 0
 #endif
 
-#define MAX_INCOMMING_CONNECTIONS 256
+#define MAX_INCOMING_CONNECTIONS 256
 
-#define TCP_MAX_BACKLOG MAX_INCOMMING_CONNECTIONS
+#define TCP_MAX_BACKLOG MAX_INCOMING_CONNECTIONS
 
 #define MAX_PACKET_SIZE 2048
 
diff --git a/toxcore/group.c b/toxcore/group.c
index 73aca875..d3f068df 100644
--- a/toxcore/group.c
+++ b/toxcore/group.c
@@ -659,7 +659,7 @@ static void set_conns_status_groups(Group_Chats *g_c, int friendcon_id, uint8_t
     }
 }
 
-static int handle_status(void *object, int friendcon_id, uint8_t status, void *userdata)
+static int g_handle_status(void *object, int friendcon_id, uint8_t status, void *userdata)
 {
     Group_Chats *g_c = (Group_Chats *)object;
 
@@ -673,7 +673,7 @@ static int handle_status(void *object, int friendcon_id, uint8_t status, void *u
     return 0;
 }
 
-static int handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
+static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
 static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
 
 /* Add friend to group chat.
@@ -715,7 +715,7 @@ static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnu
     g->close[ind].number = friendcon_id;
     g->close[ind].closest = closest;
     // TODO(irungentoo):
-    friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &handle_status, &handle_packet,
+    friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &g_handle_status, &g_handle_packet,
                                 &handle_lossy, g_c, friendcon_id);
 
     return ind;
@@ -2124,7 +2124,7 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
     send_message_all_close(g_c, groupnumber, data, length, -1/* TODO(irungentoo) close_index */);
 }
 
-static int handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
+static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
 {
     Group_Chats *g_c = (Group_Chats *)object;
 
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index ddae84e5..3c14a101 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -474,13 +474,13 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
 typedef struct {
     const uint8_t *base_public_key;
     Onion_Node entry;
-} Cmp_data;
+} Onion_Client_Cmp_data;
 
-static int cmp_entry(const void *a, const void *b)
+static int onion_client_cmp_entry(const void *a, const void *b)
 {
-    Cmp_data cmp1, cmp2;
-    memcpy(&cmp1, a, sizeof(Cmp_data));
-    memcpy(&cmp2, b, sizeof(Cmp_data));
+    Onion_Client_Cmp_data cmp1, cmp2;
+    memcpy(&cmp1, a, sizeof(Onion_Client_Cmp_data));
+    memcpy(&cmp2, b, sizeof(Onion_Client_Cmp_data));
     Onion_Node entry1 = cmp1.entry;
     Onion_Node entry2 = cmp2.entry;
     const uint8_t *cmp_public_key = cmp1.base_public_key;
@@ -517,14 +517,14 @@ static void sort_onion_node_list(Onion_Node *list, unsigned int length, const ui
 {
     // Pass comp_public_key to qsort with each Client_data entry, so the
     // comparison function can use it as the base of comparison.
-    VLA(Cmp_data, cmp_list, length);
+    VLA(Onion_Client_Cmp_data, cmp_list, length);
 
     for (uint32_t i = 0; i < length; i++) {
         cmp_list[i].base_public_key = comp_public_key;
         cmp_list[i].entry = list[i];
     }
 
-    qsort(cmp_list, length, sizeof(Cmp_data), cmp_entry);
+    qsort(cmp_list, length, sizeof(Onion_Client_Cmp_data), onion_client_cmp_entry);
 
     for (uint32_t i = 0; i < length; i++) {
         list[i] = cmp_list[i].entry;