44 files changed, 407 insertions, 368 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f2bd5381..f5ee2770 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -219,7 +219,7 @@ add_test(
 
 function(auto_test target)
   if(CHECK_FOUND)
-    add_executable(auto_${target} auto_tests/${target}.c)
+    add_c_executable(auto_${target} auto_tests/${target}.c)
     target_link_modules(auto_${target}
       toxcore
       toxencryptsave
@@ -253,13 +253,13 @@ endif()
 #
 ################################################################################
 
-add_executable(DHT_bootstrap
+add_c_executable(DHT_bootstrap
   other/DHT_bootstrap.c
   other/bootstrap_node_packets.c)
 target_link_modules(DHT_bootstrap toxnetcrypto)
 
 if(LIBCONFIG_FOUND)
-  add_executable(tox-bootstrapd
+  add_c_executable(tox-bootstrapd
     other/bootstrap_daemon/src/command_line_arguments.c
     other/bootstrap_daemon/src/command_line_arguments.h
     other/bootstrap_daemon/src/config.c
@@ -282,7 +282,7 @@ endif()
 ################################################################################
 
 if(NOT WIN32 AND BUILD_TOXAV AND SNDFILE_FOUND AND PORTAUDIO_FOUND AND OPENCV_FOUND)
-  add_executable(av_test testing/av_test.c)
+  add_c_executable(av_test testing/av_test.c)
   target_link_modules(av_test
     toxav
     ${OPENCV_LIBRARIES}
@@ -291,31 +291,31 @@ if(NOT WIN32 AND BUILD_TOXAV AND SNDFILE_FOUND AND PORTAUDIO_FOUND AND OPENCV_FO
 endif()
 
 if(NOT WIN32)
-  add_executable(nTox testing/nTox.c)
+  add_c_executable(nTox testing/nTox.c)
   target_link_modules(nTox toxcore ${NCURSES_LIBRARIES})
 endif()
 
-add_executable(DHT_test testing/DHT_test.c)
+add_c_executable(DHT_test testing/DHT_test.c)
 target_link_modules(DHT_test toxdht)
 
-add_executable(Messenger_test testing/Messenger_test.c)
+add_c_executable(Messenger_test testing/Messenger_test.c)
 target_link_modules(Messenger_test toxmessenger)
 
-add_executable(dns3_test testing/dns3_test.c)
+add_c_executable(dns3_test testing/dns3_test.c)
 target_link_modules(dns3_test toxdns)
 
 if(NOT WIN32)
-  add_executable(tox_sync testing/tox_sync.c)
+  add_c_executable(tox_sync testing/tox_sync.c)
   target_link_modules(tox_sync toxcore)
 endif()
 
 if(UTIL_LIBRARIES)
-  add_executable(tox_shell testing/tox_shell.c)
+  add_c_executable(tox_shell testing/tox_shell.c)
   target_link_modules(tox_shell toxcore ${UTIL_LIBRARIES})
 endif()
 
 if(NOT WIN32)
-  add_executable(irc_syncbot testing/irc_syncbot.c)
+  add_c_executable(irc_syncbot testing/irc_syncbot.c)
   target_link_modules(irc_syncbot toxcore)
 endif()
 
diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index 05f42a6a..1442dcae 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -132,7 +132,7 @@ struct sec_TCP_con {
 
 static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
 {
-    struct sec_TCP_con *sec_c = malloc(sizeof(struct sec_TCP_con));
+    struct sec_TCP_con *sec_c = (struct sec_TCP_con *)malloc(sizeof(struct sec_TCP_con));
     sock_t sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
     struct sockaddr_in6 addr6_loopback = {0};
     addr6_loopback.sin6_family = AF_INET6;
@@ -636,6 +636,8 @@ static bool tcp_oobdata_callback_called;
 static int tcp_oobdata_callback(void *object, const uint8_t *public_key, unsigned int id, const uint8_t *data,
                                 uint16_t length, void *userdata)
 {
+    TCP_Connections *tcp_c = (TCP_Connections *)object;
+
     if (length != 6) {
         return -1;
     }
@@ -644,7 +646,7 @@ static int tcp_oobdata_callback(void *object, const uint8_t *public_key, unsigne
         return -1;
     }
 
-    if (tcp_send_oob_packet(object, id, public_key, data, length) == 0) {
+    if (tcp_send_oob_packet(tcp_c, id, public_key, data, length) == 0) {
         tcp_oobdata_callback_called = 1;
     }
 
diff --git a/auto_tests/dht_test.c b/auto_tests/dht_test.c
index 08044637..7b22e515 100644
--- a/auto_tests/dht_test.c
+++ b/auto_tests/dht_test.c
@@ -528,11 +528,14 @@ static void test_list_main(void)
                 }
 
                 ck_assert_msg(count == 1, "Nodes in search don't know ip of friend. %u %u %u", i, j, count);
-                /*
-                            for (k = 0; k < MAX_SENT_NODES; ++k) {
-                                printf("----gn %u----\n", k);
-                                print_pk(ln[k].public_key);
-                            }*/
+#if 0
+
+                for (k = 0; k < MAX_SENT_NODES; ++k) {
+                    printf("----gn %u----\n", k);
+                    print_pk(ln[k].public_key);
+                }
+
+#endif
                 ++m_count;
             }
         }
@@ -542,7 +545,7 @@ static void test_list_main(void)
                   (NUM_DHT) * (MAX_FRIEND_CLIENTS));
 
     for (i = 0; i < NUM_DHT; ++i) {
-        void *n = dhts[i]->net;
+        Networking_Core *n = dhts[i]->net;
         kill_DHT(dhts[i]);
         kill_networking(n);
     }
@@ -643,7 +646,7 @@ loop_top:
     }
 
     for (i = 0; i < NUM_DHT; ++i) {
-        void *n = dhts[i]->net;
+        Networking_Core *n = dhts[i]->net;
         kill_DHT(dhts[i]);
         kill_networking(n);
     }
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 6e330091..ee9df7a0 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -32,7 +32,7 @@ static void do_onion(Onion *onion)
 static int handled_test_1;
 static int handle_test_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (memcmp(packet, "Install Gentoo", sizeof("Install Gentoo")) != 0) {
         return 1;
@@ -79,7 +79,7 @@ static uint8_t test_3_pub_key[crypto_box_PUBLICKEYBYTES];
 static uint8_t test_3_ping_id[crypto_hash_sha256_BYTES];
 static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length != (1 + crypto_box_NONCEBYTES + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + 1 + crypto_hash_sha256_BYTES +
                    crypto_box_MACBYTES)) {
@@ -111,7 +111,7 @@ static uint8_t nonce[crypto_box_NONCEBYTES];
 static int handled_test_4;
 static int handle_test_4(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length != (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + sizeof("Install gentoo") +
                    crypto_box_MACBYTES)) {
@@ -284,7 +284,7 @@ static Onions *new_onions(uint16_t port)
     IP ip;
     ip_init(&ip, 1);
     ip.ip6.uint8[15] = 1;
-    Onions *on = malloc(sizeof(Onions));
+    Onions *on = (Onions *)malloc(sizeof(Onions));
     DHT *dht = new_DHT(NULL, new_networking(NULL, ip, port));
     on->onion = new_onion(dht);
     on->onion_a = new_onion_announce(dht);
@@ -346,7 +346,7 @@ static uint8_t last_dht_pk[crypto_box_PUBLICKEYBYTES];
 static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key, void *userdata)
 {
     if ((NUM_FIRST == number && !first) || (NUM_LAST == number && !last)) {
-        Onions *on = object;
+        Onions *on = (Onions *)object;
         uint16_t count = 0;
         int ret = DHT_addfriend(on->onion->dht, dht_public_key, &dht_ip_callback, object, number, &count);
         ck_assert_msg(ret == 0, "DHT_addfriend() did not return 0");
diff --git a/auto_tests/tox_test.c b/auto_tests/tox_test.c
index a5745fe8..6ab03365 100644
--- a/auto_tests/tox_test.c
+++ b/auto_tests/tox_test.c
@@ -974,7 +974,7 @@ START_TEST(test_many_clients_tcp)
         tox_callback_friend_request(toxes[i], accept_friend_request);
         uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
         tox_self_get_dht_id(toxes[0], dpk);
-        TOX_ERR_BOOTSTRAP error = 0;
+        TOX_ERR_BOOTSTRAP error = TOX_ERR_BOOTSTRAP_OK;
         ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT, dpk, &error), "add relay error, %i, %i", i,
                       error);
         ck_assert_msg(tox_bootstrap(toxes[i], TOX_LOCALHOST, 33445, dpk, 0), "Bootstrap error");
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index fec2a1de..6f864f07 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -164,10 +164,10 @@ static void *call_thread(void *pd)
 
     c_sleep(30);
 
-    int16_t *PCM = calloc(960, sizeof(int16_t));
-    uint8_t *video_y = calloc(800 * 600, sizeof(uint8_t));
-    uint8_t *video_u = calloc(800 * 600 / 4, sizeof(uint8_t));
-    uint8_t *video_v = calloc(800 * 600 / 4, sizeof(uint8_t));
+    int16_t *PCM = (int16_t *)calloc(960, sizeof(int16_t));
+    uint8_t *video_y = (uint8_t *)calloc(800 * 600, sizeof(uint8_t));
+    uint8_t *video_u = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));
+    uint8_t *video_v = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));
 
     time_t start_time = time(NULL);
 
diff --git a/cmake/ModulePackage.cmake b/cmake/ModulePackage.cmake
index 1e49503a..b963e0de 100644
--- a/cmake/ModulePackage.cmake
+++ b/cmake/ModulePackage.cmake
@@ -1,8 +1,17 @@
 option(ENABLE_SHARED "Build shared (dynamic) libraries for all modules" ON)
 option(ENABLE_STATIC "Build static libraries for all modules" ON)
+option(COMPILE_AS_CXX "Compile all C code as C++ code" OFF)
 
 find_package(PkgConfig REQUIRED)
 
+function(add_c_executable exec)
+  if(COMPILE_AS_CXX)
+    set_source_files_properties(${ARGN} PROPERTIES LANGUAGE CXX)
+  endif()
+
+  add_executable(${exec} ${ARGN})
+endfunction()
+
 function(pkg_use_module mod)
   pkg_search_module(${mod} ${ARGN})
   if(${mod}_FOUND)
@@ -13,6 +22,10 @@ function(pkg_use_module mod)
 endfunction()
 
 function(add_module lib)
+  if(COMPILE_AS_CXX)
+    set_source_files_properties(${ARGN} PROPERTIES LANGUAGE CXX)
+  endif()
+
   if(ENABLE_SHARED)
     add_library(${lib}_shared SHARED ${ARGN})
     set_target_properties(${lib}_shared PROPERTIES OUTPUT_NAME ${lib})
diff --git a/other/bootstrap_daemon/src/config.c b/other/bootstrap_daemon/src/config.c
index 27d1364a..3e102af9 100644
--- a/other/bootstrap_daemon/src/config.c
+++ b/other/bootstrap_daemon/src/config.c
@@ -62,7 +62,7 @@ static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_por
         }
 
         // similar procedure to the one of reading config file below
-        *tcp_relay_ports = malloc(DEFAULT_TCP_RELAY_PORTS_COUNT * sizeof(uint16_t));
+        *tcp_relay_ports = (uint16_t *)malloc(DEFAULT_TCP_RELAY_PORTS_COUNT * sizeof(uint16_t));
 
         for (i = 0; i < DEFAULT_TCP_RELAY_PORTS_COUNT; i ++) {
 
@@ -80,7 +80,7 @@ static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_por
 
         // the loop above skips invalid ports, so we adjust the allocated memory size
         if ((*tcp_relay_port_count) > 0) {
-            *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+            *tcp_relay_ports = (uint16_t *)realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
         } else {
             free(*tcp_relay_ports);
             *tcp_relay_ports = NULL;
@@ -102,7 +102,7 @@ static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_por
         return;
     }
 
-    *tcp_relay_ports = malloc(config_port_count * sizeof(uint16_t));
+    *tcp_relay_ports = (uint16_t *)malloc(config_port_count * sizeof(uint16_t));
 
     int i;
 
@@ -134,7 +134,7 @@ static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_por
 
     // the loop above skips invalid ports, so we adjust the allocated memory size
     if ((*tcp_relay_port_count) > 0) {
-        *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+        *tcp_relay_ports = (uint16_t *)realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
     } else {
         free(*tcp_relay_ports);
         *tcp_relay_ports = NULL;
@@ -182,7 +182,7 @@ int get_general_config(const char *cfg_file_path, char **pid_file_path, char **k
         tmp_pid_file = DEFAULT_PID_FILE_PATH;
     }
 
-    *pid_file_path = malloc(strlen(tmp_pid_file) + 1);
+    *pid_file_path = (char *)malloc(strlen(tmp_pid_file) + 1);
     strcpy(*pid_file_path, tmp_pid_file);
 
     // Get keys file location
@@ -194,7 +194,7 @@ int get_general_config(const char *cfg_file_path, char **pid_file_path, char **k
         tmp_keys_file = DEFAULT_KEYS_FILE_PATH;
     }
 
-    *keys_file_path = malloc(strlen(tmp_keys_file) + 1);
+    *keys_file_path = (char *)malloc(strlen(tmp_keys_file) + 1);
     strcpy(*keys_file_path, tmp_keys_file);
 
     // Get IPv6 option
@@ -254,7 +254,7 @@ int get_general_config(const char *cfg_file_path, char **pid_file_path, char **k
 
         size_t tmp_motd_length = strlen(tmp_motd) + 1;
         size_t motd_length = tmp_motd_length > MAX_MOTD_LENGTH ? MAX_MOTD_LENGTH : tmp_motd_length;
-        *motd = malloc(motd_length);
+        *motd = (char *)malloc(motd_length);
         strncpy(*motd, tmp_motd, motd_length);
         (*motd)[motd_length - 1] = '\0';
     }
@@ -310,7 +310,7 @@ static uint8_t *hex_string_to_bin(const char *hex_string)
     }
 
     size_t len = strlen(hex_string) / 2;
-    uint8_t *ret = malloc(len);
+    uint8_t *ret = (uint8_t *)malloc(len);
 
     const char *pos = hex_string;
     size_t i;
@@ -364,6 +364,8 @@ int bootstrap_from_config(const char *cfg_file_path, DHT *dht, int enable_ipv6)
     int i = 0;
 
     while (config_setting_length(node_list)) {
+        int address_resolved;
+        uint8_t *bs_public_key_bin;
 
         node = config_setting_get_elem(node_list, 0);
 
@@ -403,9 +405,9 @@ int bootstrap_from_config(const char *cfg_file_path, DHT *dht, int enable_ipv6)
             goto next;
         }
 
-        uint8_t *bs_public_key_bin = hex_string_to_bin(bs_public_key);
-        const int address_resolved = DHT_bootstrap_from_address(dht, bs_address, enable_ipv6, htons(bs_port),
-                                     bs_public_key_bin);
+        bs_public_key_bin = hex_string_to_bin(bs_public_key);
+        address_resolved = DHT_bootstrap_from_address(dht, bs_address, enable_ipv6, htons(bs_port),
+                           bs_public_key_bin);
         free(bs_public_key_bin);
 
         if (!address_resolved) {
diff --git a/other/bootstrap_daemon/src/log.c b/other/bootstrap_daemon/src/log.c
index 2eae3286..7632d739 100644
--- a/other/bootstrap_daemon/src/log.c
+++ b/other/bootstrap_daemon/src/log.c
@@ -31,11 +31,12 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-static LOG_BACKEND current_backend = -1;
+#define INVALID_BACKEND (LOG_BACKEND)-1u
+static LOG_BACKEND current_backend = INVALID_BACKEND;
 
 bool open_log(LOG_BACKEND backend)
 {
-    if (current_backend != -1) {
+    if (current_backend != INVALID_BACKEND) {
         return false;
     }
 
@@ -50,7 +51,7 @@ bool open_log(LOG_BACKEND backend)
 
 bool close_log(void)
 {
-    if (current_backend == -1) {
+    if (current_backend == INVALID_BACKEND) {
         return false;
     }
 
@@ -58,7 +59,7 @@ bool close_log(void)
         closelog();
     }
 
-    current_backend = -1;
+    current_backend = INVALID_BACKEND;
 
     return true;
 }
@@ -121,5 +122,5 @@ bool write_log(LOG_LEVEL level, const char *format, ...)
 
     va_end(args);
 
-    return current_backend != -1;
+    return current_backend != INVALID_BACKEND;
 }
diff --git a/other/bootstrap_node_packets.c b/other/bootstrap_node_packets.c
index 8ee26786..8abbb7f2 100644
--- a/other/bootstrap_node_packets.c
+++ b/other/bootstrap_node_packets.c
@@ -40,13 +40,15 @@ static int handle_info_request(void *object, IP_Port source, const uint8_t *pack
         return 1;
     }
 
+    Networking_Core *nc = (Networking_Core *)object;
+
     uint8_t data[1 + sizeof(bootstrap_version) + MAX_MOTD_LENGTH];
     data[0] = BOOTSTRAP_INFO_PACKET_ID;
     memcpy(data + 1, &bootstrap_version, sizeof(bootstrap_version));
     uint16_t len = 1 + sizeof(bootstrap_version) + bootstrap_motd_length;
     memcpy(data + 1 + sizeof(bootstrap_version), bootstrap_motd, bootstrap_motd_length);
 
-    if (sendpacket(object, source, data, len) == len) {
+    if (sendpacket(nc, source, data, len) == len) {
         return 0;
     }
 
diff --git a/testing/Messenger_test.c b/testing/Messenger_test.c
index 8c62068e..3b7715a2 100644
--- a/testing/Messenger_test.c
+++ b/testing/Messenger_test.c
@@ -197,7 +197,7 @@ int main(int argc, char *argv[])
             return 1;
         }
 
-        uint8_t *buffer = malloc(messenger_size(m));
+        uint8_t *buffer = (uint8_t *)malloc(messenger_size(m));
         messenger_save(m, buffer);
         size_t write_result = fwrite(buffer, 1, messenger_size(m), file);
 
diff --git a/testing/av_test.c b/testing/av_test.c
index 28796abb..02dc5f36 100644
--- a/testing/av_test.c
+++ b/testing/av_test.c
@@ -97,7 +97,7 @@ static void *pa_write_thread(void *d)
     /* The purpose of this thread is to make sure Pa_WriteStream will not block
      * toxav_iterate thread
      */
-    CallControl *cc = d;
+    CallControl *cc = (CallControl *)d;
 
     while (Pa_IsStreamActive(adout)) {
         frame *f;
@@ -139,7 +139,7 @@ static void t_toxav_receive_video_frame_cb(ToxAV *av, uint32_t friend_number,
     ustride = abs(ustride);
     vstride = abs(vstride);
 
-    uint16_t *img_data = malloc(height * width * 6);
+    uint16_t *img_data = (uint16_t *)malloc(height * width * 6);
 
     unsigned long int i, j;
 
@@ -173,8 +173,8 @@ static void t_toxav_receive_audio_frame_cb(ToxAV *av, uint32_t friend_number,
         uint32_t sampling_rate,
         void *user_data)
 {
-    CallControl *cc = user_data;
-    frame *f = malloc(sizeof(uint16_t) + sample_count * sizeof(int16_t) * channels);
+    CallControl *cc = (CallControl *)user_data;
+    frame *f = (frame *)malloc(sizeof(uint16_t) + sample_count * sizeof(int16_t) * channels);
     memcpy(f->data, pcm, sample_count * sizeof(int16_t) * channels);
     f->size = sample_count;
 
@@ -297,7 +297,7 @@ static int iterate_tox(Tox *bootstrap, ToxAV *AliceAV, ToxAV *BobAV, void *userd
 }
 static void *iterate_toxav(void *data)
 {
-    struct toxav_thread_data *data_cast = data;
+    struct toxav_thread_data *data_cast = (struct toxav_thread_data *)data;
 #if defined TEST_TRANSFER_V && TEST_TRANSFER_V == 1
     cvNamedWindow(vdout, CV_WINDOW_AUTOSIZE);
 #endif
@@ -335,9 +335,9 @@ static int send_opencv_img(ToxAV *av, uint32_t friend_number, const IplImage *im
 {
     int32_t strides[3] = { 1280, 640, 640 };
     uint8_t *planes[3] = {
-        malloc(img->height * img->width),
-        malloc(img->height * img->width / 4),
-        malloc(img->height * img->width / 4),
+        (uint8_t *)malloc(img->height * img->width),
+        (uint8_t *)malloc(img->height * img->width / 4),
+        (uint8_t *)malloc(img->height * img->width / 4),
     };
 
     int x_chroma_shift = 1;
diff --git a/testing/misc_tools.c b/testing/misc_tools.c
index 8fdc936c..c1292ed8 100644
--- a/testing/misc_tools.c
+++ b/testing/misc_tools.c
@@ -43,7 +43,7 @@ uint8_t *hex_string_to_bin(const char *hex_string)
     // is odd and return error code if it is. we assume strlen is even. if it's not
     // then the last byte just won't be written in 'ret'.
     size_t i, len = strlen(hex_string) / 2;
-    uint8_t *ret = malloc(len);
+    uint8_t *ret = (uint8_t *)malloc(len);
     const char *pos = hex_string;
 
     for (i = 0; i < len; ++i, pos += 2) {
diff --git a/testing/tox_shell.c b/testing/tox_shell.c
index 944b7353..7a6678ce 100644
--- a/testing/tox_shell.c
+++ b/testing/tox_shell.c
@@ -77,7 +77,7 @@ int main(int argc, char *argv[])
         exit(0);
     }
 
-    int *master = malloc(sizeof(int));
+    int *master = (int *)malloc(sizeof(int));
     int ret = forkpty(master, NULL, NULL, NULL);
 
     if (ret == -1) {
diff --git a/toxav/audio.c b/toxav/audio.c
index 59d1554e..f3351ac3 100644
--- a/toxav/audio.c
+++ b/toxav/audio.c
@@ -45,7 +45,7 @@ bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t chan
 
 ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data)
 {
-    ACSession *ac = calloc(sizeof(ACSession), 1);
+    ACSession *ac = (ACSession *)calloc(sizeof(ACSession), 1);
 
     if (!ac) {
         LOGGER_WARNING(log, "Allocation failed! Application might misbehave!");
@@ -104,7 +104,7 @@ ACSession *ac_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_re
 
 DECODER_CLEANUP:
     opus_decoder_destroy(ac->decoder);
-    jbuf_free(ac->j_buf);
+    jbuf_free((struct JitterBuffer *)ac->j_buf);
 BASE_CLEANUP:
     pthread_mutex_destroy(ac->queue_mutex);
     free(ac);
@@ -118,7 +118,7 @@ void ac_kill(ACSession *ac)
 
     opus_encoder_destroy(ac->encoder);
     opus_decoder_destroy(ac->decoder);
-    jbuf_free(ac->j_buf);
+    jbuf_free((struct JitterBuffer *)ac->j_buf);
 
     pthread_mutex_destroy(ac->queue_mutex);
 
@@ -141,7 +141,7 @@ void ac_iterate(ACSession *ac)
 
     pthread_mutex_lock(ac->queue_mutex);
 
-    while ((msg = jbuf_read(ac->j_buf, &rc)) || rc == 2) {
+    while ((msg = jbuf_read((struct JitterBuffer *)ac->j_buf, &rc)) || rc == 2) {
         pthread_mutex_unlock(ac->queue_mutex);
 
         if (rc == 2) {
@@ -204,7 +204,7 @@ int ac_queue_message(void *acp, struct RTPMessage *msg)
         return -1;
     }
 
-    ACSession *ac = acp;
+    ACSession *ac = (ACSession *)acp;
 
     if ((msg->header.pt & 0x7f) == (rtp_TypeAudio + 2) % 128) {
         LOGGER_WARNING(ac->log, "Got dummy!");
@@ -219,7 +219,7 @@ int ac_queue_message(void *acp, struct RTPMessage *msg)
     }
 
     pthread_mutex_lock(ac->queue_mutex);
-    int rc = jbuf_write(ac->log, ac->j_buf, msg);
+    int rc = jbuf_write(ac->log, (struct JitterBuffer *)ac->j_buf, msg);
     pthread_mutex_unlock(ac->queue_mutex);
 
     if (rc == -1) {
@@ -261,13 +261,15 @@ static struct JitterBuffer *jbuf_new(uint32_t capacity)
         size *= 2;
     }
 
-    struct JitterBuffer *q;
+    struct JitterBuffer *q = (struct JitterBuffer *)calloc(sizeof(struct JitterBuffer), 1);
 
-    if (!(q = calloc(sizeof(struct JitterBuffer), 1))) {
+    if (!q) {
         return NULL;
     }
 
-    if (!(q->queue = calloc(sizeof(struct RTPMessage *), size))) {
+    q->queue = (struct RTPMessage **)calloc(sizeof(struct RTPMessage *), size);
+
+    if (!q->queue) {
         free(q);
         return NULL;
     }
diff --git a/toxav/bwcontroller.c b/toxav/bwcontroller.c
index b97135d6..f5578465 100644
--- a/toxav/bwcontroller.c
+++ b/toxav/bwcontroller.c
@@ -68,7 +68,7 @@ BWController *bwc_new(Messenger *m, uint32_t friendnumber,
                       void (*mcb)(BWController *, uint32_t, float, void *),
                       void *udata)
 {
-    BWController *retu = calloc(sizeof(struct BWController_s), 1);
+    BWController *retu = (BWController *)calloc(sizeof(struct BWController_s), 1);
 
     retu->mcb = mcb;
     retu->mcb_data = udata;
@@ -210,5 +210,5 @@ int bwc_handle_data(Messenger *m, uint32_t friendnumber, const uint8_t *data, ui
         return -1;
     }
 
-    return on_update(object, (const struct BWCMessage *)(data + 1));
+    return on_update((BWController *)object, (const struct BWCMessage *)(data + 1));
 }
diff --git a/toxav/group.c b/toxav/group.c
index 66c73572..ddefbcc4 100644
--- a/toxav/group.c
+++ b/toxav/group.c
@@ -55,11 +55,11 @@ static Group_JitterBuffer *create_queue(unsigned int capacity)
 
     Group_JitterBuffer *q;
 
-    if (!(q = calloc(sizeof(Group_JitterBuffer), 1))) {
+    if (!(q = (Group_JitterBuffer *)calloc(sizeof(Group_JitterBuffer), 1))) {
         return NULL;
     }
 
-    if (!(q->queue = calloc(sizeof(Group_Audio_Packet *), size))) {
+    if (!(q->queue = (Group_Audio_Packet **)calloc(sizeof(Group_Audio_Packet *), size))) {
         free(q);
         return NULL;
     }
@@ -233,7 +233,7 @@ static Group_AV *new_group_av(Logger *log, Group_Chats *g_c, void (*audio_callba
         return NULL;
     }
 
-    Group_AV *group_av = calloc(1, sizeof(Group_AV));
+    Group_AV *group_av = (Group_AV *)calloc(1, sizeof(Group_AV));
 
     if (!group_av) {
         return NULL;
@@ -250,8 +250,8 @@ static Group_AV *new_group_av(Logger *log, Group_Chats *g_c, void (*audio_callba
 
 static void group_av_peer_new(void *object, int groupnumber, int friendgroupnumber)
 {
-    Group_AV *group_av = object;
-    Group_Peer_AV *peer_av = calloc(1, sizeof(Group_Peer_AV));
+    Group_AV *group_av = (Group_AV *)object;
+    Group_Peer_AV *peer_av = (Group_Peer_AV *)calloc(1, sizeof(Group_Peer_AV));
 
     if (!peer_av) {
         return;
@@ -263,7 +263,7 @@ static void group_av_peer_new(void *object, int groupnumber, int friendgroupnumb
 
 static void group_av_peer_delete(void *object, int groupnumber, int friendgroupnumber, void *peer_object)
 {
-    Group_Peer_AV *peer_av = peer_object;
+    Group_Peer_AV *peer_av = (Group_Peer_AV *)peer_object;
 
     if (!peer_av) {
         return;
@@ -280,7 +280,7 @@ static void group_av_peer_delete(void *object, int groupnumber, int friendgroupn
 static void group_av_groupchat_delete(void *object, int groupnumber)
 {
     if (object) {
-        kill_group_av(object);
+        kill_group_av((Group_AV *)object);
     }
 }
 
@@ -335,7 +335,7 @@ static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int g
 
         int num_samples = opus_decoder_get_nb_samples(peer_av->audio_decoder, pk->data, pk->length);
 
-        out_audio = malloc(num_samples * peer_av->decoder_channels * sizeof(int16_t));
+        out_audio = (int16_t *)malloc(num_samples * peer_av->decoder_channels * sizeof(int16_t));
 
         if (!out_audio) {
             free(pk);
@@ -359,7 +359,7 @@ static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int g
             return -1;
         }
 
-        out_audio = malloc(peer_av->last_packet_samples * peer_av->decoder_channels * sizeof(int16_t));
+        out_audio = (int16_t *)malloc(peer_av->last_packet_samples * peer_av->decoder_channels * sizeof(int16_t));
 
         if (!out_audio) {
             free(pk);
@@ -394,9 +394,9 @@ static int handle_group_audio_packet(void *object, int groupnumber, int friendgr
         return -1;
     }
 
-    Group_Peer_AV *peer_av = peer_object;
+    Group_Peer_AV *peer_av = (Group_Peer_AV *)peer_object;
 
-    Group_Audio_Packet *pk = calloc(1, sizeof(Group_Audio_Packet) + (length - sizeof(uint16_t)));
+    Group_Audio_Packet *pk = (Group_Audio_Packet *)calloc(1, sizeof(Group_Audio_Packet) + (length - sizeof(uint16_t)));
 
     if (!pk) {
         return -1;
@@ -413,7 +413,7 @@ static int handle_group_audio_packet(void *object, int groupnumber, int friendgr
         return -1;
     }
 
-    while (decode_audio_packet(object, peer_av, groupnumber, friendgroupnumber) == 0) {
+    while (decode_audio_packet((Group_AV *)object, peer_av, groupnumber, friendgroupnumber) == 0) {
         ;
     }
 
@@ -508,7 +508,7 @@ static int send_audio_packet(Group_Chats *g_c, int groupnumber, uint8_t *packet,
         return -1;
     }
 
-    Group_AV *group_av = group_get_object(g_c, groupnumber);
+    Group_AV *group_av = (Group_AV *)group_get_object(g_c, groupnumber);
     uint8_t data[1 + sizeof(uint16_t) + length];
     data[0] = GROUP_AUDIO_PACKET_ID;
 
@@ -532,7 +532,7 @@ static int send_audio_packet(Group_Chats *g_c, int groupnumber, uint8_t *packet,
 int group_send_audio(Group_Chats *g_c, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
                      unsigned int sample_rate)
 {
-    Group_AV *group_av = group_get_object(g_c, groupnumber);
+    Group_AV *group_av = (Group_AV *)group_get_object(g_c, groupnumber);
 
     if (!group_av) {
         return -1;
diff --git a/toxav/msi.c b/toxav/msi.c
index 39086567..f1c40662 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -111,7 +111,7 @@ MSISession *msi_new(Messenger *m)
         return NULL;
     }
 
-    MSISession *retu = calloc(sizeof(MSISession), 1);
+    MSISession *retu = (MSISession *)calloc(sizeof(MSISession), 1);
 
     if (retu == NULL) {
         LOGGER_ERROR(m->log, "Allocation failed! Program might misbehave!");
@@ -337,8 +337,8 @@ int msg_parse_in(Logger *log, MSIMessage *dest, const uint8_t *data, uint16_t le
 #define CHECK_ENUM_HIGH(bytes, enum_high) /* Assumes size == 1 */ \
     if (bytes[2] > enum_high) { LOGGER_ERROR(log, "Failed enum high limit!"); return -1; }
 
-#define SET_UINT8(bytes, header) do { \
-        header.value = bytes[2]; \
+#define SET_UINT8(type, bytes, header) do { \
+        header.value = (type)bytes[2]; \
         header.exists = true; \
         bytes += 3; \
     } while(0)
@@ -367,18 +367,18 @@ int msg_parse_in(Logger *log, MSIMessage *dest, const uint8_t *data, uint16_t le
             case IDRequest:
                 CHECK_SIZE(it, size_constraint, 1);
                 CHECK_ENUM_HIGH(it, requ_pop);
-                SET_UINT8(it, dest->request);
+                SET_UINT8(MSIRequest, it, dest->request);
                 break;
 
             case IDError:
                 CHECK_SIZE(it, size_constraint, 1);
                 CHECK_ENUM_HIGH(it, msi_EUndisclosed);
-                SET_UINT8(it, dest->error);
+                SET_UINT8(MSIError, it, dest->error);
                 break;
 
             case IDCapabilities:
                 CHECK_SIZE(it, size_constraint, 1);
-                SET_UINT8(it, dest->capabilities);
+                SET_UINT8(uint8_t, it, dest->capabilities);
                 break;
 
             default:
@@ -519,7 +519,7 @@ MSICall *new_call(MSISession *session, uint32_t friend_number)
 {
     assert(session);
 
-    MSICall *rc = calloc(sizeof(MSICall), 1);
+    MSICall *rc = (MSICall *)calloc(sizeof(MSICall), 1);
 
     if (rc == NULL) {
         return NULL;
@@ -529,7 +529,7 @@ MSICall *new_call(MSISession *session, uint32_t friend_number)
     rc->friend_number = friend_number;
 
     if (session->calls == NULL) { /* Creating */
-        session->calls = calloc(sizeof(MSICall *), friend_number + 1);
+        session->calls = (MSICall **)calloc(sizeof(MSICall *), friend_number + 1);
 
         if (session->calls == NULL) {
             free(rc);
@@ -538,7 +538,7 @@ MSICall *new_call(MSISession *session, uint32_t friend_number)
 
         session->calls_tail = session->calls_head = friend_number;
     } else if (session->calls_tail < friend_number) { /* Appending */
-        void *tmp = realloc(session->calls, sizeof(MSICall *) * (friend_number + 1));
+        MSICall **tmp = (MSICall **)realloc(session->calls, sizeof(MSICall *) * (friend_number + 1));
 
         if (tmp == NULL) {
             free(rc);
@@ -610,7 +610,7 @@ CLEAR_CONTAINER:
 void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *data)
 {
     (void)m;
-    MSISession *session = data;
+    MSISession *session = (MSISession *)data;
 
     switch (status) {
         case 0: { /* Friend is now offline */
@@ -799,7 +799,7 @@ void handle_msi_packet(Messenger *m, uint32_t friend_number, const uint8_t *data
 {
     LOGGER_DEBUG(m->log, "Got msi message");
 
-    MSISession *session = object;
+    MSISession *session = (MSISession *)object;
     MSIMessage msg;
 
     if (msg_parse_in(m->log, &msg, data, length) == -1) {
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 534efc1a..edab1b1c 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -46,7 +46,7 @@ RTPSession *rtp_new(int payload_type, Messenger *m, uint32_t friendnumber,
     assert(cs);
     assert(m);
 
-    RTPSession *retu = calloc(1, sizeof(RTPSession));
+    RTPSession *retu = (RTPSession *)calloc(1, sizeof(RTPSession));
 
     if (!retu) {
         LOGGER_WARNING(m->log, "Alloc failed! Program might misbehave!");
@@ -219,7 +219,8 @@ static struct RTPMessage *new_message(size_t allocate_len, const uint8_t *data,
 {
     assert(allocate_len >= data_length);
 
-    struct RTPMessage *msg = calloc(sizeof(struct RTPMessage) + (allocate_len - sizeof(struct RTPHeader)), 1);
+    struct RTPMessage *msg = (struct RTPMessage *)calloc(sizeof(struct RTPMessage) + (allocate_len - sizeof(
+                                 struct RTPHeader)), 1);
 
     msg->len = data_length - sizeof(struct RTPHeader);
     memcpy(&msg->header, data, data_length);
@@ -238,7 +239,7 @@ int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data,
     (void) m;
     (void) friendnumber;
 
-    RTPSession *session = object;
+    RTPSession *session = (RTPSession *)object;
 
     data ++;
     length--;
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 1ae914e8..a5314d23 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -146,7 +146,7 @@ ToxAV *toxav_new(Tox *tox, TOXAV_ERR_NEW *error)
         goto END;
     }
 
-    av = calloc(sizeof(ToxAV), 1);
+    av = (ToxAV *)calloc(sizeof(ToxAV), 1);
 
     if (av == NULL) {
         LOGGER_WARNING(m->log, "Allocation failed!");
@@ -289,6 +289,7 @@ bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint
                 TOXAV_ERR_CALL *error)
 {
     TOXAV_ERR_CALL rc = TOXAV_ERR_CALL_OK;
+    ToxAVCall *call;
 
     pthread_mutex_lock(av->mutex);
 
@@ -298,7 +299,7 @@ bool toxav_call(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, uint
         goto END;
     }
 
-    ToxAVCall *call = call_new(av, friend_number, &rc);
+    call = call_new(av, friend_number, &rc);
 
     if (call == NULL) {
         goto END;
@@ -342,6 +343,7 @@ bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, ui
     pthread_mutex_lock(av->mutex);
 
     TOXAV_ERR_ANSWER rc = TOXAV_ERR_ANSWER_OK;
+    ToxAVCall *call;
 
     if (m_friend_exists(av->m, friend_number) == 0) {
         rc = TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND;
@@ -355,7 +357,7 @@ bool toxav_answer(ToxAV *av, uint32_t friend_number, uint32_t audio_bit_rate, ui
         goto END;
     }
 
-    ToxAVCall *call = call_get(av, friend_number);
+    call = call_get(av, friend_number);
 
     if (call == NULL) {
         rc = TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING;
@@ -399,13 +401,14 @@ bool toxav_call_control(ToxAV *av, uint32_t friend_number, TOXAV_CALL_CONTROL co
 {
     pthread_mutex_lock(av->mutex);
     TOXAV_ERR_CALL_CONTROL rc = TOXAV_ERR_CALL_CONTROL_OK;
+    ToxAVCall *call;
 
     if (m_friend_exists(av->m, friend_number) == 0) {
         rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND;
         goto END;
     }
 
-    ToxAVCall *call = call_get(av, friend_number);
+    call = call_get(av, friend_number);
 
     if (call == NULL || (!call->active && control != TOXAV_CALL_CONTROL_CANCEL)) {
         rc = TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL;
@@ -815,8 +818,8 @@ bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, u
         memcpy(img.planes[VPX_PLANE_U], u, (width / 2) * (height / 2));
         memcpy(img.planes[VPX_PLANE_V], v, (width / 2) * (height / 2));
 
-        int vrc = vpx_codec_encode(call->video.second->encoder, &img,
-                                   call->video.second->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
+        vpx_codec_err_t vrc = vpx_codec_encode(call->video.second->encoder, &img,
+                                               call->video.second->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
 
         vpx_img_free(&img);
 
@@ -836,7 +839,7 @@ bool toxav_video_send_frame(ToxAV *av, uint32_t friend_number, uint16_t width, u
 
         while ((pkt = vpx_codec_get_cx_data(call->video.second->encoder, &iter))) {
             if (pkt->kind == VPX_CODEC_CX_FRAME_PKT &&
-                    rtp_send_data(call->video.first, pkt->data.frame.buf, pkt->data.frame.sz) < 0) {
+                    rtp_send_data(call->video.first, (const uint8_t *)pkt->data.frame.buf, pkt->data.frame.sz) < 0) {
 
                 pthread_mutex_unlock(call->mutex_video);
                 LOGGER_WARNING(av->m->log, "Could not send video frame: %s\n", strerror(errno));
@@ -886,7 +889,7 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
      * The application may choose to disable video totally if the stream is too bad.
      */
 
-    ToxAVCall *call = user_data;
+    ToxAVCall *call = (ToxAVCall *)user_data;
     assert(call);
 
     LOGGER_DEBUG(call->av->m->log, "Reported loss of %f%%", loss * 100);
@@ -917,7 +920,7 @@ void callback_bwc(BWController *bwc, uint32_t friend_number, float loss, void *u
 }
 int callback_invite(void *toxav_inst, MSICall *call)
 {
-    ToxAV *toxav = toxav_inst;
+    ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
     ToxAVCall *av_call = call_new(toxav, call->friend_number, NULL);
@@ -945,7 +948,7 @@ int callback_invite(void *toxav_inst, MSICall *call)
 }
 int callback_start(void *toxav_inst, MSICall *call)
 {
-    ToxAV *toxav = toxav_inst;
+    ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
     ToxAVCall *av_call = call_get(toxav, call->friend_number);
@@ -973,14 +976,14 @@ int callback_start(void *toxav_inst, MSICall *call)
 }
 int callback_end(void *toxav_inst, MSICall *call)
 {
-    ToxAV *toxav = toxav_inst;
+    ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
     invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_FINISHED);
 
     if (call->av_call) {
-        call_kill_transmission(call->av_call);
-        call_remove(call->av_call);
+        call_kill_transmission((ToxAVCall *)call->av_call);
+        call_remove((ToxAVCall *)call->av_call);
     }
 
     pthread_mutex_unlock(toxav->mutex);
@@ -988,14 +991,14 @@ int callback_end(void *toxav_inst, MSICall *call)
 }
 int callback_error(void *toxav_inst, MSICall *call)
 {
-    ToxAV *toxav = toxav_inst;
+    ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
     invoke_call_state_callback(toxav, call->friend_number, TOXAV_FRIEND_CALL_STATE_ERROR);
 
     if (call->av_call) {
-        call_kill_transmission(call->av_call);
-        call_remove(call->av_call);
+        call_kill_transmission((ToxAVCall *)call->av_call);
+        call_remove((ToxAVCall *)call->av_call);
     }
 
     pthread_mutex_unlock(toxav->mutex);
@@ -1003,7 +1006,7 @@ int callback_error(void *toxav_inst, MSICall *call)
 }
 int callback_capabilites(void *toxav_inst, MSICall *call)
 {
-    ToxAV *toxav = toxav_inst;
+    ToxAV *toxav = (ToxAV *)toxav_inst;
     pthread_mutex_lock(toxav->mutex);
 
     if (call->peer_capabilities & msi_CapSAudio) {
@@ -1068,7 +1071,7 @@ ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
     }
 
 
-    call = calloc(sizeof(ToxAVCall), 1);
+    call = (ToxAVCall *)calloc(sizeof(ToxAVCall), 1);
 
     if (call == NULL) {
         rc = TOXAV_ERR_CALL_MALLOC;
@@ -1079,7 +1082,7 @@ ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
     call->friend_number = friend_number;
 
     if (av->calls == NULL) { /* Creating */
-        av->calls = calloc(sizeof(ToxAVCall *), friend_number + 1);
+        av->calls = (ToxAVCall **)calloc(sizeof(ToxAVCall *), friend_number + 1);
 
         if (av->calls == NULL) {
             free(call);
@@ -1090,7 +1093,7 @@ ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, TOXAV_ERR_CALL *error)
 
         av->calls_tail = av->calls_head = friend_number;
     } else if (av->calls_tail < friend_number) { /* Appending */
-        void *tmp = realloc(av->calls, sizeof(ToxAVCall *) * (friend_number + 1));
+        ToxAVCall **tmp = (ToxAVCall **)realloc(av->calls, sizeof(ToxAVCall *) * (friend_number + 1));
 
         if (tmp == NULL) {
             free(call);
diff --git a/toxav/toxav_old.c b/toxav/toxav_old.c
index a344455d..767fac9c 100644
--- a/toxav/toxav_old.c
+++ b/toxav/toxav_old.c
@@ -40,8 +40,9 @@ int toxav_add_av_groupchat(struct Tox *tox, void (*audio_callback)(void *, int,
                            uint8_t, unsigned int, void *), void *userdata)
 {
     Messenger *m = (Messenger *)tox;
-    return add_av_groupchat(m->log, m->group_chat_object, (void (*)(Messenger *, int, int, const int16_t *, unsigned int,
-                            uint8_t, unsigned int, void *))audio_callback, userdata);
+    return add_av_groupchat(m->log, (Group_Chats *)m->group_chat_object,
+                            (void (*)(Messenger *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *))audio_callback,
+                            userdata);
 }
 
 /* Join a AV group (you need to have been invited first.)
@@ -59,7 +60,8 @@ int toxav_join_av_groupchat(struct Tox *tox, int32_t friendnumber, const uint8_t
                             void *userdata)
 {
     Messenger *m = (Messenger *)tox;
-    return join_av_groupchat(m->log, m->group_chat_object, friendnumber, data, length, (void (*)(Messenger *, int, int,
+    return join_av_groupchat(m->log, (Group_Chats *)m->group_chat_object, friendnumber, data, length, (void (*)(Messenger *,
+                             int, int,
                              const int16_t *, unsigned int, uint8_t, unsigned int, void *))audio_callback, userdata);
 }
 
@@ -80,5 +82,5 @@ int toxav_group_send_audio(struct Tox *tox, int groupnumber, const int16_t *pcm,
                            unsigned int sample_rate)
 {
     Messenger *m = (Messenger *)tox;
-    return group_send_audio(m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
+    return group_send_audio((Group_Chats *)m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
 }
diff --git a/toxav/video.c b/toxav/video.c
index de028c7c..5bb3b8ae 100644
--- a/toxav/video.c
+++ b/toxav/video.c
@@ -39,7 +39,8 @@
 
 VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data)
 {
-    VCSession *vc = calloc(sizeof(VCSession), 1);
+    VCSession *vc = (VCSession *)calloc(sizeof(VCSession), 1);
+    vpx_codec_err_t rc;
 
     if (!vc) {
         LOGGER_WARNING(log, "Allocation failed! Application might misbehave!");
@@ -56,7 +57,7 @@ VCSession *vc_new(Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_re
         goto BASE_CLEANUP;
     }
 
-    int rc = vpx_codec_dec_init(vc->decoder, VIDEO_CODEC_DECODER_INTERFACE, NULL, 0);
+    rc = vpx_codec_dec_init(vc->decoder, VIDEO_CODEC_DECODER_INTERFACE, NULL, 0);
 
     if (rc != VPX_CODEC_OK) {
         LOGGER_ERROR(log, "Init video_decoder failed: %s", vpx_codec_err_to_string(rc));
@@ -116,7 +117,7 @@ BASE_CLEANUP_1:
     vpx_codec_destroy(vc->decoder);
 BASE_CLEANUP:
     pthread_mutex_destroy(vc->queue_mutex);
-    rb_kill(vc->vbuf_raw);
+    rb_kill((RingBuffer *)vc->vbuf_raw);
     free(vc);
     return NULL;
 }
@@ -131,11 +132,11 @@ void vc_kill(VCSession *vc)
 
     void *p;
 
-    while (rb_read(vc->vbuf_raw, &p)) {
+    while (rb_read((RingBuffer *)vc->vbuf_raw, &p)) {
         free(p);
     }
 
-    rb_kill(vc->vbuf_raw);
+    rb_kill((RingBuffer *)vc->vbuf_raw);
 
     pthread_mutex_destroy(vc->queue_mutex);
 
@@ -150,11 +151,11 @@ void vc_iterate(VCSession *vc)
 
     struct RTPMessage *p;
 
-    int rc;
+    vpx_codec_err_t rc;
 
     pthread_mutex_lock(vc->queue_mutex);
 
-    if (rb_read(vc->vbuf_raw, (void **)&p)) {
+    if (rb_read((RingBuffer *)vc->vbuf_raw, (void **)&p)) {
         pthread_mutex_unlock(vc->queue_mutex);
 
         rc = vpx_codec_decode(vc->decoder, p->data, p->len, NULL, MAX_DECODE_TIME_US);
@@ -192,7 +193,7 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
         return -1;
     }
 
-    VCSession *vc = vcp;
+    VCSession *vc = (VCSession *)vcp;
 
     if (msg->header.pt == (rtp_TypeVideo + 2) % 128) {
         LOGGER_WARNING(vc->log, "Got dummy!");
@@ -207,7 +208,7 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
     }
 
     pthread_mutex_lock(vc->queue_mutex);
-    free(rb_write(vc->vbuf_raw, msg));
+    free(rb_write((RingBuffer *)vc->vbuf_raw, msg));
     {
         /* Calculate time took for peer to send us this frame */
         uint32_t t_lcfd = current_time_monotonic() - vc->linfts;
@@ -225,7 +226,7 @@ int vc_reconfigure_encoder(VCSession *vc, uint32_t bit_rate, uint16_t width, uin
     }
 
     vpx_codec_enc_cfg_t cfg = *vc->encoder->config.enc;
-    int rc;
+    vpx_codec_err_t rc;
 
     if (cfg.rc_target_bitrate == bit_rate && cfg.g_w == width && cfg.g_h == height) {
         return 0; /* Nothing changed */
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 2f078314..ed03fac8 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -985,24 +985,24 @@ static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_k
     for (i = 0; i < dht->num_friends; ++i) {
         bool store_ok = 0;
 
-        DHT_Friend *friend = &dht->friends_list[i];
+        DHT_Friend *dht_friend = &dht->friends_list[i];
 
-        if (store_node_ok(&friend->client_list[1], public_key, friend->public_key)) {
+        if (store_node_ok(&dht_friend->client_list[1], public_key, dht_friend->public_key)) {
             store_ok = 1;
         }
 
-        if (store_node_ok(&friend->client_list[0], public_key, friend->public_key)) {
+        if (store_node_ok(&dht_friend->client_list[0], public_key, dht_friend->public_key)) {
             store_ok = 1;
         }
 
-        if (store_ok && !client_in_nodelist(friend->to_bootstrap, friend->num_to_bootstrap, public_key)
-                && !is_pk_in_client_list(friend->client_list, MAX_FRIEND_CLIENTS, public_key, ip_port)) {
-            if (friend->num_to_bootstrap < MAX_SENT_NODES) {
-                memcpy(friend->to_bootstrap[friend->num_to_bootstrap].public_key, public_key, crypto_box_PUBLICKEYBYTES);
-                friend->to_bootstrap[friend->num_to_bootstrap].ip_port = ip_port;
-                ++friend->num_to_bootstrap;
+        if (store_ok && !client_in_nodelist(dht_friend->to_bootstrap, dht_friend->num_to_bootstrap, public_key)
+                && !is_pk_in_client_list(dht_friend->client_list, MAX_FRIEND_CLIENTS, public_key, ip_port)) {
+            if (dht_friend->num_to_bootstrap < MAX_SENT_NODES) {
+                memcpy(dht_friend->to_bootstrap[dht_friend->num_to_bootstrap].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+                dht_friend->to_bootstrap[dht_friend->num_to_bootstrap].ip_port = ip_port;
+                ++dht_friend->num_to_bootstrap;
             } else {
-                add_to_list(friend->to_bootstrap, MAX_SENT_NODES, public_key, ip_port, friend->public_key);
+                add_to_list(dht_friend->to_bootstrap, MAX_SENT_NODES, public_key, ip_port, dht_friend->public_key);
             }
 
             ret = 1;
@@ -1046,19 +1046,19 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
             if (replace_all(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
                             public_key, ip_port, dht->friends_list[i].public_key)) {
 
-                DHT_Friend *friend = &dht->friends_list[i];
+                DHT_Friend *dht_friend = &dht->friends_list[i];
 
-                if (public_key_cmp(public_key, friend->public_key) == 0) {
-                    friend_foundip = friend;
+                if (public_key_cmp(public_key, dht_friend->public_key) == 0) {
+                    friend_foundip = dht_friend;
                 }
 
                 used++;
             }
         } else {
-            DHT_Friend *friend = &dht->friends_list[i];
+            DHT_Friend *dht_friend = &dht->friends_list[i];
 
-            if (public_key_cmp(public_key, friend->public_key) == 0) {
-                friend_foundip = friend;
+            if (public_key_cmp(public_key, dht_friend->public_key) == 0) {
+                friend_foundip = dht_friend;
             }
 
             used++;
@@ -1282,7 +1282,7 @@ static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet,
         return 1;
     }
 
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
 
     /* Check if packet is from ourself. */
     if (id_equal(packet + 1, dht->self_public_key)) {
@@ -1341,7 +1341,7 @@ static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto,
 static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *packet, uint16_t length,
                                  Node_format *plain_nodes, uint16_t size_plain_nodes, uint32_t *num_nodes_out)
 {
-    DHT *dht = object;
+    DHT *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 */
@@ -1411,7 +1411,7 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa
 
 static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
     Node_format plain_nodes[MAX_SENT_NODES];
     uint32_t num_nodes;
 
@@ -1447,17 +1447,17 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
     uint16_t lock_num;
 
     if (friend_num != -1) { /* Is friend already in DHT? */
-        DHT_Friend *friend = &dht->friends_list[friend_num];
+        DHT_Friend *dht_friend = &dht->friends_list[friend_num];
 
-        if (friend->lock_count == DHT_FRIEND_MAX_LOCKS) {
+        if (dht_friend->lock_count == DHT_FRIEND_MAX_LOCKS) {
             return -1;
         }
 
-        lock_num = friend->lock_count;
-        ++friend->lock_count;
-        friend->callbacks[lock_num].ip_callback = ip_callback;
-        friend->callbacks[lock_num].data = data;
-        friend->callbacks[lock_num].number = number;
+        lock_num = dht_friend->lock_count;
+        ++dht_friend->lock_count;
+        dht_friend->callbacks[lock_num].ip_callback = ip_callback;
+        dht_friend->callbacks[lock_num].data = data;
+        dht_friend->callbacks[lock_num].number = number;
 
         if (lock_count) {
             *lock_count = lock_num + 1;
@@ -1466,32 +1466,31 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
         return 0;
     }
 
-    DHT_Friend *temp;
-    temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
+    DHT_Friend *temp = (DHT_Friend *)realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
 
     if (temp == NULL) {
         return -1;
     }
 
     dht->friends_list = temp;
-    DHT_Friend *friend = &dht->friends_list[dht->num_friends];
-    memset(friend, 0, sizeof(DHT_Friend));
-    memcpy(friend->public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    DHT_Friend *dht_friend = &dht->friends_list[dht->num_friends];
+    memset(dht_friend, 0, sizeof(DHT_Friend));
+    memcpy(dht_friend->public_key, public_key, crypto_box_PUBLICKEYBYTES);
 
-    friend->nat.NATping_id = random_64b();
+    dht_friend->nat.NATping_id = random_64b();
     ++dht->num_friends;
 
-    lock_num = friend->lock_count;
-    ++friend->lock_count;
-    friend->callbacks[lock_num].ip_callback = ip_callback;
-    friend->callbacks[lock_num].data = data;
-    friend->callbacks[lock_num].number = number;
+    lock_num = dht_friend->lock_count;
+    ++dht_friend->lock_count;
+    dht_friend->callbacks[lock_num].ip_callback = ip_callback;
+    dht_friend->callbacks[lock_num].data = data;
+    dht_friend->callbacks[lock_num].number = number;
 
     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);
+    dht_friend->num_to_bootstrap = get_close_nodes(dht, dht_friend->public_key, dht_friend->to_bootstrap, 0, 1, 0);
 
     return 0;
 }
@@ -1504,19 +1503,17 @@ int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count)
         return -1;
     }
 
-    DHT_Friend *friend = &dht->friends_list[friend_num];
-    --friend->lock_count;
+    DHT_Friend *dht_friend = &dht->friends_list[friend_num];
+    --dht_friend->lock_count;
 
-    if (friend->lock_count && lock_count) { /* DHT friend is still in use.*/
+    if (dht_friend->lock_count && lock_count) { /* DHT friend is still in use.*/
         --lock_count;
-        friend->callbacks[lock_count].ip_callback = NULL;
-        friend->callbacks[lock_count].data = NULL;
-        friend->callbacks[lock_count].number = 0;
+        dht_friend->callbacks[lock_count].ip_callback = NULL;
+        dht_friend->callbacks[lock_count].data = NULL;
+        dht_friend->callbacks[lock_count].number = 0;
         return 0;
     }
 
-    DHT_Friend *temp;
-
     --dht->num_friends;
 
     if (dht->num_friends != friend_num) {
@@ -1531,7 +1528,7 @@ int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count)
         return 0;
     }
 
-    temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
+    DHT_Friend *temp = (DHT_Friend *)realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
 
     if (temp == NULL) {
         return -1;
@@ -1650,16 +1647,18 @@ static void do_DHT_friends(DHT *dht)
     unsigned int i, j;
 
     for (i = 0; i < dht->num_friends; ++i) {
-        DHT_Friend *friend = &dht->friends_list[i];
+        DHT_Friend *dht_friend = &dht->friends_list[i];
 
-        for (j = 0; j < friend->num_to_bootstrap; ++j) {
-            getnodes(dht, friend->to_bootstrap[j].ip_port, friend->to_bootstrap[j].public_key, friend->public_key, NULL);
+        for (j = 0; j < dht_friend->num_to_bootstrap; ++j) {
+            getnodes(dht, dht_friend->to_bootstrap[j].ip_port, dht_friend->to_bootstrap[j].public_key, dht_friend->public_key,
+                     NULL);
         }
 
-        friend->num_to_bootstrap = 0;
+        dht_friend->num_to_bootstrap = 0;
 
-        do_ping_and_sendnode_requests(dht, &friend->lastgetnode, friend->public_key, friend->client_list, MAX_FRIEND_CLIENTS,
-                                      &friend->bootstrap_times, 1);
+        do_ping_and_sendnode_requests(dht, &dht_friend->lastgetnode, dht_friend->public_key, dht_friend->client_list,
+                                      MAX_FRIEND_CLIENTS,
+                                      &dht_friend->bootstrap_times, 1);
     }
 }
 
@@ -1791,7 +1790,7 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
         return -1;
     }
 
-    DHT_Friend *friend = &dht->friends_list[friend_num];
+    DHT_Friend *dht_friend = &dht->friends_list[friend_num];
     Client_data *client;
     IP_Port ipv4s[MAX_FRIEND_CLIENTS];
     int num_ipv4s = 0;
@@ -1800,7 +1799,7 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
     int i;
 
     for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-        client = &(friend->client_list[i]);
+        client = &(dht_friend->client_list[i]);
 
         /* If ip is not zero and node is good. */
         if (ip_isset(&client->assoc4.ret_ip_port.ip) && !is_timeout(client->assoc4.ret_timestamp, BAD_NODE_TIMEOUT)) {
@@ -1813,7 +1812,7 @@ 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 (id_equal(client->public_key, dht_friend->public_key)) {
             if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)
                     || !is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT)) {
                 return 0; /* direct connectivity */
@@ -1877,7 +1876,7 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
         return 0; /* Reason for that? */
     }
 
-    DHT_Friend *friend = &dht->friends_list[num];
+    DHT_Friend *dht_friend = &dht->friends_list[num];
     Client_data *client;
 
     /* extra legwork, because having the outside allocating the space for us
@@ -1890,7 +1889,7 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
                 continue;
             }
 
-            client = &friend->client_list[i];
+            client = &dht_friend->client_list[i];
             IPPTsPng *assoc = NULL;
 
             if (!a) {
@@ -1927,7 +1926,7 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
         return 0;
     }
 
-    DHT_Friend *friend = &dht->friends_list[num];
+    DHT_Friend *dht_friend = &dht->friends_list[num];
     Client_data *client;
 
     IP_Port ip_list[MAX_FRIEND_CLIENTS * 2];
@@ -1940,7 +1939,7 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
 
     for (a = 0; a < 2; a++) {
         for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-            client = &friend->client_list[i];
+            client = &dht_friend->client_list[i];
             IPPTsPng *assoc = NULL;
 
             if (!a) {
@@ -2011,7 +2010,7 @@ static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pu
         return 1;
     }
 
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
     uint64_t ping_id;
     memcpy(&ping_id, packet + 1, sizeof(uint64_t));
 
@@ -2021,19 +2020,19 @@ static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pu
         return 1;
     }
 
-    DHT_Friend *friend = &dht->friends_list[friendnumber];
+    DHT_Friend *dht_friend = &dht->friends_list[friendnumber];
 
     if (packet[0] == NAT_PING_REQUEST) {
         /* 1 is reply */
         send_NATping(dht, source_pubkey, ping_id, NAT_PING_RESPONSE);
-        friend->nat.recvNATping_timestamp = unix_time();
+        dht_friend->nat.recvNATping_timestamp = unix_time();
         return 0;
     }
 
     if (packet[0] == NAT_PING_RESPONSE) {
-        if (friend->nat.NATping_id == ping_id) {
-            friend->nat.NATping_id = random_64b();
-            friend->nat.hole_punching = 1;
+        if (dht_friend->nat.NATping_id == ping_id) {
+            dht_friend->nat.NATping_id = random_64b();
+            dht_friend->nat.hole_punching = 1;
             return 0;
         }
     }
@@ -2308,7 +2307,7 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 static int handle_hardening(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
                             uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
 
     if (length < 2) {
         return 1;
@@ -2547,7 +2546,7 @@ void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_c
 
 static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
 
     if (packet[0] == NET_PACKET_CRYPTO) {
         if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
@@ -2595,7 +2594,7 @@ DHT *new_DHT(Logger *log, Networking_Core *net)
         return NULL;
     }
 
-    DHT *dht = calloc(1, sizeof(DHT));
+    DHT *dht = (DHT *)calloc(1, sizeof(DHT));
 
     if (dht == NULL) {
         return NULL;
@@ -2813,7 +2812,7 @@ int DHT_connect_after_load(DHT *dht)
 
 static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
 {
-    DHT *dht = outer;
+    DHT *dht = (DHT *)outer;
 
     switch (type) {
         case DHT_STATE_TYPE_NODES:
@@ -2824,7 +2823,7 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
             {
                 free(dht->loaded_nodes_list);
                 // Copy to loaded_clients_list
-                dht->loaded_nodes_list = calloc(MAX_SAVED_DHT_NODES, sizeof(Node_format));
+                dht->loaded_nodes_list = (Node_format *)calloc(MAX_SAVED_DHT_NODES, sizeof(Node_format));
 
                 int num = unpack_nodes(dht->loaded_nodes_list, MAX_SAVED_DHT_NODES, NULL, data, length, 0);
 
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index 1c28756b..d2bfb4e1 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -323,7 +323,7 @@ int LAN_ip(IP ip)
 
 static int handle_LANdiscovery(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *dht = (DHT *)object;
 
     if (LAN_ip(source.ip) == -1) {
         return 1;
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 8969f83d..2355eb89 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -65,7 +65,7 @@ static int realloc_friendlist(Messenger *m, uint32_t num)
         return 0;
     }
 
-    Friend *newfriendlist = realloc(m->friendlist, num * sizeof(Friend));
+    Friend *newfriendlist = (Friend *)realloc(m->friendlist, num * sizeof(Friend));
 
     if (newfriendlist == NULL) {
         return -1;
@@ -337,23 +337,23 @@ static int add_receipt(Messenger *m, int32_t friendnumber, uint32_t packet_num,
         return -1;
     }
 
-    struct Receipts *new = calloc(1, sizeof(struct Receipts));
+    struct Receipts *new_receipts = (struct Receipts *)calloc(1, sizeof(struct Receipts));
 
-    if (!new) {
+    if (!new_receipts) {
         return -1;
     }
 
-    new->packet_num = packet_num;
-    new->msg_id = msg_id;
+    new_receipts->packet_num = packet_num;
+    new_receipts->msg_id = msg_id;
 
     if (!m->friendlist[friendnumber].receipts_start) {
-        m->friendlist[friendnumber].receipts_start = new;
+        m->friendlist[friendnumber].receipts_start = new_receipts;
     } else {
-        m->friendlist[friendnumber].receipts_end->next = new;
+        m->friendlist[friendnumber].receipts_end->next = new_receipts;
     }
 
-    m->friendlist[friendnumber].receipts_end = new;
-    new->next = NULL;
+    m->friendlist[friendnumber].receipts_end = new_receipts;
+    new_receipts->next = NULL;
     return 0;
 }
 /*
@@ -676,7 +676,7 @@ int m_set_userstatus(Messenger *m, uint8_t status)
         return 0;
     }
 
-    m->userstatus = status;
+    m->userstatus = (USERSTATUS)status;
     uint32_t i;
 
     for (i = 0; i < m->numfriends; ++i) {
@@ -823,7 +823,7 @@ static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, co
 
 static void set_friend_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status)
 {
-    m->friendlist[friendnumber].userstatus = status;
+    m->friendlist[friendnumber].userstatus = (USERSTATUS)status;
 }
 
 static void set_friend_typing(const Messenger *m, int32_t friendnumber, uint8_t is_typing)
@@ -1731,7 +1731,7 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
 static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
                                       void *userdata)
 {
-    Messenger *m = object;
+    Messenger *m = (Messenger *)object;
 
     if (friend_not_valid(m, friend_num)) {
         return 1;
@@ -1815,7 +1815,7 @@ int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uin
 static int handle_custom_lossless_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
         void *userdata)
 {
-    Messenger *m = object;
+    Messenger *m = (Messenger *)object;
 
     if (friend_not_valid(m, friend_num)) {
         return -1;
@@ -1875,7 +1875,7 @@ int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const
 /* Function to filter out some friend requests*/
 static int friend_already_added(const uint8_t *real_pk, void *data)
 {
-    const Messenger *m = data;
+    const Messenger *m = (const Messenger *)data;
 
     if (getfriend_id(m, real_pk) == -1) {
         return 0;
@@ -1887,7 +1887,7 @@ static int friend_already_added(const uint8_t *real_pk, void *data)
 /* Run this at startup. */
 Messenger *new_messenger(Logger *log, Messenger_Options *options, unsigned int *error)
 {
-    Messenger *m = calloc(1, sizeof(Messenger));
+    Messenger *m = (Messenger *)calloc(1, sizeof(Messenger));
 
     if (error) {
         *error = MESSENGER_ERROR_OTHER;
@@ -1903,7 +1903,7 @@ Messenger *new_messenger(Logger *log, Messenger_Options *options, unsigned int *
 
     if (options->udp_disabled) {
         /* this is the easiest way to completely disable UDP without changing too much code. */
-        m->net = calloc(1, sizeof(Networking_Core));
+        m->net = (Networking_Core *)calloc(1, sizeof(Networking_Core));
     } else {
         IP ip;
         ip_init(&ip, options->ipv6enabled);
@@ -2036,7 +2036,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)
 {
-    Messenger *m = object;
+    Messenger *m = (Messenger *)object;
 
     if (status) { /* Went online. */
         send_online_packet(m, i);
@@ -2055,7 +2055,7 @@ static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len,
         return -1;
     }
 
-    Messenger *m = object;
+    Messenger *m = (Messenger *)object;
     uint8_t packet_id = temp[0];
     const uint8_t *data = temp + 1;
     uint32_t data_length = len - 1;
@@ -2123,7 +2123,7 @@ static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len,
                 break;
             }
 
-            USERSTATUS status = data[0];
+            USERSTATUS status = (USERSTATUS)data[0];
 
             if (status >= USERSTATUS_INVALID) {
                 break;
@@ -2529,32 +2529,32 @@ void do_messenger(Messenger *m, void *userdata)
         }
 
 
-        uint32_t friend, dhtfriend;
+        uint32_t friend_idx, dhtfriend;
 
         /* dht contains additional "friends" (requests) */
         uint32_t num_dhtfriends = m->dht->num_friends;
         int32_t m2dht[num_dhtfriends];
         int32_t dht2m[num_dhtfriends];
 
-        for (friend = 0; friend < num_dhtfriends; friend++) {
-            m2dht[friend] = -1;
-            dht2m[friend] = -1;
+        for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) {
+            m2dht[friend_idx] = -1;
+            dht2m[friend_idx] = -1;
 
-            if (friend >= m->numfriends) {
+            if (friend_idx >= m->numfriends) {
                 continue;
             }
 
             for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++) {
-                if (id_equal(m->friendlist[friend].real_pk, m->dht->friends_list[dhtfriend].public_key)) {
-                    m2dht[friend] = dhtfriend;
+                if (id_equal(m->friendlist[friend_idx].real_pk, m->dht->friends_list[dhtfriend].public_key)) {
+                    m2dht[friend_idx] = dhtfriend;
                     break;
                 }
             }
         }
 
-        for (friend = 0; friend < num_dhtfriends; friend++) {
-            if (m2dht[friend] >= 0) {
-                dht2m[m2dht[friend]] = friend;
+        for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) {
+            if (m2dht[friend_idx] >= 0) {
+                dht2m[m2dht[friend_idx]] = friend_idx;
             }
         }
 
@@ -2565,21 +2565,21 @@ void do_messenger(Messenger *m, void *userdata)
         Friend *msgfptr;
         DHT_Friend *dhtfptr;
 
-        for (friend = 0; friend < num_dhtfriends; friend++) {
-            if (dht2m[friend] >= 0) {
-                msgfptr = &m->friendlist[dht2m[friend]];
+        for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) {
+            if (dht2m[friend_idx] >= 0) {
+                msgfptr = &m->friendlist[dht2m[friend_idx]];
             } else {
                 msgfptr = NULL;
             }
 
-            dhtfptr = &m->dht->friends_list[friend];
+            dhtfptr = &m->dht->friends_list[friend_idx];
 
             if (msgfptr) {
                 LOGGER_TRACE(m->log, "F[%2u:%2u] <%s> %s",
-                             dht2m[friend], friend, msgfptr->name,
+                             dht2m[friend_idx], friend_idx, msgfptr->name,
                              ID2String(msgfptr->real_pk));
             } else {
-                LOGGER_TRACE(m->log, "F[--:%2u] %s", friend, ID2String(dhtfptr->public_key));
+                LOGGER_TRACE(m->log, "F[--:%2u] %s", friend_idx, ID2String(dhtfptr->public_key));
             }
 
             for (client = 0; client < MAX_FRIEND_CLIENTS; client++) {
@@ -2596,7 +2596,7 @@ void do_messenger(Messenger *m, void *userdata)
                         }
 
                         LOGGER_TRACE(m->log, "F[%2u] => C[%2u] %s:%u [%3u] %s",
-                                     friend, client, ip_ntoa(&assoc->ip_port.ip),
+                                     friend_idx, client, ip_ntoa(&assoc->ip_port.ip),
                                      ntohs(assoc->ip_port.port), last_pinged,
                                      ID2String(cptr->public_key));
                     }
@@ -2836,7 +2836,7 @@ void messenger_save(const Messenger *m, uint8_t *data)
 
 static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
 {
-    Messenger *m = outer;
+    Messenger *m = (Messenger *)outer;
 
     switch (type) {
         case MESSENGER_STATE_TYPE_NOSPAMKEYS:
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index 396bb9e3..ba8aeabe 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -332,25 +332,25 @@ static int send_pending_data(TCP_Client_Connection *con)
  */
 static bool add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
 {
-    TCP_Priority_List *p = con->priority_queue_end, *new;
-    new = malloc(sizeof(TCP_Priority_List) + size);
+    TCP_Priority_List *p = con->priority_queue_end;
+    TCP_Priority_List *new_list = (TCP_Priority_List *)malloc(sizeof(TCP_Priority_List) + size);
 
-    if (!new) {
+    if (!new_list) {
         return 0;
     }
 
-    new->next = NULL;
-    new->size = size;
-    new->sent = sent;
-    memcpy(new->data, packet, size);
+    new_list->next = NULL;
+    new_list->size = size;
+    new_list->sent = sent;
+    memcpy(new_list->data, packet, size);
 
     if (p) {
-        p->next = new;
+        p->next = new_list;
     } else {
-        con->priority_queue_start = new;
+        con->priority_queue_start = new_list;
     }
 
-    con->priority_queue_end = new;
+    con->priority_queue_end = new_list;
     return 1;
 }
 
@@ -668,7 +668,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
         return NULL;
     }
 
-    TCP_Client_Connection *temp = calloc(sizeof(TCP_Client_Connection), 1);
+    TCP_Client_Connection *temp = (TCP_Client_Connection *)calloc(sizeof(TCP_Client_Connection), 1);
 
     if (temp == NULL) {
         kill_sock(sock);
diff --git a/toxcore/TCP_connection.c b/toxcore/TCP_connection.c
index e838c281..234a8d79 100644
--- a/toxcore/TCP_connection.c
+++ b/toxcore/TCP_connection.c
@@ -70,7 +70,13 @@ const uint8_t *tcp_connections_public_key(const TCP_Connections *tcp_c)
  *  return -1 if realloc fails.
  *  return 0 if it succeeds.
  */
-#define realloc_tox_array(array, element_size, num, temp_pointer) (num ? (temp_pointer = realloc(array, ((num) * (element_size))), temp_pointer ? (array = temp_pointer, 0) : (-1) ) : (free(array), array = NULL, 0))
+#define realloc_tox_array(array, element_type, num, temp_pointer) \
+    (num \
+        ? (temp_pointer = (element_type *)realloc( \
+              array, \
+              (num) * sizeof(element_type)), \
+          temp_pointer ? (array = temp_pointer, 0) : -1) \
+        : (free(array), array = NULL, 0))
 
 
 /* return 1 if the connections_number is not valid.
@@ -132,7 +138,7 @@ static int create_connection(TCP_Connections *tcp_c)
 
     TCP_Connection_to *temp_pointer;
 
-    if (realloc_tox_array(tcp_c->connections, sizeof(TCP_Connection_to), tcp_c->connections_length + 1,
+    if (realloc_tox_array(tcp_c->connections, TCP_Connection_to, tcp_c->connections_length + 1,
                           temp_pointer) == 0) {
         id = tcp_c->connections_length;
         ++tcp_c->connections_length;
@@ -161,7 +167,7 @@ static int create_tcp_connection(TCP_Connections *tcp_c)
 
     TCP_con *temp_pointer;
 
-    if (realloc_tox_array(tcp_c->tcp_connections, sizeof(TCP_con), tcp_c->tcp_connections_length + 1, temp_pointer) == 0) {
+    if (realloc_tox_array(tcp_c->tcp_connections, TCP_con, tcp_c->tcp_connections_length + 1, temp_pointer) == 0) {
         id = tcp_c->tcp_connections_length;
         ++tcp_c->tcp_connections_length;
         memset(&(tcp_c->tcp_connections[id]), 0, sizeof(TCP_con));
@@ -193,7 +199,7 @@ static int wipe_connection(TCP_Connections *tcp_c, int connections_number)
     if (tcp_c->connections_length != i) {
         tcp_c->connections_length = i;
         TCP_Connection_to *temp_pointer;
-        realloc_tox_array(tcp_c->connections, sizeof(TCP_Connection_to), tcp_c->connections_length, temp_pointer);
+        realloc_tox_array(tcp_c->connections, TCP_Connection_to, tcp_c->connections_length, temp_pointer);
     }
 
     return 0;
@@ -222,7 +228,7 @@ static int wipe_tcp_connection(TCP_Connections *tcp_c, int tcp_connections_numbe
     if (tcp_c->tcp_connections_length != i) {
         tcp_c->tcp_connections_length = i;
         TCP_con *temp_pointer;
-        realloc_tox_array(tcp_c->tcp_connections, sizeof(TCP_con), tcp_c->tcp_connections_length, temp_pointer);
+        realloc_tox_array(tcp_c->tcp_connections, TCP_con, tcp_c->tcp_connections_length, temp_pointer);
     }
 
     return 0;
@@ -896,8 +902,8 @@ static int send_tcp_relay_routing_request(TCP_Connections *tcp_c, int tcp_connec
 
 static int tcp_response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
 {
-    TCP_Client_Connection *TCP_client_con = object;
-    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+    TCP_Client_Connection *TCP_client_con = (TCP_Client_Connection *)object;
+    TCP_Connections *tcp_c = (TCP_Connections *)TCP_client_con->custom_object;
 
     unsigned int tcp_connections_number = TCP_client_con->custom_uint;
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
@@ -929,8 +935,8 @@ static int tcp_response_callback(void *object, uint8_t connection_id, const uint
 
 static int tcp_status_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t status)
 {
-    TCP_Client_Connection *TCP_client_con = object;
-    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+    TCP_Client_Connection *TCP_client_con = (TCP_Client_Connection *)object;
+    TCP_Connections *tcp_c = (TCP_Connections *)TCP_client_con->custom_object;
 
     unsigned int tcp_connections_number = TCP_client_con->custom_uint;
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
@@ -968,13 +974,12 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
 static int tcp_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;
     }
 
-    TCP_Client_Connection *TCP_client_con = object;
-    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+    TCP_Client_Connection *TCP_client_con = (TCP_Client_Connection *)object;
+    TCP_Connections *tcp_c = (TCP_Connections *)TCP_client_con->custom_object;
 
     unsigned int tcp_connections_number = TCP_client_con->custom_uint;
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
@@ -1003,8 +1008,8 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
         return -1;
     }
 
-    TCP_Client_Connection *TCP_client_con = object;
-    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+    TCP_Client_Connection *TCP_client_con = (TCP_Client_Connection *)object;
+    TCP_Connections *tcp_c = (TCP_Connections *)TCP_client_con->custom_object;
 
     unsigned int tcp_connections_number = TCP_client_con->custom_uint;
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
@@ -1031,7 +1036,7 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
 
 static int tcp_onion_callback(void *object, const uint8_t *data, uint16_t length, void *userdata)
 {
-    TCP_Connections *tcp_c = object;
+    TCP_Connections *tcp_c = (TCP_Connections *)object;
 
     if (tcp_c->tcp_onion_callback) {
         tcp_c->tcp_onion_callback(tcp_c->tcp_onion_callback_object, data, length, userdata);
@@ -1365,7 +1370,7 @@ TCP_Connections *new_tcp_connections(const uint8_t *secret_key, TCP_Proxy_Info *
         return NULL;
     }
 
-    TCP_Connections *temp = calloc(1, sizeof(TCP_Connections));
+    TCP_Connections *temp = (TCP_Connections *)calloc(1, sizeof(TCP_Connections));
 
     if (temp == NULL) {
         return NULL;
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index 7e348fa5..a078da94 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -113,8 +113,9 @@ static int realloc_connection(TCP_Server *TCP_server, uint32_t num)
         return 0;
     }
 
-    TCP_Secure_Connection *new_connections = realloc(TCP_server->accepted_connection_array,
-            num * sizeof(TCP_Secure_Connection));
+    TCP_Secure_Connection *new_connections = (TCP_Secure_Connection *)realloc(
+                TCP_server->accepted_connection_array,
+                num * sizeof(TCP_Secure_Connection));
 
     if (new_connections == NULL) {
         return -1;
@@ -407,25 +408,25 @@ static int send_pending_data(TCP_Secure_Connection *con)
  */
 static bool add_priority(TCP_Secure_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
 {
-    TCP_Priority_List *p = con->priority_queue_end, *new;
-    new = malloc(sizeof(TCP_Priority_List) + size);
+    TCP_Priority_List *p = con->priority_queue_end;
+    TCP_Priority_List *new_list = (TCP_Priority_List *)malloc(sizeof(TCP_Priority_List) + size);
 
-    if (!new) {
+    if (!new_list) {
         return 0;
     }
 
-    new->next = NULL;
-    new->size = size;
-    new->sent = sent;
-    memcpy(new->data, packet, size);
+    new_list->next = NULL;
+    new_list->size = size;
+    new_list->sent = sent;
+    memcpy(new_list->data, packet, size);
 
     if (p) {
-        p->next = new;
+        p->next = new_list;
     } else {
-        con->priority_queue_start = new;
+        con->priority_queue_start = new_list;
     }
 
-    con->priority_queue_end = new;
+    con->priority_queue_end = new_list;
     return 1;
 }
 
@@ -779,7 +780,7 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
 
 static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data, uint16_t length)
 {
-    TCP_Server *TCP_server = object;
+    TCP_Server *TCP_server = (TCP_Server *)object;
     uint32_t index = dest.ip.ip6.uint32[0];
 
     if (index >= TCP_server->size_accepted_connections) {
@@ -1034,13 +1035,13 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
         return NULL;
     }
 
-    TCP_Server *temp = calloc(1, sizeof(TCP_Server));
+    TCP_Server *temp = (TCP_Server *)calloc(1, sizeof(TCP_Server));
 
     if (temp == NULL) {
         return NULL;
     }
 
-    temp->socks_listening = calloc(num_sockets, sizeof(sock_t));
+    temp->socks_listening = (sock_t *)calloc(num_sockets, sizeof(sock_t));
 
     if (temp->socks_listening == NULL) {
         free(temp);
diff --git a/toxcore/assoc.c b/toxcore/assoc.c
index 3653a8d4..74e4b0e0 100644
--- a/toxcore/assoc.c
+++ b/toxcore/assoc.c
@@ -123,8 +123,8 @@ static uint64_t id_distance(const Assoc *assoc, void *callback_data, const uint8
 /* qsort() callback for a sorting by id_distance() values */
 static int dist_index_comp(const void *a, const void *b)
 {
-    const uint64_t *_a = a;
-    const uint64_t *_b = b;
+    const uint64_t *_a = (const uint64_t *)a;
+    const uint64_t *_b = (const uint64_t *)b;
 
     if (*_a < *_b) {
         return -1;
@@ -847,7 +847,7 @@ Assoc *new_Assoc(Logger *log, size_t bits, size_t entries, const uint8_t *public
         return NULL;
     }
 
-    Assoc *assoc = calloc(1, sizeof(*assoc));
+    Assoc *assoc = (Assoc *)calloc(1, sizeof(*assoc));
 
     if (!assoc) {
         return NULL;
@@ -900,14 +900,15 @@ Assoc *new_Assoc(Logger *log, size_t bits, size_t entries, const uint8_t *public
 
     /* allocation: preferably few blobs */
     size_t bckt, cix;
-    Client_entry *clients = malloc(sizeof(*clients) * assoc->candidates_bucket_count * assoc->candidates_bucket_size);
+    Client_entry *clients = (Client_entry *)malloc(sizeof(*clients) * assoc->candidates_bucket_count *
+                            assoc->candidates_bucket_size);
 
     if (!clients) {
         free(assoc);
         return NULL;
     }
 
-    candidates_bucket *lists = malloc(sizeof(*lists) * assoc->candidates_bucket_count);
+    candidates_bucket *lists = (candidates_bucket *)malloc(sizeof(*lists) * assoc->candidates_bucket_count);
 
     if (!lists) {
         free(assoc);
diff --git a/toxcore/friend_connection.c b/toxcore/friend_connection.c
index 314f4e61..5abf6381 100644
--- a/toxcore/friend_connection.c
+++ b/toxcore/friend_connection.c
@@ -63,7 +63,7 @@ static int realloc_friendconns(Friend_Connections *fr_c, uint32_t num)
         return 0;
     }
 
-    Friend_Conn *newgroup_cons = realloc(fr_c->conns, num * sizeof(Friend_Conn));
+    Friend_Conn *newgroup_cons = (Friend_Conn *)realloc(fr_c->conns, num * sizeof(Friend_Conn));
 
     if (newgroup_cons == NULL) {
         return -1;
@@ -261,7 +261,7 @@ static unsigned int send_relays(Friend_Connections *fr_c, int friendcon_id)
 /* callback for recv TCP relay nodes. */
 static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key)
 {
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -279,7 +279,7 @@ static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id);
 /* Callback for DHT ip_port changes. */
 static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
 {
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -325,7 +325,7 @@ static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint
 
 static int handle_status(void *object, int number, uint8_t status, void *userdata)
 {
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -369,7 +369,7 @@ static int handle_status(void *object, int number, uint8_t status, void *userdat
 /* Callback for dht public key changes. */
 static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key, void *userdata)
 {
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -399,7 +399,7 @@ static int handle_packet(void *object, int number, const uint8_t *data, uint16_t
         return -1;
     }
 
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -461,7 +461,7 @@ static int handle_lossy_packet(void *object, int number, const uint8_t *data, ui
         return -1;
     }
 
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
     if (!friend_con) {
@@ -488,7 +488,7 @@ static int handle_lossy_packet(void *object, int number, const uint8_t *data, ui
 
 static int handle_new_connections(void *object, New_Connection *n_c)
 {
-    Friend_Connections *fr_c = object;
+    Friend_Connections *fr_c = (Friend_Connections *)object;
     int friendcon_id = getfriend_conn_id_pk(fr_c, n_c->public_key);
     Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
 
@@ -819,7 +819,7 @@ Friend_Connections *new_friend_connections(Onion_Client *onion_c)
         return NULL;
     }
 
-    Friend_Connections *temp = calloc(1, sizeof(Friend_Connections));
+    Friend_Connections *temp = (Friend_Connections *)calloc(1, sizeof(Friend_Connections));
 
     if (temp == NULL) {
         return NULL;
diff --git a/toxcore/friend_requests.c b/toxcore/friend_requests.c
index a011c72e..f0281d3a 100644
--- a/toxcore/friend_requests.c
+++ b/toxcore/friend_requests.c
@@ -108,7 +108,7 @@ int remove_request_received(Friend_Requests *fr, const uint8_t *real_pk)
 static int friendreq_handlepacket(void *object, const uint8_t *source_pubkey, const uint8_t *packet, uint16_t length,
                                   void *userdata)
 {
-    Friend_Requests *fr = object;
+    Friend_Requests *fr = (Friend_Requests *)object;
 
     if (length <= 1 + sizeof(fr->nospam) || length > ONION_CLIENT_MAX_DATA_SIZE) {
         return 1;
diff --git a/toxcore/group.c b/toxcore/group.c
index e4560687..d56301cf 100644
--- a/toxcore/group.c
+++ b/toxcore/group.c
@@ -63,7 +63,7 @@ static int realloc_groupchats(Group_Chats *g_c, uint32_t num)
         return 0;
     }
 
-    Group_c *newgroup_chats = realloc(g_c->chats, num * sizeof(Group_c));
+    Group_c *newgroup_chats = (Group_c *)realloc(g_c->chats, num * sizeof(Group_c));
 
     if (newgroup_chats == NULL) {
         return -1;
@@ -436,8 +436,7 @@ static int addpeer(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, co
         return -1;
     }
 
-    Group_Peer *temp;
-    temp = realloc(g->group, sizeof(Group_Peer) * (g->numpeers + 1));
+    Group_Peer *temp = (Group_Peer *)realloc(g->group, sizeof(Group_Peer) * (g->numpeers + 1));
 
     if (temp == NULL) {
         return -1;
@@ -522,7 +521,6 @@ static int delpeer(Group_Chats *g_c, int groupnumber, int peer_index, void *user
         remove_close_conn(g_c, groupnumber, friendcon_id);
     }
 
-    Group_Peer *temp;
     --g->numpeers;
 
     void *peer_object = g->group[peer_index].object;
@@ -535,7 +533,7 @@ static int delpeer(Group_Chats *g_c, int groupnumber, int peer_index, void *user
             memcpy(&g->group[peer_index], &g->group[g->numpeers], sizeof(Group_Peer));
         }
 
-        temp = realloc(g->group, sizeof(Group_Peer) * (g->numpeers));
+        Group_Peer *temp = (Group_Peer *)realloc(g->group, sizeof(Group_Peer) * (g->numpeers));
 
         if (temp == NULL) {
             return -1;
@@ -663,7 +661,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)
 {
-    Group_Chats *g_c = object;
+    Group_Chats *g_c = (Group_Chats *)object;
 
     if (status) { /* Went online */
         set_conns_status_groups(g_c, friendcon_id, GROUPCHAT_CLOSE_ONLINE);
@@ -1379,7 +1377,7 @@ int group_title_get(const Group_Chats *g_c, int groupnumber, uint8_t *title)
 static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length,
                                         void *userdata)
 {
-    Group_Chats *g_c = m->group_chat_object;
+    Group_Chats *g_c = (Group_Chats *)m->group_chat_object;
 
     if (length <= 1) {
         return;
@@ -2128,7 +2126,7 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
 
 static int handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
 {
-    Group_Chats *g_c = object;
+    Group_Chats *g_c = (Group_Chats *)object;
 
     if (length < 1 + sizeof(uint16_t) + 1) {
         return -1;
@@ -2240,7 +2238,7 @@ static unsigned int lossy_packet_not_received(Group_c *g, int peer_index, uint16
 
 static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
 {
-    Group_Chats *g_c = object;
+    Group_Chats *g_c = (Group_Chats *)object;
 
     if (length < 1 + sizeof(uint16_t) * 3 + 1) {
         return -1;
@@ -2446,7 +2444,7 @@ Group_Chats *new_groupchats(Messenger *m)
         return NULL;
     }
 
-    Group_Chats *temp = calloc(1, sizeof(Group_Chats));
+    Group_Chats *temp = (Group_Chats *)calloc(1, sizeof(Group_Chats));
 
     if (temp == NULL) {
         return NULL;
diff --git a/toxcore/list.c b/toxcore/list.c
index 305e563c..015f8f8a 100644
--- a/toxcore/list.c
+++ b/toxcore/list.c
@@ -113,23 +113,21 @@ static int find(const BS_LIST *list, const uint8_t *data)
  */
 static int resize(BS_LIST *list, uint32_t new_size)
 {
-    void *p;
+    uint8_t *data = (uint8_t *)realloc(list->data, list->element_size * new_size);
 
-    p = realloc(list->data, list->element_size * new_size);
-
-    if (!p) {
+    if (!data) {
         return 0;
     }
 
-    list->data = p;
+    list->data = data;
 
-    p = realloc(list->ids, sizeof(int) * new_size);
+    int *ids = (int *)realloc(list->ids, sizeof(int) * new_size);
 
-    if (!p) {
+    if (!ids) {
         return 0;
     }
 
-    list->ids = p;
+    list->ids = ids;
 
     return 1;
 }
diff --git a/toxcore/logger.c b/toxcore/logger.c
index c6f4056b..bbb31aa2 100644
--- a/toxcore/logger.c
+++ b/toxcore/logger.c
@@ -37,7 +37,7 @@ struct Logger {
  */
 Logger *logger_new(void)
 {
-    return calloc(1, sizeof(Logger));
+    return (Logger *)calloc(1, sizeof(Logger));
 }
 
 void logger_kill(Logger *log)
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 2da8de61..16b3c6d2 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -207,7 +207,7 @@ static int handle_cookie_request(const Net_Crypto *c, uint8_t *request_plain, ui
 static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length,
                                      void *userdata)
 {
-    Net_Crypto *c = object;
+    Net_Crypto *c = (Net_Crypto *)object;
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
     uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
@@ -592,7 +592,7 @@ static int add_data_to_buffer(Packets_Array *array, uint32_t number, const Packe
         return -1;
     }
 
-    Packet_Data *new_d = malloc(sizeof(Packet_Data));
+    Packet_Data *new_d = (Packet_Data *)malloc(sizeof(Packet_Data));
 
     if (new_d == NULL) {
         return -1;
@@ -643,7 +643,7 @@ static int64_t add_data_end_of_buffer(Packets_Array *array, const Packet_Data *d
         return -1;
     }
 
-    Packet_Data *new_d = malloc(sizeof(Packet_Data));
+    Packet_Data *new_d = (Packet_Data *)malloc(sizeof(Packet_Data));
 
     if (new_d == NULL) {
         return -1;
@@ -1183,7 +1183,7 @@ static int new_temp_packet(const Net_Crypto *c, int crypt_connection_id, const u
         return -1;
     }
 
-    uint8_t *temp_packet = malloc(length);
+    uint8_t *temp_packet = (uint8_t *)malloc(length);
 
     if (temp_packet == 0) {
         return -1;
@@ -1569,7 +1569,8 @@ static int realloc_cryptoconnection(Net_Crypto *c, uint32_t num)
         return 0;
     }
 
-    Crypto_Connection *newcrypto_connections = realloc(c->crypto_connections, num * sizeof(Crypto_Connection));
+    Crypto_Connection *newcrypto_connections = (Crypto_Connection *)realloc(c->crypto_connections,
+            num * sizeof(Crypto_Connection));
 
     if (newcrypto_connections == NULL) {
         return -1;
@@ -1738,7 +1739,7 @@ static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const
         void *userdata)
 {
     New_Connection n_c;
-    n_c.cookie = malloc(COOKIE_LENGTH);
+    n_c.cookie = (uint8_t *)malloc(COOKIE_LENGTH);
 
     if (n_c.cookie == NULL) {
         return -1;
@@ -1947,7 +1948,7 @@ static int tcp_data_callback(void *object, int id, const uint8_t *data, uint16_t
         return -1;
     }
 
-    Net_Crypto *c = object;
+    Net_Crypto *c = (Net_Crypto *)object;
 
     Crypto_Connection *conn = get_crypto_connection(c, id);
 
@@ -1978,7 +1979,7 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, unsigned in
         return -1;
     }
 
-    Net_Crypto *c = object;
+    Net_Crypto *c = (Net_Crypto *)object;
 
     if (data[0] == NET_PACKET_COOKIE_REQUEST) {
         return tcp_oob_handle_cookie_request(c, tcp_connections_number, public_key, data, length);
@@ -2238,7 +2239,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
         return 1;
     }
 
-    Net_Crypto *c = object;
+    Net_Crypto *c = (Net_Crypto *)object;
     int crypt_connection_id = crypto_id_ip_port(c, source);
 
     if (crypt_connection_id == -1) {
@@ -2787,7 +2788,7 @@ Net_Crypto *new_net_crypto(Logger *log, DHT *dht, TCP_Proxy_Info *proxy_info)
         return NULL;
     }
 
-    Net_Crypto *temp = calloc(1, sizeof(Net_Crypto));
+    Net_Crypto *temp = (Net_Crypto *)calloc(1, sizeof(Net_Crypto));
 
     if (temp == NULL) {
         return NULL;
diff --git a/toxcore/network.c b/toxcore/network.c
index e20f4c01..39e1fc98 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -557,7 +557,7 @@ Networking_Core *new_networking_ex(Logger *log, IP ip, uint16_t port_from, uint1
         return NULL;
     }
 
-    Networking_Core *temp = calloc(1, sizeof(Networking_Core));
+    Networking_Core *temp = (Networking_Core *)calloc(1, sizeof(Networking_Core));
 
     if (temp == NULL) {
         return NULL;
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 5e5fd135..5705c14f 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -325,7 +325,7 @@ int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data,
 
 static int handle_send_initial(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -394,7 +394,7 @@ int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port
 
 static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -450,7 +450,7 @@ static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, ui
 
 static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -505,7 +505,7 @@ static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, ui
 
 static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -546,7 +546,7 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
 
 static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -587,7 +587,7 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
 
 static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion *onion = object;
+    Onion *onion = (Onion *)object;
 
     if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
@@ -638,7 +638,7 @@ Onion *new_onion(DHT *dht)
         return NULL;
     }
 
-    Onion *onion = calloc(1, sizeof(Onion));
+    Onion *onion = (Onion *)calloc(1, sizeof(Onion));
 
     if (onion == NULL) {
         return NULL;
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index 42b3a635..acde04a7 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -309,7 +309,7 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
 
 static int handle_announce_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion_Announce *onion_a = object;
+    Onion_Announce *onion_a = (Onion_Announce *)object;
 
     if (length != ANNOUNCE_REQUEST_SIZE_RECV) {
         return 1;
@@ -408,7 +408,7 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
 
 static int handle_data_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion_Announce *onion_a = object;
+    Onion_Announce *onion_a = (Onion_Announce *)object;
 
     if (length <= DATA_REQUEST_MIN_SIZE_RECV) {
         return 1;
@@ -442,7 +442,7 @@ Onion_Announce *new_onion_announce(DHT *dht)
         return NULL;
     }
 
-    Onion_Announce *onion_a = calloc(1, sizeof(Onion_Announce));
+    Onion_Announce *onion_a = (Onion_Announce *)calloc(1, sizeof(Onion_Announce));
 
     if (onion_a == NULL) {
         return NULL;
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index 316ed3d1..86f4de72 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -662,7 +662,7 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
 static int handle_announce_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length,
                                     void *userdata)
 {
-    Onion_Client *onion_c = object;
+    Onion_Client *onion_c = (Onion_Client *)object;
 
     if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE) {
         return 1;
@@ -727,7 +727,7 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
 
 static int handle_data_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    Onion_Client *onion_c = object;
+    Onion_Client *onion_c = (Onion_Client *)object;
 
     if (length <= (ONION_DATA_RESPONSE_MIN_SIZE + DATA_IN_RESPONSE_MIN_SIZE)) {
         return 1;
@@ -767,7 +767,7 @@ static int handle_data_response(void *object, IP_Port source, const uint8_t *pac
 static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t length,
                                  void *userdata)
 {
-    Onion_Client *onion_c = object;
+    Onion_Client *onion_c = (Onion_Client *)object;
 
     if (length < DHTPK_DATA_MIN_LENGTH) {
         return 1;
@@ -975,7 +975,7 @@ static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uin
 static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
                             uint16_t length, void *userdata)
 {
-    Onion_Client *onion_c = object;
+    Onion_Client *onion_c = (Onion_Client *)object;
 
     if (length < DHTPK_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES) {
         return 1;
@@ -1092,7 +1092,7 @@ static int realloc_onion_friends(Onion_Client *onion_c, uint32_t num)
         return 0;
     }
 
-    Onion_Friend *newonion_friends = realloc(onion_c->friends_list, num * sizeof(Onion_Friend));
+    Onion_Friend *newonion_friends = (Onion_Friend *)realloc(onion_c->friends_list, num * sizeof(Onion_Friend));
 
     if (newonion_friends == NULL) {
         return -1;
@@ -1605,7 +1605,7 @@ Onion_Client *new_onion_client(Net_Crypto *c)
         return NULL;
     }
 
-    Onion_Client *onion_c = calloc(1, sizeof(Onion_Client));
+    Onion_Client *onion_c = (Onion_Client *)calloc(1, sizeof(Onion_Client));
 
     if (onion_c == NULL) {
         return NULL;
diff --git a/toxcore/ping.c b/toxcore/ping.c
index d15ccd47..052650e3 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -134,9 +134,9 @@ static int send_ping_response(PING *ping, IP_Port ipp, const uint8_t *public_key
     return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
 }
 
-static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
+static int handle_ping_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT       *dht = _dht;
+    DHT       *dht = (DHT *)object;
     int        rc;
 
     if (length != DHT_PING_SIZE) {
@@ -177,9 +177,9 @@ static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet
     return 0;
 }
 
-static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
+static int handle_ping_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT      *dht = _dht;
+    DHT      *dht = (DHT *)object;
     int       rc;
 
     if (length != DHT_PING_SIZE) {
@@ -353,7 +353,7 @@ void do_to_ping(PING *ping)
 
 PING *new_ping(DHT *dht)
 {
-    PING *ping = calloc(1, sizeof(PING));
+    PING *ping = (PING *)calloc(1, sizeof(PING));
 
     if (ping == NULL) {
         return NULL;
diff --git a/toxcore/ping_array.c b/toxcore/ping_array.c
index 8a23c6d8..ee7ff8be 100644
--- a/toxcore/ping_array.c
+++ b/toxcore/ping_array.c
@@ -145,7 +145,7 @@ int ping_array_init(Ping_Array *empty_array, uint32_t size, uint32_t timeout)
         return -1;
     }
 
-    empty_array->entries = calloc(size, sizeof(Ping_Array_Entry));
+    empty_array->entries = (Ping_Array_Entry *)calloc(size, sizeof(Ping_Array_Entry));
 
     if (empty_array->entries == NULL) {
         return -1;
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 93993c53..bf664b41 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -158,7 +158,7 @@ void tox_options_default(struct Tox_Options *options)
 
 struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error)
 {
-    struct Tox_Options *options = calloc(sizeof(struct Tox_Options), 1);
+    struct Tox_Options *options = (struct Tox_Options *)calloc(sizeof(struct Tox_Options), 1);
 
     if (options) {
         tox_options_default(options);
@@ -303,7 +303,7 @@ void tox_kill(Tox *tox)
 
     Messenger *m = tox;
     Logger *log = m->log;
-    kill_groupchats(m->group_chat_object);
+    kill_groupchats((Group_Chats *)m->group_chat_object);
     kill_messenger(m);
     logger_kill(log);
 }
@@ -463,7 +463,7 @@ TOX_CONNECTION tox_self_get_connection_status(const Tox *tox)
 void tox_callback_self_connection_status(Tox *tox, tox_self_connection_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_core_connection(m, callback);
+    m_callback_core_connection(m, (void (*)(Messenger *, unsigned int, void *))callback);
 }
 
 uint32_t tox_iteration_interval(const Tox *tox)
@@ -476,7 +476,7 @@ void tox_iterate(Tox *tox, void *user_data)
 {
     Messenger *m = tox;
     do_messenger(m, user_data);
-    do_groupchats(m->group_chat_object, user_data);
+    do_groupchats((Group_Chats *)m->group_chat_object, user_data);
 }
 
 void tox_self_get_address(const Tox *tox, uint8_t *address)
@@ -528,7 +528,7 @@ bool tox_self_set_name(Tox *tox, const uint8_t *name, size_t length, TOX_ERR_SET
 
     if (setname(m, name, length) == 0) {
         // TODO(irungentoo): function to set different per group names?
-        send_name_all_groups(m->group_chat_object);
+        send_name_all_groups((Group_Chats *)m->group_chat_object);
         SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_OK);
         return 1;
     }
@@ -592,7 +592,7 @@ void tox_self_set_status(Tox *tox, TOX_USER_STATUS status)
 TOX_USER_STATUS tox_self_get_status(const Tox *tox)
 {
     const Messenger *m = tox;
-    return m_get_self_userstatus(m);
+    return (TOX_USER_STATUS)m_get_self_userstatus(m);
 }
 
 static void set_friend_error(int32_t ret, TOX_ERR_FRIEND_ADD *error)
@@ -842,17 +842,17 @@ TOX_USER_STATUS tox_friend_get_status(const Tox *tox, uint32_t friend_number, TO
 
     if (ret == USERSTATUS_INVALID) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
-        return TOX_USER_STATUS_BUSY + 1;
+        return (TOX_USER_STATUS)(TOX_USER_STATUS_BUSY + 1);
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
-    return ret;
+    return (TOX_USER_STATUS)ret;
 }
 
 void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_userstatus(m, callback);
+    m_callback_userstatus(m, (void (*)(Messenger *, uint32_t, unsigned int, void *))callback);
 }
 
 TOX_CONNECTION tox_friend_get_connection_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
@@ -867,13 +867,13 @@ TOX_CONNECTION tox_friend_get_connection_status(const Tox *tox, uint32_t friend_
     }
 
     SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
-    return ret;
+    return (TOX_CONNECTION)ret;
 }
 
 void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_connectionstatus(m, callback);
+    m_callback_connectionstatus(m, (void (*)(Messenger *, uint32_t, unsigned int, void *))callback);
 }
 
 bool tox_friend_get_typing(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
@@ -972,7 +972,7 @@ void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *callback)
 void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_friendmessage(m, callback);
+    m_callback_friendmessage(m, (void (*)(Messenger *, uint32_t, unsigned int, const uint8_t *, size_t, void *))callback);
 }
 
 bool tox_hash(uint8_t *hash, const uint8_t *data, size_t length)
@@ -1079,7 +1079,7 @@ bool tox_file_seek(Tox *tox, uint32_t friend_number, uint32_t file_number, uint6
 void tox_callback_file_recv_control(Tox *tox, tox_file_recv_control_cb *callback)
 {
     Messenger *m = tox;
-    callback_file_control(m, callback);
+    callback_file_control(m, (void (*)(Messenger *, uint32_t, uint32_t, unsigned int, void *))callback);
 }
 
 bool tox_file_get_file_id(const Tox *tox, uint32_t friend_number, uint32_t file_number, uint8_t *file_id,
diff --git a/toxcore/util.c b/toxcore/util.c
index f9fe7852..93a3d436 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -240,7 +240,7 @@ bool rb_read(RingBuffer *b, void **p)
 }
 RingBuffer *rb_new(int size)
 {
-    RingBuffer *buf = calloc(sizeof(RingBuffer), 1);
+    RingBuffer *buf = (RingBuffer *)calloc(sizeof(RingBuffer), 1);
 
     if (!buf) {
         return NULL;
@@ -248,7 +248,7 @@ RingBuffer *rb_new(int size)
 
     buf->size = size + 1; /* include empty elem */
 
-    if (!(buf->data = calloc(buf->size, sizeof(void *)))) {
+    if (!(buf->data = (void **)calloc(buf->size, sizeof(void *)))) {
         free(buf);
         return NULL;
     }
diff --git a/toxdns/toxdns.c b/toxdns/toxdns.c
index c420c944..6622d6a5 100644
--- a/toxdns/toxdns.c
+++ b/toxdns/toxdns.c
@@ -29,7 +29,11 @@
 #include "../toxcore/logger.h"
 #include "toxdns.h"
 
-static const char base32[32] = {"abcdefghijklmnopqrstuvwxyz012345"};
+static const char base32[32] = {
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5',
+};
 
 #define _encode(a, b, c) \
 { \
@@ -68,7 +72,7 @@ static void dns_new_temp_keys(DNS_Object *d)
  */
 void *tox_dns3_new(uint8_t *server_public_key)
 {
-    DNS_Object *d = malloc(sizeof(DNS_Object));
+    DNS_Object *d = (DNS_Object *)malloc(sizeof(DNS_Object));
 
     if (d == NULL) {
         return NULL;
@@ -111,7 +115,7 @@ int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string
         return -1;
     }
 
-    DNS_Object *d = dns3_object;
+    DNS_Object *d = (DNS_Object *)dns3_object;
     uint8_t buffer[1024];
     uint8_t nonce[crypto_box_NONCEBYTES] = {0};
     memcpy(nonce, &d->nonce, sizeof(uint32_t));
@@ -202,7 +206,7 @@ static int decode(uint8_t *dest, uint8_t *src)
 int tox_decrypt_dns3_TXT(void *dns3_object, uint8_t *tox_id, uint8_t *id_record, uint32_t id_record_len,
                          uint32_t request_id)
 {
-    DNS_Object *d = dns3_object;
+    DNS_Object *d = (DNS_Object *)dns3_object;
 
     if (id_record_len != 87) {
         return -1;