59 files changed, 14799 insertions, 8986 deletions

diff --git a/toxcore/BUILD.bazel b/toxcore/BUILD.bazel
new file mode 100644
index 00000000..b22f9b9e
--- /dev/null
+++ b/toxcore/BUILD.bazel
@@ -0,0 +1,230 @@
+load("//tools:no_undefined.bzl", "cc_library")
+
+filegroup(
+    name = "public_headers",
+    srcs = ["tox.h"],
+    visibility = ["//c-toxcore:__pkg__"],
+)
+
+cc_library(
+    name = "ccompat",
+    hdrs = ["ccompat.h"],
+    visibility = ["//c-toxcore:__subpackages__"],
+)
+
+cc_library(
+    name = "crypto_core",
+    srcs = [
+        "crypto_core.c",
+        "crypto_core_mem.c",
+    ],
+    hdrs = [
+        "crypto_core.h",
+    ],
+    visibility = ["//c-toxcore:__subpackages__"],
+    deps = [
+        ":ccompat",
+        "@libsodium",
+    ],
+)
+
+cc_test(
+    name = "crypto_core_test",
+    srcs = ["crypto_core_test.cpp"],
+    deps = [
+        ":crypto_core",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "list",
+    srcs = ["list.c"],
+    hdrs = ["list.h"],
+    deps = [":ccompat"],
+)
+
+cc_library(
+    name = "logger",
+    srcs = ["logger.c"],
+    hdrs = ["logger.h"],
+    deps = [":ccompat"],
+)
+
+cc_library(
+    name = "network",
+    srcs = [
+        "network.c",
+        "util.c",
+    ],
+    hdrs = [
+        "network.h",
+        "util.h",
+    ],
+    linkopts = ["-lpthread"],
+    visibility = [
+        "//c-toxcore/other:__pkg__",
+        "//c-toxcore/toxav:__pkg__",
+    ],
+    deps = [
+        ":ccompat",
+        ":crypto_core",
+        ":logger",
+    ],
+)
+
+cc_test(
+    name = "util_test",
+    srcs = ["util_test.cpp"],
+    deps = [
+        ":network",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "ping_array",
+    srcs = ["ping_array.c"],
+    hdrs = ["ping_array.h"],
+    deps = [":network"],
+)
+
+cc_library(
+    name = "DHT",
+    srcs = [
+        "DHT.c",
+        "LAN_discovery.c",
+        "ping.c",
+    ],
+    hdrs = [
+        "DHT.h",
+        "LAN_discovery.h",
+        "ping.h",
+    ],
+    visibility = ["//c-toxcore/other/bootstrap_daemon:__pkg__"],
+    deps = [
+        ":crypto_core",
+        ":logger",
+        ":ping_array",
+    ],
+)
+
+cc_library(
+    name = "onion",
+    srcs = ["onion.c"],
+    hdrs = ["onion.h"],
+    deps = [":DHT"],
+)
+
+cc_library(
+    name = "TCP_connection",
+    srcs = [
+        "TCP_client.c",
+        "TCP_connection.c",
+        "TCP_server.c",
+    ],
+    hdrs = [
+        "TCP_client.h",
+        "TCP_connection.h",
+        "TCP_server.h",
+    ],
+    copts = select({
+        "//tools/config:freebsd": [],
+        "//tools/config:linux": ["-DTCP_SERVER_USE_EPOLL=1"],
+        "//tools/config:osx": [],
+    }),
+    deps = [
+        ":crypto_core",
+        ":list",
+        ":onion",
+    ],
+)
+
+cc_library(
+    name = "net_crypto",
+    srcs = ["net_crypto.c"],
+    hdrs = ["net_crypto.h"],
+    deps = [
+        ":DHT",
+        ":TCP_connection",
+    ],
+)
+
+cc_library(
+    name = "onion_announce",
+    srcs = ["onion_announce.c"],
+    hdrs = ["onion_announce.h"],
+    deps = [":onion"],
+)
+
+cc_library(
+    name = "onion_client",
+    srcs = ["onion_client.c"],
+    hdrs = ["onion_client.h"],
+    deps = [
+        ":net_crypto",
+        ":onion_announce",
+    ],
+)
+
+cc_library(
+    name = "friend_connection",
+    srcs = ["friend_connection.c"],
+    hdrs = ["friend_connection.h"],
+    deps = [
+        ":DHT",
+        ":net_crypto",
+        ":onion_client",
+    ],
+)
+
+cc_library(
+    name = "friend_requests",
+    srcs = ["friend_requests.c"],
+    hdrs = ["friend_requests.h"],
+    deps = [":friend_connection"],
+)
+
+cc_library(
+    name = "Messenger",
+    srcs = ["Messenger.c"],
+    hdrs = ["Messenger.h"],
+    visibility = ["//c-toxcore/toxav:__pkg__"],
+    deps = [":friend_requests"],
+)
+
+cc_library(
+    name = "group",
+    srcs = ["group.c"],
+    hdrs = ["group.h"],
+    visibility = ["//c-toxcore/toxav:__pkg__"],
+    deps = [":Messenger"],
+)
+
+cc_library(
+    name = "toxcore",
+    srcs = [
+        "tox.c",
+        "tox.h",
+        "tox_api.c",
+    ],
+    visibility = ["//c-toxcore:__subpackages__"],
+    deps = [
+        ":group",
+        "//c-toxcore/toxencryptsave:defines",
+    ],
+)
+
+cc_library(
+    name = "monolith",
+    hdrs = glob([
+        "*.c",
+        "*.h",
+    ]),
+    linkopts = ["-lpthread"],
+    visibility = ["//c-toxcore/other:__pkg__"],
+    deps = [
+        "//c-toxcore/toxencryptsave:defines",
+        "@libsodium",
+    ],
+)
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 6d9479a6..6134f59b 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -1,51 +1,42 @@
-/* DHT.c
- *
+/*
  * An implementation of the DHT as seen in docs/updates/DHT.md
+ */
+
+/*
+ * Copyright © 2016-2018 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-/*----------------------------------------------------------------------------------*/
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifdef DEBUG
-#include <assert.h>
-#endif
-
-#include "logger.h"
-
 #include "DHT.h"
 
-#ifdef ENABLE_ASSOC_DHT
-#include "assoc.h"
-#endif
-
-#include "ping.h"
-
-#include "network.h"
 #include "LAN_discovery.h"
-#include "misc_tools.h"
+#include "logger.h"
+#include "network.h"
+#include "ping.h"
 #include "util.h"
 
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
 /* The timeout after which a node is discarded completely. */
 #define KILL_NODE_TIMEOUT (BAD_NODE_TIMEOUT + PING_INTERVAL)
 
@@ -57,6 +48,9 @@
 /* Interval in seconds between punching attempts*/
 #define PUNCH_INTERVAL 3
 
+/* Time in seconds after which punching parameters will be reset */
+#define PUNCH_RESET_TIME 40
+
 #define MAX_NORMAL_PUNCHING_TRIES 5
 
 #define NAT_PING_REQUEST    0
@@ -65,6 +59,127 @@
 /* Number of get node requests to send to quickly find close nodes. */
 #define MAX_BOOTSTRAP_TIMES 5
 
+#define ARRAY_SIZE(ARR) (sizeof (ARR) / sizeof (ARR)[0])
+
+struct DHT_Friend {
+    uint8_t     public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    Client_data client_list[MAX_FRIEND_CLIENTS];
+
+    /* Time at which the last get_nodes request was sent. */
+    uint64_t    lastgetnode;
+    /* number of times get_node packets were sent. */
+    uint32_t    bootstrap_times;
+
+    /* Symetric NAT hole punching stuff. */
+    NAT         nat;
+
+    uint16_t lock_count;
+    struct {
+        void (*ip_callback)(void *, int32_t, IP_Port);
+        void *data;
+        int32_t number;
+    } callbacks[DHT_FRIEND_MAX_LOCKS];
+
+    Node_format to_bootstrap[MAX_SENT_NODES];
+    unsigned int num_to_bootstrap;
+};
+
+struct DHT {
+    Logger *log;
+    Networking_Core *net;
+
+    bool hole_punching_enabled;
+
+    Client_data    close_clientlist[LCLIENT_LIST];
+    uint64_t       close_lastgetnodes;
+    uint32_t       close_bootstrap_times;
+
+    /* DHT keypair */
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    DHT_Friend    *friends_list;
+    uint16_t       num_friends;
+
+    Node_format   *loaded_nodes_list;
+    uint32_t       loaded_num_nodes;
+    unsigned int   loaded_nodes_index;
+
+    Shared_Keys shared_keys_recv;
+    Shared_Keys shared_keys_sent;
+
+    struct Ping   *ping;
+    Ping_Array    *dht_ping_array;
+    Ping_Array    *dht_harden_ping_array;
+    uint64_t       last_run;
+
+    Cryptopacket_Handles cryptopackethandlers[256];
+
+    Node_format to_bootstrap[MAX_CLOSE_TO_BOOTSTRAP_NODES];
+    unsigned int num_to_bootstrap;
+};
+
+const uint8_t *dht_friend_public_key(const DHT_Friend *dht_friend)
+{
+    return dht_friend->public_key;
+}
+
+const Client_data *dht_friend_client(const DHT_Friend *dht_friend, size_t index)
+{
+    return &dht_friend->client_list[index];
+}
+
+const uint8_t *dht_get_self_public_key(const DHT *dht)
+{
+    return dht->self_public_key;
+}
+const uint8_t *dht_get_self_secret_key(const DHT *dht)
+{
+    return dht->self_secret_key;
+}
+
+void dht_set_self_public_key(DHT *dht, const uint8_t *key)
+{
+    memcpy(dht->self_public_key, key, CRYPTO_PUBLIC_KEY_SIZE);
+}
+void dht_set_self_secret_key(DHT *dht, const uint8_t *key)
+{
+    memcpy(dht->self_secret_key, key, CRYPTO_SECRET_KEY_SIZE);
+}
+
+Networking_Core *dht_get_net(const DHT *dht)
+{
+    return dht->net;
+}
+struct Ping *dht_get_ping(const DHT *dht)
+{
+    return dht->ping;
+}
+const Client_data *dht_get_close_clientlist(const DHT *dht)
+{
+    return dht->close_clientlist;
+}
+const Client_data *dht_get_close_client(const DHT *dht, uint32_t client_num)
+{
+    assert(client_num < sizeof(dht->close_clientlist) / sizeof(dht->close_clientlist[0]));
+    return &dht->close_clientlist[client_num];
+}
+uint16_t dht_get_num_friends(const DHT *dht)
+{
+    return dht->num_friends;
+}
+
+DHT_Friend *dht_get_friend(DHT *dht, uint32_t friend_num)
+{
+    assert(friend_num < dht->num_friends);
+    return &dht->friends_list[friend_num];
+}
+const uint8_t *dht_get_friend_public_key(const DHT *dht, uint32_t friend_num)
+{
+    assert(friend_num < dht->num_friends);
+    return dht->friends_list[friend_num].public_key;
+}
+
 /* Compares pk1 and pk2 with pk.
  *
  *  return 0 if both are same distance.
@@ -73,19 +188,17 @@
  */
 int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2)
 {
-    size_t   i;
-    uint8_t distance1, distance2;
-
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) {
-
-        distance1 = pk[i] ^ pk1[i];
-        distance2 = pk[i] ^ pk2[i];
+    for (size_t i = 0; i < CRYPTO_PUBLIC_KEY_SIZE; ++i) {
+        const uint8_t distance1 = pk[i] ^ pk1[i];
+        const uint8_t distance2 = pk[i] ^ pk2[i];
 
-        if (distance1 < distance2)
+        if (distance1 < distance2) {
             return 1;
+        }
 
-        if (distance1 > distance2)
+        if (distance1 > distance2) {
             return 2;
+        }
     }
 
     return 0;
@@ -95,15 +208,20 @@ int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2)
  */
 static unsigned int bit_by_bit_cmp(const uint8_t *pk1, const uint8_t *pk2)
 {
-    unsigned int i, j = 0;
+    unsigned int i;
+    unsigned int j = 0;
 
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) {
-        if (pk1[i] == pk2[i])
+    for (i = 0; i < CRYPTO_PUBLIC_KEY_SIZE; ++i) {
+        if (pk1[i] == pk2[i]) {
             continue;
+        }
 
         for (j = 0; j < 8; ++j) {
-            if ((pk1[i] & (1 << (7 - j))) != (pk2[i] & (1 << (7 - j))))
+            const uint8_t mask = 1 << (7 - j);
+
+            if ((pk1[i] & mask) != (pk2[i] & mask)) {
                 break;
+            }
         }
 
         break;
@@ -120,44 +238,45 @@ static unsigned int bit_by_bit_cmp(const uint8_t *pk1, const uint8_t *pk2)
  */
 void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t *secret_key, const uint8_t *public_key)
 {
-    uint32_t i, num = ~0, curr = 0;
+    uint32_t num = ~0;
+    uint32_t curr = 0;
 
-    for (i = 0; i < MAX_KEYS_PER_SLOT; ++i) {
-        int index = public_key[30] * MAX_KEYS_PER_SLOT + i;
+    for (uint32_t i = 0; i < MAX_KEYS_PER_SLOT; ++i) {
+        const int index = public_key[30] * MAX_KEYS_PER_SLOT + i;
+        Shared_Key *const key = &shared_keys->keys[index];
 
-        if (shared_keys->keys[index].stored) {
-            if (public_key_cmp(public_key, shared_keys->keys[index].public_key) == 0) {
-                memcpy(shared_key, shared_keys->keys[index].shared_key, crypto_box_BEFORENMBYTES);
-                ++shared_keys->keys[index].times_requested;
-                shared_keys->keys[index].time_last_requested = unix_time();
+        if (key->stored) {
+            if (id_equal(public_key, key->public_key)) {
+                memcpy(shared_key, key->shared_key, CRYPTO_SHARED_KEY_SIZE);
+                ++key->times_requested;
+                key->time_last_requested = unix_time();
                 return;
             }
 
             if (num != 0) {
-                if (is_timeout(shared_keys->keys[index].time_last_requested, KEYS_TIMEOUT)) {
+                if (is_timeout(key->time_last_requested, KEYS_TIMEOUT)) {
                     num = 0;
                     curr = index;
-                } else if (num > shared_keys->keys[index].times_requested) {
-                    num = shared_keys->keys[index].times_requested;
+                } else if (num > key->times_requested) {
+                    num = key->times_requested;
                     curr = index;
                 }
             }
-        } else {
-            if (num != 0) {
-                num = 0;
-                curr = index;
-            }
+        } else if (num != 0) {
+            num = 0;
+            curr = index;
         }
     }
 
     encrypt_precompute(public_key, secret_key, shared_key);
 
-    if (num != (uint32_t)~0) {
-        shared_keys->keys[curr].stored = 1;
-        shared_keys->keys[curr].times_requested = 1;
-        memcpy(shared_keys->keys[curr].public_key, public_key, crypto_box_PUBLICKEYBYTES);
-        memcpy(shared_keys->keys[curr].shared_key, shared_key, crypto_box_BEFORENMBYTES);
-        shared_keys->keys[curr].time_last_requested = unix_time();
+    if (num != UINT32_MAX) {
+        Shared_Key *const key = &shared_keys->keys[curr];
+        key->stored = 1;
+        key->times_requested = 1;
+        memcpy(key->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+        memcpy(key->shared_key, shared_key, CRYPTO_SHARED_KEY_SIZE);
+        key->time_last_requested = unix_time();
     }
 }
 
@@ -177,48 +296,249 @@ void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *publi
     get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, public_key);
 }
 
-void to_net_family(IP *ip)
+#define CRYPTO_SIZE 1 + CRYPTO_PUBLIC_KEY_SIZE * 2 + CRYPTO_NONCE_SIZE
+
+/* Create a request to peer.
+ * send_public_key and send_secret_key are the pub/secret keys of the sender.
+ * recv_public_key is public key of receiver.
+ * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
+ * Data represents the data we send with the request with length being the length of the data.
+ * request_id is the id of the request (32 = friend request, 254 = ping request).
+ *
+ *  return -1 on failure.
+ *  return the length of the created packet on success.
+ */
+int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_key, uint8_t *packet,
+                   const uint8_t *recv_public_key, const uint8_t *data, uint32_t length, uint8_t request_id)
 {
-    if (ip->family == AF_INET)
-        ip->family = TOX_AF_INET;
-    else if (ip->family == AF_INET6)
-        ip->family = TOX_AF_INET6;
+    if (!send_public_key || !packet || !recv_public_key || !data) {
+        return -1;
+    }
+
+    if (MAX_CRYPTO_REQUEST_SIZE < length + CRYPTO_SIZE + 1 + CRYPTO_MAC_SIZE) {
+        return -1;
+    }
+
+    uint8_t *const nonce = packet + 1 + CRYPTO_PUBLIC_KEY_SIZE * 2;
+    random_nonce(nonce);
+    uint8_t temp[MAX_CRYPTO_REQUEST_SIZE];
+    memcpy(temp + 1, data, length);
+    temp[0] = request_id;
+    const int len = encrypt_data(recv_public_key, send_secret_key, nonce, temp, length + 1,
+                                 CRYPTO_SIZE + packet);
+
+    if (len == -1) {
+        crypto_memzero(temp, MAX_CRYPTO_REQUEST_SIZE);
+        return -1;
+    }
+
+    packet[0] = NET_PACKET_CRYPTO;
+    memcpy(packet + 1, recv_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, send_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+
+    crypto_memzero(temp, MAX_CRYPTO_REQUEST_SIZE);
+    return len + CRYPTO_SIZE;
 }
 
-int to_host_family(IP *ip)
+/* Puts the senders public key in the request in public_key, the data from the request
+ * in data if a friend or ping request was sent to us and returns the length of the data.
+ * packet is the request packet and length is its length.
+ *
+ *  return -1 if not valid request.
+ */
+int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data,
+                   uint8_t *request_id, const uint8_t *packet, uint16_t length)
 {
-    if (ip->family == TOX_AF_INET) {
-        ip->family = AF_INET;
-        return 0;
-    } else if (ip->family == TOX_AF_INET6) {
-        ip->family = AF_INET6;
-        return 0;
-    } else {
+    if (!self_public_key || !public_key || !data || !request_id || !packet) {
+        return -1;
+    }
+
+    if (length <= CRYPTO_SIZE + CRYPTO_MAC_SIZE || length > MAX_CRYPTO_REQUEST_SIZE) {
+        return -1;
+    }
+
+    if (!id_equal(packet + 1, self_public_key)) {
+        return -1;
+    }
+
+    memcpy(public_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, CRYPTO_PUBLIC_KEY_SIZE);
+    const uint8_t *const nonce = packet + 1 + CRYPTO_PUBLIC_KEY_SIZE * 2;
+    uint8_t temp[MAX_CRYPTO_REQUEST_SIZE];
+    int len1 = decrypt_data(public_key, self_secret_key, nonce,
+                            packet + CRYPTO_SIZE, length - CRYPTO_SIZE, temp);
+
+    if (len1 == -1 || len1 == 0) {
+        crypto_memzero(temp, MAX_CRYPTO_REQUEST_SIZE);
         return -1;
     }
+
+    request_id[0] = temp[0];
+    --len1;
+    memcpy(data, temp + 1, len1);
+    crypto_memzero(temp, MAX_CRYPTO_REQUEST_SIZE);
+    return len1;
 }
 
-#define PACKED_NODE_SIZE_IP4 (1 + SIZE_IP4 + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES)
-#define PACKED_NODE_SIZE_IP6 (1 + SIZE_IP6 + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES)
+#define PACKED_NODE_SIZE_IP4 (1 + SIZE_IP4 + sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE)
+#define PACKED_NODE_SIZE_IP6 (1 + SIZE_IP6 + sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE)
 
 /* Return packet size of packed node with ip_family on success.
  * Return -1 on failure.
  */
-int packed_node_size(uint8_t ip_family)
+int packed_node_size(Family ip_family)
 {
-    if (ip_family == AF_INET) {
-        return PACKED_NODE_SIZE_IP4;
-    } else if (ip_family == TCP_INET) {
+    if (net_family_is_ipv4(ip_family) || net_family_is_tcp_ipv4(ip_family)) {
         return PACKED_NODE_SIZE_IP4;
-    } else if (ip_family == AF_INET6) {
-        return PACKED_NODE_SIZE_IP6;
-    } else if (ip_family == TCP_INET6) {
+    }
+
+    if (net_family_is_ipv6(ip_family) || net_family_is_tcp_ipv6(ip_family)) {
         return PACKED_NODE_SIZE_IP6;
+    }
+
+    return -1;
+}
+
+
+/* Packs an IP_Port structure into data of max size length.
+ *
+ * Returns size of packed IP_Port data on success
+ * Return -1 on failure.
+ */
+int pack_ip_port(uint8_t *data, uint16_t length, const IP_Port *ip_port)
+{
+    if (data == nullptr) {
+        return -1;
+    }
+
+    bool is_ipv4;
+    uint8_t net_family;
+
+    if (net_family_is_ipv4(ip_port->ip.family)) {
+        // TODO(irungentoo): use functions to convert endianness
+        is_ipv4 = true;
+        net_family = TOX_AF_INET;
+    } else if (net_family_is_tcp_ipv4(ip_port->ip.family)) {
+        is_ipv4 = true;
+        net_family = TOX_TCP_INET;
+    } else if (net_family_is_ipv6(ip_port->ip.family)) {
+        is_ipv4 = false;
+        net_family = TOX_AF_INET6;
+    } else if (net_family_is_tcp_ipv6(ip_port->ip.family)) {
+        is_ipv4 = false;
+        net_family = TOX_TCP_INET6;
+    } else {
+        return -1;
+    }
+
+    if (is_ipv4) {
+        const uint32_t size = 1 + SIZE_IP4 + sizeof(uint16_t);
+
+        if (size > length) {
+            return -1;
+        }
+
+        data[0] = net_family;
+        memcpy(data + 1, &ip_port->ip.ip.v4, SIZE_IP4);
+        memcpy(data + 1 + SIZE_IP4, &ip_port->port, sizeof(uint16_t));
+        return size;
     } else {
+        const uint32_t size = 1 + SIZE_IP6 + sizeof(uint16_t);
+
+        if (size > length) {
+            return -1;
+        }
+
+        data[0] = net_family;
+        memcpy(data + 1, &ip_port->ip.ip.v6, SIZE_IP6);
+        memcpy(data + 1 + SIZE_IP6, &ip_port->port, sizeof(uint16_t));
+        return size;
+    }
+}
+
+static int DHT_create_packet(const uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE],
+                             const uint8_t *shared_key, const uint8_t type, uint8_t *plain, size_t plain_length, uint8_t *packet)
+{
+    VLA(uint8_t, encrypted, plain_length + CRYPTO_MAC_SIZE);
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
+
+    random_nonce(nonce);
+
+    const int encrypted_length = encrypt_data_symmetric(shared_key, nonce, plain, plain_length, encrypted);
+
+    if (encrypted_length == -1) {
         return -1;
     }
+
+    packet[0] = type;
+    memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, encrypted, encrypted_length);
+
+    return 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + encrypted_length;
 }
 
+/* Unpack IP_Port structure from data of max size length into ip_port.
+ *
+ * Return size of unpacked ip_port on success.
+ * Return -1 on failure.
+ */
+int unpack_ip_port(IP_Port *ip_port, const uint8_t *data, uint16_t length, uint8_t tcp_enabled)
+{
+    if (data == nullptr) {
+        return -1;
+    }
+
+    bool is_ipv4;
+    Family host_family;
+
+    if (data[0] == TOX_AF_INET) {
+        is_ipv4 = true;
+        host_family = net_family_ipv4;
+    } else if (data[0] == TOX_TCP_INET) {
+        if (!tcp_enabled) {
+            return -1;
+        }
+
+        is_ipv4 = true;
+        host_family = net_family_tcp_ipv4;
+    } else if (data[0] == TOX_AF_INET6) {
+        is_ipv4 = false;
+        host_family = net_family_ipv6;
+    } else if (data[0] == TOX_TCP_INET6) {
+        if (!tcp_enabled) {
+            return -1;
+        }
+
+        is_ipv4 = false;
+        host_family = net_family_tcp_ipv6;
+    } else {
+        return -1;
+    }
+
+    if (is_ipv4) {
+        const uint32_t size = 1 + SIZE_IP4 + sizeof(uint16_t);
+
+        if (size > length) {
+            return -1;
+        }
+
+        ip_port->ip.family = host_family;
+        memcpy(&ip_port->ip.ip.v4, data + 1, SIZE_IP4);
+        memcpy(&ip_port->port, data + 1 + SIZE_IP4, sizeof(uint16_t));
+        return size;
+    } else {
+        const uint32_t size = 1 + SIZE_IP6 + sizeof(uint16_t);
+
+        if (size > length) {
+            return -1;
+        }
+
+        ip_port->ip.family = host_family;
+        memcpy(&ip_port->ip.ip.v6, data + 1, SIZE_IP6);
+        memcpy(&ip_port->port, data + 1 + SIZE_IP6, sizeof(uint16_t));
+        return size;
+    }
+}
 
 /* Pack number of nodes into data of maxlength length.
  *
@@ -227,54 +547,26 @@ int packed_node_size(uint8_t ip_family)
  */
 int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_t number)
 {
-    uint32_t i, packed_length = 0;
-
-    for (i = 0; i < number; ++i) {
-        int ipv6 = -1;
-        uint8_t net_family;
-
-        // FIXME use functions to convert endianness
-        if (nodes[i].ip_port.ip.family == AF_INET) {
-            ipv6 = 0;
-            net_family = TOX_AF_INET;
-        } else if (nodes[i].ip_port.ip.family == TCP_INET) {
-            ipv6 = 0;
-            net_family = TOX_TCP_INET;
-        } else if (nodes[i].ip_port.ip.family == AF_INET6) {
-            ipv6 = 1;
-            net_family = TOX_AF_INET6;
-        } else if (nodes[i].ip_port.ip.family == TCP_INET6) {
-            ipv6 = 1;
-            net_family = TOX_TCP_INET6;
-        } else {
-            return -1;
-        }
+    uint32_t packed_length = 0;
 
-        if (ipv6 == 0) {
-            uint32_t size = PACKED_NODE_SIZE_IP4;
+    for (uint32_t i = 0; i < number && packed_length < length; ++i) {
+        const int ipp_size = pack_ip_port(data + packed_length, length - packed_length, &nodes[i].ip_port);
 
-            if (packed_length + size > length)
-                return -1;
-
-            data[packed_length] = net_family;
-            memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip4, SIZE_IP4);
-            memcpy(data + packed_length + 1 + SIZE_IP4, &nodes[i].ip_port.port, sizeof(uint16_t));
-            memcpy(data + packed_length + 1 + SIZE_IP4 + sizeof(uint16_t), nodes[i].public_key, crypto_box_PUBLICKEYBYTES);
-            packed_length += size;
-        } else if (ipv6 == 1) {
-            uint32_t size = PACKED_NODE_SIZE_IP6;
+        if (ipp_size == -1) {
+            return -1;
+        }
 
-            if (packed_length + size > length)
-                return -1;
+        packed_length += ipp_size;
 
-            data[packed_length] = net_family;
-            memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip6, SIZE_IP6);
-            memcpy(data + packed_length + 1 + SIZE_IP6, &nodes[i].ip_port.port, sizeof(uint16_t));
-            memcpy(data + packed_length + 1 + SIZE_IP6 + sizeof(uint16_t), nodes[i].public_key, crypto_box_PUBLICKEYBYTES);
-            packed_length += size;
-        } else {
+        if (packed_length + CRYPTO_PUBLIC_KEY_SIZE > length) {
             return -1;
         }
+
+        memcpy(data + packed_length, nodes[i].public_key, CRYPTO_PUBLIC_KEY_SIZE);
+        packed_length += CRYPTO_PUBLIC_KEY_SIZE;
+
+        const uint32_t increment = ipp_size + CRYPTO_PUBLIC_KEY_SIZE;
+        assert(increment == PACKED_NODE_SIZE_IP4 || increment == PACKED_NODE_SIZE_IP6);
     }
 
     return packed_length;
@@ -293,200 +585,182 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
     uint32_t num = 0, len_processed = 0;
 
     while (num < max_num_nodes && len_processed < length) {
-        int ipv6 = -1;
-        uint8_t host_family;
-
-        if (data[len_processed] == TOX_AF_INET) {
-            ipv6 = 0;
-            host_family = AF_INET;
-        } else if (data[len_processed] == TOX_TCP_INET) {
-            if (!tcp_enabled)
-                return -1;
-
-            ipv6 = 0;
-            host_family = TCP_INET;
-        } else if (data[len_processed] == TOX_AF_INET6) {
-            ipv6 = 1;
-            host_family = AF_INET6;
-        } else if (data[len_processed] == TOX_TCP_INET6) {
-            if (!tcp_enabled)
-                return -1;
-
-            ipv6 = 1;
-            host_family = TCP_INET6;
-        } else {
+        const int ipp_size = unpack_ip_port(&nodes[num].ip_port, data + len_processed, length - len_processed, tcp_enabled);
+
+        if (ipp_size == -1) {
             return -1;
         }
 
-        if (ipv6 == 0) {
-            uint32_t size = PACKED_NODE_SIZE_IP4;
-
-            if (len_processed + size > length)
-                return -1;
-
-            nodes[num].ip_port.ip.family = host_family;
-            memcpy(&nodes[num].ip_port.ip.ip4, data + len_processed + 1, SIZE_IP4);
-            memcpy(&nodes[num].ip_port.port, data + len_processed + 1 + SIZE_IP4, sizeof(uint16_t));
-            memcpy(nodes[num].public_key, data + len_processed + 1 + SIZE_IP4 + sizeof(uint16_t), crypto_box_PUBLICKEYBYTES);
-            len_processed += size;
-            ++num;
-        } else if (ipv6 == 1) {
-            uint32_t size = PACKED_NODE_SIZE_IP6;
-
-            if (len_processed + size > length)
-                return -1;
+        len_processed += ipp_size;
 
-            nodes[num].ip_port.ip.family = host_family;
-            memcpy(&nodes[num].ip_port.ip.ip6, data + len_processed + 1, SIZE_IP6);
-            memcpy(&nodes[num].ip_port.port, data + len_processed + 1 + SIZE_IP6, sizeof(uint16_t));
-            memcpy(nodes[num].public_key, data + len_processed + 1 + SIZE_IP6 + sizeof(uint16_t), crypto_box_PUBLICKEYBYTES);
-            len_processed += size;
-            ++num;
-        } else {
+        if (len_processed + CRYPTO_PUBLIC_KEY_SIZE > length) {
             return -1;
         }
+
+        memcpy(nodes[num].public_key, data + len_processed, CRYPTO_PUBLIC_KEY_SIZE);
+        len_processed += CRYPTO_PUBLIC_KEY_SIZE;
+        ++num;
+
+        const uint32_t increment = ipp_size + CRYPTO_PUBLIC_KEY_SIZE;
+        assert(increment == PACKED_NODE_SIZE_IP4 || increment == PACKED_NODE_SIZE_IP6);
     }
 
-    if (processed_data_len)
+    if (processed_data_len) {
         *processed_data_len = len_processed;
+    }
 
     return num;
 }
 
-
-
-/* Check if client with public_key is already in list of length length.
- * If it is then set its corresponding timestamp to current time.
- * If the id is already in the list with a different ip_port, update it.
- *  TODO: Maybe optimize this.
+/* Find index of ##type with public_key equal to pk.
  *
- *  return True(1) or False(0)
+ *  return index or UINT32_MAX if not found.
  */
-static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const uint8_t *public_key, IP_Port ip_port)
-{
-    uint32_t i;
-    uint64_t temp_time = unix_time();
-
-    /* if public_key is in list, find it and maybe overwrite ip_port */
-    for (i = 0; i < length; ++i)
-        if (id_equal(list[i].public_key, public_key)) {
-            /* Refresh the client timestamp. */
-            if (ip_port.ip.family == AF_INET) {
-
-                LOGGER_SCOPE( if (!ipport_equal(&list[i].assoc4.ip_port, &ip_port)) {
-                LOGGER_TRACE("coipil[%u]: switching ipv4 from %s:%u to %s:%u", i,
-                             ip_ntoa(&list[i].assoc4.ip_port.ip), ntohs(list[i].assoc4.ip_port.port),
-                             ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
-                }
-                            );
+#define INDEX_OF_PK \
+    for (uint32_t i = 0; i < size; i++) { \
+        if (id_equal(array[i].public_key, pk)) { \
+            return i; \
+        } \
+    } \
+ \
+    return UINT32_MAX;
 
-                if (LAN_ip(list[i].assoc4.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0)
-                    return 1;
+static uint32_t index_of_client_pk(const Client_data *array, uint32_t size, const uint8_t *pk)
+{
+    INDEX_OF_PK
+}
 
-                list[i].assoc4.ip_port = ip_port;
-                list[i].assoc4.timestamp = temp_time;
-            } else if (ip_port.ip.family == AF_INET6) {
+static uint32_t index_of_friend_pk(const DHT_Friend *array, uint32_t size, const uint8_t *pk)
+{
+    INDEX_OF_PK
+}
 
-                LOGGER_SCOPE( if (!ipport_equal(&list[i].assoc4.ip_port, &ip_port)) {
-                LOGGER_TRACE("coipil[%u]: switching ipv6 from %s:%u to %s:%u", i,
-                             ip_ntoa(&list[i].assoc6.ip_port.ip), ntohs(list[i].assoc6.ip_port.port),
-                             ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
-                }
-                            );
+static uint32_t index_of_node_pk(const Node_format *array, uint32_t size, const uint8_t *pk)
+{
+    INDEX_OF_PK
+}
 
-                if (LAN_ip(list[i].assoc6.ip_port.ip) != 0 && LAN_ip(ip_port.ip) == 0)
-                    return 1;
+/* Find index of Client_data with ip_port equal to param ip_port.
+ *
+ * return index or UINT32_MAX if not found.
+ */
+static uint32_t index_of_client_ip_port(const Client_data *array, uint32_t size, const IP_Port *ip_port)
+{
+    for (uint32_t i = 0; i < size; ++i) {
+        if ((net_family_is_ipv4(ip_port->ip.family) && ipport_equal(&array[i].assoc4.ip_port, ip_port)) ||
+                (net_family_is_ipv6(ip_port->ip.family) && ipport_equal(&array[i].assoc6.ip_port, ip_port))) {
+            return i;
+        }
+    }
 
-                list[i].assoc6.ip_port = ip_port;
-                list[i].assoc6.timestamp = temp_time;
-            }
+    return UINT32_MAX;
+}
 
-            return 1;
-        }
+/* Update ip_port of client if it's needed.
+ */
+static void update_client(Logger *log, int index, Client_data *client, IP_Port ip_port)
+{
+    IPPTsPng *assoc;
+    int ip_version;
 
-    /* public_key not in list yet: see if we can find an identical ip_port, in
-     * that case we kill the old public_key by overwriting it with the new one
-     * TODO: maybe we SHOULDN'T do that if that public_key is in a friend_list
-     * and the one who is the actual friend's public_key/address set? */
-    for (i = 0; i < length; ++i) {
-        /* MAYBE: check the other address, if valid, don't nuke? */
-        if ((ip_port.ip.family == AF_INET) && ipport_equal(&list[i].assoc4.ip_port, &ip_port)) {
-            /* Initialize client timestamp. */
-            list[i].assoc4.timestamp = temp_time;
-            memcpy(list[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
-
-            LOGGER_DEBUG("coipil[%u]: switching public_key (ipv4)", i);
-
-            /* kill the other address, if it was set */
-            memset(&list[i].assoc6, 0, sizeof(list[i].assoc6));
-            return 1;
-        } else if ((ip_port.ip.family == AF_INET6) && ipport_equal(&list[i].assoc6.ip_port, &ip_port)) {
-            /* Initialize client timestamp. */
-            list[i].assoc6.timestamp = temp_time;
-            memcpy(list[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        assoc = &client->assoc4;
+        ip_version = 4;
+    } else if (net_family_is_ipv6(ip_port.ip.family)) {
+        assoc = &client->assoc6;
+        ip_version = 6;
+    } else {
+        return;
+    }
 
-            LOGGER_DEBUG("coipil[%u]: switching public_key (ipv6)", i);
+    if (!ipport_equal(&assoc->ip_port, &ip_port)) {
+        char ip_str[IP_NTOA_LEN];
+        LOGGER_TRACE(log, "coipil[%u]: switching ipv%d from %s:%u to %s:%u",
+                     index, ip_version,
+                     ip_ntoa(&assoc->ip_port.ip, ip_str, sizeof(ip_str)),
+                     net_ntohs(assoc->ip_port.port),
+                     ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)),
+                     net_ntohs(ip_port.port));
+    }
 
-            /* kill the other address, if it was set */
-            memset(&list[i].assoc4, 0, sizeof(list[i].assoc4));
-            return 1;
-        }
+    if (ip_is_lan(assoc->ip_port.ip) != 0 && ip_is_lan(ip_port.ip) == 0) {
+        return;
     }
 
-    return 0;
+    assoc->ip_port = ip_port;
+    assoc->timestamp = unix_time();
 }
 
-/* Check if client with public_key is already in node format list of length length.
+/* Check if client with public_key is already in list of length length.
+ * If it is then set its corresponding timestamp to current time.
+ * If the id is already in the list with a different ip_port, update it.
+ * TODO(irungentoo): Maybe optimize this.
  *
- *  return 1 if true.
- *  return 0 if false.
+ *  return True(1) or False(0)
  */
-static int client_in_nodelist(const Node_format *list, uint16_t length, const uint8_t *public_key)
+static int client_or_ip_port_in_list(Logger *log, Client_data *list, uint16_t length, const uint8_t *public_key,
+                                     IP_Port ip_port)
 {
-    uint32_t i;
+    const uint64_t temp_time = unix_time();
+    uint32_t index = index_of_client_pk(list, length, public_key);
 
-    for (i = 0; i < length; ++i) {
-        if (id_equal(list[i].public_key, public_key))
-            return 1;
+    /* if public_key is in list, find it and maybe overwrite ip_port */
+    if (index != UINT32_MAX) {
+        update_client(log, index, &list[index], ip_port);
+        return 1;
     }
 
-    return 0;
-}
+    /* public_key not in list yet: see if we can find an identical ip_port, in
+     * that case we kill the old public_key by overwriting it with the new one
+     * TODO(irungentoo): maybe we SHOULDN'T do that if that public_key is in a friend_list
+     * and the one who is the actual friend's public_key/address set?
+     * MAYBE: check the other address, if valid, don't nuke? */
+    index = index_of_client_ip_port(list, length, &ip_port);
 
-/*  return friend number from the public_key.
- *  return -1 if a failure occurs.
- */
-static int friend_number(const DHT *dht, const uint8_t *public_key)
-{
-    uint32_t i;
+    if (index == UINT32_MAX) {
+        return 0;
+    }
 
-    for (i = 0; i < dht->num_friends; ++i) {
-        if (id_equal(dht->friends_list[i].public_key, public_key))
-            return i;
+    IPPTsPng *assoc;
+    int ip_version;
+
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        assoc = &list[index].assoc4;
+        ip_version = 4;
+    } else {
+        assoc = &list[index].assoc6;
+        ip_version = 6;
     }
 
-    return -1;
+    /* Initialize client timestamp. */
+    assoc->timestamp = temp_time;
+    memcpy(list[index].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+
+    LOGGER_DEBUG(log, "coipil[%u]: switching public_key (ipv%d)", index, ip_version);
+
+    /* kill the other address, if it was set */
+    memset(assoc, 0, sizeof(IPPTsPng));
+    return 1;
 }
 
 /* Add node to the node list making sure only the nodes closest to cmp_pk are in the list.
  */
-_Bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *pk, IP_Port ip_port,
-                  const uint8_t *cmp_pk)
+bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *pk, IP_Port ip_port,
+                 const uint8_t *cmp_pk)
 {
-    uint8_t pk_bak[crypto_box_PUBLICKEYBYTES];
+    uint8_t pk_bak[CRYPTO_PUBLIC_KEY_SIZE];
     IP_Port ip_port_bak;
 
-    unsigned int i;
-
-    for (i = 0; i < length; ++i) {
+    for (size_t i = 0; i < length; ++i) {
         if (id_closest(cmp_pk, nodes_list[i].public_key, pk) == 2) {
-            memcpy(pk_bak, nodes_list[i].public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(pk_bak, nodes_list[i].public_key, CRYPTO_PUBLIC_KEY_SIZE);
             ip_port_bak = nodes_list[i].ip_port;
-            memcpy(nodes_list[i].public_key, pk, crypto_box_PUBLICKEYBYTES);
+            memcpy(nodes_list[i].public_key, pk, CRYPTO_PUBLIC_KEY_SIZE);
             nodes_list[i].ip_port = ip_port;
 
-            if (i != (length - 1))
+            if (i != (length - 1)) {
                 add_to_list(nodes_list, length, pk_bak, ip_port_bak, cmp_pk);
+            }
 
             return 1;
         }
@@ -495,7 +769,7 @@ _Bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *p
     return 0;
 }
 
-/*TODO: change this to 7 when done*/
+/* TODO(irungentoo): change this to 7 when done*/
 #define HARDENING_ALL_OK 2
 /* return 0 if not.
  * return 1 if route request are ok
@@ -511,53 +785,52 @@ static uint8_t hardening_correct(const Hardening *h)
  * helper for get_close_nodes(). argument list is a monster :D
  */
 static void get_close_nodes_inner(const uint8_t *public_key, Node_format *nodes_list,
-                                  sa_family_t sa_family, const Client_data *client_list, uint32_t client_list_length,
+                                  Family sa_family, const Client_data *client_list, uint32_t client_list_length,
                                   uint32_t *num_nodes_ptr, uint8_t is_LAN, uint8_t want_good)
 {
-    if ((sa_family != AF_INET) && (sa_family != AF_INET6) && (sa_family != 0))
+    if (!net_family_is_ipv4(sa_family) && !net_family_is_ipv6(sa_family) && !net_family_is_unspec(sa_family)) {
         return;
+    }
 
     uint32_t num_nodes = *num_nodes_ptr;
-    uint32_t i;
 
-    for (i = 0; i < client_list_length; i++) {
-        const Client_data *client = &client_list[i];
+    for (uint32_t i = 0; i < client_list_length; i++) {
+        const Client_data *const client = &client_list[i];
 
         /* node already in list? */
-        if (client_in_nodelist(nodes_list, MAX_SENT_NODES, client->public_key))
+        if (index_of_node_pk(nodes_list, MAX_SENT_NODES, client->public_key) != UINT32_MAX) {
             continue;
+        }
 
-        const IPPTsPng *ipptp = NULL;
+        const IPPTsPng *ipptp = nullptr;
 
-        if (sa_family == AF_INET) {
+        if (net_family_is_ipv4(sa_family)) {
             ipptp = &client->assoc4;
-        } else if (sa_family == AF_INET6) {
+        } else if (net_family_is_ipv6(sa_family)) {
             ipptp = &client->assoc6;
+        } else if (client->assoc4.timestamp >= client->assoc6.timestamp) {
+            ipptp = &client->assoc4;
         } else {
-            if (client->assoc4.timestamp >= client->assoc6.timestamp) {
-                ipptp = &client->assoc4;
-            } else {
-                ipptp = &client->assoc6;
-            }
+            ipptp = &client->assoc6;
         }
 
         /* node not in a good condition? */
-        if (is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT))
+        if (is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT)) {
             continue;
+        }
 
         /* don't send LAN ips to non LAN peers */
-        if (LAN_ip(ipptp->ip_port.ip) == 0 && !is_LAN)
+        if (ip_is_lan(ipptp->ip_port.ip) == 0 && !is_LAN) {
             continue;
+        }
 
-        if (LAN_ip(ipptp->ip_port.ip) != 0 && want_good && hardening_correct(&ipptp->hardening) != HARDENING_ALL_OK
-                && !id_equal(public_key, client->public_key))
+        if (ip_is_lan(ipptp->ip_port.ip) != 0 && want_good && hardening_correct(&ipptp->hardening) != HARDENING_ALL_OK
+                && !id_equal(public_key, client->public_key)) {
             continue;
+        }
 
         if (num_nodes < MAX_SENT_NODES) {
-            memcpy(nodes_list[num_nodes].public_key,
-                   client->public_key,
-                   crypto_box_PUBLICKEYBYTES );
-
+            memcpy(nodes_list[num_nodes].public_key, client->public_key, CRYPTO_PUBLIC_KEY_SIZE);
             nodes_list[num_nodes].ip_port = ipptp->ip_port;
             num_nodes++;
         } else {
@@ -571,130 +844,98 @@ static void get_close_nodes_inner(const uint8_t *public_key, Node_format *nodes_
 /* Find MAX_SENT_NODES nodes closest to the public_key for the send nodes request:
  * put them in the nodes_list and return how many were found.
  *
- * TODO: For the love of based <your favorite deity, in doubt use "love"> make
- * this function cleaner and much more efficient.
+ * TODO(irungentoo): For the love of based <your favorite deity, in doubt use
+ * "love"> make this function cleaner and much more efficient.
  *
  * want_good : do we want only good nodes as checked with the hardening returned or not?
  */
 static int get_somewhat_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list,
-                                    sa_family_t sa_family, uint8_t is_LAN, uint8_t want_good)
+                                    Family sa_family, uint8_t is_LAN, uint8_t want_good)
 {
-    uint32_t num_nodes = 0, i;
+    uint32_t num_nodes = 0;
     get_close_nodes_inner(public_key, nodes_list, sa_family,
                           dht->close_clientlist, LCLIENT_LIST, &num_nodes, is_LAN, 0);
 
-    /*TODO uncomment this when hardening is added to close friend clients
-        for (i = 0; i < dht->num_friends; ++i)
-            get_close_nodes_inner(dht, public_key, nodes_list, sa_family,
-                                  dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
-                                  &num_nodes, is_LAN, want_good);
-    */
-    for (i = 0; i < dht->num_friends; ++i)
+    /* TODO(irungentoo): uncomment this when hardening is added to close friend clients */
+#if 0
+
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
+        get_close_nodes_inner(dht, public_key, nodes_list, sa_family,
+                              dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
+                              &num_nodes, is_LAN, want_good);
+    }
+
+#endif
+
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
         get_close_nodes_inner(public_key, nodes_list, sa_family,
                               dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
                               &num_nodes, is_LAN, 0);
+    }
 
     return num_nodes;
 }
 
-int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list, sa_family_t sa_family,
+int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list, Family sa_family,
                     uint8_t is_LAN, uint8_t want_good)
 {
     memset(nodes_list, 0, MAX_SENT_NODES * sizeof(Node_format));
-#ifdef ENABLE_ASSOC_DHT
+    return get_somewhat_close_nodes(dht, public_key, nodes_list, sa_family, is_LAN, want_good);
+}
 
-    if (!dht->assoc)
-#endif
-        return get_somewhat_close_nodes(dht, public_key, nodes_list, sa_family, is_LAN, want_good);
+typedef struct {
+    const uint8_t *base_public_key;
+    Client_data entry;
+} DHT_Cmp_data;
 
-#ifdef ENABLE_ASSOC_DHT
-    //TODO: assoc, sa_family 0 (don't care if ipv4 or ipv6) support.
-    Client_data *result[MAX_SENT_NODES];
+static int cmp_dht_entry(const void *a, const void *b)
+{
+    DHT_Cmp_data cmp1, cmp2;
+    memcpy(&cmp1, a, sizeof(DHT_Cmp_data));
+    memcpy(&cmp2, b, sizeof(DHT_Cmp_data));
+    const Client_data entry1 = cmp1.entry;
+    const Client_data entry2 = cmp2.entry;
+    const uint8_t *cmp_public_key = cmp1.base_public_key;
 
-    Assoc_close_entries request;
-    memset(&request, 0, sizeof(request));
-    request.count = MAX_SENT_NODES;
-    request.count_good = MAX_SENT_NODES - 2; /* allow 2 'indirect' nodes */
-    request.result = result;
-    request.wanted_id = public_key;
-    request.flags = (is_LAN ? LANOk : 0) + (sa_family == AF_INET ? ProtoIPv4 : ProtoIPv6);
+#define ASSOC_TIMEOUT(assoc) is_timeout((assoc).timestamp, BAD_NODE_TIMEOUT)
 
-    uint8_t num_found = Assoc_get_close_entries(dht->assoc, &request);
+    bool t1 = ASSOC_TIMEOUT(entry1.assoc4) && ASSOC_TIMEOUT(entry1.assoc6);
+    bool t2 = ASSOC_TIMEOUT(entry2.assoc4) && ASSOC_TIMEOUT(entry2.assoc6);
 
-    if (!num_found) {
-        LOGGER_DEBUG("get_close_nodes(): Assoc_get_close_entries() returned zero nodes");
-        return get_somewhat_close_nodes(dht, public_key, nodes_list, sa_family, is_LAN, want_good);
+    if (t1 && t2) {
+        return 0;
     }
 
-    LOGGER_DEBUG("get_close_nodes(): Assoc_get_close_entries() returned %i 'direct' and %i 'indirect' nodes",
-                 request.count_good, num_found - request.count_good);
-
-    uint8_t i, num_returned = 0;
-
-    for (i = 0; i < num_found; i++) {
-        Client_data *client = result[i];
-
-        if (client) {
-            id_copy(nodes_list[num_returned].public_key, client->public_key);
-
-            if (sa_family == AF_INET)
-                if (ipport_isset(&client->assoc4.ip_port)) {
-                    nodes_list[num_returned].ip_port = client->assoc4.ip_port;
-                    num_returned++;
-                    continue;
-                }
-
-            if (sa_family == AF_INET6)
-                if (ipport_isset(&client->assoc6.ip_port)) {
-                    nodes_list[num_returned].ip_port = client->assoc6.ip_port;
-                    num_returned++;
-                    continue;
-                }
-        }
+    if (t1) {
+        return -1;
     }
 
-    return num_returned;
-#endif
-}
+    if (t2) {
+        return 1;
+    }
 
-static uint8_t cmp_public_key[crypto_box_PUBLICKEYBYTES];
-static int cmp_dht_entry(const void *a, const void *b)
-{
-    Client_data entry1, entry2;
-    memcpy(&entry1, a, sizeof(Client_data));
-    memcpy(&entry2, b, sizeof(Client_data));
-    int t1 = is_timeout(entry1.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry1.assoc6.timestamp, BAD_NODE_TIMEOUT);
-    int t2 = is_timeout(entry2.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry2.assoc6.timestamp, BAD_NODE_TIMEOUT);
+#define INCORRECT_HARDENING(assoc) hardening_correct(&(assoc).hardening) != HARDENING_ALL_OK
 
-    if (t1 && t2)
-        return 0;
+    t1 = INCORRECT_HARDENING(entry1.assoc4) && INCORRECT_HARDENING(entry1.assoc6);
+    t2 = INCORRECT_HARDENING(entry2.assoc4) && INCORRECT_HARDENING(entry2.assoc6);
 
-    if (t1)
+    if (t1 && !t2) {
         return -1;
+    }
 
-    if (t2)
+    if (!t1 && t2) {
         return 1;
-
-    t1 = hardening_correct(&entry1.assoc4.hardening) != HARDENING_ALL_OK
-         && hardening_correct(&entry1.assoc6.hardening) != HARDENING_ALL_OK;
-    t2 = hardening_correct(&entry2.assoc4.hardening) != HARDENING_ALL_OK
-         && hardening_correct(&entry2.assoc6.hardening) != HARDENING_ALL_OK;
-
-    if (t1 != t2) {
-        if (t1)
-            return -1;
-
-        if (t2)
-            return 1;
     }
 
-    int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
+    const int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
 
-    if (close == 1)
+    if (close == 1) {
         return 1;
+    }
 
-    if (close == 2)
+    if (close == 2) {
         return -1;
+    }
 
     return 0;
 }
@@ -706,18 +947,51 @@ static int cmp_dht_entry(const void *a, const void *b)
  */
 static unsigned int store_node_ok(const Client_data *client, const uint8_t *public_key, const uint8_t *comp_public_key)
 {
-    if ((is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT))
-            || (id_closest(comp_public_key, client->public_key, public_key) == 2)) {
-        return 1;
-    } else {
-        return 0;
-    }
+    return (is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT)
+            && is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT))
+           || id_closest(comp_public_key, client->public_key, public_key) == 2;
 }
 
 static void sort_client_list(Client_data *list, unsigned int length, const uint8_t *comp_public_key)
 {
-    memcpy(cmp_public_key, comp_public_key, crypto_box_PUBLICKEYBYTES);
-    qsort(list, length, sizeof(Client_data), cmp_dht_entry);
+    // Pass comp_public_key to qsort with each Client_data entry, so the
+    // comparison function can use it as the base of comparison.
+    VLA(DHT_Cmp_data, cmp_list, length);
+
+    for (uint32_t i = 0; i < length; i++) {
+        cmp_list[i].base_public_key = comp_public_key;
+        cmp_list[i].entry = list[i];
+    }
+
+    qsort(cmp_list, length, sizeof(DHT_Cmp_data), cmp_dht_entry);
+
+    for (uint32_t i = 0; i < length; i++) {
+        list[i] = cmp_list[i].entry;
+    }
+}
+
+static void update_client_with_reset(Client_data *client, const IP_Port *ip_port)
+{
+    IPPTsPng *ipptp_write = nullptr;
+    IPPTsPng *ipptp_clear = nullptr;
+
+    if (net_family_is_ipv4(ip_port->ip.family)) {
+        ipptp_write = &client->assoc4;
+        ipptp_clear = &client->assoc6;
+    } else {
+        ipptp_write = &client->assoc6;
+        ipptp_clear = &client->assoc4;
+    }
+
+    ipptp_write->ip_port = *ip_port;
+    ipptp_write->timestamp = unix_time();
+
+    ip_reset(&ipptp_write->ret_ip_port.ip);
+    ipptp_write->ret_ip_port.port = 0;
+    ipptp_write->ret_timestamp = 0;
+
+    /* zero out other address */
+    memset(ipptp_clear, 0, sizeof(*ipptp_clear));
 }
 
 /* Replace a first bad (or empty) node with this one
@@ -732,47 +1006,29 @@ static void sort_client_list(Client_data *list, unsigned int length, const uint8
  *  and all nodes in the list are closer to comp_public_key
  *  than public_key.
  *
- *  returns True(1) when the item was stored, False(0) otherwise */
-static int replace_all(   Client_data    *list,
-                          uint16_t        length,
-                          const uint8_t  *public_key,
-                          IP_Port         ip_port,
-                          const uint8_t  *comp_public_key )
-{
-    if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6))
-        return 0;
-
-    if (store_node_ok(&list[1], public_key, comp_public_key) || store_node_ok(&list[0], public_key, comp_public_key)) {
-        sort_client_list(list, length, comp_public_key);
-
-        IPPTsPng *ipptp_write = NULL;
-        IPPTsPng *ipptp_clear = NULL;
-
-        Client_data *client = &list[0];
-
-        if (ip_port.ip.family == AF_INET) {
-            ipptp_write = &client->assoc4;
-            ipptp_clear = &client->assoc6;
-        } else {
-            ipptp_write = &client->assoc6;
-            ipptp_clear = &client->assoc4;
-        }
-
-        id_copy(client->public_key, public_key);
-        ipptp_write->ip_port = ip_port;
-        ipptp_write->timestamp = unix_time();
+ *  returns true when the item was stored, false otherwise */
+static bool replace_all(Client_data    *list,
+                        uint16_t        length,
+                        const uint8_t  *public_key,
+                        IP_Port         ip_port,
+                        const uint8_t  *comp_public_key)
+{
+    if (!net_family_is_ipv4(ip_port.ip.family) && !net_family_is_ipv6(ip_port.ip.family)) {
+        return false;
+    }
 
-        ip_reset(&ipptp_write->ret_ip_port.ip);
-        ipptp_write->ret_ip_port.port = 0;
-        ipptp_write->ret_timestamp = 0;
+    if (!store_node_ok(&list[1], public_key, comp_public_key) &&
+            !store_node_ok(&list[0], public_key, comp_public_key)) {
+        return false;
+    }
 
-        /* zero out other address */
-        memset(ipptp_clear, 0, sizeof(*ipptp_clear));
+    sort_client_list(list, length, comp_public_key);
 
-        return 1;
-    }
+    Client_data *const client = &list[0];
+    id_copy(client->public_key, public_key);
 
-    return 0;
+    update_client_with_reset(client, &ip_port);
+    return true;
 }
 
 /* Add node to close list.
@@ -782,45 +1038,31 @@ static int replace_all(   Client_data    *list,
  * return -1 on failure.
  * return 0 on success.
  */
-static int add_to_close(DHT *dht, const uint8_t *public_key, IP_Port ip_port, _Bool simulate)
+static int add_to_close(DHT *dht, const uint8_t *public_key, IP_Port ip_port, bool simulate)
 {
-    unsigned int i;
-
     unsigned int index = bit_by_bit_cmp(public_key, dht->self_public_key);
 
-    if (index > LCLIENT_LENGTH)
+    if (index >= LCLIENT_LENGTH) {
         index = LCLIENT_LENGTH - 1;
+    }
 
-    for (i = 0; i < LCLIENT_NODES; ++i) {
-        Client_data *client = &dht->close_clientlist[(index * LCLIENT_NODES) + i];
-
-        if (is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)) {
-            if (!simulate) {
-                IPPTsPng *ipptp_write = NULL;
-                IPPTsPng *ipptp_clear = NULL;
-
-                if (ip_port.ip.family == AF_INET) {
-                    ipptp_write = &client->assoc4;
-                    ipptp_clear = &client->assoc6;
-                } else {
-                    ipptp_write = &client->assoc6;
-                    ipptp_clear = &client->assoc4;
-                }
-
-                id_copy(client->public_key, public_key);
-                ipptp_write->ip_port = ip_port;
-                ipptp_write->timestamp = unix_time();
-
-                ip_reset(&ipptp_write->ret_ip_port.ip);
-                ipptp_write->ret_ip_port.port = 0;
-                ipptp_write->ret_timestamp = 0;
+    for (uint32_t i = 0; i < LCLIENT_NODES; ++i) {
+        /* TODO(iphydf): write bounds checking test to catch the case that
+         * index is left as >= LCLIENT_LENGTH */
+        Client_data *const client = &dht->close_clientlist[(index * LCLIENT_NODES) + i];
 
-                /* zero out other address */
-                memset(ipptp_clear, 0, sizeof(*ipptp_clear));
-            }
+        if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) ||
+                !is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)) {
+            continue;
+        }
 
+        if (simulate) {
             return 0;
         }
+
+        id_copy(client->public_key, public_key);
+        update_client_with_reset(client, &ip_port);
+        return 0;
     }
 
     return -1;
@@ -828,83 +1070,97 @@ static int add_to_close(DHT *dht, const uint8_t *public_key, IP_Port ip_port, _B
 
 /* Return 1 if node can be added to close list, 0 if it can't.
  */
-_Bool node_addable_to_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port)
+bool node_addable_to_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port)
 {
-    if (add_to_close(dht, public_key, ip_port, 1) == 0) {
-        return 1;
+    return add_to_close(dht, public_key, ip_port, 1) == 0;
+}
+
+static bool is_pk_in_client_list(const Client_data *list, unsigned int client_list_length, const uint8_t *public_key,
+                                 IP_Port ip_port)
+{
+    const uint32_t index = index_of_client_pk(list, client_list_length, public_key);
+
+    if (index == UINT32_MAX) {
+        return 0;
     }
 
-    return 0;
+    const IPPTsPng *assoc = net_family_is_ipv4(ip_port.ip.family)
+                            ? &list[index].assoc4
+                            : &list[index].assoc6;
+
+    return !is_timeout(assoc->timestamp, BAD_NODE_TIMEOUT);
 }
 
-static _Bool is_pk_in_client_list(Client_data *list, unsigned int client_list_length, const uint8_t *public_key,
-                                  IP_Port ip_port)
+static bool is_pk_in_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port)
 {
-    unsigned int i;
+    unsigned int index = bit_by_bit_cmp(public_key, dht->self_public_key);
 
-    for (i = 0; i < client_list_length; ++i) {
-        if ((ip_port.ip.family == AF_INET && !is_timeout(list[i].assoc4.timestamp, BAD_NODE_TIMEOUT))
-                || (ip_port.ip.family == AF_INET6 && !is_timeout(list[i].assoc6.timestamp, BAD_NODE_TIMEOUT))) {
-            if (public_key_cmp(list[i].public_key, public_key) == 0) {
-                return 1;
-            }
-        }
+    if (index >= LCLIENT_LENGTH) {
+        index = LCLIENT_LENGTH - 1;
     }
 
-    return 0;
+    return is_pk_in_client_list(dht->close_clientlist + index * LCLIENT_NODES, LCLIENT_NODES, public_key, ip_port);
 }
 
 /* Check if the node obtained with a get_nodes with public_key should be pinged.
  * NOTE: for best results call it after addto_lists;
  *
- * return 0 if the node should not be pinged.
- * return 1 if it should.
+ * return false if the node should not be pinged.
+ * return true if it should.
  */
-static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_key, IP_Port ip_port)
+static bool ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_key, IP_Port ip_port)
 {
-    _Bool ret = 0;
+    bool ret = false;
 
     if (add_to_close(dht, public_key, ip_port, 1) == 0) {
-        ret = 1;
+        ret = true;
     }
 
-    if (ret && !client_in_nodelist(dht->to_bootstrap, dht->num_to_bootstrap, public_key)) {
-        if (dht->num_to_bootstrap < MAX_CLOSE_TO_BOOTSTRAP_NODES) {
-            memcpy(dht->to_bootstrap[dht->num_to_bootstrap].public_key, public_key, crypto_box_PUBLICKEYBYTES);
-            dht->to_bootstrap[dht->num_to_bootstrap].ip_port = ip_port;
-            ++dht->num_to_bootstrap;
-        } else {
-            //TODO: ipv6 vs v4
-            add_to_list(dht->to_bootstrap, MAX_CLOSE_TO_BOOTSTRAP_NODES, public_key, ip_port, dht->self_public_key);
+    {
+        unsigned int *const num = &dht->num_to_bootstrap;
+        const uint32_t index = index_of_node_pk(dht->to_bootstrap, *num, public_key);
+        const bool in_close_list = is_pk_in_close_list(dht, public_key, ip_port);
+
+        if (ret && index == UINT32_MAX && !in_close_list) {
+            if (*num < MAX_CLOSE_TO_BOOTSTRAP_NODES) {
+                memcpy(dht->to_bootstrap[*num].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+                dht->to_bootstrap[*num].ip_port = ip_port;
+                ++*num;
+            } else {
+                // TODO(irungentoo): ipv6 vs v4
+                add_to_list(dht->to_bootstrap, MAX_CLOSE_TO_BOOTSTRAP_NODES, public_key, ip_port, dht->self_public_key);
+            }
         }
     }
 
-    unsigned int i;
-
-    for (i = 0; i < dht->num_friends; ++i) {
-        _Bool store_ok = 0;
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
+        DHT_Friend *dht_friend = &dht->friends_list[i];
 
-        DHT_Friend *friend = &dht->friends_list[i];
+        bool store_ok = false;
 
-        if (store_node_ok(&friend->client_list[1], public_key, friend->public_key)) {
-            store_ok = 1;
+        if (store_node_ok(&dht_friend->client_list[1], public_key, dht_friend->public_key)) {
+            store_ok = true;
         }
 
-        if (store_node_ok(&friend->client_list[0], public_key, friend->public_key)) {
-            store_ok = 1;
+        if (store_node_ok(&dht_friend->client_list[0], public_key, dht_friend->public_key)) {
+            store_ok = true;
         }
 
-        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;
+        unsigned int *const friend_num = &dht_friend->num_to_bootstrap;
+        const uint32_t index = index_of_node_pk(dht_friend->to_bootstrap, *friend_num, public_key);
+        const bool pk_in_list = is_pk_in_client_list(dht_friend->client_list, MAX_FRIEND_CLIENTS, public_key, ip_port);
+
+        if (store_ok && index == UINT32_MAX && !pk_in_list) {
+            if (*friend_num < MAX_SENT_NODES) {
+                Node_format *const format = &dht_friend->to_bootstrap[*friend_num];
+                memcpy(format->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+                format->ip_port = ip_port;
+                ++*friend_num;
             } 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;
+            ret = true;
         }
     }
 
@@ -916,143 +1172,110 @@ static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_k
  *
  *  returns 1+ if the item is used in any list, 0 else
  */
-int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
+uint32_t addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
 {
-    uint32_t i, used = 0;
+    uint32_t used = 0;
 
     /* convert IPv4-in-IPv6 to IPv4 */
-    if ((ip_port.ip.family == AF_INET6) && IPV6_IPV4_IN_V6(ip_port.ip.ip6)) {
-        ip_port.ip.family = AF_INET;
-        ip_port.ip.ip4.uint32 = ip_port.ip.ip6.uint32[3];
+    if (net_family_is_ipv6(ip_port.ip.family) && IPV6_IPV4_IN_V6(ip_port.ip.ip.v6)) {
+        ip_port.ip.family = net_family_ipv4;
+        ip_port.ip.ip.v4.uint32 = ip_port.ip.ip.v6.uint32[3];
     }
 
     /* NOTE: Current behavior if there are two clients with the same id is
      * to replace the first ip by the second.
      */
-    if (!client_or_ip_port_in_list(dht->close_clientlist, LCLIENT_LIST, public_key, ip_port)) {
-        if (add_to_close(dht, public_key, ip_port, 0))
-            used++;
-    } else
-        used++;
-
-    DHT_Friend *friend_foundip = 0;
+    const bool in_close_list = client_or_ip_port_in_list(dht->log, dht->close_clientlist,
+                               LCLIENT_LIST, public_key, ip_port);
 
-    for (i = 0; i < dht->num_friends; ++i) {
-        if (!client_or_ip_port_in_list(dht->friends_list[i].client_list,
-                                       MAX_FRIEND_CLIENTS, public_key, ip_port)) {
-            if (replace_all(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
-                            public_key, ip_port, dht->friends_list[i].public_key)) {
+    /* add_to_close should be called only if !in_list (don't extract to variable) */
+    if (in_close_list || add_to_close(dht, public_key, ip_port, 0)) {
+        used++;
+    }
 
-                DHT_Friend *friend = &dht->friends_list[i];
+    DHT_Friend *friend_foundip = nullptr;
 
-                if (public_key_cmp(public_key, friend->public_key) == 0) {
-                    friend_foundip = friend;
-                }
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
+        const bool in_list = client_or_ip_port_in_list(dht->log, dht->friends_list[i].client_list,
+                             MAX_FRIEND_CLIENTS, public_key, ip_port);
 
-                used++;
-            }
-        } else {
-            DHT_Friend *friend = &dht->friends_list[i];
+        /* replace_all should be called only if !in_list (don't extract to variable) */
+        if (in_list || replace_all(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, public_key,
+                                   ip_port, dht->friends_list[i].public_key)) {
+            DHT_Friend *dht_friend = &dht->friends_list[i];
 
-            if (public_key_cmp(public_key, friend->public_key) == 0) {
-                friend_foundip = friend;
+            if (id_equal(public_key, dht_friend->public_key)) {
+                friend_foundip = dht_friend;
             }
 
             used++;
         }
     }
 
-    if (friend_foundip) {
-        uint32_t j;
+    if (!friend_foundip) {
+        return used;
+    }
 
-        for (j = 0; j < friend_foundip->lock_count; ++j) {
-            if (friend_foundip->callbacks[j].ip_callback)
-                friend_foundip->callbacks[j].ip_callback(friend_foundip->callbacks[j].data, friend_foundip->callbacks[j].number,
-                        ip_port);
+    for (uint32_t i = 0; i < friend_foundip->lock_count; ++i) {
+        if (friend_foundip->callbacks[i].ip_callback) {
+            friend_foundip->callbacks[i].ip_callback(friend_foundip->callbacks[i].data,
+                    friend_foundip->callbacks[i].number, ip_port);
         }
     }
 
-#ifdef ENABLE_ASSOC_DHT
+    return used;
+}
 
-    if (dht->assoc) {
-        IPPTs ippts;
+static bool update_client_data(Client_data *array, size_t size, IP_Port ip_port, const uint8_t *pk)
+{
+    const uint64_t temp_time = unix_time();
+    const uint32_t index = index_of_client_pk(array, size, pk);
+
+    if (index == UINT32_MAX) {
+        return false;
+    }
 
-        ippts.ip_port = ip_port;
-        ippts.timestamp = unix_time();
+    Client_data *const data = &array[index];
+    IPPTsPng *assoc;
 
-        Assoc_add_entry(dht->assoc, public_key, &ippts, NULL, used ? 1 : 0);
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        assoc = &data->assoc4;
+    } else if (net_family_is_ipv6(ip_port.ip.family)) {
+        assoc = &data->assoc6;
+    } else {
+        return true;
     }
 
-#endif
-    return used;
+    assoc->ret_ip_port = ip_port;
+    assoc->ret_timestamp = temp_time;
+    return true;
 }
 
 /* If public_key is a friend or us, update ret_ip_port
  * nodepublic_key is the id of the node that sent us this info.
  */
-static int returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t *nodepublic_key)
+static void returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t *nodepublic_key)
 {
-    uint32_t i, j;
-    uint64_t temp_time = unix_time();
-
-    uint32_t used = 0;
-
     /* convert IPv4-in-IPv6 to IPv4 */
-    if ((ip_port.ip.family == AF_INET6) && IPV6_IPV4_IN_V6(ip_port.ip.ip6)) {
-        ip_port.ip.family = AF_INET;
-        ip_port.ip.ip4.uint32 = ip_port.ip.ip6.uint32[3];
+    if (net_family_is_ipv6(ip_port.ip.family) && IPV6_IPV4_IN_V6(ip_port.ip.ip.v6)) {
+        ip_port.ip.family = net_family_ipv4;
+        ip_port.ip.ip.v4.uint32 = ip_port.ip.ip.v6.uint32[3];
     }
 
     if (id_equal(public_key, dht->self_public_key)) {
-        for (i = 0; i < LCLIENT_LIST; ++i) {
-            if (id_equal(nodepublic_key, dht->close_clientlist[i].public_key)) {
-                if (ip_port.ip.family == AF_INET) {
-                    dht->close_clientlist[i].assoc4.ret_ip_port = ip_port;
-                    dht->close_clientlist[i].assoc4.ret_timestamp = temp_time;
-                } else if (ip_port.ip.family == AF_INET6) {
-                    dht->close_clientlist[i].assoc6.ret_ip_port = ip_port;
-                    dht->close_clientlist[i].assoc6.ret_timestamp = temp_time;
-                }
-
-                ++used;
-                break;
-            }
-        }
-    } else {
-        for (i = 0; i < dht->num_friends; ++i) {
-            if (id_equal(public_key, dht->friends_list[i].public_key)) {
-                for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                    if (id_equal(nodepublic_key, dht->friends_list[i].client_list[j].public_key)) {
-                        if (ip_port.ip.family == AF_INET) {
-                            dht->friends_list[i].client_list[j].assoc4.ret_ip_port = ip_port;
-                            dht->friends_list[i].client_list[j].assoc4.ret_timestamp = temp_time;
-                        } else if (ip_port.ip.family == AF_INET6) {
-                            dht->friends_list[i].client_list[j].assoc6.ret_ip_port = ip_port;
-                            dht->friends_list[i].client_list[j].assoc6.ret_timestamp = temp_time;
-                        }
-
-                        ++used;
-                        goto end;
-                    }
-                }
-            }
-        }
+        update_client_data(dht->close_clientlist, LCLIENT_LIST, ip_port, nodepublic_key);
+        return;
     }
 
-end:
-#ifdef ENABLE_ASSOC_DHT
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
+        if (id_equal(public_key, dht->friends_list[i].public_key)) {
+            Client_data *const client_list = dht->friends_list[i].client_list;
 
-    if (dht->assoc) {
-        IPPTs ippts;
-        ippts.ip_port = ip_port;
-        ippts.timestamp = temp_time;
-        /* this is only a hear-say entry, so ret-ipp is NULL, but used is required
-         * to decide how valuable it is ("used" may throw an "unused" entry out) */
-        Assoc_add_entry(dht->assoc, public_key, &ippts, NULL, used ? 1 : 0);
+            if (update_client_data(client_list, MAX_FRIEND_CLIENTS, ip_port, nodepublic_key)) {
+                return;
+            }
+        }
     }
-
-#endif
-    return 0;
 }
 
 /* Send a getnodes request.
@@ -1061,56 +1284,47 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const
                     const Node_format *sendback_node)
 {
     /* Check if packet is going to be sent to ourself. */
-    if (id_equal(public_key, dht->self_public_key))
+    if (id_equal(public_key, dht->self_public_key)) {
         return -1;
+    }
 
     uint8_t plain_message[sizeof(Node_format) * 2] = {0};
 
     Node_format receiver;
-    memcpy(receiver.public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(receiver.public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     receiver.ip_port = ip_port;
     memcpy(plain_message, &receiver, sizeof(receiver));
 
     uint64_t ping_id = 0;
 
-    if (sendback_node != NULL) {
+    if (sendback_node != nullptr) {
         memcpy(plain_message + sizeof(receiver), sendback_node, sizeof(Node_format));
-        ping_id = ping_array_add(&dht->dht_harden_ping_array, plain_message, sizeof(plain_message));
+        ping_id = ping_array_add(dht->dht_harden_ping_array, plain_message, sizeof(plain_message));
     } else {
-        ping_id = ping_array_add(&dht->dht_ping_array, plain_message, sizeof(receiver));
+        ping_id = ping_array_add(dht->dht_ping_array, plain_message, sizeof(receiver));
     }
 
-    if (ping_id == 0)
+    if (ping_id == 0) {
         return -1;
+    }
 
-    uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(ping_id)];
-    uint8_t encrypt[sizeof(plain) + crypto_box_MACBYTES];
-    uint8_t data[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + sizeof(encrypt)];
+    uint8_t plain[CRYPTO_PUBLIC_KEY_SIZE + sizeof(ping_id)];
+    uint8_t data[1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + sizeof(plain) + CRYPTO_MAC_SIZE];
 
-    memcpy(plain, client_id, crypto_box_PUBLICKEYBYTES);
-    memcpy(plain + crypto_box_PUBLICKEYBYTES, &ping_id, sizeof(ping_id));
+    memcpy(plain, client_id, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, &ping_id, sizeof(ping_id));
 
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
     DHT_get_shared_key_sent(dht, shared_key, public_key);
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    new_nonce(nonce);
+    const int len = DHT_create_packet(dht->self_public_key, shared_key, NET_PACKET_GET_NODES,
+                                      plain, sizeof(plain), data);
 
-    int len = encrypt_data_symmetric( shared_key,
-                                      nonce,
-                                      plain,
-                                      sizeof(plain),
-                                      encrypt );
-
-    if (len != sizeof(encrypt))
+    if (len != sizeof(data)) {
         return -1;
+    }
 
-    data[0] = NET_PACKET_GET_NODES;
-    memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, encrypt, len);
-
-    return sendpacket(dht->net, ip_port, data, sizeof(data));
+    return sendpacket(dht->net, ip_port, data, len);
 }
 
 /* Send a send nodes response: message for IPv6 nodes */
@@ -1118,105 +1332,108 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
                           const uint8_t *sendback_data, uint16_t length, const uint8_t *shared_encryption_key)
 {
     /* Check if packet is going to be sent to ourself. */
-    if (id_equal(public_key, dht->self_public_key))
+    if (id_equal(public_key, dht->self_public_key)) {
         return -1;
+    }
 
-    if (length != sizeof(uint64_t))
+    if (length != sizeof(uint64_t)) {
         return -1;
+    }
 
-    size_t Node_format_size = sizeof(Node_format);
-    uint8_t data[1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES
-                 + Node_format_size * MAX_SENT_NODES + length + crypto_box_MACBYTES];
+    const size_t node_format_size = sizeof(Node_format);
 
     Node_format nodes_list[MAX_SENT_NODES];
-    uint32_t num_nodes = get_close_nodes(dht, client_id, nodes_list, 0, LAN_ip(ip_port.ip) == 0, 1);
+    const uint32_t num_nodes = get_close_nodes(dht, client_id, nodes_list, net_family_unspec, ip_is_lan(ip_port.ip) == 0,
+                               1);
 
-    uint8_t plain[1 + Node_format_size * MAX_SENT_NODES + length];
-    uint8_t encrypt[sizeof(plain) + crypto_box_MACBYTES];
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    new_nonce(nonce);
+    VLA(uint8_t, plain, 1 + node_format_size * MAX_SENT_NODES + length);
 
     int nodes_length = 0;
 
     if (num_nodes) {
-        nodes_length = pack_nodes(plain + 1, Node_format_size * MAX_SENT_NODES, nodes_list, num_nodes);
+        nodes_length = pack_nodes(plain + 1, node_format_size * MAX_SENT_NODES, nodes_list, num_nodes);
 
-        if (nodes_length <= 0)
+        if (nodes_length <= 0) {
             return -1;
+        }
     }
 
     plain[0] = num_nodes;
     memcpy(plain + 1 + nodes_length, sendback_data, length);
-    int len = encrypt_data_symmetric( shared_encryption_key,
-                                      nonce,
-                                      plain,
-                                      1 + nodes_length + length,
-                                      encrypt );
 
-    if (len != 1 + nodes_length + length + crypto_box_MACBYTES)
-        return -1;
+    const uint32_t crypto_size = 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE;
+    VLA(uint8_t, data, 1 + nodes_length + length + crypto_size);
 
-    data[0] = NET_PACKET_SEND_NODES_IPV6;
-    memcpy(data + 1, dht->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, encrypt, len);
+    const int len = DHT_create_packet(dht->self_public_key, shared_encryption_key, NET_PACKET_SEND_NODES_IPV6,
+                                      plain, 1 + nodes_length + length, data);
 
-    return sendpacket(dht->net, ip_port, data, 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + len);
+    if (len != SIZEOF_VLA(data)) {
+        return -1;
+    }
+
+    return sendpacket(dht->net, ip_port, data, len);
 }
 
-static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+#define CRYPTO_NODE_SIZE (CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint64_t))
+
+static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    if (length != (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + sizeof(
-                       uint64_t) + crypto_box_MACBYTES))
-        return 1;
+    if (length != (CRYPTO_SIZE + CRYPTO_MAC_SIZE + sizeof(uint64_t))) {
+        return true;
+    }
 
-    DHT *dht = object;
+    DHT *const dht = (DHT *)object;
 
     /* Check if packet is from ourself. */
-    if (id_equal(packet + 1, dht->self_public_key))
-        return 1;
+    if (id_equal(packet + 1, dht->self_public_key)) {
+        return true;
+    }
 
-    uint8_t plain[crypto_box_PUBLICKEYBYTES + sizeof(uint64_t)];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t plain[CRYPTO_NODE_SIZE];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 
     DHT_get_shared_key_recv(dht, shared_key, packet + 1);
-    int len = decrypt_data_symmetric( shared_key,
-                                      packet + 1 + crypto_box_PUBLICKEYBYTES,
-                                      packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
-                                      crypto_box_PUBLICKEYBYTES + sizeof(uint64_t) + crypto_box_MACBYTES,
-                                      plain );
+    const int len = decrypt_data_symmetric(
+                        shared_key,
+                        packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                        packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE,
+                        CRYPTO_NODE_SIZE + CRYPTO_MAC_SIZE,
+                        plain);
 
-    if (len != crypto_box_PUBLICKEYBYTES + sizeof(uint64_t))
-        return 1;
+    if (len != CRYPTO_NODE_SIZE) {
+        return true;
+    }
 
-    sendnodes_ipv6(dht, source, packet + 1, plain, plain + crypto_box_PUBLICKEYBYTES, sizeof(uint64_t), shared_key);
+    sendnodes_ipv6(dht, source, packet + 1, plain, plain + CRYPTO_PUBLIC_KEY_SIZE, sizeof(uint64_t), shared_key);
 
-    add_to_ping(dht->ping, packet + 1, source);
+    ping_add(dht->ping, packet + 1, source);
 
-    return 0;
+    return false;
 }
-/* return 0 if no
-   return 1 if yes */
-static uint8_t sent_getnode_to_node(DHT *dht, const uint8_t *public_key, IP_Port node_ip_port, uint64_t ping_id,
-                                    Node_format *sendback_node)
+
+/* return false if no
+   return true if yes */
+static bool sent_getnode_to_node(DHT *dht, const uint8_t *public_key, IP_Port node_ip_port, uint64_t ping_id,
+                                 Node_format *sendback_node)
 {
     uint8_t data[sizeof(Node_format) * 2];
 
-    if (ping_array_check(data, sizeof(data), &dht->dht_ping_array, ping_id) == sizeof(Node_format)) {
+    if (ping_array_check(dht->dht_ping_array, data, sizeof(data), ping_id) == sizeof(Node_format)) {
         memset(sendback_node, 0, sizeof(Node_format));
-    } else if (ping_array_check(data, sizeof(data), &dht->dht_harden_ping_array, ping_id) == sizeof(data)) {
+    } else if (ping_array_check(dht->dht_harden_ping_array, data, sizeof(data), ping_id) == sizeof(data)) {
         memcpy(sendback_node, data + sizeof(Node_format), sizeof(Node_format));
     } else {
-        return 0;
+        return false;
     }
 
     Node_format test;
     memcpy(&test, data, sizeof(Node_format));
 
-    if (!ipport_equal(&test.ip_port, &node_ip_port) || public_key_cmp(test.public_key, public_key) != 0)
-        return 0;
+    if (!ipport_equal(&test.ip_port, &node_ip_port) || !id_equal(test.public_key, public_key)) {
+        return false;
+    }
 
-    return 1;
+    return true;
 }
 
 /* Function is needed in following functions. */
@@ -1226,55 +1443,64 @@ 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;
-    uint32_t cid_size = 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + 1 + sizeof(uint64_t) + crypto_box_MACBYTES;
+    DHT *const dht = (DHT *)object;
+    const uint32_t cid_size = 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + 1 + sizeof(uint64_t) + CRYPTO_MAC_SIZE;
 
-    if (length < cid_size) /* too short */
+    if (length < cid_size) { /* too short */
         return 1;
+    }
 
-    uint32_t data_size = length - cid_size;
+    const uint32_t data_size = length - cid_size;
 
-    if (data_size == 0)
+    if (data_size == 0) {
         return 1;
+    }
 
-    if (data_size > sizeof(Node_format) * MAX_SENT_NODES) /* invalid length */
+    if (data_size > sizeof(Node_format) * MAX_SENT_NODES) { /* invalid length */
         return 1;
+    }
 
-    uint8_t plain[1 + data_size + sizeof(uint64_t)];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    VLA(uint8_t, plain, 1 + data_size + sizeof(uint64_t));
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
     DHT_get_shared_key_sent(dht, shared_key, packet + 1);
-    int len = decrypt_data_symmetric(
-                  shared_key,
-                  packet + 1 + crypto_box_PUBLICKEYBYTES,
-                  packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
-                  1 + data_size + sizeof(uint64_t) + crypto_box_MACBYTES,
-                  plain);
-
-    if ((unsigned int)len != sizeof(plain))
+    const int len = decrypt_data_symmetric(
+                        shared_key,
+                        packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                        packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE,
+                        1 + data_size + sizeof(uint64_t) + CRYPTO_MAC_SIZE,
+                        plain);
+
+    if ((unsigned int)len != SIZEOF_VLA(plain)) {
         return 1;
+    }
 
-    if (plain[0] > size_plain_nodes)
+    if (plain[0] > size_plain_nodes) {
         return 1;
+    }
 
     Node_format sendback_node;
 
     uint64_t ping_id;
     memcpy(&ping_id, plain + 1 + data_size, sizeof(ping_id));
 
-    if (!sent_getnode_to_node(dht, packet + 1, source, ping_id, &sendback_node))
+    if (!sent_getnode_to_node(dht, packet + 1, source, ping_id, &sendback_node)) {
         return 1;
+    }
 
     uint16_t length_nodes = 0;
-    int num_nodes = unpack_nodes(plain_nodes, plain[0], &length_nodes, plain + 1, data_size, 0);
+    const int num_nodes = unpack_nodes(plain_nodes, plain[0], &length_nodes, plain + 1, data_size, 0);
 
-    if (length_nodes != data_size)
+    if (length_nodes != data_size) {
         return 1;
+    }
 
-    if (num_nodes != plain[0])
+    if (num_nodes != plain[0]) {
         return 1;
+    }
 
-    if (num_nodes < 0)
+    if (num_nodes < 0) {
         return 1;
+    }
 
     /* store the address the *request* was sent to */
     addto_lists(dht, source, packet + 1);
@@ -1285,22 +1511,21 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa
     return 0;
 }
 
-static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *const dht = (DHT *)object;
     Node_format plain_nodes[MAX_SENT_NODES];
     uint32_t num_nodes;
 
-    if (handle_sendnodes_core(object, source, packet, length, plain_nodes, MAX_SENT_NODES, &num_nodes))
+    if (handle_sendnodes_core(object, source, packet, length, plain_nodes, MAX_SENT_NODES, &num_nodes)) {
         return 1;
+    }
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
-    uint32_t i;
-
-    for (i = 0; i < num_nodes; i++) {
-
+    for (uint32_t i = 0; i < num_nodes; i++) {
         if (ipport_isset(&plain_nodes[i].ip_port)) {
             ping_node_from_getnodes_ok(dht, plain_nodes[i].public_key, plain_nodes[i].ip_port);
             returnedip_ports(dht, plain_nodes[i].ip_port, plain_nodes[i].public_key, packet + 1);
@@ -1316,127 +1541,131 @@ static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *pa
 int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void *data, int32_t number, IP_Port),
                   void *data, int32_t number, uint16_t *lock_count)
 {
-    int friend_num = friend_number(dht, public_key);
+    const uint32_t friend_num = index_of_friend_pk(dht->friends_list, dht->num_friends, public_key);
 
     uint16_t lock_num;
 
-    if (friend_num != -1) { /* Is friend already in DHT? */
-        DHT_Friend *friend = &dht->friends_list[friend_num];
+    if (friend_num != UINT32_MAX) { /* Is friend already in DHT? */
+        DHT_Friend *const 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)
+        if (lock_count) {
             *lock_count = lock_num + 1;
+        }
 
         return 0;
     }
 
-    DHT_Friend *temp;
-    temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
+    DHT_Friend *const temp = (DHT_Friend *)realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
 
-    if (temp == NULL)
+    if (temp == nullptr) {
         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 *const dht_friend = &dht->friends_list[dht->num_friends];
+    memset(dht_friend, 0, sizeof(DHT_Friend));
+    memcpy(dht_friend->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
-    friend->nat.NATping_id = random_64b();
+    dht_friend->nat.NATping_id = random_u64();
     ++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)
+    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, net_family_unspec,
+                                   1, 0);
 
     return 0;
 }
 
 int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count)
 {
-    int friend_num = friend_number(dht, public_key);
+    const uint32_t friend_num = index_of_friend_pk(dht->friends_list, dht->num_friends, public_key);
 
-    if (friend_num == -1) {
+    if (friend_num == UINT32_MAX) {
         return -1;
     }
 
-    DHT_Friend *friend = &dht->friends_list[friend_num];
-    --friend->lock_count;
+    DHT_Friend *const 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 = nullptr;
+        dht_friend->callbacks[lock_count].data = nullptr;
+        dht_friend->callbacks[lock_count].number = 0;
         return 0;
     }
 
-    DHT_Friend *temp;
-
     --dht->num_friends;
 
     if (dht->num_friends != friend_num) {
-        memcpy( &dht->friends_list[friend_num],
-                &dht->friends_list[dht->num_friends],
-                sizeof(DHT_Friend) );
+        memcpy(&dht->friends_list[friend_num],
+               &dht->friends_list[dht->num_friends],
+               sizeof(DHT_Friend));
     }
 
     if (dht->num_friends == 0) {
         free(dht->friends_list);
-        dht->friends_list = NULL;
+        dht->friends_list = nullptr;
         return 0;
     }
 
-    temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
+    DHT_Friend *const temp = (DHT_Friend *)realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
 
-    if (temp == NULL)
+    if (temp == nullptr) {
         return -1;
+    }
 
     dht->friends_list = temp;
     return 0;
 }
 
-/* TODO: Optimize this. */
+/* TODO(irungentoo): Optimize this. */
 int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port)
 {
-    uint32_t i, j;
-
     ip_reset(&ip_port->ip);
     ip_port->port = 0;
 
-    for (i = 0; i < dht->num_friends; ++i) {
-        /* Equal */
-        if (id_equal(dht->friends_list[i].public_key, public_key)) {
-            for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                Client_data *client = &dht->friends_list[i].client_list[j];
-
-                if (id_equal(client->public_key, public_key)) {
-                    IPPTsPng *assoc = NULL;
-                    uint32_t a;
-
-                    for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4)
-                        if (!is_timeout(assoc->timestamp, BAD_NODE_TIMEOUT)) {
-                            *ip_port = assoc->ip_port;
-                            return 1;
-                        }
-                }
-            }
+    const uint32_t friend_index = index_of_friend_pk(dht->friends_list, dht->num_friends, public_key);
 
-            return 0;
+    if (friend_index == UINT32_MAX) {
+        return -1;
+    }
+
+    DHT_Friend *const frnd = &dht->friends_list[friend_index];
+    const uint32_t client_index = index_of_client_pk(frnd->client_list, MAX_FRIEND_CLIENTS, public_key);
+
+    if (client_index == -1) {
+        return 0;
+    }
+
+    const Client_data *const client = &frnd->client_list[client_index];
+    const IPPTsPng *const assocs[] = { &client->assoc6, &client->assoc4 };
+
+    for (size_t i = 0; i < ARRAY_SIZE(assocs); i++) {
+        const IPPTsPng *const assoc = assocs[i];
+
+        if (!is_timeout(assoc->timestamp, BAD_NODE_TIMEOUT)) {
+            *ip_port = assoc->ip_port;
+            return 1;
         }
     }
 
@@ -1445,31 +1674,32 @@ int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port)
 
 /* returns number of nodes not in kill-timeout */
 static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, const uint8_t *public_key,
-        Client_data *list, uint32_t list_count, uint32_t *bootstrap_times, _Bool sortable)
+        Client_data *list, uint32_t list_count, uint32_t *bootstrap_times, bool sortable)
 {
-    uint32_t i;
     uint8_t not_kill = 0;
-    uint64_t temp_time = unix_time();
+    const uint64_t temp_time = unix_time();
 
     uint32_t num_nodes = 0;
-    Client_data *client_list[list_count * 2];
-    IPPTsPng    *assoc_list[list_count * 2];
+    VLA(Client_data *, client_list, list_count * 2);
+    VLA(IPPTsPng *, assoc_list, list_count * 2);
     unsigned int sort = 0;
-    _Bool sort_ok = 0;
+    bool sort_ok = false;
 
-    for (i = 0; i < list_count; i++) {
+    for (uint32_t i = 0; i < list_count; i++) {
         /* If node is not dead. */
         Client_data *client = &list[i];
-        IPPTsPng *assoc;
-        uint32_t a;
 
-        for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4)
+        IPPTsPng *assocs[] = { &client->assoc6, &client->assoc4 };
+
+        for (size_t j = 0; j < ARRAY_SIZE(assocs); j++) {
+            IPPTsPng *assoc = assocs[j];
+
             if (!is_timeout(assoc->timestamp, KILL_NODE_TIMEOUT)) {
                 sort = 0;
                 not_kill++;
 
                 if (is_timeout(assoc->last_pinged, PING_INTERVAL)) {
-                    getnodes(dht, assoc->ip_port, client->public_key, public_key, NULL);
+                    getnodes(dht, assoc->ip_port, client->public_key, public_key, nullptr);
                     assoc->last_pinged = temp_time;
                 }
 
@@ -1483,10 +1713,11 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
                 ++sort;
 
                 /* Timed out should be at beginning, if they are not, sort the list. */
-                if (sort > 1 && sort < (((i + 1) * 2) - 1)) {
-                    sort_ok = 1;
+                if (sort > 1 && sort < (((j + 1) * 2) - 1)) {
+                    sort_ok = true;
                 }
             }
+        }
     }
 
     if (sortable && sort_ok) {
@@ -1494,13 +1725,13 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
     }
 
     if ((num_nodes != 0) && (is_timeout(*lastgetnode, GET_NODE_INTERVAL) || *bootstrap_times < MAX_BOOTSTRAP_TIMES)) {
-        uint32_t rand_node = rand() % (num_nodes);
+        uint32_t rand_node = rand() % num_nodes;
 
         if ((num_nodes - 1) != rand_node) {
             rand_node += rand() % (num_nodes - (rand_node + 1));
         }
 
-        getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->public_key, public_key, NULL);
+        getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->public_key, public_key, nullptr);
 
         *lastgetnode = temp_time;
         ++*bootstrap_times;
@@ -1514,19 +1745,19 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
  */
 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];
+    for (size_t i = 0; i < dht->num_friends; ++i) {
+        DHT_Friend *const 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 (size_t 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,
+                     nullptr);
         }
 
-        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);
     }
 }
 
@@ -1535,68 +1766,63 @@ static void do_DHT_friends(DHT *dht)
  */
 static void do_Close(DHT *dht)
 {
-    unsigned int i;
-
-    for (i = 0; i < dht->num_to_bootstrap; ++i) {
-        getnodes(dht, dht->to_bootstrap[i].ip_port, dht->to_bootstrap[i].public_key, dht->self_public_key, NULL);
+    for (size_t i = 0; i < dht->num_to_bootstrap; ++i) {
+        getnodes(dht, dht->to_bootstrap[i].ip_port, dht->to_bootstrap[i].public_key, dht->self_public_key, nullptr);
     }
 
     dht->num_to_bootstrap = 0;
 
-    uint8_t not_killed = do_ping_and_sendnode_requests(dht, &dht->close_lastgetnodes, dht->self_public_key,
-                         dht->close_clientlist, LCLIENT_LIST, &dht->close_bootstrap_times, 0);
+    uint8_t not_killed = do_ping_and_sendnode_requests(
+                             dht, &dht->close_lastgetnodes, dht->self_public_key, dht->close_clientlist, LCLIENT_LIST, &dht->close_bootstrap_times,
+                             0);
+
+    if (not_killed != 0) {
+        return;
+    }
+
+    /* all existing nodes are at least KILL_NODE_TIMEOUT,
+     * which means we are mute, as we only send packets to
+     * nodes NOT in KILL_NODE_TIMEOUT
+     *
+     * so: reset all nodes to be BAD_NODE_TIMEOUT, but not
+     * KILL_NODE_TIMEOUT, so we at least keep trying pings */
+    const uint64_t badonly = unix_time() - BAD_NODE_TIMEOUT;
+
+    for (size_t i = 0; i < LCLIENT_LIST; i++) {
+        Client_data *const client = &dht->close_clientlist[i];
 
-    if (!not_killed) {
-        /* all existing nodes are at least KILL_NODE_TIMEOUT,
-         * which means we are mute, as we only send packets to
-         * nodes NOT in KILL_NODE_TIMEOUT
-         *
-         * so: reset all nodes to be BAD_NODE_TIMEOUT, but not
-         * KILL_NODE_TIMEOUT, so we at least keep trying pings */
-        uint64_t badonly = unix_time() - BAD_NODE_TIMEOUT;
-        size_t i, a;
+        IPPTsPng *const assocs[] = { &client->assoc6, &client->assoc4 };
 
-        for (i = 0; i < LCLIENT_LIST; i++) {
-            Client_data *client = &dht->close_clientlist[i];
-            IPPTsPng *assoc;
+        for (size_t j = 0; j < ARRAY_SIZE(assocs); j++) {
+            IPPTsPng *const assoc = assocs[j];
 
-            for (a = 0, assoc = &client->assoc4; a < 2; a++, assoc = &client->assoc6)
-                if (assoc->timestamp)
-                    assoc->timestamp = badonly;
+            if (assoc->timestamp) {
+                assoc->timestamp = badonly;
+            }
         }
     }
 }
 
 void DHT_getnodes(DHT *dht, const IP_Port *from_ipp, const uint8_t *from_id, const uint8_t *which_id)
 {
-    getnodes(dht, *from_ipp, from_id, which_id, NULL);
+    getnodes(dht, *from_ipp, from_id, which_id, nullptr);
 }
 
 void DHT_bootstrap(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
 {
-    /*#ifdef ENABLE_ASSOC_DHT
-       if (dht->assoc) {
-           IPPTs ippts;
-           ippts.ip_port = ip_port;
-           ippts.timestamp = 0;
-
-           Assoc_add_entry(dht->assoc, public_key, &ippts, NULL, 0);
-       }
-       #endif*/
-
-    getnodes(dht, ip_port, public_key, dht->self_public_key, NULL);
+    getnodes(dht, ip_port, public_key, dht->self_public_key, nullptr);
 }
 int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enabled,
                                uint16_t port, const uint8_t *public_key)
 {
     IP_Port ip_port_v64;
-    IP *ip_extra = NULL;
+    IP *ip_extra = nullptr;
     IP_Port ip_port_v4;
     ip_init(&ip_port_v64.ip, ipv6enabled);
 
     if (ipv6enabled) {
         /* setup for getting BOTH: an IPv6 AND an IPv4 address */
-        ip_port_v64.ip.family = AF_UNSPEC;
+        ip_port_v64.ip.family = net_family_unspec;
         ip_reset(&ip_port_v4.ip);
         ip_extra = &ip_port_v4.ip;
     }
@@ -1605,14 +1831,15 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
         ip_port_v64.port = port;
         DHT_bootstrap(dht, ip_port_v64, public_key);
 
-        if ((ip_extra != NULL) && ip_isset(ip_extra)) {
+        if ((ip_extra != nullptr) && ip_isset(ip_extra)) {
             ip_port_v4.port = port;
             DHT_bootstrap(dht, ip_port_v4, public_key);
         }
 
         return 1;
-    } else
-        return 0;
+    }
+
+    return 0;
 }
 
 /* Send the given packet to node with public_key
@@ -1621,18 +1848,20 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
  */
 int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packet, uint16_t length)
 {
-    uint32_t i;
-
-    for (i = 0; i < LCLIENT_LIST; ++i) {
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
         if (id_equal(public_key, dht->close_clientlist[i].public_key)) {
-            const Client_data *client = &dht->close_clientlist[i];
+            const Client_data *const client = &dht->close_clientlist[i];
+            const IPPTsPng *const assocs[] = { &client->assoc6, &client->assoc4 };
 
-            if (ip_isset(&client->assoc6.ip_port.ip))
-                return sendpacket(dht->net, client->assoc6.ip_port, packet, length);
-            else if (ip_isset(&client->assoc4.ip_port.ip))
-                return sendpacket(dht->net, client->assoc4.ip_port, packet, length);
-            else
-                break;
+            for (size_t j = 0; j < ARRAY_SIZE(assocs); j++) {
+                const IPPTsPng *const assoc = assocs[j];
+
+                if (ip_isset(&assoc->ip_port.ip)) {
+                    return sendpacket(dht->net, assoc->ip_port, packet, length);
+                }
+            }
+
+            break;
         }
     }
 
@@ -1648,19 +1877,18 @@ int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packe
  */
 static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_num)
 {
-    if (friend_num >= dht->num_friends)
+    if (friend_num >= dht->num_friends) {
         return -1;
+    }
 
-    DHT_Friend *friend = &dht->friends_list[friend_num];
-    Client_data *client;
+    const DHT_Friend *const dht_friend = &dht->friends_list[friend_num];
     IP_Port ipv4s[MAX_FRIEND_CLIENTS];
     int num_ipv4s = 0;
     IP_Port ipv6s[MAX_FRIEND_CLIENTS];
     int num_ipv6s = 0;
-    int i;
 
-    for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-        client = &(friend->client_list[i]);
+    for (size_t i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
+        const Client_data *const 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)) {
@@ -1673,21 +1901,26 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
             ++num_ipv6s;
         }
 
-        if (id_equal(client->public_key, friend->public_key))
-            if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) || !is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT))
+        if (id_equal(client->public_key, 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 */
+            }
+        }
     }
 
 #ifdef FRIEND_IPLIST_PAD
     memcpy(ip_portlist, ipv6s, num_ipv6s * sizeof(IP_Port));
 
-    if (num_ipv6s == MAX_FRIEND_CLIENTS)
+    if (num_ipv6s == MAX_FRIEND_CLIENTS) {
         return MAX_FRIEND_CLIENTS;
+    }
 
     int num_ipv4s_used = MAX_FRIEND_CLIENTS - num_ipv6s;
 
-    if (num_ipv4s_used > num_ipv4s)
+    if (num_ipv4s_used > num_ipv4s) {
         num_ipv4s_used = num_ipv4s;
+    }
 
     memcpy(&ip_portlist[num_ipv6s], ipv4s, num_ipv4s_used * sizeof(IP_Port));
     return num_ipv6s + num_ipv4s_used;
@@ -1716,44 +1949,41 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
  */
 int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length)
 {
-    int num = friend_number(dht, friend_id);
+    const uint32_t num = index_of_friend_pk(dht->friends_list, dht->num_friends, friend_id);
 
-    if (num == -1)
+    if (num == UINT32_MAX) {
         return 0;
+    }
 
-    uint32_t i, sent = 0;
+    uint32_t sent = 0;
     uint8_t friend_sent[MAX_FRIEND_CLIENTS] = {0};
 
     IP_Port ip_list[MAX_FRIEND_CLIENTS];
-    int ip_num = friend_iplist(dht, ip_list, num);
+    const int ip_num = friend_iplist(dht, ip_list, num);
 
-    if (ip_num < (MAX_FRIEND_CLIENTS / 4))
+    if (ip_num < (MAX_FRIEND_CLIENTS / 4)) {
         return 0; /* Reason for that? */
+    }
 
-    DHT_Friend *friend = &dht->friends_list[num];
-    Client_data *client;
+    const DHT_Friend *const dht_friend = &dht->friends_list[num];
 
     /* extra legwork, because having the outside allocating the space for us
      * is *usually* good(tm) (bites us in the behind in this case though) */
-    uint32_t a;
 
-    for (a = 0; a < 2; a++)
-        for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-            if (friend_sent[i])/* Send one packet per client.*/
-                continue;
+    for (uint32_t i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
+        if (friend_sent[i]) {/* Send one packet per client.*/
+            continue;
+        }
 
-            client = &friend->client_list[i];
-            IPPTsPng *assoc = NULL;
+        const Client_data *const client = &dht_friend->client_list[i];
+        const IPPTsPng *const assocs[] = { &client->assoc4, &client->assoc6 };
 
-            if (!a)
-                assoc = &client->assoc4;
-            else
-                assoc = &client->assoc6;
+        for (size_t j = 0; j < ARRAY_SIZE(assocs); j++) {
+            const IPPTsPng *const assoc = assocs[j];
 
             /* If ip is not zero and node is good. */
-            if (ip_isset(&assoc->ret_ip_port.ip) &&
-                    !is_timeout(assoc->ret_timestamp, BAD_NODE_TIMEOUT)) {
-                int retval = sendpacket(dht->net, assoc->ip_port, packet, length);
+            if (ip_isset(&assoc->ret_ip_port.ip) && !is_timeout(assoc->ret_timestamp, BAD_NODE_TIMEOUT)) {
+                const int retval = sendpacket(dht->net, assoc->ip_port, packet, length);
 
                 if ((unsigned int)retval == length) {
                     ++sent;
@@ -1761,6 +1991,7 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
                 }
             }
         }
+    }
 
     return sent;
 }
@@ -1771,31 +2002,26 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
  */
 static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length)
 {
-    int num = friend_number(dht, friend_id);
+    const uint32_t num = index_of_friend_pk(dht->friends_list, dht->num_friends, friend_id);
 
-    if (num == -1)
+    if (num == UINT32_MAX) {
         return 0;
+    }
 
-    DHT_Friend *friend = &dht->friends_list[num];
-    Client_data *client;
+    const DHT_Friend *const dht_friend = &dht->friends_list[num];
 
     IP_Port ip_list[MAX_FRIEND_CLIENTS * 2];
     int n = 0;
-    uint32_t i;
 
     /* extra legwork, because having the outside allocating the space for us
      * is *usually* good(tm) (bites us in the behind in this case though) */
-    uint32_t a;
 
-    for (a = 0; a < 2; a++)
-        for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
-            client = &friend->client_list[i];
-            IPPTsPng *assoc = NULL;
+    for (uint32_t i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
+        const Client_data *const client = &dht_friend->client_list[i];
+        const IPPTsPng *const assocs[] = { &client->assoc4, &client->assoc6 };
 
-            if (!a)
-                assoc = &client->assoc4;
-            else
-                assoc = &client->assoc6;
+        for (size_t j = 0; j < ARRAY_SIZE(assocs); j++) {
+            const IPPTsPng *assoc = assocs[j];
 
             /* If ip is not zero and node is good. */
             if (ip_isset(&assoc->ret_ip_port.ip) && !is_timeout(assoc->ret_timestamp, BAD_NODE_TIMEOUT)) {
@@ -1803,14 +2029,17 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
                 ++n;
             }
         }
+    }
 
-    if (n < 1)
+    if (n < 1) {
         return 0;
+    }
 
-    int retval = sendpacket(dht->net, ip_list[rand() % n], packet, length);
+    const int retval = sendpacket(dht->net, ip_list[rand() % n], packet, length);
 
-    if ((unsigned int)retval == length)
+    if ((unsigned int)retval == length) {
         return 1;
+    }
 
     return 0;
 }
@@ -1828,50 +2057,58 @@ static int send_NATping(DHT *dht, const uint8_t *public_key, uint64_t ping_id, u
     data[0] = type;
     memcpy(data + 1, &ping_id, sizeof(uint64_t));
     /* 254 is NAT ping request packet id */
-    int len = create_request(dht->self_public_key, dht->self_secret_key, packet, public_key, data,
-                             sizeof(uint64_t) + 1, CRYPTO_PACKET_NAT_PING);
+    const int len = create_request(
+                        dht->self_public_key, dht->self_secret_key, packet, public_key, data,
+                        sizeof(uint64_t) + 1, CRYPTO_PACKET_NAT_PING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
-    if (type == 0) /* If packet is request use many people to route it. */
+    if (type == 0) { /* If packet is request use many people to route it. */
         num = route_tofriend(dht, public_key, packet, len);
-    else if (type == 1) /* If packet is response use only one person to route it */
+    } else if (type == 1) { /* If packet is response use only one person to route it */
         num = routeone_tofriend(dht, public_key, packet, len);
+    }
 
-    if (num == 0)
+    if (num == 0) {
         return -1;
+    }
 
     return num;
 }
 
 /* Handle a received ping request for. */
 static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                          uint16_t length)
+                          uint16_t length, void *userdata)
 {
-    if (length != sizeof(uint64_t) + 1)
+    if (length != sizeof(uint64_t) + 1) {
         return 1;
+    }
 
-    DHT *dht = object;
+    DHT *const dht = (DHT *)object;
     uint64_t ping_id;
     memcpy(&ping_id, packet + 1, sizeof(uint64_t));
 
-    int friendnumber = friend_number(dht, source_pubkey);
+    uint32_t friendnumber = index_of_friend_pk(dht->friends_list, dht->num_friends, source_pubkey);
 
-    if (friendnumber == -1)
+    if (friendnumber == UINT32_MAX) {
         return 1;
+    }
 
-    DHT_Friend *friend = &dht->friends_list[friendnumber];
+    DHT_Friend *const 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;
-    } else 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 (packet[0] == NAT_PING_RESPONSE) {
+        if (dht_friend->nat.NATping_id == ping_id) {
+            dht_friend->nat.NATping_id = random_u64();
+            dht_friend->nat.hole_punching = 1;
             return 0;
         }
     }
@@ -1890,20 +2127,22 @@ static IP NAT_commonip(IP_Port *ip_portlist, uint16_t len, uint16_t min_num)
     IP zero;
     ip_reset(&zero);
 
-    if (len > MAX_FRIEND_CLIENTS)
+    if (len > MAX_FRIEND_CLIENTS) {
         return zero;
+    }
 
-    uint32_t i, j;
     uint16_t numbers[MAX_FRIEND_CLIENTS] = {0};
 
-    for (i = 0; i < len; ++i) {
-        for (j = 0; j < len; ++j) {
-            if (ip_equal(&ip_portlist[i].ip, &ip_portlist[j].ip))
+    for (uint32_t i = 0; i < len; ++i) {
+        for (uint32_t j = 0; j < len; ++j) {
+            if (ip_equal(&ip_portlist[i].ip, &ip_portlist[j].ip)) {
                 ++numbers[i];
+            }
         }
 
-        if (numbers[i] >= min_num)
+        if (numbers[i] >= min_num) {
             return ip_portlist[i].ip;
+        }
     }
 
     return zero;
@@ -1917,12 +2156,11 @@ static IP NAT_commonip(IP_Port *ip_portlist, uint16_t len, uint16_t min_num)
  */
 static uint16_t NAT_getports(uint16_t *portlist, IP_Port *ip_portlist, uint16_t len, IP ip)
 {
-    uint32_t i;
     uint16_t num = 0;
 
-    for (i = 0; i < len; ++i) {
+    for (uint32_t i = 0; i < len; ++i) {
         if (ip_equal(&ip_portlist[i].ip, &ip)) {
-            portlist[num] = ntohs(ip_portlist[i].port);
+            portlist[num] = net_ntohs(ip_portlist[i].port);
             ++num;
         }
     }
@@ -1932,48 +2170,57 @@ static uint16_t NAT_getports(uint16_t *portlist, IP_Port *ip_portlist, uint16_t
 
 static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports, uint16_t friend_num)
 {
-    if (numports > MAX_FRIEND_CLIENTS || numports == 0)
+    if (!dht->hole_punching_enabled) {
         return;
+    }
 
+    if (numports > MAX_FRIEND_CLIENTS || numports == 0) {
+        return;
+    }
+
+    const uint16_t first_port = port_list[0];
     uint32_t i;
-    uint32_t top = dht->friends_list[friend_num].nat.punching_index + MAX_PUNCHING_PORTS;
-    uint16_t firstport = port_list[0];
 
     for (i = 0; i < numports; ++i) {
-        if (firstport != port_list[i])
+        if (first_port != port_list[i]) {
             break;
+        }
     }
 
     if (i == numports) { /* If all ports are the same, only try that one port. */
         IP_Port pinging;
         ip_copy(&pinging.ip, &ip);
-        pinging.port = htons(firstport);
-        send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
+        pinging.port = net_htons(first_port);
+        ping_send_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
     } else {
-        for (i = dht->friends_list[friend_num].nat.punching_index; i != top; ++i) {
-            /* TODO: Improve port guessing algorithm. */
-            uint16_t port = port_list[(i / 2) % numports] + (i / (2 * numports)) * ((i % 2) ? -1 : 1);
+        for (i = 0; i < MAX_PUNCHING_PORTS; ++i) {
+            /* TODO(irungentoo): Improve port guessing algorithm. */
+            const uint32_t it = i + dht->friends_list[friend_num].nat.punching_index;
+            const int8_t sign = (it % 2) ? -1 : 1;
+            const uint32_t delta = sign * (it / (2 * numports));
+            const uint32_t index = (it / 2) % numports;
+            const uint16_t port = port_list[index] + delta;
             IP_Port pinging;
             ip_copy(&pinging.ip, &ip);
-            pinging.port = htons(port);
-            send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
+            pinging.port = net_htons(port);
+            ping_send_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
         }
 
-        dht->friends_list[friend_num].nat.punching_index = i;
+        dht->friends_list[friend_num].nat.punching_index += i;
     }
 
     if (dht->friends_list[friend_num].nat.tries > MAX_NORMAL_PUNCHING_TRIES) {
-        top = dht->friends_list[friend_num].nat.punching_index2 + MAX_PUNCHING_PORTS;
-        uint16_t port = 1024;
+        const uint16_t port = 1024;
         IP_Port pinging;
         ip_copy(&pinging.ip, &ip);
 
-        for (i = dht->friends_list[friend_num].nat.punching_index2; i != top; ++i) {
-            pinging.port = htons(port + i);
-            send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
+        for (i = 0; i < MAX_PUNCHING_PORTS; ++i) {
+            uint32_t it = i + dht->friends_list[friend_num].nat.punching_index2;
+            pinging.port = net_htons(port + it);
+            ping_send_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
         }
 
-        dht->friends_list[friend_num].nat.punching_index2 = i - (MAX_PUNCHING_PORTS / 2);
+        dht->friends_list[friend_num].nat.punching_index2 += i - (MAX_PUNCHING_PORTS / 2);
     }
 
     ++dht->friends_list[friend_num].nat.tries;
@@ -1981,16 +2228,16 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports,
 
 static void do_NAT(DHT *dht)
 {
-    uint32_t i;
-    uint64_t temp_time = unix_time();
+    const uint64_t temp_time = unix_time();
 
-    for (i = 0; i < dht->num_friends; ++i) {
+    for (uint32_t i = 0; i < dht->num_friends; ++i) {
         IP_Port ip_list[MAX_FRIEND_CLIENTS];
-        int num = friend_iplist(dht, ip_list, i);
+        const int num = friend_iplist(dht, ip_list, i);
 
         /* If already connected or friend is not online don't try to hole punch. */
-        if (num < MAX_FRIEND_CLIENTS / 2)
+        if (num < MAX_FRIEND_CLIENTS / 2) {
             continue;
+        }
 
         if (dht->friends_list[i].nat.NATping_timestamp + PUNCH_INTERVAL < temp_time) {
             send_NATping(dht, dht->friends_list[i].public_key, dht->friends_list[i].nat.NATping_id, NAT_PING_REQUEST);
@@ -2001,13 +2248,20 @@ static void do_NAT(DHT *dht)
                 dht->friends_list[i].nat.punching_timestamp + PUNCH_INTERVAL < temp_time &&
                 dht->friends_list[i].nat.recvNATping_timestamp + PUNCH_INTERVAL * 2 >= temp_time) {
 
-            IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS / 2);
+            const IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS / 2);
 
-            if (!ip_isset(&ip))
+            if (!ip_isset(&ip)) {
                 continue;
+            }
+
+            if (dht->friends_list[i].nat.punching_timestamp + PUNCH_RESET_TIME < temp_time) {
+                dht->friends_list[i].nat.tries = 0;
+                dht->friends_list[i].nat.punching_index = 0;
+                dht->friends_list[i].nat.punching_index2 = 0;
+            }
 
             uint16_t port_list[MAX_FRIEND_CLIENTS];
-            uint16_t numports = NAT_getports(port_list, ip_list, num, ip);
+            const uint16_t numports = NAT_getports(port_list, ip_list, num, ip);
             punch_holes(dht, ip, port_list, numports, i);
 
             dht->friends_list[i].nat.punching_timestamp = temp_time;
@@ -2019,29 +2273,36 @@ static void do_NAT(DHT *dht)
 /*----------------------------------------------------------------------------------*/
 /*-----------------------END OF NAT PUNCHING FUNCTIONS------------------------------*/
 
+#define DHT_HARDENING 0
 #define HARDREQ_DATA_SIZE 384 /* Attempt to prevent amplification/other attacks*/
 
-#define CHECK_TYPE_ROUTE_REQ 0
-#define CHECK_TYPE_ROUTE_RES 1
-#define CHECK_TYPE_GETNODE_REQ 2
-#define CHECK_TYPE_GETNODE_RES 3
-#define CHECK_TYPE_TEST_REQ 4
-#define CHECK_TYPE_TEST_RES 5
+enum {
+    CHECK_TYPE_ROUTE_REQ = 0,
+    CHECK_TYPE_ROUTE_RES = 1,
+    CHECK_TYPE_GETNODE_REQ = 2,
+    CHECK_TYPE_GETNODE_RES = 3,
+    CHECK_TYPE_TEST_REQ = 4,
+    CHECK_TYPE_TEST_RES = 5,
+};
 
+#if DHT_HARDENING
 static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8_t *contents, uint16_t length)
 {
-    if (length > HARDREQ_DATA_SIZE - 1)
+    if (length > HARDREQ_DATA_SIZE - 1) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
     uint8_t data[HARDREQ_DATA_SIZE] = {0};
     data[0] = type;
     memcpy(data + 1, contents, length);
-    int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->public_key, data,
-                             sizeof(data), CRYPTO_PACKET_HARDENING);
+    const int len = create_request(
+                        dht->self_public_key, dht->self_secret_key, packet, sendto->public_key,
+                        data, sizeof(data), CRYPTO_PACKET_HARDENING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return sendpacket(dht->net, sendto->ip_port, packet, len);
 }
@@ -2049,67 +2310,72 @@ static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8
 /* Send a get node hardening request */
 static int send_hardening_getnode_req(DHT *dht, Node_format *dest, Node_format *node_totest, uint8_t *search_id)
 {
-    uint8_t data[sizeof(Node_format) + crypto_box_PUBLICKEYBYTES];
+    uint8_t data[sizeof(Node_format) + CRYPTO_PUBLIC_KEY_SIZE];
     memcpy(data, node_totest, sizeof(Node_format));
-    memcpy(data + sizeof(Node_format), search_id, crypto_box_PUBLICKEYBYTES);
-    return send_hardening_req(dht, dest, CHECK_TYPE_GETNODE_REQ, data, sizeof(Node_format) + crypto_box_PUBLICKEYBYTES);
+    memcpy(data + sizeof(Node_format), search_id, CRYPTO_PUBLIC_KEY_SIZE);
+    return send_hardening_req(dht, dest, CHECK_TYPE_GETNODE_REQ, data, sizeof(Node_format) + CRYPTO_PUBLIC_KEY_SIZE);
 }
+#endif
 
 /* Send a get node hardening response */
 static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto, const uint8_t *queried_client_id,
                                       const uint8_t *nodes_data, uint16_t nodes_data_length)
 {
-    if (!ip_isset(&sendto->ip_port.ip))
+    if (!ip_isset(&sendto->ip_port.ip)) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
-    uint8_t data[1 + crypto_box_PUBLICKEYBYTES + nodes_data_length];
+    VLA(uint8_t, data, 1 + CRYPTO_PUBLIC_KEY_SIZE + nodes_data_length);
     data[0] = CHECK_TYPE_GETNODE_RES;
-    memcpy(data + 1, queried_client_id, crypto_box_PUBLICKEYBYTES);
-    memcpy(data + 1 + crypto_box_PUBLICKEYBYTES, nodes_data, nodes_data_length);
-    int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->public_key, data,
-                             sizeof(data), CRYPTO_PACKET_HARDENING);
+    memcpy(data + 1, queried_client_id, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(data + 1 + CRYPTO_PUBLIC_KEY_SIZE, nodes_data, nodes_data_length);
+    const int len = create_request(
+                        dht->self_public_key, dht->self_secret_key, packet, sendto->public_key,
+                        data, SIZEOF_VLA(data), CRYPTO_PACKET_HARDENING);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return sendpacket(dht->net, sendto->ip_port, packet, len);
 }
 
-/* TODO: improve */
-static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *public_key, sa_family_t sa_family)
+/* TODO(irungentoo): improve */
+static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *public_key, Family sa_family)
 {
-    uint32_t i;
-
-    for (i = 0; i < LCLIENT_LIST; ++i) {
-        if (public_key_cmp(dht->close_clientlist[i].public_key, public_key) != 0)
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
+        if (!id_equal(dht->close_clientlist[i].public_key, public_key)) {
             continue;
+        }
 
-        if (sa_family == AF_INET)
+        if (net_family_is_ipv4(sa_family)) {
             return &dht->close_clientlist[i].assoc4;
-        else if (sa_family == AF_INET6)
+        }
+
+        if (net_family_is_ipv6(sa_family)) {
             return &dht->close_clientlist[i].assoc6;
+        }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 /*
  * check how many nodes in nodes are also present in the closelist.
- * TODO: make this function better.
+ * TODO(irungentoo): make this function better.
  */
 static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 {
     uint32_t counter = 0;
-    uint32_t i;
 
-    for (i = 0; i < num; ++i) {
+    for (uint32_t i = 0; i < num; ++i) {
         if (id_equal(nodes[i].public_key, dht->self_public_key)) {
             ++counter;
             continue;
         }
 
-        IPPTsPng *temp = get_closelist_IPPTsPng(dht, nodes[i].public_key, nodes[i].ip_port.ip.family);
+        const IPPTsPng *const temp = get_closelist_IPPTsPng(dht, nodes[i].public_key, nodes[i].ip_port.ip.family);
 
         if (temp) {
             if (!is_timeout(temp->timestamp, BAD_NODE_TIMEOUT)) {
@@ -2123,13 +2389,12 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 
 /* Interval in seconds between hardening checks */
 #define HARDENING_INTERVAL 120
-#define HARDEN_TIMEOUT 1200
 
 /* Handle a received hardening packet */
 static int handle_hardening(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                            uint16_t length)
+                            uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *const dht = (DHT *)object;
 
     if (length < 2) {
         return 1;
@@ -2137,50 +2402,60 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
 
     switch (packet[0]) {
         case CHECK_TYPE_GETNODE_REQ: {
-            if (length != HARDREQ_DATA_SIZE)
+            if (length != HARDREQ_DATA_SIZE) {
                 return 1;
+            }
 
             Node_format node, tocheck_node;
             node.ip_port = source;
-            memcpy(node.public_key, source_pubkey, crypto_box_PUBLICKEYBYTES);
+            memcpy(node.public_key, source_pubkey, CRYPTO_PUBLIC_KEY_SIZE);
             memcpy(&tocheck_node, packet + 1, sizeof(Node_format));
 
-            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.public_key, packet + 1 + sizeof(Node_format), &node) == -1)
+            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.public_key, packet + 1 + sizeof(Node_format), &node) == -1) {
                 return 1;
+            }
 
             return 0;
         }
 
         case CHECK_TYPE_GETNODE_RES: {
-            if (length <= crypto_box_PUBLICKEYBYTES + 1)
+            if (length <= CRYPTO_PUBLIC_KEY_SIZE + 1) {
                 return 1;
+            }
 
-            if (length > 1 + crypto_box_PUBLICKEYBYTES + sizeof(Node_format) * MAX_SENT_NODES)
+            if (length > 1 + CRYPTO_PUBLIC_KEY_SIZE + sizeof(Node_format) * MAX_SENT_NODES) {
                 return 1;
+            }
 
-            uint16_t length_nodes = length - 1 - crypto_box_PUBLICKEYBYTES;
+            uint16_t length_nodes = length - 1 - CRYPTO_PUBLIC_KEY_SIZE;
             Node_format nodes[MAX_SENT_NODES];
-            int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, packet + 1 + crypto_box_PUBLICKEYBYTES, length_nodes, 0);
+            const int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, nullptr, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                               length_nodes, 0);
 
-            /* TODO: MAX_SENT_NODES nodes should be returned at all times
+            /* TODO(irungentoo): MAX_SENT_NODES nodes should be returned at all times
              (right now we have a small network size so it could cause problems for testing and etc..) */
-            if (num_nodes <= 0)
+            if (num_nodes <= 0) {
                 return 1;
+            }
 
             /* NOTE: This should work for now but should be changed to something better. */
-            if (have_nodes_closelist(dht, nodes, num_nodes) < (uint32_t)((num_nodes + 2) / 2))
+            if (have_nodes_closelist(dht, nodes, num_nodes) < (uint32_t)((num_nodes + 2) / 2)) {
                 return 1;
+            }
 
-            IPPTsPng *temp = get_closelist_IPPTsPng(dht, packet + 1, nodes[0].ip_port.ip.family);
+            IPPTsPng *const temp = get_closelist_IPPTsPng(dht, packet + 1, nodes[0].ip_port.ip.family);
 
-            if (temp == NULL)
+            if (temp == nullptr) {
                 return 1;
+            }
 
-            if (is_timeout(temp->hardening.send_nodes_timestamp, HARDENING_INTERVAL))
+            if (is_timeout(temp->hardening.send_nodes_timestamp, HARDENING_INTERVAL)) {
                 return 1;
+            }
 
-            if (public_key_cmp(temp->hardening.send_nodes_pingedid, source_pubkey) != 0)
+            if (!id_equal(temp->hardening.send_nodes_pingedid, source_pubkey)) {
                 return 1;
+            }
 
             /* If Nodes look good and the request checks out */
             temp->hardening.send_nodes_ok = 1;
@@ -2191,62 +2466,68 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
     return 1;
 }
 
+#if DHT_HARDENING
+#define HARDEN_TIMEOUT 1200
+
 /* Return a random node from all the nodes we are connected to.
- * TODO: improve this function.
+ * TODO(irungentoo): improve this function.
  */
-Node_format random_node(DHT *dht, sa_family_t sa_family)
+static Node_format random_node(DHT *dht, Family sa_family)
 {
-    uint8_t id[crypto_box_PUBLICKEYBYTES];
-    uint32_t i;
+    uint8_t id[CRYPTO_PUBLIC_KEY_SIZE];
 
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES / 4; ++i) { /* populate the id with pseudorandom bytes.*/
-        uint32_t t = rand();
+    for (uint32_t i = 0; i < CRYPTO_PUBLIC_KEY_SIZE / 4; ++i) { /* populate the id with pseudorandom bytes.*/
+        const uint32_t t = rand();
         memcpy(id + i * sizeof(t), &t, sizeof(t));
     }
 
     Node_format nodes_list[MAX_SENT_NODES];
     memset(nodes_list, 0, sizeof(nodes_list));
-    uint32_t num_nodes = get_close_nodes(dht, id, nodes_list, sa_family, 1, 0);
+    const uint32_t num_nodes = get_close_nodes(dht, id, nodes_list, sa_family, 1, 0);
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return nodes_list[0];
-    else
-        return nodes_list[rand() % num_nodes];
+    }
+
+    return nodes_list[rand() % num_nodes];
 }
+#endif
 
 /* Put up to max_num nodes in nodes from the closelist.
  *
  * return the number of nodes.
  */
-uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes, uint16_t max_num)
+static uint16_t list_nodes(Client_data *list, size_t length, Node_format *nodes, uint16_t max_num)
 {
-    if (max_num == 0)
+    if (max_num == 0) {
         return 0;
+    }
 
     uint16_t count = 0;
 
-    unsigned int i;
-
-    for (i = length; i != 0; --i) {
-        IPPTsPng *assoc = NULL;
+    for (size_t i = length; i != 0; --i) {
+        const IPPTsPng *assoc = nullptr;
 
-        if (!is_timeout(list[i - 1].assoc4.timestamp, BAD_NODE_TIMEOUT))
+        if (!is_timeout(list[i - 1].assoc4.timestamp, BAD_NODE_TIMEOUT)) {
             assoc = &list[i - 1].assoc4;
+        }
 
         if (!is_timeout(list[i - 1].assoc6.timestamp, BAD_NODE_TIMEOUT)) {
-            if (assoc == NULL)
+            if (assoc == nullptr) {
                 assoc = &list[i - 1].assoc6;
-            else if (rand() % 2)
+            } else if (rand() % 2) {
                 assoc = &list[i - 1].assoc6;
+            }
         }
 
-        if (assoc != NULL) {
-            memcpy(nodes[count].public_key, list[i - 1].public_key, crypto_box_PUBLICKEYBYTES);
+        if (assoc != nullptr) {
+            memcpy(nodes[count].public_key, list[i - 1].public_key, CRYPTO_PUBLIC_KEY_SIZE);
             nodes[count].ip_port = assoc->ip_port;
             ++count;
 
-            if (count >= max_num)
+            if (count >= max_num) {
                 return count;
+            }
         }
     }
 
@@ -2259,18 +2540,20 @@ uint16_t list_nodes(Client_data *list, unsigned int length, Node_format *nodes,
  */
 uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
 {
-    if (max_num == 0)
+    if (max_num == 0) {
         return 0;
+    }
 
     uint16_t count = 0;
-    unsigned int i, r = rand();
+    const unsigned int r = rand();
 
-    for (i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) {
+    for (size_t i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) {
         count += list_nodes(dht->friends_list[(i + r) % DHT_FAKE_FRIEND_NUMBER].client_list, MAX_FRIEND_CLIENTS, nodes + count,
                             max_num - count);
 
-        if (count >= max_num)
+        if (count >= max_num) {
             break;
+        }
     }
 
     return count;
@@ -2285,43 +2568,45 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
     return list_nodes(dht->close_clientlist, LCLIENT_LIST, nodes, max_num);
 }
 
-void do_hardening(DHT *dht)
+#if DHT_HARDENING
+static void do_hardening(DHT *dht)
 {
-    uint32_t i;
-
-    for (i = 0; i < LCLIENT_LIST * 2; ++i) {
-        IPPTsPng  *cur_iptspng;
-        sa_family_t sa_family;
-        uint8_t   *public_key = dht->close_clientlist[i / 2].public_key;
+    for (uint32_t i = 0; i < LCLIENT_LIST * 2; ++i) {
+        IPPTsPng *cur_iptspng;
+        Family sa_family;
+        const uint8_t *const public_key = dht->close_clientlist[i / 2].public_key;
 
         if (i % 2 == 0) {
             cur_iptspng = &dht->close_clientlist[i / 2].assoc4;
-            sa_family = AF_INET;
+            sa_family = net_family_ipv4;
         } else {
             cur_iptspng = &dht->close_clientlist[i / 2].assoc6;
-            sa_family = AF_INET6;
+            sa_family = net_family_ipv6;
         }
 
-        if (is_timeout(cur_iptspng->timestamp, BAD_NODE_TIMEOUT))
+        if (is_timeout(cur_iptspng->timestamp, BAD_NODE_TIMEOUT)) {
             continue;
+        }
 
         if (cur_iptspng->hardening.send_nodes_ok == 0) {
             if (is_timeout(cur_iptspng->hardening.send_nodes_timestamp, HARDENING_INTERVAL)) {
                 Node_format rand_node = random_node(dht, sa_family);
 
-                if (!ipport_isset(&rand_node.ip_port))
+                if (!ipport_isset(&rand_node.ip_port)) {
                     continue;
+                }
 
-                if (id_equal(public_key, rand_node.public_key))
+                if (id_equal(public_key, rand_node.public_key)) {
                     continue;
+                }
 
                 Node_format to_test;
                 to_test.ip_port = cur_iptspng->ip_port;
-                memcpy(to_test.public_key, public_key, crypto_box_PUBLICKEYBYTES);
+                memcpy(to_test.public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
-                //TODO: The search id should maybe not be ours?
+                // TODO(irungentoo): The search id should maybe not be ours?
                 if (send_hardening_getnode_req(dht, &rand_node, &to_test, dht->self_public_key) > 0) {
-                    memcpy(cur_iptspng->hardening.send_nodes_pingedid, rand_node.public_key, crypto_box_PUBLICKEYBYTES);
+                    memcpy(cur_iptspng->hardening.send_nodes_pingedid, rand_node.public_key, CRYPTO_PUBLIC_KEY_SIZE);
                     cur_iptspng->hardening.send_nodes_timestamp = unix_time();
                 }
             }
@@ -2331,9 +2616,10 @@ void do_hardening(DHT *dht)
             }
         }
 
-        //TODO: add the 2 other testers.
+        // TODO(irungentoo): add the 2 other testers.
     }
 }
+#endif
 
 /*----------------------------------------------------------------------------------*/
 
@@ -2343,35 +2629,43 @@ void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_c
     dht->cryptopackethandlers[byte].object = object;
 }
 
-static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    DHT *dht = object;
+    DHT *const dht = (DHT *)object;
 
-    if (packet[0] == NET_PACKET_CRYPTO) {
-        if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
-                length > MAX_CRYPTO_REQUEST_SIZE + crypto_box_MACBYTES)
-            return 1;
+    assert(packet[0] == NET_PACKET_CRYPTO);
+
+    if (length <= CRYPTO_PUBLIC_KEY_SIZE * 2 + CRYPTO_NONCE_SIZE + 1 + CRYPTO_MAC_SIZE ||
+            length > MAX_CRYPTO_REQUEST_SIZE + CRYPTO_MAC_SIZE) {
+        return 1;
+    }
 
-        if (public_key_cmp(packet + 1, dht->self_public_key) == 0) { // Check if request is for us.
-            uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-            uint8_t data[MAX_CRYPTO_REQUEST_SIZE];
-            uint8_t number;
-            int len = handle_request(dht->self_public_key, dht->self_secret_key, public_key, data, &number, packet, length);
+    // Check if request is for us.
+    if (id_equal(packet + 1, dht->self_public_key)) {
+        uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+        uint8_t data[MAX_CRYPTO_REQUEST_SIZE];
+        uint8_t number;
+        const int len = handle_request(dht->self_public_key, dht->self_secret_key, public_key,
+                                       data, &number, packet, length);
 
-            if (len == -1 || len == 0)
-                return 1;
+        if (len == -1 || len == 0) {
+            return 1;
+        }
 
-            if (!dht->cryptopackethandlers[number].function) return 1;
+        if (!dht->cryptopackethandlers[number].function) {
+            return 1;
+        }
 
-            return dht->cryptopackethandlers[number].function(dht->cryptopackethandlers[number].object, source, public_key,
-                    data, len);
+        return dht->cryptopackethandlers[number].function(
+                   dht->cryptopackethandlers[number].object, source, public_key,
+                   data, len, userdata);
+    }
 
-        } else { /* If request is not for us, try routing it. */
-            int retval = route_packet(dht, packet + 1, packet, length);
+    /* If request is not for us, try routing it. */
+    const int retval = route_packet(dht, packet + 1, packet, length);
 
-            if ((unsigned int)retval == length)
-                return 0;
-        }
+    if ((unsigned int)retval == length) {
+        return 0;
     }
 
     return 1;
@@ -2379,25 +2673,31 @@ static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *pack
 
 /*----------------------------------------------------------------------------------*/
 
-DHT *new_DHT(Networking_Core *net)
+DHT *new_DHT(Logger *log, Networking_Core *net, bool holepunching_enabled)
 {
     /* init time */
     unix_time_update();
 
-    if (net == NULL)
-        return NULL;
+    if (net == nullptr) {
+        return nullptr;
+    }
 
-    DHT *dht = calloc(1, sizeof(DHT));
+    DHT *const dht = (DHT *)calloc(1, sizeof(DHT));
 
-    if (dht == NULL)
-        return NULL;
+    if (dht == nullptr) {
+        return nullptr;
+    }
 
+    dht->log = log;
     dht->net = net;
-    dht->ping = new_ping(dht);
 
-    if (dht->ping == NULL) {
+    dht->hole_punching_enabled = holepunching_enabled;
+
+    dht->ping = ping_new(dht);
+
+    if (dht->ping == nullptr) {
         kill_DHT(dht);
-        return NULL;
+        return nullptr;
     }
 
     networking_registerhandler(dht->net, NET_PACKET_GET_NODES, &handle_getnodes, dht);
@@ -2406,23 +2706,18 @@ DHT *new_DHT(Networking_Core *net)
     cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, &handle_NATping, dht);
     cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, &handle_hardening, dht);
 
-    new_symmetric_key(dht->secret_symmetric_key);
-    crypto_box_keypair(dht->self_public_key, dht->self_secret_key);
+    crypto_new_keypair(dht->self_public_key, dht->self_secret_key);
 
-    ping_array_init(&dht->dht_ping_array, DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
-    ping_array_init(&dht->dht_harden_ping_array, DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
-#ifdef ENABLE_ASSOC_DHT
-    dht->assoc = new_Assoc_default(dht->self_public_key);
-#endif
-    uint32_t i;
+    dht->dht_ping_array = ping_array_new(DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
+    dht->dht_harden_ping_array = ping_array_new(DHT_PING_ARRAY_SIZE, PING_TIMEOUT);
 
-    for (i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) {
-        uint8_t random_key_bytes[crypto_box_PUBLICKEYBYTES];
-        randombytes(random_key_bytes, sizeof(random_key_bytes));
+    for (uint32_t i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) {
+        uint8_t random_key_bytes[CRYPTO_PUBLIC_KEY_SIZE];
+        random_bytes(random_key_bytes, sizeof(random_key_bytes));
 
-        if (DHT_addfriend(dht, random_key_bytes, 0, 0, 0, 0) != 0) {
+        if (DHT_addfriend(dht, random_key_bytes, nullptr, nullptr, 0, nullptr) != 0) {
             kill_DHT(dht);
-            return NULL;
+            return nullptr;
         }
     }
 
@@ -2445,35 +2740,29 @@ void do_DHT(DHT *dht)
     do_Close(dht);
     do_DHT_friends(dht);
     do_NAT(dht);
-    do_to_ping(dht->ping);
-    //do_hardening(dht);
-#ifdef ENABLE_ASSOC_DHT
-
-    if (dht->assoc)
-        do_Assoc(dht->assoc, dht);
-
+    ping_iterate(dht->ping);
+#if DHT_HARDENING
+    do_hardening(dht);
 #endif
     dht->last_run = unix_time();
 }
+
 void kill_DHT(DHT *dht)
 {
-#ifdef ENABLE_ASSOC_DHT
-    kill_Assoc(dht->assoc);
-#endif
-    networking_registerhandler(dht->net, NET_PACKET_GET_NODES, NULL, NULL);
-    networking_registerhandler(dht->net, NET_PACKET_SEND_NODES_IPV6, NULL, NULL);
-    cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, NULL, NULL);
-    cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, NULL, NULL);
-    ping_array_free_all(&dht->dht_ping_array);
-    ping_array_free_all(&dht->dht_harden_ping_array);
-    kill_ping(dht->ping);
+    networking_registerhandler(dht->net, NET_PACKET_GET_NODES, nullptr, nullptr);
+    networking_registerhandler(dht->net, NET_PACKET_SEND_NODES_IPV6, nullptr, nullptr);
+    cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, nullptr, nullptr);
+    cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, nullptr, nullptr);
+    ping_array_kill(dht->dht_ping_array);
+    ping_array_kill(dht->dht_harden_ping_array);
+    ping_kill(dht->ping);
     free(dht->friends_list);
     free(dht->loaded_nodes_list);
     free(dht);
 }
 
 /* new DHT format for load/save, more robust and forward compatible */
-//TODO: Move this closer to Messenger.
+// TODO(irungentoo): Move this closer to Messenger.
 #define DHT_STATE_COOKIE_GLOBAL 0x159000d
 
 #define DHT_STATE_COOKIE_TYPE      0x11ce
@@ -2484,28 +2773,30 @@ void kill_DHT(DHT *dht)
 /* Get the size of the DHT (for saving). */
 uint32_t DHT_size(const DHT *dht)
 {
-    uint32_t numv4 = 0, numv6 = 0, i, j;
+    uint32_t numv4 = 0;
+    uint32_t numv6 = 0;
 
-    for (i = 0; i < LCLIENT_LIST; ++i) {
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
         numv4 += (dht->close_clientlist[i].assoc4.timestamp != 0);
         numv6 += (dht->close_clientlist[i].assoc6.timestamp != 0);
     }
 
-    for (i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
-        DHT_Friend *fr = &dht->friends_list[i];
+    for (uint32_t i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
+        const DHT_Friend *const fr = &dht->friends_list[i];
 
-        for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
+        for (uint32_t j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
             numv4 += (fr->client_list[j].assoc4.timestamp != 0);
             numv6 += (fr->client_list[j].assoc6.timestamp != 0);
         }
     }
 
-    uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2;
+    const uint32_t size32 = sizeof(uint32_t);
+    const uint32_t sizesubhead = size32 * 2;
 
-    return size32 + sizesubhead + (packed_node_size(AF_INET) * numv4) + (packed_node_size(AF_INET6) * numv6);
+    return size32 + sizesubhead + packed_node_size(net_family_ipv4) * numv4 + packed_node_size(net_family_ipv6) * numv6;
 }
 
-static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
+static uint8_t *DHT_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
 {
     host_to_lendian32(data, len);
     data += sizeof(uint32_t);
@@ -2516,53 +2807,53 @@ static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t typ
 
 
 /* Save the DHT in data where data is an array of size DHT_size(). */
-void DHT_save(DHT *dht, uint8_t *data)
+void DHT_save(const DHT *dht, uint8_t *data)
 {
     host_to_lendian32(data,  DHT_STATE_COOKIE_GLOBAL);
     data += sizeof(uint32_t);
 
-    uint32_t num, i, j;
-
-    uint8_t *old_data = data;
+    uint8_t *const old_data = data;
 
     /* get right offset. we write the actual header later. */
-    data = z_state_save_subheader(data, 0, 0);
+    data = DHT_save_subheader(data, 0, 0);
 
     Node_format clients[MAX_SAVED_DHT_NODES];
 
-    for (num = 0, i = 0; i < LCLIENT_LIST; ++i) {
+    uint32_t num = 0;
+
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
         if (dht->close_clientlist[i].assoc4.timestamp != 0) {
-            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, CRYPTO_PUBLIC_KEY_SIZE);
             clients[num].ip_port = dht->close_clientlist[i].assoc4.ip_port;
             ++num;
         }
 
         if (dht->close_clientlist[i].assoc6.timestamp != 0) {
-            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, CRYPTO_PUBLIC_KEY_SIZE);
             clients[num].ip_port = dht->close_clientlist[i].assoc6.ip_port;
             ++num;
         }
     }
 
-    for (i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
-        DHT_Friend *fr = &dht->friends_list[i];
+    for (uint32_t i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
+        const DHT_Friend *const fr = &dht->friends_list[i];
 
-        for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
+        for (uint32_t j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
             if (fr->client_list[j].assoc4.timestamp != 0) {
-                memcpy(clients[num].public_key, fr->client_list[j].public_key, crypto_box_PUBLICKEYBYTES);
+                memcpy(clients[num].public_key, fr->client_list[j].public_key, CRYPTO_PUBLIC_KEY_SIZE);
                 clients[num].ip_port = fr->client_list[j].assoc4.ip_port;
                 ++num;
             }
 
             if (fr->client_list[j].assoc6.timestamp != 0) {
-                memcpy(clients[num].public_key, fr->client_list[j].public_key, crypto_box_PUBLICKEYBYTES);
+                memcpy(clients[num].public_key, fr->client_list[j].public_key, CRYPTO_PUBLIC_KEY_SIZE);
                 clients[num].ip_port = fr->client_list[j].assoc6.ip_port;
                 ++num;
             }
         }
     }
 
-    z_state_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
+    DHT_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
 }
 
 /* Bootstrap from this number of nodes every time DHT_connect_after_load() is called */
@@ -2571,24 +2862,24 @@ void DHT_save(DHT *dht, uint8_t *data)
 /* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set */
 int DHT_connect_after_load(DHT *dht)
 {
-    if (dht == NULL)
+    if (dht == nullptr) {
         return -1;
+    }
 
-    if (!dht->loaded_nodes_list)
+    if (!dht->loaded_nodes_list) {
         return -1;
+    }
 
     /* DHT is connected, stop. */
     if (DHT_non_lan_connected(dht)) {
         free(dht->loaded_nodes_list);
-        dht->loaded_nodes_list = NULL;
+        dht->loaded_nodes_list = nullptr;
         dht->loaded_num_nodes = 0;
         return 0;
     }
 
-    unsigned int i;
-
-    for (i = 0; i < dht->loaded_num_nodes && i < SAVE_BOOTSTAP_FREQUENCY; ++i) {
-        unsigned int index = dht->loaded_nodes_index % dht->loaded_num_nodes;
+    for (uint32_t i = 0; i < dht->loaded_num_nodes && i < SAVE_BOOTSTAP_FREQUENCY; ++i) {
+        const unsigned int index = dht->loaded_nodes_index % dht->loaded_num_nodes;
         DHT_bootstrap(dht, dht->loaded_nodes_list[index].ip_port, dht->loaded_nodes_list[index].public_key);
         ++dht->loaded_nodes_index;
     }
@@ -2598,37 +2889,33 @@ 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:
-            if (length == 0)
+        case DHT_STATE_TYPE_NODES: {
+            if (length == 0) {
                 break;
+            }
 
-            {
-                free(dht->loaded_nodes_list);
-                // Copy to loaded_clients_list
-                dht->loaded_nodes_list = calloc(MAX_SAVED_DHT_NODES, sizeof(Node_format));
-
-                int num = unpack_nodes(dht->loaded_nodes_list, MAX_SAVED_DHT_NODES, NULL, data, length, 0);
+            free(dht->loaded_nodes_list);
+            // Copy to loaded_clients_list
+            dht->loaded_nodes_list = (Node_format *)calloc(MAX_SAVED_DHT_NODES, sizeof(Node_format));
 
-                if (num > 0) {
-                    dht->loaded_num_nodes = num;
-                } else {
-                    dht->loaded_num_nodes = 0;
-                }
+            const int num = unpack_nodes(dht->loaded_nodes_list, MAX_SAVED_DHT_NODES, nullptr, data, length, 0);
 
-            } /* localize declarations */
+            if (num > 0) {
+                dht->loaded_num_nodes = num;
+            } else {
+                dht->loaded_num_nodes = 0;
+            }
 
             break;
-
-#ifdef DEBUG
+        }
 
         default:
-            fprintf(stderr, "Load state (DHT): contains unrecognized part (len %u, type %u)\n",
-                    length, type);
+            LOGGER_ERROR(dht->log, "Load state (DHT): contains unrecognized part (len %u, type %u)\n",
+                         length, type);
             break;
-#endif
     }
 
     return 0;
@@ -2641,57 +2928,58 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
  */
 int DHT_load(DHT *dht, const uint8_t *data, uint32_t length)
 {
-    uint32_t cookie_len = sizeof(uint32_t);
+    const uint32_t cookie_len = sizeof(uint32_t);
 
     if (length > cookie_len) {
         uint32_t data32;
         lendian_to_host32(&data32, data);
 
-        if (data32 == DHT_STATE_COOKIE_GLOBAL)
-            return load_state(dht_load_state_callback, dht, data + cookie_len,
+        if (data32 == DHT_STATE_COOKIE_GLOBAL) {
+            return load_state(dht_load_state_callback, dht->log, dht, data + cookie_len,
                               length - cookie_len, DHT_STATE_COOKIE_TYPE);
+        }
     }
 
     return -1;
 }
 
-/*  return 0 if we are not connected to the DHT.
- *  return 1 if we are.
+/*  return false if we are not connected to the DHT.
+ *  return true if we are.
  */
-int DHT_isconnected(const DHT *dht)
+bool DHT_isconnected(const DHT *dht)
 {
-    uint32_t i;
     unix_time_update();
 
-    for (i = 0; i < LCLIENT_LIST; ++i) {
-        const Client_data *client = &dht->close_clientlist[i];
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
+        const Client_data *const client = &dht->close_clientlist[i];
 
         if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) ||
-                !is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT))
-            return 1;
+                !is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)) {
+            return true;
+        }
     }
 
-    return 0;
+    return false;
 }
 
-/*  return 0 if we are not connected or only connected to lan peers with the DHT.
- *  return 1 if we are.
+/*  return false if we are not connected or only connected to lan peers with the DHT.
+ *  return true if we are.
  */
-int DHT_non_lan_connected(const DHT *dht)
+bool DHT_non_lan_connected(const DHT *dht)
 {
-    uint32_t i;
     unix_time_update();
 
-    for (i = 0; i < LCLIENT_LIST; ++i) {
-        const Client_data *client = &dht->close_clientlist[i];
-
-        if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc4.ip_port.ip) == -1)
-            return 1;
+    for (uint32_t i = 0; i < LCLIENT_LIST; ++i) {
+        const Client_data *const client = &dht->close_clientlist[i];
 
-        if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) && LAN_ip(client->assoc6.ip_port.ip) == -1)
-            return 1;
+        if (!is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && ip_is_lan(client->assoc4.ip_port.ip) == -1) {
+            return true;
+        }
 
+        if (!is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT) && ip_is_lan(client->assoc6.ip_port.ip) == -1) {
+            return true;
+        }
     }
 
-    return 0;
+    return false;
 }
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index aea3d73b..3ad28d8c 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -1,33 +1,36 @@
-/* DHT.h
- *
+/*
  * An implementation of the DHT as seen in docs/updates/DHT.md
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef DHT_H
 #define DHT_H
 
 #include "crypto_core.h"
+#include "logger.h"
 #include "network.h"
 #include "ping_array.h"
 
+#include <stdbool.h>
+
 /* Maximum number of clients stored per friend. */
 #define MAX_FRIEND_CLIENTS 8
 
@@ -56,20 +59,35 @@
 #define PING_ROUNDTRIP 2
 #define BAD_NODE_TIMEOUT (PING_INTERVAL + PINGS_MISSED_NODE_GOES_BAD * (PING_INTERVAL + PING_ROUNDTRIP))
 
-/* Redefinitions of variables for safe transfer over wire. */
-#define TOX_AF_INET 2
-#define TOX_AF_INET6 10
-#define TOX_TCP_INET 130
-#define TOX_TCP_INET6 138
-
 /* The number of "fake" friends to add (for optimization purposes and so our paths for the onion part are more random) */
 #define DHT_FAKE_FRIEND_NUMBER 2
 
-/* Functions to transfer ips safely across wire. */
-void to_net_family(IP *ip);
+#define MAX_CRYPTO_REQUEST_SIZE 1024
+
+#define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
+#define CRYPTO_PACKET_HARDENING     48  /* Hardening crypto packet ID. */
+#define CRYPTO_PACKET_DHTPK         156
+#define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
 
-/* return 0 on success, -1 on failure. */
-int to_host_family(IP *ip);
+/* Create a request to peer.
+ * send_public_key and send_secret_key are the pub/secret keys of the sender.
+ * recv_public_key is public key of receiver.
+ * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
+ * Data represents the data we send with the request with length being the length of the data.
+ * request_id is the id of the request (32 = friend request, 254 = ping request).
+ *
+ * return -1 on failure.
+ * return the length of the created packet on success.
+ */
+int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_key, uint8_t *packet,
+                   const uint8_t *recv_public_key, const uint8_t *data, uint32_t length, uint8_t request_id);
+
+/* puts the senders public key in the request in public_key, the data from the request
+   in data if a friend or ping request was sent to us and returns the length of the data.
+   packet is the request packet and length is its length
+   return -1 if not valid request. */
+int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data,
+                   uint8_t *request_id, const uint8_t *packet, uint16_t length);
 
 typedef struct {
     IP_Port     ip_port;
@@ -81,17 +99,17 @@ typedef struct {
     uint8_t     routes_requests_ok;
     /* Time which we last checked this.*/
     uint64_t    routes_requests_timestamp;
-    uint8_t     routes_requests_pingedid[crypto_box_PUBLICKEYBYTES];
+    uint8_t     routes_requests_pingedid[CRYPTO_PUBLIC_KEY_SIZE];
     /* Node sends correct send_node (true (1) or false/didn't check (0)) */
     uint8_t     send_nodes_ok;
     /* Time which we last checked this.*/
     uint64_t    send_nodes_timestamp;
-    uint8_t     send_nodes_pingedid[crypto_box_PUBLICKEYBYTES];
+    uint8_t     send_nodes_pingedid[CRYPTO_PUBLIC_KEY_SIZE];
     /* Node can be used to test other nodes (true (1) or false/didn't check (0)) */
     uint8_t     testing_requests;
     /* Time which we last checked this.*/
     uint64_t    testing_timestamp;
-    uint8_t     testing_pingedid[crypto_box_PUBLICKEYBYTES];
+    uint8_t     testing_pingedid[CRYPTO_PUBLIC_KEY_SIZE];
 } Hardening;
 
 typedef struct {
@@ -106,7 +124,7 @@ typedef struct {
 } IPPTsPng;
 
 typedef struct {
-    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t     public_key[CRYPTO_PUBLIC_KEY_SIZE];
     IPPTsPng    assoc4;
     IPPTsPng    assoc6;
 } Client_data;
@@ -129,38 +147,34 @@ typedef struct {
 #define DHT_FRIEND_MAX_LOCKS 32
 
 typedef struct {
-    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t     public_key[CRYPTO_PUBLIC_KEY_SIZE];
     IP_Port     ip_port;
 }
 Node_format;
 
-typedef struct {
-    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
-    Client_data client_list[MAX_FRIEND_CLIENTS];
-
-    /* Time at which the last get_nodes request was sent. */
-    uint64_t    lastgetnode;
-    /* number of times get_node packets were sent. */
-    uint32_t    bootstrap_times;
+typedef struct DHT_Friend DHT_Friend;
 
-    /* Symetric NAT hole punching stuff. */
-    NAT         nat;
+const uint8_t *dht_friend_public_key(const DHT_Friend *dht_friend);
+const Client_data *dht_friend_client(const DHT_Friend *dht_friend, size_t index);
 
-    uint16_t lock_count;
-    struct {
-        void (*ip_callback)(void *, int32_t, IP_Port);
-        void *data;
-        int32_t number;
-    } callbacks[DHT_FRIEND_MAX_LOCKS];
+/* Return packet size of packed node with ip_family on success.
+ * Return -1 on failure.
+ */
+int packed_node_size(Family ip_family);
 
-    Node_format to_bootstrap[MAX_SENT_NODES];
-    unsigned int num_to_bootstrap;
-} DHT_Friend;
+/* Packs an IP_Port structure into data of max size length.
+ *
+ * Returns size of packed IP_Port data on success
+ * Return -1 on failure.
+ */
+int pack_ip_port(uint8_t *data, uint16_t length, const IP_Port *ip_port);
 
-/* Return packet size of packed node with ip_family on success.
+/* Unpack IP_Port structure from data of max size length into ip_port.
+ *
+ * Return size of unpacked ip_port on success.
  * Return -1 on failure.
  */
-int packed_node_size(uint8_t ip_family);
+int unpack_ip_port(IP_Port *ip_port, const uint8_t *data, uint16_t length, uint8_t tcp_enabled);
 
 /* Pack number of nodes into data of maxlength length.
  *
@@ -184,62 +198,46 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
 /* struct to store some shared keys so we don't have to regenerate them for each request. */
 #define MAX_KEYS_PER_SLOT 4
 #define KEYS_TIMEOUT 600
+
 typedef struct {
-    struct {
-        uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-        uint8_t shared_key[crypto_box_BEFORENMBYTES];
-        uint32_t times_requested;
-        uint8_t  stored; /* 0 if not, 1 if is */
-        uint64_t time_last_requested;
-    } keys[256 * MAX_KEYS_PER_SLOT];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint32_t times_requested;
+    uint8_t  stored; /* 0 if not, 1 if is */
+    uint64_t time_last_requested;
+} Shared_Key;
+
+typedef struct {
+    Shared_Key keys[256 * MAX_KEYS_PER_SLOT];
 } Shared_Keys;
 
 /*----------------------------------------------------------------------------------*/
 
 typedef int (*cryptopacket_handler_callback)(void *object, IP_Port ip_port, const uint8_t *source_pubkey,
-        const uint8_t *data, uint16_t len);
+        const uint8_t *data, uint16_t len, void *userdata);
 
 typedef struct {
     cryptopacket_handler_callback function;
     void *object;
 } Cryptopacket_Handles;
 
-typedef struct {
-    Networking_Core *net;
-
-    Client_data    close_clientlist[LCLIENT_LIST];
-    uint64_t       close_lastgetnodes;
-    uint32_t       close_bootstrap_times;
-
-    /* Note: this key should not be/is not used to transmit any sensitive materials */
-    uint8_t      secret_symmetric_key[crypto_box_KEYBYTES];
-    /* DHT keypair */
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
+#define DHT_DEFINED
+typedef struct DHT DHT;
 
-    DHT_Friend    *friends_list;
-    uint16_t       num_friends;
+const uint8_t *dht_get_self_public_key(const DHT *dht);
+const uint8_t *dht_get_self_secret_key(const DHT *dht);
+void dht_set_self_public_key(DHT *dht, const uint8_t *key);
+void dht_set_self_secret_key(DHT *dht, const uint8_t *key);
 
-    Node_format   *loaded_nodes_list;
-    uint32_t       loaded_num_nodes;
-    unsigned int   loaded_nodes_index;
+Networking_Core *dht_get_net(const DHT *dht);
+struct Ping *dht_get_ping(const DHT *dht);
+const Client_data *dht_get_close_clientlist(const DHT *dht);
+const Client_data *dht_get_close_client(const DHT *dht, uint32_t client_num);
+uint16_t dht_get_num_friends(const DHT *dht);
 
-    Shared_Keys shared_keys_recv;
-    Shared_Keys shared_keys_sent;
+DHT_Friend *dht_get_friend(DHT *dht, uint32_t friend_num);
+const uint8_t *dht_get_friend_public_key(const DHT *dht, uint32_t friend_num);
 
-    struct PING   *ping;
-    Ping_Array    dht_ping_array;
-    Ping_Array    dht_harden_ping_array;
-#ifdef ENABLE_ASSOC_DHT
-    struct Assoc  *assoc;
-#endif
-    uint64_t       last_run;
-
-    Cryptopacket_Handles cryptopackethandlers[256];
-
-    Node_format to_bootstrap[MAX_CLOSE_TO_BOOTSTRAP_NODES];
-    unsigned int num_to_bootstrap;
-} DHT;
 /*----------------------------------------------------------------------------------*/
 
 /* Shared key generations are costly, it is therefor smart to store commonly used
@@ -264,7 +262,7 @@ void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *publi
 void DHT_getnodes(DHT *dht, const IP_Port *from_ipp, const uint8_t *from_id, const uint8_t *which_id);
 
 /* Add a new friend to the friends list.
- * public_key must be crypto_box_PUBLICKEYBYTES bytes long.
+ * public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long.
  *
  * ip_callback is the callback of a function that will be called when the ip address
  * is found along with arguments data and number.
@@ -279,7 +277,7 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
                   void *data, int32_t number, uint16_t *lock_count);
 
 /* Delete a friend from the friends list.
- * public_key must be crypto_box_PUBLICKEYBYTES bytes long.
+ * public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long.
  *
  *  return 0 if success.
  *  return -1 if failure (public_key not in friends list).
@@ -287,7 +285,7 @@ int DHT_addfriend(DHT *dht, const uint8_t *public_key, void (*ip_callback)(void
 int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count);
 
 /* Get ip of friend.
- *  public_key must be crypto_box_PUBLICKEYBYTES bytes long.
+ *  public_key must be CRYPTO_PUBLIC_KEY_SIZE bytes long.
  *  ip must be 4 bytes long.
  *  port must be 2 bytes long.
  *
@@ -309,24 +307,24 @@ int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2);
 
 /* Add node to the node list making sure only the nodes closest to cmp_pk are in the list.
  */
-_Bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *pk, IP_Port ip_port,
-                  const uint8_t *cmp_pk);
+bool add_to_list(Node_format *nodes_list, unsigned int length, const uint8_t *pk, IP_Port ip_port,
+                 const uint8_t *cmp_pk);
 
 /* Return 1 if node can be added to close list, 0 if it can't.
  */
-_Bool node_addable_to_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port);
+bool node_addable_to_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port);
 
 /* Get the (maximum MAX_SENT_NODES) closest nodes to public_key we know
  * and put them in nodes_list (must be MAX_SENT_NODES big).
  *
  * sa_family = family (IPv4 or IPv6) (0 if we don't care)?
  * is_LAN = return some LAN ips (true or false)
- * want_good = do we want tested nodes or not? (TODO)
+ * want_good = do we want tested nodes or not? (TODO(irungentoo))
  *
  * return the number of nodes returned.
  *
  */
-int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list, sa_family_t sa_family,
+int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *nodes_list, Family sa_family,
                     uint8_t is_LAN, uint8_t want_good);
 
 
@@ -397,7 +395,7 @@ void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_c
 uint32_t DHT_size(const DHT *dht);
 
 /* Save the DHT in data where data is an array of size DHT_size(). */
-void DHT_save(DHT *dht, uint8_t *data);
+void DHT_save(const DHT *dht, uint8_t *data);
 
 /* Load the DHT from data of size size.
  *
@@ -407,22 +405,21 @@ void DHT_save(DHT *dht, uint8_t *data);
 int DHT_load(DHT *dht, const uint8_t *data, uint32_t length);
 
 /* Initialize DHT. */
-DHT *new_DHT(Networking_Core *net);
+DHT *new_DHT(Logger *log, Networking_Core *net, bool holepunching_enabled);
 
 void kill_DHT(DHT *dht);
 
-/*  return 0 if we are not connected to the DHT.
- *  return 1 if we are.
+/*  return false if we are not connected to the DHT.
+ *  return true if we are.
  */
-int DHT_isconnected(const DHT *dht);
+bool DHT_isconnected(const DHT *dht);
 
-/*  return 0 if we are not connected or only connected to lan peers with the DHT.
- *  return 1 if we are.
+/*  return false if we are not connected or only connected to lan peers with the DHT.
+ *  return true if we are.
  */
-int DHT_non_lan_connected(const DHT *dht);
+bool DHT_non_lan_connected(const DHT *dht);
 
 
-int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
+uint32_t addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
 
 #endif
-
diff --git a/toxcore/LAN_discovery.api.h b/toxcore/LAN_discovery.api.h
new file mode 100644
index 00000000..9e6c6481
--- /dev/null
+++ b/toxcore/LAN_discovery.api.h
@@ -0,0 +1,73 @@
+%{
+/*
+ * LAN discovery implementation.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef LAN_DISCOVERY_H
+#define LAN_DISCOVERY_H
+
+#include "DHT.h"
+%}
+
+class dHT { struct this; }
+class iP { struct this; }
+
+namespace lan_discovery {
+
+/**
+ * Interval in seconds between LAN discovery packet sending.
+ */
+const INTERVAL = 10;
+
+/**
+ * Send a LAN discovery pcaket to the broadcast address with port port.
+ */
+static int32_t send(uint16_t port, dHT::this *dht);
+
+/**
+ * Sets up packet handlers.
+ */
+static void init(dHT::this *dht);
+
+/**
+ * Clear packet handlers.
+ */
+static void kill(dHT::this *dht);
+
+}
+
+/**
+ * Is IP a local ip or not.
+ */
+static bool ip_is_local(iP::this ip);
+
+/**
+ * checks if a given IP isn't routable
+ *
+ *  return 0 if ip is a LAN ip.
+ *  return -1 if it is not.
+ */
+static int32_t ip_is_lan(iP::this ip);
+
+%{
+#endif
+%}
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index 3ea09eb9..d25aace3 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -1,70 +1,81 @@
-/*  LAN_discovery.c
- *
- *  LAN discovery implementation.
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
+/*
+ * LAN discovery implementation.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "LAN_discovery.h"
-#include "util.h"
 
-/* Used for get_broadcast(). */
-#ifdef __linux
-#include <sys/ioctl.h>
-#include <arpa/inet.h>
-#include <linux/netdevice.h>
-#endif
+#include <string.h>
+
+#include "util.h"
 
 #define MAX_INTERFACES 16
 
 
+/* TODO: multiple threads might concurrently try to set these, and it isn't clear that this couldn't lead to undesirable
+ * behaviour. Consider storing the data in per-instance variables instead. */
 static int     broadcast_count = -1;
-static IP_Port broadcast_ip_port[MAX_INTERFACES];
+static IP_Port broadcast_ip_ports[MAX_INTERFACES];
 
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+
+// The mingw32/64 Windows library warns about including winsock2.h after
+// windows.h even though with the above it's a valid thing to do. So, to make
+// mingw32 headers happy, we include winsock2.h first.
+#include <winsock2.h>
+
+#include <windows.h>
+#include <ws2tcpip.h>
 
 #include <iphlpapi.h>
 
 static void fetch_broadcast_info(uint16_t port)
 {
-    broadcast_count = 0;
-
-    IP_ADAPTER_INFO *pAdapterInfo = malloc(sizeof(IP_ADAPTER_INFO));
+    IP_ADAPTER_INFO *pAdapterInfo = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO));
     unsigned long ulOutBufLen = sizeof(IP_ADAPTER_INFO);
 
-    if (pAdapterInfo == NULL) {
+    if (pAdapterInfo == nullptr) {
         return;
     }
 
     if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
         free(pAdapterInfo);
-        pAdapterInfo = malloc(ulOutBufLen);
+        pAdapterInfo = (IP_ADAPTER_INFO *)malloc(ulOutBufLen);
 
-        if (pAdapterInfo == NULL) {
+        if (pAdapterInfo == nullptr) {
             return;
         }
     }
 
+    /* We copy these to the static variables broadcast_* only at the end of fetch_broadcast_info().
+     * The intention is to ensure that even if multiple threads enter fetch_broadcast_info() concurrently, only valid
+     * interfaces will be set to be broadcast to.
+     * */
+    int count = 0;
+    IP_Port ip_ports[MAX_INTERFACES];
+
     int ret;
 
     if ((ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) {
@@ -75,17 +86,17 @@ static void fetch_broadcast_info(uint16_t port)
 
             if (addr_parse_ip(pAdapter->IpAddressList.IpMask.String, &subnet_mask)
                     && addr_parse_ip(pAdapter->GatewayList.IpAddress.String, &gateway)) {
-                if (gateway.family == AF_INET && subnet_mask.family == AF_INET) {
-                    IP_Port *ip_port = &broadcast_ip_port[broadcast_count];
-                    ip_port->ip.family = AF_INET;
-                    uint32_t gateway_ip = ntohl(gateway.ip4.uint32), subnet_ip = ntohl(subnet_mask.ip4.uint32);
+                if (net_family_is_ipv4(gateway.family) && net_family_is_ipv4(subnet_mask.family)) {
+                    IP_Port *ip_port = &ip_ports[count];
+                    ip_port->ip.family = net_family_ipv4;
+                    uint32_t gateway_ip = net_ntohl(gateway.ip.v4.uint32), subnet_ip = net_ntohl(subnet_mask.ip.v4.uint32);
                     uint32_t broadcast_ip = gateway_ip + ~subnet_ip - 1;
-                    ip_port->ip.ip4.uint32 = htonl(broadcast_ip);
+                    ip_port->ip.ip.v4.uint32 = net_htonl(broadcast_ip);
                     ip_port->port = port;
-                    broadcast_count++;
+                    count++;
 
-                    if (broadcast_count >= MAX_INTERFACES) {
-                        return;
+                    if (count >= MAX_INTERFACES) {
+                        break;
                     }
                 }
             }
@@ -97,9 +108,29 @@ static void fetch_broadcast_info(uint16_t port)
     if (pAdapterInfo) {
         free(pAdapterInfo);
     }
+
+    broadcast_count = count;
+
+    for (uint32_t i = 0; i < count; i++) {
+        broadcast_ip_ports[i] = ip_ports[i];
+    }
 }
 
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__FreeBSD__)
+
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#ifdef __linux__
+#include <linux/netdevice.h>
+#endif
+
+#ifdef __FreeBSD__
+#include <net/if.h>
+#endif
 
 static void fetch_broadcast_info(uint16_t port)
 {
@@ -108,10 +139,11 @@ static void fetch_broadcast_info(uint16_t port)
      * Definitely won't work like this on Windows...
      */
     broadcast_count = 0;
-    sock_t sock = 0;
+    const Socket sock = net_socket(net_family_ipv4, TOX_SOCK_STREAM, 0);
 
-    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+    if (!sock_valid(sock)) {
         return;
+    }
 
     /* Configure ifconf for the ioctl call. */
     struct ifreq i_faces[MAX_INTERFACES];
@@ -121,50 +153,64 @@ static void fetch_broadcast_info(uint16_t port)
     ifconf.ifc_buf = (char *)i_faces;
     ifconf.ifc_len = sizeof(i_faces);
 
-    if (ioctl(sock, SIOCGIFCONF, &ifconf) < 0) {
-        close(sock);
+    if (ioctl(sock.socket, SIOCGIFCONF, &ifconf) < 0) {
+        kill_sock(sock);
         return;
     }
 
+    /* We copy these to the static variables broadcast_* only at the end of fetch_broadcast_info().
+     * The intention is to ensure that even if multiple threads enter fetch_broadcast_info() concurrently, only valid
+     * interfaces will be set to be broadcast to.
+     * */
+    int count = 0;
+    IP_Port ip_ports[MAX_INTERFACES];
+
     /* ifconf.ifc_len is set by the ioctl() to the actual length used;
      * on usage of the complete array the call should be repeated with
      * a larger array, not done (640kB and 16 interfaces shall be
      * enough, for everybody!)
      */
-    int i, count = ifconf.ifc_len / sizeof(struct ifreq);
+    int n = ifconf.ifc_len / sizeof(struct ifreq);
 
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < n; i++) {
         /* there are interfaces with are incapable of broadcast */
-        if (ioctl(sock, SIOCGIFBRDADDR, &i_faces[i]) < 0)
+        if (ioctl(sock.socket, SIOCGIFBRDADDR, &i_faces[i]) < 0) {
             continue;
+        }
 
         /* moot check: only AF_INET returned (backwards compat.) */
-        if (i_faces[i].ifr_broadaddr.sa_family != AF_INET)
+        if (i_faces[i].ifr_broadaddr.sa_family != AF_INET) {
             continue;
+        }
 
         struct sockaddr_in *sock4 = (struct sockaddr_in *)&i_faces[i].ifr_broadaddr;
 
-        if (broadcast_count >= MAX_INTERFACES) {
-            close(sock);
-            return;
+        if (count >= MAX_INTERFACES) {
+            break;
         }
 
-        IP_Port *ip_port = &broadcast_ip_port[broadcast_count];
-        ip_port->ip.family = AF_INET;
-        ip_port->ip.ip4.in_addr = sock4->sin_addr;
+        IP_Port *ip_port = &ip_ports[count];
+        ip_port->ip.family = net_family_ipv4;
+        ip_port->ip.ip.v4.uint32 = sock4->sin_addr.s_addr;
 
-        if (ip_port->ip.ip4.uint32 == 0) {
+        if (ip_port->ip.ip.v4.uint32 == 0) {
             continue;
         }
 
         ip_port->port = port;
-        broadcast_count++;
+        count++;
     }
 
-    close(sock);
+    kill_sock(sock);
+
+    broadcast_count = count;
+
+    for (uint32_t i = 0; i < count; i++) {
+        broadcast_ip_ports[i] = ip_ports[i];
+    }
 }
 
-#else //TODO: Other platforms?
+#else // TODO(irungentoo): Other platforms?
 
 static void fetch_broadcast_info(uint16_t port)
 {
@@ -181,73 +227,71 @@ static uint32_t send_broadcasts(Networking_Core *net, uint16_t port, const uint8
 {
     /* fetch only once? on every packet? every X seconds?
      * old: every packet, new: once */
-    if (broadcast_count < 0)
+    if (broadcast_count < 0) {
         fetch_broadcast_info(port);
+    }
 
-    if (!broadcast_count)
+    if (!broadcast_count) {
         return 0;
+    }
 
-    int i;
-
-    for (i = 0; i < broadcast_count; i++)
-        sendpacket(net, broadcast_ip_port[i], data, length);
+    for (int i = 0; i < broadcast_count; i++) {
+        sendpacket(net, broadcast_ip_ports[i], data, length);
+    }
 
     return 1;
 }
 
 /* Return the broadcast ip. */
-static IP broadcast_ip(sa_family_t family_socket, sa_family_t family_broadcast)
+static IP broadcast_ip(Family family_socket, Family family_broadcast)
 {
     IP ip;
     ip_reset(&ip);
 
-    if (family_socket == AF_INET6) {
-        if (family_broadcast == AF_INET6) {
-            ip.family = AF_INET6;
+    if (net_family_is_ipv6(family_socket)) {
+        if (net_family_is_ipv6(family_broadcast)) {
+            ip.family = net_family_ipv6;
             /* FF02::1 is - according to RFC 4291 - multicast all-nodes link-local */
             /* FE80::*: MUST be exact, for that we would need to look over all
              * interfaces and check in which status they are */
-            ip.ip6.uint8[ 0] = 0xFF;
-            ip.ip6.uint8[ 1] = 0x02;
-            ip.ip6.uint8[15] = 0x01;
-        } else if (family_broadcast == AF_INET) {
-            ip.family = AF_INET6;
-            ip.ip6.uint32[0] = 0;
-            ip.ip6.uint32[1] = 0;
-            ip.ip6.uint32[2] = htonl(0xFFFF);
-            ip.ip6.uint32[3] = INADDR_BROADCAST;
-        }
-    } else if (family_socket == AF_INET) {
-        if (family_broadcast == AF_INET) {
-            ip.family = AF_INET;
-            ip.ip4.uint32 = INADDR_BROADCAST;
+            ip.ip.v6.uint8[ 0] = 0xFF;
+            ip.ip.v6.uint8[ 1] = 0x02;
+            ip.ip.v6.uint8[15] = 0x01;
+        } else if (net_family_is_ipv4(family_broadcast)) {
+            ip.family = net_family_ipv6;
+            ip.ip.v6 = IP6_BROADCAST;
         }
+    } else if (net_family_is_ipv4(family_socket) && net_family_is_ipv4(family_broadcast)) {
+        ip.family = net_family_ipv4;
+        ip.ip.v4 = IP4_BROADCAST;
     }
 
     return ip;
 }
 
 /* Is IP a local ip or not. */
-_Bool Local_ip(IP ip)
+bool ip_is_local(IP ip)
 {
-    if (ip.family == AF_INET) {
-        IP4 ip4 = ip.ip4;
+    if (net_family_is_ipv4(ip.family)) {
+        IP4 ip4 = ip.ip.v4;
 
         /* Loopback. */
-        if (ip4.uint8[0] == 127)
+        if (ip4.uint8[0] == 127) {
             return 1;
+        }
     } else {
         /* embedded IPv4-in-IPv6 */
-        if (IPV6_IPV4_IN_V6(ip.ip6)) {
+        if (IPV6_IPV4_IN_V6(ip.ip.v6)) {
             IP ip4;
-            ip4.family = AF_INET;
-            ip4.ip4.uint32 = ip.ip6.uint32[3];
-            return Local_ip(ip4);
+            ip4.family = net_family_ipv4;
+            ip4.ip.v4.uint32 = ip.ip.v6.uint32[3];
+            return ip_is_local(ip4);
         }
 
         /* localhost in IPv6 (::1) */
-        if (ip.ip6.uint64[0] == 0 && ip.ip6.uint32[2] == 0 && ip.ip6.uint32[3] == htonl(1))
+        if (ip.ip.v6.uint64[0] == 0 && ip.ip.v6.uint32[2] == 0 && ip.ip.v6.uint32[3] == net_htonl(1)) {
             return 1;
+        }
     }
 
     return 0;
@@ -256,109 +300,124 @@ _Bool Local_ip(IP ip)
 /*  return 0 if ip is a LAN ip.
  *  return -1 if it is not.
  */
-int LAN_ip(IP ip)
+int ip_is_lan(IP ip)
 {
-    if (Local_ip(ip))
+    if (ip_is_local(ip)) {
         return 0;
+    }
 
-    if (ip.family == AF_INET) {
-        IP4 ip4 = ip.ip4;
+    if (net_family_is_ipv4(ip.family)) {
+        IP4 ip4 = ip.ip.v4;
 
         /* 10.0.0.0 to 10.255.255.255 range. */
-        if (ip4.uint8[0] == 10)
+        if (ip4.uint8[0] == 10) {
             return 0;
+        }
 
         /* 172.16.0.0 to 172.31.255.255 range. */
-        if (ip4.uint8[0] == 172 && ip4.uint8[1] >= 16 && ip4.uint8[1] <= 31)
+        if (ip4.uint8[0] == 172 && ip4.uint8[1] >= 16 && ip4.uint8[1] <= 31) {
             return 0;
+        }
 
         /* 192.168.0.0 to 192.168.255.255 range. */
-        if (ip4.uint8[0] == 192 && ip4.uint8[1] == 168)
+        if (ip4.uint8[0] == 192 && ip4.uint8[1] == 168) {
             return 0;
+        }
 
         /* 169.254.1.0 to 169.254.254.255 range. */
         if (ip4.uint8[0] == 169 && ip4.uint8[1] == 254 && ip4.uint8[2] != 0
-                && ip4.uint8[2] != 255)
+                && ip4.uint8[2] != 255) {
             return 0;
+        }
 
         /* RFC 6598: 100.64.0.0 to 100.127.255.255 (100.64.0.0/10)
          * (shared address space to stack another layer of NAT) */
-        if ((ip4.uint8[0] == 100) && ((ip4.uint8[1] & 0xC0) == 0x40))
+        if ((ip4.uint8[0] == 100) && ((ip4.uint8[1] & 0xC0) == 0x40)) {
             return 0;
-
-    } else if (ip.family == AF_INET6) {
+        }
+    } else if (net_family_is_ipv6(ip.family)) {
 
         /* autogenerated for each interface: FE80::* (up to FEBF::*)
            FF02::1 is - according to RFC 4291 - multicast all-nodes link-local */
-        if (((ip.ip6.uint8[0] == 0xFF) && (ip.ip6.uint8[1] < 3) && (ip.ip6.uint8[15] == 1)) ||
-                ((ip.ip6.uint8[0] == 0xFE) && ((ip.ip6.uint8[1] & 0xC0) == 0x80)))
+        if (((ip.ip.v6.uint8[0] == 0xFF) && (ip.ip.v6.uint8[1] < 3) && (ip.ip.v6.uint8[15] == 1)) ||
+                ((ip.ip.v6.uint8[0] == 0xFE) && ((ip.ip.v6.uint8[1] & 0xC0) == 0x80))) {
             return 0;
+        }
 
         /* embedded IPv4-in-IPv6 */
-        if (IPV6_IPV4_IN_V6(ip.ip6)) {
+        if (IPV6_IPV4_IN_V6(ip.ip.v6)) {
             IP ip4;
-            ip4.family = AF_INET;
-            ip4.ip4.uint32 = ip.ip6.uint32[3];
-            return LAN_ip(ip4);
+            ip4.family = net_family_ipv4;
+            ip4.ip.v4.uint32 = ip.ip.v6.uint32[3];
+            return ip_is_lan(ip4);
         }
     }
 
     return -1;
 }
 
-static int handle_LANdiscovery(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    char ip_str[IP_NTOA_LEN] = { 0 };
+    ip_ntoa(&source.ip, ip_str, sizeof(ip_str));
+
+    if (ip_is_lan(source.ip) == -1) {
         return 1;
+    }
 
-    if (length != crypto_box_PUBLICKEYBYTES + 1)
+    if (length != CRYPTO_PUBLIC_KEY_SIZE + 1) {
         return 1;
+    }
 
     DHT_bootstrap(dht, source, packet + 1);
     return 0;
 }
 
 
-int send_LANdiscovery(uint16_t port, DHT *dht)
+int lan_discovery_send(uint16_t port, DHT *dht)
 {
-    uint8_t data[crypto_box_PUBLICKEYBYTES + 1];
+    uint8_t data[CRYPTO_PUBLIC_KEY_SIZE + 1];
     data[0] = NET_PACKET_LAN_DISCOVERY;
-    id_copy(data + 1, dht->self_public_key);
+    id_copy(data + 1, dht_get_self_public_key(dht));
 
-    send_broadcasts(dht->net, port, data, 1 + crypto_box_PUBLICKEYBYTES);
+    send_broadcasts(dht_get_net(dht), port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE);
 
     int res = -1;
     IP_Port ip_port;
     ip_port.port = port;
 
     /* IPv6 multicast */
-    if (dht->net->family == AF_INET6) {
-        ip_port.ip = broadcast_ip(AF_INET6, AF_INET6);
+    if (net_family_is_ipv6(net_family(dht_get_net(dht)))) {
+        ip_port.ip = broadcast_ip(net_family_ipv6, net_family_ipv6);
 
-        if (ip_isset(&ip_port.ip))
-            if (sendpacket(dht->net, ip_port, data, 1 + crypto_box_PUBLICKEYBYTES) > 0)
+        if (ip_isset(&ip_port.ip)) {
+            if (sendpacket(dht_get_net(dht), ip_port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE) > 0) {
                 res = 1;
+            }
+        }
     }
 
-    /* IPv4 broadcast (has to be IPv4-in-IPv6 mapping if socket is AF_INET6 */
-    ip_port.ip = broadcast_ip(dht->net->family, AF_INET);
+    /* IPv4 broadcast (has to be IPv4-in-IPv6 mapping if socket is IPv6 */
+    ip_port.ip = broadcast_ip(net_family(dht_get_net(dht)), net_family_ipv4);
 
-    if (ip_isset(&ip_port.ip))
-        if (sendpacket(dht->net, ip_port, data, 1 + crypto_box_PUBLICKEYBYTES))
+    if (ip_isset(&ip_port.ip)) {
+        if (sendpacket(dht_get_net(dht), ip_port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE)) {
             res = 1;
+        }
+    }
 
     return res;
 }
 
 
-void LANdiscovery_init(DHT *dht)
+void lan_discovery_init(DHT *dht)
 {
-    networking_registerhandler(dht->net, NET_PACKET_LAN_DISCOVERY, &handle_LANdiscovery, dht);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_LAN_DISCOVERY, &handle_LANdiscovery, dht);
 }
 
-void LANdiscovery_kill(DHT *dht)
+void lan_discovery_kill(DHT *dht)
 {
-    networking_registerhandler(dht->net, NET_PACKET_LAN_DISCOVERY, NULL, NULL);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_LAN_DISCOVERY, nullptr, nullptr);
 }
diff --git a/toxcore/LAN_discovery.h b/toxcore/LAN_discovery.h
index 358bea2f..6d9d17b6 100644
--- a/toxcore/LAN_discovery.h
+++ b/toxcore/LAN_discovery.h
@@ -1,54 +1,74 @@
-/*  LAN_discovery.h
- *
- *  LAN discovery implementation.
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
+/*
+ * LAN discovery implementation.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-
 #ifndef LAN_DISCOVERY_H
 #define LAN_DISCOVERY_H
 
-
 #include "DHT.h"
 
-/* Interval in seconds between LAN discovery packet sending. */
-#define LAN_DISCOVERY_INTERVAL 10
+#ifndef DHT_DEFINED
+#define DHT_DEFINED
+typedef struct DHT DHT;
+#endif /* DHT_DEFINED */
 
-/* Send a LAN discovery pcaket to the broadcast address with port port. */
-int send_LANdiscovery(uint16_t port, DHT *dht);
+#ifndef IP_DEFINED
+#define IP_DEFINED
+typedef struct IP IP;
+#endif /* IP_DEFINED */
 
-/* Sets up packet handlers. */
-void LANdiscovery_init(DHT *dht);
+/**
+ * Interval in seconds between LAN discovery packet sending.
+ */
+#define LAN_DISCOVERY_INTERVAL         10
 
-/* Clear packet handlers. */
-void LANdiscovery_kill(DHT *dht);
+uint32_t lan_discovery_interval(void);
 
-/* Is IP a local ip or not. */
-_Bool Local_ip(IP ip);
+/**
+ * Send a LAN discovery pcaket to the broadcast address with port port.
+ */
+int32_t lan_discovery_send(uint16_t port, DHT *dht);
+
+/**
+ * Sets up packet handlers.
+ */
+void lan_discovery_init(DHT *dht);
+
+/**
+ * Clear packet handlers.
+ */
+void lan_discovery_kill(DHT *dht);
+
+/**
+ * Is IP a local ip or not.
+ */
+bool ip_is_local(IP ip);
 
-/* checks if a given IP isn't routable
+/**
+ * checks if a given IP isn't routable
  *
  *  return 0 if ip is a LAN ip.
  *  return -1 if it is not.
  */
-int LAN_ip(IP ip);
-
+int32_t ip_is_lan(IP ip);
 
 #endif
diff --git a/toxcore/Makefile.inc b/toxcore/Makefile.inc
index d6b67eb2..2ca25650 100644
--- a/toxcore/Makefile.inc
+++ b/toxcore/Makefile.inc
@@ -1,17 +1,18 @@
 lib_LTLIBRARIES += libtoxcore.la
 
 libtoxcore_la_include_HEADERS = \
-                        ../toxcore/tox.h \
-                        ../toxcore/tox_old.h
+                        ../toxcore/tox.h
 
 libtoxcore_la_includedir = $(includedir)/tox
 
-libtoxcore_la_SOURCES = ../toxcore/DHT.h \
+libtoxcore_la_SOURCES = ../toxcore/ccompat.h \
+                        ../toxcore/DHT.h \
                         ../toxcore/DHT.c \
                         ../toxcore/network.h \
                         ../toxcore/network.c \
                         ../toxcore/crypto_core.h \
                         ../toxcore/crypto_core.c \
+                        ../toxcore/crypto_core_mem.c \
                         ../toxcore/ping_array.h \
                         ../toxcore/ping_array.c \
                         ../toxcore/net_crypto.h \
@@ -28,12 +29,11 @@ libtoxcore_la_SOURCES = ../toxcore/DHT.h \
                         ../toxcore/ping.c \
                         ../toxcore/tox.h \
                         ../toxcore/tox.c \
+                        ../toxcore/tox_api.c \
                         ../toxcore/util.h \
                         ../toxcore/util.c \
                         ../toxcore/group.h \
                         ../toxcore/group.c \
-                        ../toxcore/assoc.h \
-                        ../toxcore/assoc.c \
                         ../toxcore/onion.h \
                         ../toxcore/onion.c \
                         ../toxcore/logger.h \
@@ -49,9 +49,7 @@ libtoxcore_la_SOURCES = ../toxcore/DHT.h \
                         ../toxcore/TCP_connection.h \
                         ../toxcore/TCP_connection.c \
                         ../toxcore/list.c \
-                        ../toxcore/list.h \
-                        ../toxcore/misc_tools.h \
-                        ../toxcore/tox_old_code.h
+                        ../toxcore/list.h
 
 libtoxcore_la_CFLAGS =  -I$(top_srcdir) \
                         -I$(top_srcdir)/toxcore \
@@ -59,7 +57,7 @@ libtoxcore_la_CFLAGS =  -I$(top_srcdir) \
                         $(NACL_CFLAGS) \
                         $(PTHREAD_CFLAGS)
 
-libtoxcore_la_LDFLAGS = $(TOXCORE_LT_LDFLAGS) \
+libtoxcore_la_LDFLAGS = $(LT_LDFLAGS) \
                         $(EXTRA_LT_LDFLAGS) \
                         $(LIBSODIUM_LDFLAGS) \
                         $(NACL_LDFLAGS) \
@@ -71,3 +69,9 @@ libtoxcore_la_LIBADD =  $(LIBSODIUM_LIBS) \
                         $(NACL_OBJECTS) \
                         $(NAC_LIBS) \
                         $(PTHREAD_LIBS)
+
+if SET_SO_VERSION
+
+EXTRA_libtoxcore_la_DEPENDENCIES = ../so.version
+
+endif
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 34296c24..11109815 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -1,42 +1,42 @@
-/* Messenger.c
- *
+/*
  * An implementation of a simple text chat only messenger on the tox network core.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifdef DEBUG
+#include "Messenger.h"
+
 #include <assert.h>
-#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
 
 #include "logger.h"
-#include "Messenger.h"
-#include "assoc.h"
 #include "network.h"
 #include "util.h"
 
-
-static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status);
 static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
                                 uint32_t length, uint8_t congestion_control);
 
@@ -56,18 +56,19 @@ static uint8_t friend_not_valid(const Messenger *m, int32_t friendnumber)
  *
  *  return -1 if realloc fails.
  */
-int realloc_friendlist(Messenger *m, uint32_t num)
+static int realloc_friendlist(Messenger *m, uint32_t num)
 {
     if (num == 0) {
         free(m->friendlist);
-        m->friendlist = NULL;
+        m->friendlist = nullptr;
         return 0;
     }
 
-    Friend *newfriendlist = realloc(m->friendlist, num * sizeof(Friend));
+    Friend *newfriendlist = (Friend *)realloc(m->friendlist, num * sizeof(Friend));
 
-    if (newfriendlist == NULL)
+    if (newfriendlist == nullptr) {
         return -1;
+    }
 
     m->friendlist = newfriendlist;
     return 0;
@@ -81,26 +82,29 @@ int32_t getfriend_id(const Messenger *m, const uint8_t *real_pk)
     uint32_t i;
 
     for (i = 0; i < m->numfriends; ++i) {
-        if (m->friendlist[i].status > 0)
-            if (id_equal(real_pk, m->friendlist[i].real_pk))
+        if (m->friendlist[i].status > 0) {
+            if (id_equal(real_pk, m->friendlist[i].real_pk)) {
                 return i;
+            }
+        }
     }
 
     return -1;
 }
 
 /* Copies the public key associated to that friend id into real_pk buffer.
- * Make sure that real_pk is of size crypto_box_PUBLICKEYBYTES.
+ * Make sure that real_pk is of size CRYPTO_PUBLIC_KEY_SIZE.
  *
  *  return 0 if success.
  *  return -1 if failure.
  */
 int get_real_pk(const Messenger *m, int32_t friendnumber, uint8_t *real_pk)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    memcpy(real_pk, m->friendlist[friendnumber].real_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(real_pk, m->friendlist[friendnumber].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
     return 0;
 }
 
@@ -109,8 +113,9 @@ int get_real_pk(const Messenger *m, int32_t friendnumber, uint8_t *real_pk)
  */
 int getfriendcon_id(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     return m->friendlist[friendnumber].friendcon_id;
 }
@@ -124,8 +129,9 @@ static uint16_t address_checksum(const uint8_t *address, uint32_t len)
     uint16_t check;
     uint32_t i;
 
-    for (i = 0; i < len; ++i)
+    for (i = 0; i < len; ++i) {
         checksum[i % 2] ^= address[i];
+    }
 
     memcpy(&check, checksum, sizeof(check));
     return check;
@@ -137,17 +143,18 @@ static uint16_t address_checksum(const uint8_t *address, uint32_t len)
  */
 void getaddress(const Messenger *m, uint8_t *address)
 {
-    id_copy(address, m->net_crypto->self_public_key);
-    uint32_t nospam = get_nospam(&(m->fr));
-    memcpy(address + crypto_box_PUBLICKEYBYTES, &nospam, sizeof(nospam));
+    id_copy(address, nc_get_self_public_key(m->net_crypto));
+    uint32_t nospam = get_nospam(m->fr);
+    memcpy(address + CRYPTO_PUBLIC_KEY_SIZE, &nospam, sizeof(nospam));
     uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
-    memcpy(address + crypto_box_PUBLICKEYBYTES + sizeof(nospam), &checksum, sizeof(checksum));
+    memcpy(address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(nospam), &checksum, sizeof(checksum));
 }
 
 static int send_online_packet(Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return 0;
+    }
 
     uint8_t packet = PACKET_ID_ONLINE;
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
@@ -161,22 +168,25 @@ static int send_offline_packet(Messenger *m, int friendcon_id)
                              sizeof(packet), 0) != -1;
 }
 
-static int handle_status(void *object, int i, uint8_t status);
-static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len);
-static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length);
+static int m_handle_status(void *object, int i, uint8_t status, void *userdata);
+static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata);
+static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
+                                        void *userdata);
 
 static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t status)
 {
     /* Resize the friend list if necessary. */
-    if (realloc_friendlist(m, m->numfriends + 1) != 0)
+    if (realloc_friendlist(m, m->numfriends + 1) != 0) {
         return FAERR_NOMEM;
+    }
 
-    memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend));
+    memset(&m->friendlist[m->numfriends], 0, sizeof(Friend));
 
     int friendcon_id = new_friend_connection(m->fr_c, real_pk);
 
-    if (friendcon_id == -1)
+    if (friendcon_id == -1) {
         return FAERR_NOMEM;
+    }
 
     uint32_t i;
 
@@ -190,11 +200,12 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta
             m->friendlist[i].userstatus = USERSTATUS_NONE;
             m->friendlist[i].is_typing = 0;
             m->friendlist[i].message_id = 0;
-            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
-                                        &handle_custom_lossy_packet, m, i);
+            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &m_handle_status, &m_handle_packet,
+                                        &m_handle_custom_lossy_packet, m, i);
 
-            if (m->numfriends == i)
+            if (m->numfriends == i) {
                 ++m->numfriends;
+            }
 
             if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
                 send_online_packet(m, i);
@@ -225,38 +236,45 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta
  */
 int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, uint16_t length)
 {
-    if (length > MAX_FRIEND_REQUEST_DATA_SIZE)
+    if (length > MAX_FRIEND_REQUEST_DATA_SIZE) {
         return FAERR_TOOLONG;
+    }
 
-    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
     id_copy(real_pk, address);
 
-    if (!public_key_valid(real_pk))
+    if (!public_key_valid(real_pk)) {
         return FAERR_BADCHECKSUM;
+    }
 
     uint16_t check, checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
-    memcpy(&check, address + crypto_box_PUBLICKEYBYTES + sizeof(uint32_t), sizeof(check));
+    memcpy(&check, address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t), sizeof(check));
 
-    if (check != checksum)
+    if (check != checksum) {
         return FAERR_BADCHECKSUM;
+    }
 
-    if (length < 1)
+    if (length < 1) {
         return FAERR_NOMESSAGE;
+    }
 
-    if (id_equal(real_pk, m->net_crypto->self_public_key))
+    if (id_equal(real_pk, nc_get_self_public_key(m->net_crypto))) {
         return FAERR_OWNKEY;
+    }
 
     int32_t friend_id = getfriend_id(m, real_pk);
 
     if (friend_id != -1) {
-        if (m->friendlist[friend_id].status >= FRIEND_CONFIRMED)
+        if (m->friendlist[friend_id].status >= FRIEND_CONFIRMED) {
             return FAERR_ALREADYSENT;
+        }
 
         uint32_t nospam;
-        memcpy(&nospam, address + crypto_box_PUBLICKEYBYTES, sizeof(nospam));
+        memcpy(&nospam, address + CRYPTO_PUBLIC_KEY_SIZE, sizeof(nospam));
 
-        if (m->friendlist[friend_id].friendrequest_nospam == nospam)
+        if (m->friendlist[friend_id].friendrequest_nospam == nospam) {
             return FAERR_ALREADYSENT;
+        }
 
         m->friendlist[friend_id].friendrequest_nospam = nospam;
         return FAERR_SETNEWNOSPAM;
@@ -271,29 +289,33 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
     m->friendlist[ret].friendrequest_timeout = FRIENDREQUEST_TIMEOUT;
     memcpy(m->friendlist[ret].info, data, length);
     m->friendlist[ret].info_size = length;
-    memcpy(&(m->friendlist[ret].friendrequest_nospam), address + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
+    memcpy(&m->friendlist[ret].friendrequest_nospam, address + CRYPTO_PUBLIC_KEY_SIZE, sizeof(uint32_t));
 
     return ret;
 }
 
 int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk)
 {
-    if (getfriend_id(m, real_pk) != -1)
+    if (getfriend_id(m, real_pk) != -1) {
         return FAERR_ALREADYSENT;
+    }
 
-    if (!public_key_valid(real_pk))
+    if (!public_key_valid(real_pk)) {
         return FAERR_BADCHECKSUM;
+    }
 
-    if (id_equal(real_pk, m->net_crypto->self_public_key))
+    if (id_equal(real_pk, nc_get_self_public_key(m->net_crypto))) {
         return FAERR_OWNKEY;
+    }
 
     return init_new_friend(m, real_pk, FRIEND_CONFIRMED);
 }
 
 static int clear_receipts(Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     struct Receipts *receipts = m->friendlist[friendnumber].receipts_start;
 
@@ -303,32 +325,34 @@ static int clear_receipts(Messenger *m, int32_t friendnumber)
         receipts = temp_r;
     }
 
-    m->friendlist[friendnumber].receipts_start = NULL;
-    m->friendlist[friendnumber].receipts_end = NULL;
+    m->friendlist[friendnumber].receipts_start = nullptr;
+    m->friendlist[friendnumber].receipts_end = nullptr;
     return 0;
 }
 
 static int add_receipt(Messenger *m, int32_t friendnumber, uint32_t packet_num, uint32_t msg_id)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         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 = nullptr;
     return 0;
 }
 /*
@@ -337,36 +361,43 @@ static int add_receipt(Messenger *m, int32_t friendnumber, uint32_t packet_num,
  */
 static int friend_received_packet(const Messenger *m, int32_t friendnumber, uint32_t number)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     return cryptpacket_received(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
                                 m->friendlist[friendnumber].friendcon_id), number);
 }
 
-static int do_receipts(Messenger *m, int32_t friendnumber)
+static int do_receipts(Messenger *m, int32_t friendnumber, void *userdata)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     struct Receipts *receipts = m->friendlist[friendnumber].receipts_start;
 
     while (receipts) {
-        struct Receipts *temp_r = receipts->next;
-
-        if (friend_received_packet(m, friendnumber, receipts->packet_num) == -1)
+        if (friend_received_packet(m, friendnumber, receipts->packet_num) == -1) {
             break;
+        }
+
+        if (m->read_receipt) {
+            (*m->read_receipt)(m, friendnumber, receipts->msg_id, userdata);
+        }
 
-        if (m->read_receipt)
-            (*m->read_receipt)(m, friendnumber, receipts->msg_id, m->read_receipt_userdata);
+        struct Receipts *r_next = receipts->next;
 
         free(receipts);
-        m->friendlist[friendnumber].receipts_start = temp_r;
-        receipts = temp_r;
+
+        m->friendlist[friendnumber].receipts_start = r_next;
+
+        receipts = r_next;
     }
 
-    if (!m->friendlist[friendnumber].receipts_start)
-        m->friendlist[friendnumber].receipts_end = NULL;
+    if (!m->friendlist[friendnumber].receipts_start) {
+        m->friendlist[friendnumber].receipts_end = nullptr;
+    }
 
     return 0;
 }
@@ -378,66 +409,73 @@ static int do_receipts(Messenger *m, int32_t friendnumber)
  */
 int m_delfriend(Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friend_connectionstatuschange_internal)
+    if (m->friend_connectionstatuschange_internal) {
         m->friend_connectionstatuschange_internal(m, friendnumber, 0, m->friend_connectionstatuschange_internal_userdata);
+    }
 
     clear_receipts(m, friendnumber);
-    remove_request_received(&(m->fr), m->friendlist[friendnumber].real_pk);
-    friend_connection_callbacks(m->fr_c, m->friendlist[friendnumber].friendcon_id, MESSENGER_CALLBACK_INDEX, 0, 0, 0, 0, 0);
+    remove_request_received(m->fr, m->friendlist[friendnumber].real_pk);
+    friend_connection_callbacks(m->fr_c, m->friendlist[friendnumber].friendcon_id, MESSENGER_CALLBACK_INDEX, nullptr,
+                                nullptr, nullptr, nullptr, 0);
 
     if (friend_con_connected(m->fr_c, m->friendlist[friendnumber].friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
         send_offline_packet(m, m->friendlist[friendnumber].friendcon_id);
     }
 
     kill_friend_connection(m->fr_c, m->friendlist[friendnumber].friendcon_id);
-    memset(&(m->friendlist[friendnumber]), 0, sizeof(Friend));
+    memset(&m->friendlist[friendnumber], 0, sizeof(Friend));
     uint32_t i;
 
     for (i = m->numfriends; i != 0; --i) {
-        if (m->friendlist[i - 1].status != NOFRIEND)
+        if (m->friendlist[i - 1].status != NOFRIEND) {
             break;
+        }
     }
 
     m->numfriends = i;
 
-    if (realloc_friendlist(m, m->numfriends) != 0)
+    if (realloc_friendlist(m, m->numfriends) != 0) {
         return FAERR_NOMEM;
+    }
 
     return 0;
 }
 
 int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     if (m->friendlist[friendnumber].status == FRIEND_ONLINE) {
-        _Bool direct_connected = 0;
+        bool direct_connected = 0;
         unsigned int num_online_relays = 0;
-        crypto_connection_status(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                                 m->friendlist[friendnumber].friendcon_id), &direct_connected, &num_online_relays);
+        int crypt_conn_id = friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id);
+        crypto_connection_status(m->net_crypto, crypt_conn_id, &direct_connected, &num_online_relays);
 
         if (direct_connected) {
             return CONNECTION_UDP;
-        } else {
-            if (num_online_relays) {
-                return CONNECTION_TCP;
-            } else {
-                return CONNECTION_UNKNOWN;
-            }
         }
-    } else {
-        return CONNECTION_NONE;
+
+        if (num_online_relays) {
+            return CONNECTION_TCP;
+        }
+
+        return CONNECTION_UNKNOWN;
     }
+
+    return CONNECTION_NONE;
 }
 
 int m_friend_exists(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return 0;
+    }
 
     return 1;
 }
@@ -454,36 +492,43 @@ int m_friend_exists(const Messenger *m, int32_t friendnumber)
 int m_send_message_generic(Messenger *m, int32_t friendnumber, uint8_t type, const uint8_t *message, uint32_t length,
                            uint32_t *message_id)
 {
-    if (type > MESSAGE_ACTION)
+    if (type > MESSAGE_ACTION) {
         return -5;
+    }
 
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (length >= MAX_CRYPTO_DATA_SIZE)
+    if (length >= MAX_CRYPTO_DATA_SIZE) {
         return -2;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -3;
+    }
 
-    uint8_t packet[length + 1];
+    VLA(uint8_t, packet, length + 1);
     packet[0] = type + PACKET_ID_MESSAGE;
 
-    if (length != 0)
+    if (length != 0) {
         memcpy(packet + 1, message, length);
+    }
 
     int64_t packet_num = write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
                                            m->friendlist[friendnumber].friendcon_id), packet, length + 1, 0);
 
-    if (packet_num == -1)
+    if (packet_num == -1) {
         return -4;
+    }
 
     uint32_t msg_id = ++m->friendlist[friendnumber].message_id;
 
     add_receipt(m, friendnumber, packet_num, msg_id);
 
-    if (message_id)
+    if (message_id) {
         *message_id = msg_id;
+    }
 
     return 0;
 }
@@ -493,8 +538,9 @@ int m_send_message_generic(Messenger *m, int32_t friendnumber, uint8_t type, con
  */
 static int m_sendname(const Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length)
 {
-    if (length > MAX_NAME_LENGTH)
+    if (length > MAX_NAME_LENGTH) {
         return 0;
+    }
 
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_NICKNAME, name, length, 0);
 }
@@ -506,11 +552,13 @@ static int m_sendname(const Messenger *m, int32_t friendnumber, const uint8_t *n
  */
 int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (length > MAX_NAME_LENGTH || length == 0)
+    if (length > MAX_NAME_LENGTH || length == 0) {
         return -1;
+    }
 
     m->friendlist[friendnumber].name_length = length;
     memcpy(m->friendlist[friendnumber].name, name, length);
@@ -527,20 +575,24 @@ int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint1
  */
 int setname(Messenger *m, const uint8_t *name, uint16_t length)
 {
-    if (length > MAX_NAME_LENGTH)
+    if (length > MAX_NAME_LENGTH) {
         return -1;
+    }
 
-    if (m->name_length == length && (length == 0 || memcmp(name, m->name, length) == 0))
+    if (m->name_length == length && (length == 0 || memcmp(name, m->name, length) == 0)) {
         return 0;
+    }
 
-    if (length)
+    if (length) {
         memcpy(m->name, name, length);
+    }
 
     m->name_length = length;
     uint32_t i;
 
-    for (i = 0; i < m->numfriends; ++i)
+    for (i = 0; i < m->numfriends; ++i) {
         m->friendlist[i].name_sent = 0;
+    }
 
     return 0;
 }
@@ -552,7 +604,7 @@ int setname(Messenger *m, const uint8_t *name, uint16_t length)
  */
 uint16_t getself_name(const Messenger *m, uint8_t *name)
 {
-    if (name == NULL) {
+    if (name == nullptr) {
         return 0;
     }
 
@@ -569,8 +621,9 @@ uint16_t getself_name(const Messenger *m, uint8_t *name)
  */
 int getname(const Messenger *m, int32_t friendnumber, uint8_t *name)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     memcpy(name, m->friendlist[friendnumber].name, m->friendlist[friendnumber].name_length);
     return m->friendlist[friendnumber].name_length;
@@ -578,8 +631,9 @@ int getname(const Messenger *m, int32_t friendnumber, uint8_t *name)
 
 int m_get_name_size(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     return m->friendlist[friendnumber].name_length;
 }
@@ -591,38 +645,45 @@ int m_get_self_name_size(const Messenger *m)
 
 int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length)
 {
-    if (length > MAX_STATUSMESSAGE_LENGTH)
+    if (length > MAX_STATUSMESSAGE_LENGTH) {
         return -1;
+    }
 
-    if (m->statusmessage_length == length && (length == 0 || memcmp(m->statusmessage, status, length) == 0))
+    if (m->statusmessage_length == length && (length == 0 || memcmp(m->statusmessage, status, length) == 0)) {
         return 0;
+    }
 
-    if (length)
+    if (length) {
         memcpy(m->statusmessage, status, length);
+    }
 
     m->statusmessage_length = length;
 
     uint32_t i;
 
-    for (i = 0; i < m->numfriends; ++i)
+    for (i = 0; i < m->numfriends; ++i) {
         m->friendlist[i].statusmessage_sent = 0;
+    }
 
     return 0;
 }
 
 int m_set_userstatus(Messenger *m, uint8_t status)
 {
-    if (status >= USERSTATUS_INVALID)
+    if (status >= USERSTATUS_INVALID) {
         return -1;
+    }
 
-    if (m->userstatus == status)
+    if (m->userstatus == status) {
         return 0;
+    }
 
-    m->userstatus = status;
+    m->userstatus = (USERSTATUS)status;
     uint32_t i;
 
-    for (i = 0; i < m->numfriends; ++i)
+    for (i = 0; i < m->numfriends; ++i) {
         m->friendlist[i].userstatus_sent = 0;
+    }
 
     return 0;
 }
@@ -632,8 +693,9 @@ int m_set_userstatus(Messenger *m, uint8_t status)
  */
 int m_get_statusmessage_size(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     return m->friendlist[friendnumber].statusmessage_length;
 }
@@ -643,8 +705,9 @@ int m_get_statusmessage_size(const Messenger *m, int32_t friendnumber)
  */
 int m_copy_statusmessage(const Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     int msglen = MIN(maxlen, m->friendlist[friendnumber].statusmessage_length);
 
@@ -669,8 +732,9 @@ int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf)
 
 uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return USERSTATUS_INVALID;
+    }
 
     uint8_t status = m->friendlist[friendnumber].userstatus;
 
@@ -688,23 +752,26 @@ uint8_t m_get_self_userstatus(const Messenger *m)
 
 uint64_t m_get_last_online(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return UINT64_MAX;
+    }
 
     return m->friendlist[friendnumber].last_seen_time;
 }
 
 int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing)
-
 {
-    if (is_typing != 0 && is_typing != 1)
+    if (is_typing != 0 && is_typing != 1) {
         return -1;
+    }
 
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friendlist[friendnumber].user_istyping == is_typing)
+    if (m->friendlist[friendnumber].user_istyping == is_typing) {
         return 0;
+    }
 
     m->friendlist[friendnumber].user_istyping = is_typing;
     m->friendlist[friendnumber].user_istyping_sent = 0;
@@ -714,8 +781,9 @@ int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing)
 
 int m_get_istyping(const Messenger *m, int32_t friendnumber)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
     return m->friendlist[friendnumber].is_typing;
 }
@@ -738,14 +806,17 @@ static int send_user_istyping(const Messenger *m, int32_t friendnumber, uint8_t
 
 static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, const uint8_t *status, uint16_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (length > MAX_STATUSMESSAGE_LENGTH)
+    if (length > MAX_STATUSMESSAGE_LENGTH) {
         return -1;
+    }
 
-    if (length)
+    if (length) {
         memcpy(m->friendlist[friendnumber].statusmessage, status, length);
+    }
 
     m->friendlist[friendnumber].statusmessage_length = length;
     return 0;
@@ -753,7 +824,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)
@@ -761,65 +832,58 @@ static void set_friend_typing(const Messenger *m, int32_t friendnumber, uint8_t
     m->friendlist[friendnumber].is_typing = is_typing;
 }
 
+void m_callback_log(Messenger *m, logger_cb *function, void *context, void *userdata)
+{
+    logger_callback_log(m->log, function, context, userdata);
+}
+
 /* Set the function that will be executed when a friend request is received. */
 void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, size_t,
-                              void *), void *userdata)
+                              void *))
 {
-    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, size_t, void *) = (void *)function;
-    callback_friendrequest(&(m->fr), handle_friendrequest, m, userdata);
+    callback_friendrequest(m->fr, (void (*)(void *, const uint8_t *, const uint8_t *, size_t, void *))function, m);
 }
 
 /* Set the function that will be executed when a message from a friend is received. */
 void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, const uint8_t *,
-                              size_t, void *), void *userdata)
+                              size_t, void *))
 {
     m->friend_message = function;
-    m->friend_message_userdata = userdata;
 }
 
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
-                           void *userdata)
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *))
 {
     m->friend_namechange = function;
-    m->friend_namechange_userdata = userdata;
 }
 
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
-                              void *userdata)
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *))
 {
     m->friend_statusmessagechange = function;
-    m->friend_statusmessagechange_userdata = userdata;
 }
 
-void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *), void *userdata)
+void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *))
 {
     m->friend_userstatuschange = function;
-    m->friend_userstatuschange_userdata = userdata;
 }
 
-void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, _Bool, void *), void *userdata)
+void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, bool, void *))
 {
     m->friend_typingchange = function;
-    m->friend_typingchange_userdata = userdata;
 }
 
-void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *), void *userdata)
+void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *))
 {
     m->read_receipt = function;
-    m->read_receipt_userdata = userdata;
 }
 
-void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *),
-                                 void *userdata)
+void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *))
 {
     m->friend_connectionstatuschange = function;
-    m->friend_connectionstatuschange_userdata = userdata;
 }
 
-void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, unsigned int, void *), void *userdata)
+void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, unsigned int, void *))
 {
     m->core_connection_change = function;
-    m->core_connection_change_userdata = userdata;
 }
 
 void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
@@ -829,36 +893,39 @@ void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Mess
     m->friend_connectionstatuschange_internal_userdata = userdata;
 }
 
-static void check_friend_tcp_udp(Messenger *m, int32_t friendnumber)
+static void check_friend_tcp_udp(Messenger *m, int32_t friendnumber, void *userdata)
 {
     int last_connection_udp_tcp = m->friendlist[friendnumber].last_connection_udp_tcp;
 
     int ret = m_get_friend_connectionstatus(m, friendnumber);
 
-    if (ret == -1)
+    if (ret == -1) {
         return;
+    }
 
     if (ret == CONNECTION_UNKNOWN) {
         if (last_connection_udp_tcp == CONNECTION_UDP) {
             return;
-        } else {
-            ret = CONNECTION_TCP;
         }
+
+        ret = CONNECTION_TCP;
     }
 
     if (last_connection_udp_tcp != ret) {
-        if (m->friend_connectionstatuschange)
-            m->friend_connectionstatuschange(m, friendnumber, ret, m->friend_connectionstatuschange_userdata);
+        if (m->friend_connectionstatuschange) {
+            m->friend_connectionstatuschange(m, friendnumber, ret, userdata);
+        }
     }
 
     m->friendlist[friendnumber].last_connection_udp_tcp = ret;
 }
 
 static void break_files(const Messenger *m, int32_t friendnumber);
-static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, uint8_t status)
+static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata)
 {
-    if (status == NOFRIEND)
+    if (status == NOFRIEND) {
         return;
+    }
 
     const uint8_t was_online = m->friendlist[friendnumber].status == FRIEND_ONLINE;
     const uint8_t is_online = status == FRIEND_ONLINE;
@@ -876,60 +943,65 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
 
         m->friendlist[friendnumber].status = status;
 
-        check_friend_tcp_udp(m, friendnumber);
+        check_friend_tcp_udp(m, friendnumber, userdata);
 
-        if (m->friend_connectionstatuschange_internal)
+        if (m->friend_connectionstatuschange_internal) {
             m->friend_connectionstatuschange_internal(m, friendnumber, is_online,
                     m->friend_connectionstatuschange_internal_userdata);
+        }
     }
 }
 
-void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status)
+static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status, void *userdata)
 {
-    check_friend_connectionstatus(m, friendnumber, status);
+    check_friend_connectionstatus(m, friendnumber, status, userdata);
     m->friendlist[friendnumber].status = status;
 }
 
 static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
                                 uint32_t length, uint8_t congestion_control)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return 0;
+    }
 
-    if (length >= MAX_CRYPTO_DATA_SIZE || m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (length >= MAX_CRYPTO_DATA_SIZE || m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return 0;
+    }
 
-    uint8_t packet[length + 1];
+    VLA(uint8_t, packet, length + 1);
     packet[0] = packet_id;
 
-    if (length != 0)
+    if (length != 0) {
         memcpy(packet + 1, data, length);
+    }
 
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
                              m->friendlist[friendnumber].friendcon_id), packet, length + 1, congestion_control) != -1;
 }
 
-/**********GROUP CHATS************/
+/**********CONFERENCES************/
 
 
-/* Set the callback for group invites.
+/* Set the callback for conference invites.
  *
- *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length)
+ *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t))
+void m_callback_conference_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t,
+                                  void *))
 {
-    m->group_invite = function;
+    m->conference_invite = function;
 }
 
 
-/* Send a group invite packet.
+/* Send a conference invite packet.
  *
  *  return 1 on success
  *  return 0 on failure
  */
-int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length)
+int send_conference_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length)
 {
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_GROUPCHAT, data, length, 0);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_CONFERENCE, data, length, 0);
 }
 
 /****************FILE SENDING*****************/
@@ -940,10 +1012,9 @@ int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uin
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint32_t filetype, uint64_t filesize, uint8_t *filename, size_t filename_length, void *userdata)
  */
 void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m,  uint32_t, uint32_t, uint32_t, uint64_t,
-                               const uint8_t *, size_t, void *), void *userdata)
+                               const uint8_t *, size_t, void *))
 {
     m->file_sendrequest = function;
-    m->file_sendrequest_userdata = userdata;
 }
 
 /* Set the callback for file control requests.
@@ -951,11 +1022,9 @@ void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m,  uin
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, unsigned int control_type, void *userdata)
  *
  */
-void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, unsigned int, void *),
-                           void *userdata)
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, unsigned int, void *))
 {
     m->file_filecontrol = function;
-    m->file_filecontrol_userdata = userdata;
 }
 
 /* Set the callback for file data.
@@ -964,10 +1033,9 @@ void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t
  *
  */
 void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, const uint8_t *,
-                        size_t, void *), void *userdata)
+                        size_t, void *))
 {
     m->file_filedata = function;
-    m->file_filedata_userdata = userdata;
 }
 
 /* Set the callback for file request chunk.
@@ -975,11 +1043,9 @@ void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, u
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, size_t length, void *userdata)
  *
  */
-void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *),
-                            void *userdata)
+void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *))
 {
     m->file_reqchunk = function;
-    m->file_reqchunk_userdata = userdata;
 }
 
 #define MAX_FILENAME_LENGTH 255
@@ -992,11 +1058,13 @@ void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_
  */
 int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint8_t *file_id)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -2;
+    }
 
     uint32_t temp_filenum;
     uint8_t send_receive, file_number;
@@ -1009,8 +1077,9 @@ int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, u
         temp_filenum = filenumber;
     }
 
-    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES)
+    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) {
         return -2;
+    }
 
     file_number = temp_filenum;
 
@@ -1022,8 +1091,9 @@ int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, u
         ft = &m->friendlist[friendnumber].file_sending[file_number];
     }
 
-    if (ft->status == FILESTATUS_NONE)
+    if (ft->status == FILESTATUS_NONE) {
         return -2;
+    }
 
     memcpy(file_id, ft->id, FILE_ID_LENGTH);
     return 0;
@@ -1037,15 +1107,17 @@ int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, u
 static int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint32_t file_type,
                             uint64_t filesize, const uint8_t *file_id, const uint8_t *filename, uint16_t filename_length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return 0;
+    }
 
-    if (filename_length > MAX_FILENAME_LENGTH)
+    if (filename_length > MAX_FILENAME_LENGTH) {
         return 0;
+    }
 
-    uint8_t packet[1 + sizeof(file_type) + sizeof(filesize) + FILE_ID_LENGTH + filename_length];
+    VLA(uint8_t, packet, 1 + sizeof(file_type) + sizeof(filesize) + FILE_ID_LENGTH + filename_length);
     packet[0] = filenumber;
-    file_type = htonl(file_type);
+    file_type = net_htonl(file_type);
     memcpy(packet + 1, &file_type, sizeof(file_type));
     host_to_net((uint8_t *)&filesize, sizeof(filesize));
     memcpy(packet + 1 + sizeof(file_type), &filesize, sizeof(filesize));
@@ -1055,7 +1127,7 @@ static int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t fi
         memcpy(packet + 1 + sizeof(file_type) + sizeof(filesize) + FILE_ID_LENGTH, filename, filename_length);
     }
 
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_SENDREQUEST, packet, sizeof(packet), 0);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_SENDREQUEST, packet, SIZEOF_VLA(packet), 0);
 }
 
 /* Send a file send request.
@@ -1070,32 +1142,44 @@ static int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t fi
 long int new_filesender(const Messenger *m, int32_t friendnumber, uint32_t file_type, uint64_t filesize,
                         const uint8_t *file_id, const uint8_t *filename, uint16_t filename_length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (filename_length > MAX_FILENAME_LENGTH)
+    if (filename_length > MAX_FILENAME_LENGTH) {
         return -2;
+    }
 
     uint32_t i;
 
     for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
-        if (m->friendlist[friendnumber].file_sending[i].status == FILESTATUS_NONE)
+        if (m->friendlist[friendnumber].file_sending[i].status == FILESTATUS_NONE) {
             break;
+        }
     }
 
-    if (i == MAX_CONCURRENT_FILE_PIPES)
+    if (i == MAX_CONCURRENT_FILE_PIPES) {
         return -3;
+    }
 
-    if (file_sendrequest(m, friendnumber, i, file_type, filesize, file_id, filename, filename_length) == 0)
+    if (file_sendrequest(m, friendnumber, i, file_type, filesize, file_id, filename, filename_length) == 0) {
         return -4;
+    }
 
     struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[i];
+
     ft->status = FILESTATUS_NOT_ACCEPTED;
+
     ft->size = filesize;
+
     ft->transferred = 0;
+
     ft->requested = 0;
+
     ft->slots_allocated = 0;
+
     ft->paused = FILE_PAUSE_NOT;
+
     memcpy(ft->id, file_id, FILE_ID_LENGTH);
 
     ++m->friendlist[friendnumber].num_sending_files;
@@ -1103,13 +1187,14 @@ long int new_filesender(const Messenger *m, int32_t friendnumber, uint32_t file_
     return i;
 }
 
-int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber,
-                             uint8_t control_type, uint8_t *data, uint16_t data_length)
+static int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber,
+                                    uint8_t control_type, uint8_t *data, uint16_t data_length)
 {
-    if ((unsigned int)(1 + 3 + data_length) > MAX_CRYPTO_DATA_SIZE)
+    if ((unsigned int)(1 + 3 + data_length) > MAX_CRYPTO_DATA_SIZE) {
         return -1;
+    }
 
-    uint8_t packet[3 + data_length];
+    VLA(uint8_t, packet, 3 + data_length);
 
     packet[0] = send_receive;
     packet[1] = filenumber;
@@ -1119,7 +1204,7 @@ int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t s
         memcpy(packet + 3, data, data_length);
     }
 
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_CONTROL, packet, sizeof(packet), 0);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_CONTROL, packet, SIZEOF_VLA(packet), 0);
 }
 
 /* Send a file control request.
@@ -1136,11 +1221,13 @@ int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t s
  */
 int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber, unsigned int control)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -2;
+    }
 
     uint32_t temp_filenum;
     uint8_t send_receive, file_number;
@@ -1153,8 +1240,9 @@ int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber,
         temp_filenum = filenumber;
     }
 
-    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES)
+    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) {
         return -3;
+    }
 
     file_number = temp_filenum;
 
@@ -1166,34 +1254,39 @@ int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber,
         ft = &m->friendlist[friendnumber].file_sending[file_number];
     }
 
-    if (ft->status == FILESTATUS_NONE)
+    if (ft->status == FILESTATUS_NONE) {
         return -3;
+    }
 
-    if (control > FILECONTROL_KILL)
+    if (control > FILECONTROL_KILL) {
         return -4;
+    }
 
-    if (control == FILECONTROL_PAUSE && ((ft->paused & FILE_PAUSE_US) || ft->status != FILESTATUS_TRANSFERRING))
+    if (control == FILECONTROL_PAUSE && ((ft->paused & FILE_PAUSE_US) || ft->status != FILESTATUS_TRANSFERRING)) {
         return -5;
+    }
 
     if (control == FILECONTROL_ACCEPT) {
         if (ft->status == FILESTATUS_TRANSFERRING) {
             if (!(ft->paused & FILE_PAUSE_US)) {
                 if (ft->paused & FILE_PAUSE_OTHER) {
                     return -6;
-                } else {
-                    return -7;
                 }
+
+                return -7;
             }
         } else {
-            if (ft->status != FILESTATUS_NOT_ACCEPTED)
+            if (ft->status != FILESTATUS_NOT_ACCEPTED) {
                 return -7;
+            }
 
-            if (!send_receive)
+            if (!send_receive) {
                 return -6;
+            }
         }
     }
 
-    if (send_file_control_packet(m, friendnumber, send_receive, file_number, control, 0, 0)) {
+    if (send_file_control_packet(m, friendnumber, send_receive, file_number, control, nullptr, 0)) {
         if (control == FILECONTROL_KILL) {
             ft->status = FILESTATUS_NONE;
 
@@ -1229,40 +1322,38 @@ int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber,
  */
 int file_seek(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -2;
+    }
 
-    uint32_t temp_filenum;
-    uint8_t send_receive, file_number;
-
-    if (filenumber >= (1 << 16)) {
-        send_receive = 1;
-        temp_filenum = (filenumber >> 16) - 1;
-    } else {
+    if (filenumber < (1 << 16)) {
+        // Not receiving.
         return -4;
     }
 
-    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES)
-        return -3;
+    uint32_t temp_filenum = (filenumber >> 16) - 1;
 
-    file_number = temp_filenum;
+    if (temp_filenum >= MAX_CONCURRENT_FILE_PIPES) {
+        return -3;
+    }
 
-    struct File_Transfers *ft;
+    assert(temp_filenum <= UINT8_MAX);
+    uint8_t file_number = temp_filenum;
 
-    if (send_receive) {
-        ft = &m->friendlist[friendnumber].file_receiving[file_number];
-    } else {
-        ft = &m->friendlist[friendnumber].file_sending[file_number];
-    }
+    // We're always receiving at this point.
+    struct File_Transfers *ft = &m->friendlist[friendnumber].file_receiving[file_number];
 
-    if (ft->status == FILESTATUS_NONE)
+    if (ft->status == FILESTATUS_NONE) {
         return -3;
+    }
 
-    if (ft->status != FILESTATUS_NOT_ACCEPTED)
+    if (ft->status != FILESTATUS_NOT_ACCEPTED) {
         return -5;
+    }
 
     if (position >= ft->size) {
         return -6;
@@ -1271,7 +1362,7 @@ int file_seek(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin
     uint64_t sending_pos = position;
     host_to_net((uint8_t *)&sending_pos, sizeof(sending_pos));
 
-    if (send_file_control_packet(m, friendnumber, send_receive, file_number, FILECONTROL_SEEK, (uint8_t *)&sending_pos,
+    if (send_file_control_packet(m, friendnumber, 1, file_number, FILECONTROL_SEEK, (uint8_t *)&sending_pos,
                                  sizeof(sending_pos))) {
         ft->transferred = position;
     } else {
@@ -1287,10 +1378,11 @@ int file_seek(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin
 static int64_t send_file_data_packet(const Messenger *m, int32_t friendnumber, uint8_t filenumber, const uint8_t *data,
                                      uint16_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    uint8_t packet[2 + length];
+    VLA(uint8_t, packet, 2 + length);
     packet[0] = PACKET_ID_FILE_DATA;
     packet[1] = filenumber;
 
@@ -1299,7 +1391,7 @@ static int64_t send_file_data_packet(const Messenger *m, int32_t friendnumber, u
     }
 
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                             m->friendlist[friendnumber].friendcon_id), packet, sizeof(packet), 1);
+                             m->friendlist[friendnumber].friendcon_id), packet, SIZEOF_VLA(packet), 1);
 }
 
 #define MAX_FILE_DATA_SIZE (MAX_CRYPTO_DATA_SIZE - 2)
@@ -1318,22 +1410,27 @@ static int64_t send_file_data_packet(const Messenger *m, int32_t friendnumber, u
 int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
               uint16_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -2;
+    }
 
-    if (filenumber >= MAX_CONCURRENT_FILE_PIPES)
+    if (filenumber >= MAX_CONCURRENT_FILE_PIPES) {
         return -3;
+    }
 
     struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[filenumber];
 
-    if (ft->status != FILESTATUS_TRANSFERRING)
+    if (ft->status != FILESTATUS_TRANSFERRING) {
         return -4;
+    }
 
-    if (length > MAX_FILE_DATA_SIZE)
+    if (length > MAX_FILE_DATA_SIZE) {
         return -5;
+    }
 
     if (ft->size - ft->transferred < length) {
         return -5;
@@ -1347,15 +1444,17 @@ int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin
         return -7;
     }
 
-    /* Prevent file sending from filling up the entire buffer preventing messages from being sent. TODO: remove */
+    /* Prevent file sending from filling up the entire buffer preventing messages from being sent.
+     * TODO(irungentoo): remove */
     if (crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                                        m->friendlist[friendnumber].friendcon_id)) < MIN_SLOTS_FREE)
+                                        m->friendlist[friendnumber].friendcon_id)) < MIN_SLOTS_FREE) {
         return -6;
+    }
 
     int64_t ret = send_file_data_packet(m, friendnumber, filenumber, data, length);
 
     if (ret != -1) {
-        //TODO record packet ids to check if other received complete file.
+        // TODO(irungentoo): record packet ids to check if other received complete file.
         ft->transferred += length;
 
         if (ft->slots_allocated) {
@@ -1371,7 +1470,6 @@ int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin
     }
 
     return -6;
-
 }
 
 /* Give the number of bytes left to be sent/received.
@@ -1383,210 +1481,302 @@ int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin
  */
 uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return 0;
+    }
+
+    const struct File_Transfers *const sending = &m->friendlist[friendnumber].file_sending[filenumber];
 
     if (send_receive == 0) {
-        if (m->friendlist[friendnumber].file_sending[filenumber].status == FILESTATUS_NONE)
+        if (sending->status == FILESTATUS_NONE) {
             return 0;
+        }
 
-        return m->friendlist[friendnumber].file_sending[filenumber].size -
-               m->friendlist[friendnumber].file_sending[filenumber].transferred;
-    } else {
-        if (m->friendlist[friendnumber].file_receiving[filenumber].status == FILESTATUS_NONE)
-            return 0;
+        return sending->size - sending->transferred;
+    }
 
-        return m->friendlist[friendnumber].file_receiving[filenumber].size -
-               m->friendlist[friendnumber].file_receiving[filenumber].transferred;
+    const struct File_Transfers *const receiving = &m->friendlist[friendnumber].file_receiving[filenumber];
+
+    if (receiving->status == FILESTATUS_NONE) {
+        return 0;
     }
+
+    return receiving->size - receiving->transferred;
 }
 
-static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber)
+/**
+ * Iterate over all file transfers and request chunks (from the client) for each
+ * of them.
+ *
+ * The free_slots parameter is updated by this function.
+ *
+ * @param m Our messenger object.
+ * @param friendnumber The friend we're sending files to.
+ * @param userdata The client userdata to pass along to chunk request callbacks.
+ * @param free_slots A pointer to the number of free send queue slots in the
+ *   crypto connection.
+ *
+ * @return true if there are still file transfers ongoing, false if all file
+ *   transfers are complete.
+ */
+static bool do_all_filetransfers(Messenger *m, int32_t friendnumber, void *userdata, uint32_t *free_slots)
 {
-    if (!m->friendlist[friendnumber].num_sending_files)
-        return;
-
-    int free_slots = crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                     m->friendlist[friendnumber].friendcon_id));
-
-    if (free_slots < MIN_SLOTS_FREE) {
-        free_slots = 0;
-    } else {
-        free_slots -= MIN_SLOTS_FREE;
-    }
+    Friend *const friendcon = &m->friendlist[friendnumber];
+    uint32_t num = friendcon->num_sending_files;
 
-    unsigned int i, num = m->friendlist[friendnumber].num_sending_files;
+    bool any_active_fts = false;
 
-    for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
-        struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[i];
+    // Iterate over all file transfers, including inactive ones. I.e. we always
+    // iterate exactly MAX_CONCURRENT_FILE_PIPES times.
+    for (uint32_t i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
+        struct File_Transfers *const ft = &friendcon->file_sending[i];
 
+        // Any status other than NONE means the file transfer is active.
         if (ft->status != FILESTATUS_NONE) {
+            any_active_fts = true;
             --num;
 
-            if (ft->status == FILESTATUS_FINISHED) {
-                /* Check if file was entirely sent. */
-                if (friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) {
-                    if (m->file_reqchunk)
-                        (*m->file_reqchunk)(m, friendnumber, i, ft->transferred, 0, m->file_reqchunk_userdata);
-
-                    ft->status = FILESTATUS_NONE;
-                    --m->friendlist[friendnumber].num_sending_files;
+            // If the file transfer is complete, we request a chunk of size 0.
+            if (ft->status == FILESTATUS_FINISHED && friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) {
+                if (m->file_reqchunk) {
+                    m->file_reqchunk(m, friendnumber, i, ft->transferred, 0, userdata);
                 }
-            }
 
-            /* TODO: if file is too slow, switch to the next. */
-            if (ft->slots_allocated > (unsigned int)free_slots) {
-                free_slots = 0;
-            } else {
-                free_slots -= ft->slots_allocated;
+                // Now it's inactive, we're no longer sending this.
+                ft->status = FILESTATUS_NONE;
+                --friendcon->num_sending_files;
             }
+
+            // Decrease free slots by the number of slots this FT uses.
+            *free_slots = max_s32(0, (int32_t) * free_slots - ft->slots_allocated);
         }
 
-        while (ft->status == FILESTATUS_TRANSFERRING && (ft->paused == FILE_PAUSE_NOT)) {
-            if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                                  m->friendlist[friendnumber].friendcon_id))) {
-                free_slots = 0;
+        if (ft->status == FILESTATUS_TRANSFERRING && ft->paused == FILE_PAUSE_NOT) {
+            if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id(
+                                      m->fr_c, friendcon->friendcon_id))) {
+                *free_slots = 0;
             }
 
-            if (free_slots == 0)
-                break;
-
-            uint16_t length = MAX_FILE_DATA_SIZE;
+            if (*free_slots == 0) {
+                continue;
+            }
 
             if (ft->size == 0) {
                 /* Send 0 data to friend if file is 0 length. */
-                file_data(m, friendnumber, i, 0, 0, 0);
-                break;
+                file_data(m, friendnumber, i, 0, nullptr, 0);
+                continue;
             }
 
             if (ft->size == ft->requested) {
-                break;
-            }
-
-            if (ft->size - ft->requested < length) {
-                length = ft->size - ft->requested;
+                // This file transfer is done.
+                continue;
             }
 
-            ++ft->slots_allocated;
+            // Allocate 1 slot to this file transfer.
+            ft->slots_allocated++;
 
-            uint64_t position = ft->requested;
+            const uint16_t length = min_u64(ft->size - ft->requested, MAX_FILE_DATA_SIZE);
+            const uint64_t position = ft->requested;
             ft->requested += length;
 
-            if (m->file_reqchunk)
-                (*m->file_reqchunk)(m, friendnumber, i, position, length, m->file_reqchunk_userdata);
+            if (m->file_reqchunk) {
+                m->file_reqchunk(m, friendnumber, i, position, length, userdata);
+            }
 
-            --free_slots;
+            // The allocated slot is no longer free.
+            --*free_slots;
+        }
 
+        if (num == 0) {
+            continue;
         }
+    }
 
-        if (num == 0)
-            break;
+    return any_active_fts;
+}
+
+static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdata)
+{
+    // We're not currently doing any file transfers.
+    if (m->friendlist[friendnumber].num_sending_files == 0) {
+        return;
+    }
+
+    // The number of packet slots left in the sendbuffer.
+    // This is a per friend count (CRYPTO_PACKET_BUFFER_SIZE).
+    uint32_t free_slots = crypto_num_free_sendqueue_slots(
+                              m->net_crypto,
+                              friend_connection_crypt_connection_id(
+                                  m->fr_c,
+                                  m->friendlist[friendnumber].friendcon_id));
+
+    // We keep MIN_SLOTS_FREE slots free for other packets, otherwise file
+    // transfers might block other traffic for a long time.
+    free_slots = max_s32(0, (int32_t)free_slots - MIN_SLOTS_FREE);
+
+    bool any_active_fts = true;
+    uint32_t loop_counter = 0;
+    // Maximum number of outer loops below. If the client doesn't send file
+    // chunks from within the chunk request callback handler, we never realise
+    // that the file transfer has finished and may end up in an infinite loop.
+    //
+    // TODO(zoff99): Fix this to exit the loop properly when we're done
+    // requesting all chunks for all file transfers.
+    const uint32_t MAX_FT_LOOPS = 16;
+
+    while (((free_slots > 0) || loop_counter == 0) && any_active_fts && (loop_counter < MAX_FT_LOOPS)) {
+        any_active_fts = do_all_filetransfers(m, friendnumber, userdata, &free_slots);
+        loop_counter++;
     }
 }
 
+
 /* Run this when the friend disconnects.
  *  Kill all current file transfers.
  */
 static void break_files(const Messenger *m, int32_t friendnumber)
 {
-    uint32_t i;
-
-    //TODO: Inform the client which file transfers get killed with a callback?
-    for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
-        if (m->friendlist[friendnumber].file_sending[i].status != FILESTATUS_NONE)
+    // TODO(irungentoo): Inform the client which file transfers get killed with a callback?
+    for (uint32_t i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
+        if (m->friendlist[friendnumber].file_sending[i].status != FILESTATUS_NONE) {
             m->friendlist[friendnumber].file_sending[i].status = FILESTATUS_NONE;
+        }
 
-        if (m->friendlist[friendnumber].file_receiving[i].status != FILESTATUS_NONE)
+        if (m->friendlist[friendnumber].file_receiving[i].status != FILESTATUS_NONE) {
             m->friendlist[friendnumber].file_receiving[i].status = FILESTATUS_NONE;
+        }
     }
 }
 
-/* return -1 on failure, 0 on success.
- */
-static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber,
-                              uint8_t control_type, uint8_t *data, uint16_t length)
+static struct File_Transfers *get_file_transfer(uint8_t receive_send, uint8_t filenumber,
+        uint32_t *real_filenumber, Friend *sender)
 {
-    if (receive_send > 1)
-        return -1;
-
-    if (control_type > FILECONTROL_SEEK)
-        return -1;
-
-    uint32_t real_filenumber = filenumber;
     struct File_Transfers *ft;
 
     if (receive_send == 0) {
-        real_filenumber += 1;
-        real_filenumber <<= 16;
-        ft = &m->friendlist[friendnumber].file_receiving[filenumber];
+        *real_filenumber = (filenumber + 1) << 16;
+        ft = &sender->file_receiving[filenumber];
     } else {
-        ft = &m->friendlist[friendnumber].file_sending[filenumber];
+        *real_filenumber = filenumber;
+        ft = &sender->file_sending[filenumber];
     }
 
     if (ft->status == FILESTATUS_NONE) {
-        /* File transfer doesn't exist, tell the other to kill it. */
-        send_file_control_packet(m, friendnumber, !receive_send, filenumber, FILECONTROL_KILL, 0, 0);
+        return nullptr;
+    }
+
+    return ft;
+}
+
+/* return -1 on failure, 0 on success.
+ */
+static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber,
+                              uint8_t control_type, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (receive_send > 1) {
+        LOGGER_DEBUG(m->log, "file control (friend %d, file %d): receive_send value is invalid (should be 0 or 1): %d",
+                     friendnumber, filenumber, receive_send);
         return -1;
     }
 
-    if (control_type == FILECONTROL_ACCEPT) {
-        if (receive_send && ft->status == FILESTATUS_NOT_ACCEPTED) {
-            ft->status = FILESTATUS_TRANSFERRING;
-        } else {
-            if (ft->paused & FILE_PAUSE_OTHER) {
-                ft->paused ^= FILE_PAUSE_OTHER;
+    uint32_t real_filenumber;
+    struct File_Transfers *ft = get_file_transfer(receive_send, filenumber, &real_filenumber, &m->friendlist[friendnumber]);
+
+    if (ft == nullptr) {
+        LOGGER_DEBUG(m->log, "file control (friend %d, file %d): file transfer does not exist; telling the other to kill it",
+                     friendnumber, filenumber);
+        send_file_control_packet(m, friendnumber, !receive_send, filenumber, FILECONTROL_KILL, nullptr, 0);
+        return -1;
+    }
+
+    switch (control_type) {
+        case FILECONTROL_ACCEPT: {
+            if (receive_send && ft->status == FILESTATUS_NOT_ACCEPTED) {
+                ft->status = FILESTATUS_TRANSFERRING;
             } else {
-                return -1;
+                if (ft->paused & FILE_PAUSE_OTHER) {
+                    ft->paused ^= FILE_PAUSE_OTHER;
+                } else {
+                    LOGGER_DEBUG(m->log, "file control (friend %d, file %d): friend told us to resume file transfer that wasn't paused",
+                                 friendnumber, filenumber);
+                    return -1;
+                }
             }
-        }
 
-        if (m->file_filecontrol)
-            (*m->file_filecontrol)(m, friendnumber, real_filenumber, control_type, m->file_filecontrol_userdata);
-    } else if (control_type == FILECONTROL_PAUSE) {
-        if ((ft->paused & FILE_PAUSE_OTHER) || ft->status != FILESTATUS_TRANSFERRING) {
-            return -1;
-        }
+            if (m->file_filecontrol) {
+                m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata);
+            }
 
-        ft->paused |= FILE_PAUSE_OTHER;
+            return 0;
+        }
 
-        if (m->file_filecontrol)
-            (*m->file_filecontrol)(m, friendnumber, real_filenumber, control_type, m->file_filecontrol_userdata);
-    } else if (control_type == FILECONTROL_KILL) {
+        case FILECONTROL_PAUSE: {
+            if ((ft->paused & FILE_PAUSE_OTHER) || ft->status != FILESTATUS_TRANSFERRING) {
+                LOGGER_DEBUG(m->log, "file control (friend %d, file %d): friend told us to pause file transfer that is already paused",
+                             friendnumber, filenumber);
+                return -1;
+            }
 
-        if (m->file_filecontrol)
-            (*m->file_filecontrol)(m, friendnumber, real_filenumber, control_type, m->file_filecontrol_userdata);
+            ft->paused |= FILE_PAUSE_OTHER;
 
-        ft->status = FILESTATUS_NONE;
+            if (m->file_filecontrol) {
+                m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata);
+            }
 
-        if (receive_send) {
-            --m->friendlist[friendnumber].num_sending_files;
+            return 0;
         }
 
-    } else if (control_type == FILECONTROL_SEEK) {
-        uint64_t position;
+        case FILECONTROL_KILL: {
+            if (m->file_filecontrol) {
+                m->file_filecontrol(m, friendnumber, real_filenumber, control_type, userdata);
+            }
 
-        if (length != sizeof(position)) {
-            return -1;
-        }
+            ft->status = FILESTATUS_NONE;
 
-        /* seek can only be sent by the receiver to seek before resuming broken transfers. */
-        if (ft->status != FILESTATUS_NOT_ACCEPTED || !receive_send) {
-            return -1;
+            if (receive_send) {
+                --m->friendlist[friendnumber].num_sending_files;
+            }
+
+            return 0;
         }
 
-        memcpy(&position, data, sizeof(position));
-        net_to_host((uint8_t *) &position, sizeof(position));
+        case FILECONTROL_SEEK: {
+            uint64_t position;
 
-        if (position >= ft->size) {
-            return -1;
+            if (length != sizeof(position)) {
+                LOGGER_DEBUG(m->log, "file control (friend %d, file %d): expected payload of length %d, but got %d",
+                             friendnumber, filenumber, (uint32_t)sizeof(position), length);
+                return -1;
+            }
+
+            /* seek can only be sent by the receiver to seek before resuming broken transfers. */
+            if (ft->status != FILESTATUS_NOT_ACCEPTED || !receive_send) {
+                LOGGER_DEBUG(m->log,
+                             "file control (friend %d, file %d): seek was either sent by a sender or by the receiver after accepting",
+                             friendnumber, filenumber);
+                return -1;
+            }
+
+            memcpy(&position, data, sizeof(position));
+            net_to_host((uint8_t *) &position, sizeof(position));
+
+            if (position >= ft->size) {
+                LOGGER_DEBUG(m->log,
+                             "file control (friend %d, file %d): seek position %lld exceeds file size %lld",
+                             friendnumber, filenumber, (unsigned long long)position, (unsigned long long)ft->size);
+                return -1;
+            }
+
+            ft->transferred = ft->requested = position;
+            return 0;
         }
 
-        ft->transferred = ft->requested = position;
-    } else {
-        return -1;
+        default: {
+            LOGGER_DEBUG(m->log, "file control (friend %d, file %d): invalid file control: %d",
+                         friendnumber, filenumber, control_type);
+            return -1;
+        }
     }
-
-    return 0;
 }
 
 /**************************************/
@@ -1612,137 +1802,157 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length, 0);
 }
 
-static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
+static int m_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))
+    if (friend_not_valid(m, friend_num)) {
         return 1;
+    }
 
     if (packet[0] < (PACKET_ID_LOSSY_RANGE_START + PACKET_LOSSY_AV_RESERVED)) {
-        if (m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function)
+        if (m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function) {
             return m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] % PACKET_LOSSY_AV_RESERVED].function(
                        m, friend_num, packet, length, m->friendlist[friend_num].lossy_rtp_packethandlers[packet[0] %
                                PACKET_LOSSY_AV_RESERVED].object);
+        }
 
         return 1;
     }
 
-    if (m->lossy_packethandler)
-        m->lossy_packethandler(m, friend_num, packet, length, m->lossy_packethandler_userdata);
+    if (m->lossy_packethandler) {
+        m->lossy_packethandler(m, friend_num, packet, length, userdata);
+    }
 
     return 1;
 }
 
-void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
-        uint32_t friendnumber, const uint8_t *data, size_t len, void *object), void *object)
+void custom_lossy_packet_registerhandler(Messenger *m, void (*lossy_packethandler)(Messenger *m,
+        uint32_t friendnumber, const uint8_t *data, size_t len, void *object))
 {
-    m->lossy_packethandler = packet_handler_callback;
-    m->lossy_packethandler_userdata = object;
+    m->lossy_packethandler = lossy_packethandler;
 }
 
-int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*packet_handler_callback)(Messenger *m,
+int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int (*function)(Messenger *m,
                           uint32_t friendnumber, const uint8_t *data, uint16_t len, void *object), void *object)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (byte < PACKET_ID_LOSSY_RANGE_START)
+    if (byte < PACKET_ID_LOSSY_RANGE_START) {
         return -1;
+    }
 
-    if (byte >= (PACKET_ID_LOSSY_RANGE_START + PACKET_LOSSY_AV_RESERVED))
+    if (byte >= (PACKET_ID_LOSSY_RANGE_START + PACKET_LOSSY_AV_RESERVED)) {
         return -1;
+    }
 
-    m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].function =
-        packet_handler_callback;
+    m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].function = function;
     m->friendlist[friendnumber].lossy_rtp_packethandlers[byte % PACKET_LOSSY_AV_RESERVED].object = object;
     return 0;
 }
 
 
-int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
+int m_send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) {
         return -2;
+    }
 
-    if (data[0] < PACKET_ID_LOSSY_RANGE_START)
+    if (data[0] < PACKET_ID_LOSSY_RANGE_START) {
         return -3;
+    }
 
-    if (data[0] >= (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE))
+    if (data[0] >= (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE)) {
         return -3;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -4;
+    }
 
     if (send_lossy_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
                                m->friendlist[friendnumber].friendcon_id), data, length) == -1) {
         return -5;
-    } else {
-        return 0;
     }
+
+    return 0;
 }
 
-static int handle_custom_lossless_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
+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))
+    if (friend_not_valid(m, friend_num)) {
         return -1;
+    }
 
-    if (packet[0] < PACKET_ID_LOSSLESS_RANGE_START)
+    if (packet[0] < PACKET_ID_LOSSLESS_RANGE_START) {
         return -1;
+    }
 
-    if (packet[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE))
+    if (packet[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE)) {
         return -1;
+    }
 
-    if (m->lossless_packethandler)
-        m->lossless_packethandler(m, friend_num, packet, length, m->lossless_packethandler_userdata);
+    if (m->lossless_packethandler) {
+        m->lossless_packethandler(m, friend_num, packet, length, userdata);
+    }
 
     return 1;
 }
 
-void custom_lossless_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
-        uint32_t friendnumber, const uint8_t *data, size_t len, void *object), void *object)
+void custom_lossless_packet_registerhandler(Messenger *m, void (*lossless_packethandler)(Messenger *m,
+        uint32_t friendnumber, const uint8_t *data, size_t len, void *object))
 {
-    m->lossless_packethandler = packet_handler_callback;
-    m->lossless_packethandler_userdata = object;
+    m->lossless_packethandler = lossless_packethandler;
 }
 
 int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
 {
-    if (friend_not_valid(m, friendnumber))
+    if (friend_not_valid(m, friendnumber)) {
         return -1;
+    }
 
-    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) {
         return -2;
+    }
 
-    if (data[0] < PACKET_ID_LOSSLESS_RANGE_START)
+    if (data[0] < PACKET_ID_LOSSLESS_RANGE_START) {
         return -3;
+    }
 
-    if (data[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE))
+    if (data[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE)) {
         return -3;
+    }
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE) {
         return -4;
+    }
 
     if (write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
                           m->friendlist[friendnumber].friendcon_id), data, length, 1) == -1) {
         return -5;
-    } else {
-        return 0;
     }
+
+    return 0;
 }
 
 /* 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)
+    if (getfriend_id(m, real_pk) == -1) {
         return 0;
+    }
 
     return -1;
 }
@@ -1750,56 +1960,84 @@ static int friend_already_added(const uint8_t *real_pk, void *data)
 /* Run this at startup. */
 Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
 {
-    Messenger *m = calloc(1, sizeof(Messenger));
+    if (!options) {
+        return nullptr;
+    }
 
-    if (error)
+    if (error) {
         *error = MESSENGER_ERROR_OTHER;
+    }
+
+    Messenger *m = (Messenger *)calloc(1, sizeof(Messenger));
 
-    if ( ! m )
-        return NULL;
+    if (!m) {
+        return nullptr;
+    }
+
+    m->fr = friendreq_new();
+
+    if (!m->fr) {
+        free(m);
+        return nullptr;
+    }
+
+    m->log = logger_new();
+
+    if (m->log == nullptr) {
+        friendreq_kill(m->fr);
+        free(m);
+        return nullptr;
+    }
+
+    logger_callback_log(m->log, options->log_callback, m, options->log_user_data);
 
     unsigned int net_err = 0;
 
     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 = new_networking_no_udp(m->log);
     } else {
         IP ip;
         ip_init(&ip, options->ipv6enabled);
-        m->net = new_networking_ex(ip, options->port_range[0], options->port_range[1], &net_err);
+        m->net = new_networking_ex(m->log, ip, options->port_range[0], options->port_range[1], &net_err);
     }
 
-    if (m->net == NULL) {
+    if (m->net == nullptr) {
+        friendreq_kill(m->fr);
+        logger_kill(m->log);
         free(m);
 
         if (error && net_err == 1) {
             *error = MESSENGER_ERROR_PORT;
         }
 
-        return NULL;
+        return nullptr;
     }
 
-    m->dht = new_DHT(m->net);
+    m->dht = new_DHT(m->log, m->net, options->hole_punching_enabled);
 
-    if (m->dht == NULL) {
+    if (m->dht == nullptr) {
         kill_networking(m->net);
+        friendreq_kill(m->fr);
+        logger_kill(m->log);
         free(m);
-        return NULL;
+        return nullptr;
     }
 
-    m->net_crypto = new_net_crypto(m->dht, &options->proxy_info);
+    m->net_crypto = new_net_crypto(m->log, m->dht, &options->proxy_info);
 
-    if (m->net_crypto == NULL) {
+    if (m->net_crypto == nullptr) {
         kill_networking(m->net);
         kill_DHT(m->dht);
+        friendreq_kill(m->fr);
+        logger_kill(m->log);
         free(m);
-        return NULL;
+        return nullptr;
     }
 
     m->onion = new_onion(m->dht);
     m->onion_a = new_onion_announce(m->dht);
     m->onion_c =  new_onion_client(m->net_crypto);
-    m->fr_c = new_friend_connections(m->onion_c);
+    m->fr_c = new_friend_connections(m->onion_c, options->local_discovery_enabled);
 
     if (!(m->onion && m->onion_a && m->onion_c)) {
         kill_friend_connections(m->fr_c);
@@ -1809,14 +2047,17 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
         kill_net_crypto(m->net_crypto);
         kill_DHT(m->dht);
         kill_networking(m->net);
+        friendreq_kill(m->fr);
+        logger_kill(m->log);
         free(m);
-        return NULL;
+        return nullptr;
     }
 
     if (options->tcp_server_port) {
-        m->tcp_server = new_TCP_server(options->ipv6enabled, 1, &options->tcp_server_port, m->dht->self_secret_key, m->onion);
+        m->tcp_server = new_TCP_server(options->ipv6enabled, 1, &options->tcp_server_port, dht_get_self_secret_key(m->dht),
+                                       m->onion);
 
-        if (m->tcp_server == NULL) {
+        if (m->tcp_server == nullptr) {
             kill_friend_connections(m->fr_c);
             kill_onion(m->onion);
             kill_onion_announce(m->onion_a);
@@ -1824,22 +2065,28 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
             kill_net_crypto(m->net_crypto);
             kill_DHT(m->dht);
             kill_networking(m->net);
+            friendreq_kill(m->fr);
+            logger_kill(m->log);
             free(m);
 
-            if (error)
+            if (error) {
                 *error = MESSENGER_ERROR_TCP_SERVER;
+            }
 
-            return NULL;
+            return nullptr;
         }
     }
 
     m->options = *options;
-    friendreq_init(&(m->fr), m->fr_c);
-    set_nospam(&(m->fr), random_int());
-    set_filter_function(&(m->fr), &friend_already_added, m);
+    friendreq_init(m->fr, m->fr_c);
+    set_nospam(m->fr, random_u32());
+    set_filter_function(m->fr, &friend_already_added, m);
 
-    if (error)
+    m->lastdump = 0;
+
+    if (error) {
         *error = MESSENGER_ERROR_NONE;
+    }
 
     return m;
 }
@@ -1847,8 +2094,9 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
 /* Run this before closing shop. */
 void kill_messenger(Messenger *m)
 {
-    if (!m)
+    if (!m) {
         return;
+    }
 
     uint32_t i;
 
@@ -1868,7 +2116,9 @@ void kill_messenger(Messenger *m)
         clear_receipts(m, i);
     }
 
+    logger_kill(m->log);
     free(m->friendlist);
+    friendreq_kill(m->fr);
     free(m);
 }
 
@@ -1877,12 +2127,12 @@ void kill_messenger(Messenger *m)
  *   i: friendlist index of the timed-out friend
  *   t: time
  */
-static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t)
+static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t, void *userdata)
 {
     Friend *f = &m->friendlist[i];
 
     if (f->friendrequest_lastsent + f->friendrequest_timeout < t) {
-        set_friend_status(m, i, FRIEND_ADDED);
+        set_friend_status(m, i, FRIEND_ADDED, userdata);
         /* Double the default timeout every time if friendrequest is assumed
          * to have been sent unsuccessfully.
          */
@@ -1890,34 +2140,35 @@ 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)
+static int m_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);
     } else { /* Went offline. */
         if (m->friendlist[i].status == FRIEND_ONLINE) {
-            set_friend_status(m, i, FRIEND_CONFIRMED);
+            set_friend_status(m, i, FRIEND_CONFIRMED, userdata);
         }
     }
 
     return 0;
 }
 
-static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
+static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata)
 {
-    if (len == 0)
+    if (len == 0) {
         return -1;
+    }
 
-    Messenger *m = object;
+    Messenger *m = (Messenger *)object;
     uint8_t packet_id = temp[0];
-    uint8_t *data = temp + 1;
+    const uint8_t *data = temp + 1;
     uint32_t data_length = len - 1;
 
     if (m->friendlist[i].status != FRIEND_ONLINE) {
         if (packet_id == PACKET_ID_ONLINE && len == 1) {
-            set_friend_status(m, i, FRIEND_ONLINE);
+            set_friend_status(m, i, FRIEND_ONLINE, userdata);
             send_online_packet(m, i);
         } else {
             return -1;
@@ -1926,25 +2177,28 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
 
     switch (packet_id) {
         case PACKET_ID_OFFLINE: {
-            if (data_length != 0)
+            if (data_length != 0) {
                 break;
+            }
 
-            set_friend_status(m, i, FRIEND_CONFIRMED);
+            set_friend_status(m, i, FRIEND_CONFIRMED, userdata);
             break;
         }
 
         case PACKET_ID_NICKNAME: {
-            if (data_length > MAX_NAME_LENGTH)
+            if (data_length > MAX_NAME_LENGTH) {
                 break;
+            }
 
             /* Make sure the NULL terminator is present. */
-            uint8_t data_terminated[data_length + 1];
+            VLA(uint8_t, data_terminated, data_length + 1);
             memcpy(data_terminated, data, data_length);
             data_terminated[data_length] = 0;
 
             /* inform of namechange before we overwrite the old name */
-            if (m->friend_namechange)
-                m->friend_namechange(m, i, data_terminated, data_length, m->friend_namechange_userdata);
+            if (m->friend_namechange) {
+                m->friend_namechange(m, i, data_terminated, data_length, userdata);
+            }
 
             memcpy(m->friendlist[i].name, data_terminated, data_length);
             m->friendlist[i].name_length = data_length;
@@ -1953,78 +2207,88 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         }
 
         case PACKET_ID_STATUSMESSAGE: {
-            if (data_length > MAX_STATUSMESSAGE_LENGTH)
+            if (data_length > MAX_STATUSMESSAGE_LENGTH) {
                 break;
+            }
 
             /* Make sure the NULL terminator is present. */
-            uint8_t data_terminated[data_length + 1];
+            VLA(uint8_t, data_terminated, data_length + 1);
             memcpy(data_terminated, data, data_length);
             data_terminated[data_length] = 0;
 
-            if (m->friend_statusmessagechange)
-                m->friend_statusmessagechange(m, i, data_terminated, data_length,
-                                              m->friend_statusmessagechange_userdata);
+            if (m->friend_statusmessagechange) {
+                m->friend_statusmessagechange(m, i, data_terminated, data_length, userdata);
+            }
 
             set_friend_statusmessage(m, i, data_terminated, data_length);
             break;
         }
 
         case PACKET_ID_USERSTATUS: {
-            if (data_length != 1)
+            if (data_length != 1) {
                 break;
+            }
 
-            USERSTATUS status = data[0];
+            USERSTATUS status = (USERSTATUS)data[0];
 
-            if (status >= USERSTATUS_INVALID)
+            if (status >= USERSTATUS_INVALID) {
                 break;
+            }
 
-            if (m->friend_userstatuschange)
-                m->friend_userstatuschange(m, i, status, m->friend_userstatuschange_userdata);
+            if (m->friend_userstatuschange) {
+                m->friend_userstatuschange(m, i, status, userdata);
+            }
 
             set_friend_userstatus(m, i, status);
             break;
         }
 
         case PACKET_ID_TYPING: {
-            if (data_length != 1)
+            if (data_length != 1) {
                 break;
+            }
 
-            _Bool typing = !!data[0];
+            bool typing = !!data[0];
 
             set_friend_typing(m, i, typing);
 
-            if (m->friend_typingchange)
-                m->friend_typingchange(m, i, typing, m->friend_typingchange_userdata);
+            if (m->friend_typingchange) {
+                m->friend_typingchange(m, i, typing, userdata);
+            }
 
             break;
         }
 
-        case PACKET_ID_MESSAGE:
+        case PACKET_ID_MESSAGE: // fall-through
         case PACKET_ID_ACTION: {
-            if (data_length == 0)
+            if (data_length == 0) {
                 break;
+            }
 
             const uint8_t *message = data;
             uint16_t message_length = data_length;
 
             /* Make sure the NULL terminator is present. */
-            uint8_t message_terminated[message_length + 1];
+            VLA(uint8_t, message_terminated, message_length + 1);
             memcpy(message_terminated, message, message_length);
             message_terminated[message_length] = 0;
             uint8_t type = packet_id - PACKET_ID_MESSAGE;
 
-            if (m->friend_message)
-                (*m->friend_message)(m, i, type, message_terminated, message_length, m->friend_message_userdata);
+            if (m->friend_message) {
+                (*m->friend_message)(m, i, type, message_terminated, message_length, userdata);
+            }
 
             break;
         }
 
-        case PACKET_ID_INVITE_GROUPCHAT: {
-            if (data_length == 0)
+        case PACKET_ID_INVITE_CONFERENCE: {
+            if (data_length == 0) {
                 break;
+            }
 
-            if (m->group_invite)
-                (*m->group_invite)(m, i, data, data_length);
+            if (m->conference_invite) {
+                (*m->conference_invite)(m, i, data, data_length, userdata);
+            }
 
             break;
         }
@@ -2032,30 +2296,38 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         case PACKET_ID_FILE_SENDREQUEST: {
             const unsigned int head_length = 1 + sizeof(uint32_t) + sizeof(uint64_t) + FILE_ID_LENGTH;
 
-            if (data_length < head_length)
+            if (data_length < head_length) {
                 break;
+            }
 
             uint8_t filenumber = data[0];
 
-            if (filenumber >= MAX_CONCURRENT_FILE_PIPES)
+#if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES
+
+            if (filenumber >= MAX_CONCURRENT_FILE_PIPES) {
                 break;
+            }
+
+#endif
 
             uint64_t filesize;
             uint32_t file_type;
             uint16_t filename_length = data_length - head_length;
 
-            if (filename_length > MAX_FILENAME_LENGTH)
+            if (filename_length > MAX_FILENAME_LENGTH) {
                 break;
+            }
 
             memcpy(&file_type, data + 1, sizeof(file_type));
-            file_type = ntohl(file_type);
+            file_type = net_ntohl(file_type);
 
             memcpy(&filesize, data + 1 + sizeof(uint32_t), sizeof(filesize));
             net_to_host((uint8_t *) &filesize, sizeof(filesize));
             struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber];
 
-            if (ft->status != FILESTATUS_NONE)
+            if (ft->status != FILESTATUS_NONE) {
                 break;
+            }
 
             ft->status = FILESTATUS_NOT_ACCEPTED;
             ft->size = filesize;
@@ -2063,8 +2335,8 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
             ft->paused = FILE_PAUSE_NOT;
             memcpy(ft->id, data + 1 + sizeof(uint32_t) + sizeof(uint64_t), FILE_ID_LENGTH);
 
-            uint8_t filename_terminated[filename_length + 1];
-            uint8_t *filename = NULL;
+            VLA(uint8_t, filename_terminated, filename_length + 1);
+            uint8_t *filename = nullptr;
 
             if (filename_length) {
                 /* Force NULL terminate file name. */
@@ -2077,53 +2349,70 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
             real_filenumber += 1;
             real_filenumber <<= 16;
 
-            if (m->file_sendrequest)
+            if (m->file_sendrequest) {
                 (*m->file_sendrequest)(m, i, real_filenumber, file_type, filesize, filename, filename_length,
-                                       m->file_sendrequest_userdata);
+                                       userdata);
+            }
 
             break;
         }
 
         case PACKET_ID_FILE_CONTROL: {
-            if (data_length < 3)
+            if (data_length < 3) {
                 break;
+            }
 
             uint8_t send_receive = data[0];
             uint8_t filenumber = data[1];
             uint8_t control_type = data[2];
 
-            if (filenumber >= MAX_CONCURRENT_FILE_PIPES)
+#if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES
+
+            if (filenumber >= MAX_CONCURRENT_FILE_PIPES) {
                 break;
+            }
+
+#endif
 
-            if (handle_filecontrol(m, i, send_receive, filenumber, control_type, data + 3, data_length - 3) == -1)
+            if (handle_filecontrol(m, i, send_receive, filenumber, control_type, data + 3, data_length - 3, userdata) == -1) {
+                // TODO(iphydf): Do something different here? Right now, this
+                // check is pointless.
                 break;
+            }
 
             break;
         }
 
         case PACKET_ID_FILE_DATA: {
-            if (data_length < 1)
+            if (data_length < 1) {
                 break;
+            }
 
             uint8_t filenumber = data[0];
 
-            if (filenumber >= MAX_CONCURRENT_FILE_PIPES)
+#if UINT8_MAX >= MAX_CONCURRENT_FILE_PIPES
+
+            if (filenumber >= MAX_CONCURRENT_FILE_PIPES) {
                 break;
+            }
+
+#endif
 
             struct File_Transfers *ft = &m->friendlist[i].file_receiving[filenumber];
 
-            if (ft->status != FILESTATUS_TRANSFERRING)
+            if (ft->status != FILESTATUS_TRANSFERRING) {
                 break;
+            }
 
             uint64_t position = ft->transferred;
             uint32_t real_filenumber = filenumber;
             real_filenumber += 1;
             real_filenumber <<= 16;
             uint16_t file_data_length = (data_length - 1);
-            uint8_t *file_data;
+            const uint8_t *file_data;
 
             if (file_data_length == 0) {
-                file_data = NULL;
+                file_data = nullptr;
             } else {
                 file_data = data + 1;
             }
@@ -2133,19 +2422,21 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
                 file_data_length = ft->size - ft->transferred;
             }
 
-            if (m->file_filedata)
-                (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, m->file_filedata_userdata);
+            if (m->file_filedata) {
+                (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, userdata);
+            }
 
             ft->transferred += file_data_length;
 
             if (file_data_length && (ft->transferred >= ft->size || file_data_length != MAX_FILE_DATA_SIZE)) {
                 file_data_length = 0;
-                file_data = NULL;
+                file_data = nullptr;
                 position = ft->transferred;
 
                 /* Full file received. */
-                if (m->file_filedata)
-                    (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, m->file_filedata_userdata);
+                if (m->file_filedata) {
+                    (*m->file_filedata)(m, i, real_filenumber, position, file_data, file_data_length, userdata);
+                }
             }
 
             /* Data is zero, filetransfer is over. */
@@ -2157,17 +2448,19 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         }
 
         case PACKET_ID_MSI: {
-            if (data_length == 0)
+            if (data_length == 0) {
                 break;
+            }
 
-            if (m->msi_packet)
+            if (m->msi_packet) {
                 (*m->msi_packet)(m, i, data, data_length, m->msi_packet_userdata);
+            }
 
             break;
         }
 
         default: {
-            handle_custom_lossless_packet(object, i, temp, len);
+            handle_custom_lossless_packet(object, i, temp, len, userdata);
             break;
         }
     }
@@ -2175,7 +2468,7 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
     return 0;
 }
 
-void do_friends(Messenger *m)
+static void do_friends(Messenger *m, void *userdata)
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
@@ -2187,7 +2480,7 @@ void do_friends(Messenger *m)
                                                 m->friendlist[i].info_size);
 
             if (fr >= 0) {
-                set_friend_status(m, i, FRIEND_REQUESTED);
+                set_friend_status(m, i, FRIEND_REQUESTED, userdata);
                 m->friendlist[i].friendrequest_lastsent = temp_time;
             }
         }
@@ -2198,71 +2491,79 @@ void do_friends(Messenger *m)
                 /* If we didn't connect to friend after successfully sending him a friend request the request is deemed
                  * unsuccessful so we set the status back to FRIEND_ADDED and try again.
                  */
-                check_friend_request_timed_out(m, i, temp_time);
+                check_friend_request_timed_out(m, i, temp_time, userdata);
             }
         }
 
         if (m->friendlist[i].status == FRIEND_ONLINE) { /* friend is online. */
             if (m->friendlist[i].name_sent == 0) {
-                if (m_sendname(m, i, m->name, m->name_length))
+                if (m_sendname(m, i, m->name, m->name_length)) {
                     m->friendlist[i].name_sent = 1;
+                }
             }
 
             if (m->friendlist[i].statusmessage_sent == 0) {
-                if (send_statusmessage(m, i, m->statusmessage, m->statusmessage_length))
+                if (send_statusmessage(m, i, m->statusmessage, m->statusmessage_length)) {
                     m->friendlist[i].statusmessage_sent = 1;
+                }
             }
 
             if (m->friendlist[i].userstatus_sent == 0) {
-                if (send_userstatus(m, i, m->userstatus))
+                if (send_userstatus(m, i, m->userstatus)) {
                     m->friendlist[i].userstatus_sent = 1;
+                }
             }
 
             if (m->friendlist[i].user_istyping_sent == 0) {
-                if (send_user_istyping(m, i, m->friendlist[i].user_istyping))
+                if (send_user_istyping(m, i, m->friendlist[i].user_istyping)) {
                     m->friendlist[i].user_istyping_sent = 1;
+                }
             }
 
-            check_friend_tcp_udp(m, i);
-            do_receipts(m, i);
-            do_reqchunk_filecb(m, i);
+            check_friend_tcp_udp(m, i, userdata);
+            do_receipts(m, i, userdata);
+            do_reqchunk_filecb(m, i, userdata);
 
-            m->friendlist[i].last_seen_time = (uint64_t) time(NULL);
+            m->friendlist[i].last_seen_time = (uint64_t) time(nullptr);
         }
     }
 }
 
-static void connection_status_cb(Messenger *m)
+static void connection_status_cb(Messenger *m, void *userdata)
 {
     unsigned int conn_status = onion_connection_status(m->onion_c);
 
     if (conn_status != m->last_connection_status) {
-        if (m->core_connection_change)
-            (*m->core_connection_change)(m, conn_status, m->core_connection_change_userdata);
+        if (m->core_connection_change) {
+            (*m->core_connection_change)(m, conn_status, userdata);
+        }
 
         m->last_connection_status = conn_status;
     }
 }
 
 
-#ifdef TOX_LOGGER
 #define DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS 60UL
-static time_t lastdump = 0;
-static char IDString[crypto_box_PUBLICKEYBYTES * 2 + 1];
-static char *ID2String(const uint8_t *pk)
+
+#define IDSTRING_LEN (CRYPTO_PUBLIC_KEY_SIZE * 2 + 1)
+/* id_str should be of length at least IDSTRING_LEN */
+static char *id_to_string(const uint8_t *pk, char *id_str, size_t length)
 {
-    uint32_t i;
+    if (length < IDSTRING_LEN) {
+        snprintf(id_str, length, "Bad buf length");
+        return id_str;
+    }
 
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++)
-        sprintf(&IDString[i * 2], "%02X", pk[i]);
+    for (uint32_t i = 0; i < CRYPTO_PUBLIC_KEY_SIZE; i++) {
+        sprintf(&id_str[i * 2], "%02X", pk[i]);
+    }
 
-    IDString[crypto_box_PUBLICKEYBYTES * 2] = 0;
-    return IDString;
+    id_str[CRYPTO_PUBLIC_KEY_SIZE * 2] = 0;
+    return id_str;
 }
-#endif
 
 /* Minimum messenger run interval in ms
-   TODO: A/V */
+   TODO(mannol): A/V */
 #define MIN_RUN_INTERVAL 50
 
 /* Return the time in milliseconds before do_messenger() should be called again
@@ -2276,13 +2577,13 @@ uint32_t messenger_run_interval(const Messenger *m)
 
     if (crypto_interval > MIN_RUN_INTERVAL) {
         return MIN_RUN_INTERVAL;
-    } else {
-        return crypto_interval;
     }
+
+    return crypto_interval;
 }
 
 /* The main loop that needs to be run at least 20 times per second. */
-void do_messenger(Messenger *m)
+void do_messenger(Messenger *m, void *userdata)
 {
     // Add the TCP relays, but only if this is the first time calling do_messenger
     if (m->has_added_relays == 0) {
@@ -2298,16 +2599,17 @@ void do_messenger(Messenger *m)
             /* Add self tcp server. */
             IP_Port local_ip_port;
             local_ip_port.port = m->options.tcp_server_port;
-            local_ip_port.ip.family = AF_INET;
-            local_ip_port.ip.ip4.uint32 = INADDR_LOOPBACK;
-            add_tcp_relay(m->net_crypto, local_ip_port, m->tcp_server->public_key);
+            local_ip_port.ip.family = net_family_ipv4;
+            local_ip_port.ip.ip.v4 = get_ip4_loopback();
+            add_tcp_relay(m->net_crypto, local_ip_port,
+                          tcp_server_public_key(m->tcp_server));
         }
     }
 
     unix_time_update();
 
     if (!m->options.udp_disabled) {
-        networking_poll(m->net);
+        networking_poll(m->net, userdata);
         do_DHT(m->dht);
     }
 
@@ -2315,112 +2617,121 @@ void do_messenger(Messenger *m)
         do_TCP_server(m->tcp_server);
     }
 
-    do_net_crypto(m->net_crypto);
+    do_net_crypto(m->net_crypto, userdata);
     do_onion_client(m->onion_c);
-    do_friend_connections(m->fr_c);
-    do_friends(m);
-    connection_status_cb(m);
-
-#ifdef TOX_LOGGER
-
-    if (unix_time() > lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
+    do_friend_connections(m->fr_c, userdata);
+    do_friends(m, userdata);
+    connection_status_cb(m, userdata);
 
-#ifdef ENABLE_ASSOC_DHT
-        Assoc_status(m->dht->assoc);
-#endif
-
-        lastdump = unix_time();
+    if (unix_time() > m->lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
+        m->lastdump = unix_time();
         uint32_t client, last_pinged;
 
         for (client = 0; client < LCLIENT_LIST; client++) {
-            Client_data *cptr = &m->dht->close_clientlist[client];
-            IPPTsPng *assoc = NULL;
+            const Client_data *cptr = dht_get_close_client(m->dht, client);
+            const IPPTsPng *assoc = nullptr;
             uint32_t a;
 
-            for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6)
+            for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6) {
                 if (ip_isset(&assoc->ip_port.ip)) {
-                    last_pinged = lastdump - assoc->last_pinged;
+                    last_pinged = m->lastdump - assoc->last_pinged;
 
-                    if (last_pinged > 999)
+                    if (last_pinged > 999) {
                         last_pinged = 999;
+                    }
 
-                    LOGGER_TRACE("C[%2u] %s:%u [%3u] %s",
-                                 client, ip_ntoa(&assoc->ip_port.ip), ntohs(assoc->ip_port.port),
-                                 last_pinged, ID2String(cptr->public_key));
+                    char ip_str[IP_NTOA_LEN];
+                    char id_str[IDSTRING_LEN];
+                    LOGGER_TRACE(m->log, "C[%2u] %s:%u [%3u] %s",
+                                 client, ip_ntoa(&assoc->ip_port.ip, ip_str, sizeof(ip_str)),
+                                 net_ntohs(assoc->ip_port.port), last_pinged,
+                                 id_to_string(cptr->public_key, id_str, sizeof(id_str)));
                 }
+            }
         }
 
 
-        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];
+        uint32_t num_dhtfriends = dht_get_num_friends(m->dht);
+        VLA(int32_t, m2dht, num_dhtfriends);
+        VLA(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;
+            for (dhtfriend = 0; dhtfriend < dht_get_num_friends(m->dht); dhtfriend++) {
+                if (id_equal(m->friendlist[friend_idx].real_pk, dht_get_friend_public_key(m->dht, dhtfriend))) {
+                    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;
+            }
+        }
 
-        if (m->numfriends != m->dht->num_friends) {
-            LOGGER_TRACE("Friend num in DHT %u != friend num in msger %u\n", m->dht->num_friends, m->numfriends);
+        if (m->numfriends != dht_get_num_friends(m->dht)) {
+            LOGGER_TRACE(m->log, "Friend num in DHT %u != friend num in msger %u\n", dht_get_num_friends(m->dht), m->numfriends);
         }
 
         Friend *msgfptr;
         DHT_Friend *dhtfptr;
 
-        for (friend = 0; friend < num_dhtfriends; friend++) {
-            if (dht2m[friend] >= 0)
-                msgfptr = &m->friendlist[dht2m[friend]];
-            else
-                msgfptr = NULL;
+        for (friend_idx = 0; friend_idx < num_dhtfriends; friend_idx++) {
+            if (dht2m[friend_idx] >= 0) {
+                msgfptr = &m->friendlist[dht2m[friend_idx]];
+            } else {
+                msgfptr = nullptr;
+            }
 
-            dhtfptr = &m->dht->friends_list[friend];
+            dhtfptr = dht_get_friend(m->dht, friend_idx);
 
             if (msgfptr) {
-                LOGGER_TRACE("F[%2u:%2u] <%s> %s",
-                             dht2m[friend], friend, msgfptr->name,
-                             ID2String(msgfptr->real_pk));
+                char id_str[IDSTRING_LEN];
+                LOGGER_TRACE(m->log, "F[%2u:%2u] <%s> %s",
+                             dht2m[friend_idx], friend_idx, msgfptr->name,
+                             id_to_string(msgfptr->real_pk, id_str, sizeof(id_str)));
             } else {
-                LOGGER_TRACE("F[--:%2u] %s", friend, ID2String(dhtfptr->public_key));
+                char id_str[IDSTRING_LEN];
+                LOGGER_TRACE(m->log, "F[--:%2u] %s", friend_idx,
+                             id_to_string(dht_friend_public_key(dhtfptr), id_str, sizeof(id_str)));
             }
 
             for (client = 0; client < MAX_FRIEND_CLIENTS; client++) {
-                Client_data *cptr = &dhtfptr->client_list[client];
-                IPPTsPng *assoc = NULL;
-                uint32_t a;
+                const Client_data *cptr = dht_friend_client(dhtfptr, client);
+                const IPPTsPng *const assocs[] = {&cptr->assoc4, &cptr->assoc6};
+
+                for (size_t a = 0; a < sizeof(assocs) / sizeof(assocs[0]); a++) {
+                    const IPPTsPng *const assoc = assocs[a];
 
-                for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6)
                     if (ip_isset(&assoc->ip_port.ip)) {
-                        last_pinged = lastdump - assoc->last_pinged;
+                        last_pinged = m->lastdump - assoc->last_pinged;
 
-                        if (last_pinged > 999)
+                        if (last_pinged > 999) {
                             last_pinged = 999;
-
-                        LOGGER_TRACE("F[%2u] => C[%2u] %s:%u [%3u] %s",
-                                     friend, client, ip_ntoa(&assoc->ip_port.ip),
-                                     ntohs(assoc->ip_port.port), last_pinged,
-                                     ID2String(cptr->public_key));
+                        }
+
+                        char ip_str[IP_NTOA_LEN];
+                        char id_str[IDSTRING_LEN];
+                        LOGGER_TRACE(m->log, "F[%2u] => C[%2u] %s:%u [%3u] %s",
+                                     friend_idx, client, ip_ntoa(&assoc->ip_port.ip, ip_str, sizeof(ip_str)),
+                                     net_ntohs(assoc->ip_port.port), last_pinged,
+                                     id_to_string(cptr->public_key, id_str, sizeof(id_str)));
                     }
+                }
             }
         }
     }
-
-#endif /* TOX_LOGGER */
 }
 
 /* new messenger format for load/save, more robust and forward compatible */
@@ -2440,9 +2751,10 @@ void do_messenger(Messenger *m)
 
 #define SAVED_FRIEND_REQUEST_SIZE 1024
 #define NUM_SAVED_PATH_NODES 8
+
 struct SAVED_FRIEND {
     uint8_t status;
-    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t info[SAVED_FRIEND_REQUEST_SIZE]; // the data that is sent during the friend requests we do.
     uint16_t info_size; // Length of the info.
     uint8_t name[MAX_NAME_LENGTH];
@@ -2454,37 +2766,98 @@ struct SAVED_FRIEND {
     uint64_t last_seen_time;
 };
 
+static uint32_t friend_size(void)
+{
+    uint32_t data = 0;
+    const struct SAVED_FRIEND *const temp = nullptr;
+
+#define VALUE_MEMBER(NAME) data += sizeof(temp->NAME)
+#define ARRAY_MEMBER(NAME) data += sizeof(temp->NAME)
+
+    // Exactly the same in friend_load, friend_save, and friend_size
+    VALUE_MEMBER(status);
+    ARRAY_MEMBER(real_pk);
+    ARRAY_MEMBER(info);
+    data++; // padding
+    VALUE_MEMBER(info_size);
+    ARRAY_MEMBER(name);
+    VALUE_MEMBER(name_length);
+    ARRAY_MEMBER(statusmessage);
+    data++; // padding
+    VALUE_MEMBER(statusmessage_length);
+    VALUE_MEMBER(userstatus);
+    data += 3; // padding
+    VALUE_MEMBER(friendrequest_nospam);
+    VALUE_MEMBER(last_seen_time);
+
+#undef VALUE_MEMBER
+#undef ARRAY_MEMBER
+
+    return data;
+}
+
 static uint32_t saved_friendslist_size(const Messenger *m)
 {
-    return count_friendlist(m) * sizeof(struct SAVED_FRIEND);
+    return count_friendlist(m) * friend_size();
+}
+
+static uint8_t *friend_save(const struct SAVED_FRIEND *temp, uint8_t *data)
+{
+#define VALUE_MEMBER(NAME)                            \
+    memcpy(data, &temp->NAME, sizeof(temp->NAME));  \
+    data += sizeof(temp->NAME)
+
+#define ARRAY_MEMBER(NAME)                            \
+    memcpy(data, temp->NAME, sizeof(temp->NAME));   \
+    data += sizeof(temp->NAME)
+
+    // Exactly the same in friend_load, friend_save, and friend_size
+    VALUE_MEMBER(status);
+    ARRAY_MEMBER(real_pk);
+    ARRAY_MEMBER(info);
+    data++; // padding
+    VALUE_MEMBER(info_size);
+    ARRAY_MEMBER(name);
+    VALUE_MEMBER(name_length);
+    ARRAY_MEMBER(statusmessage);
+    data++; // padding
+    VALUE_MEMBER(statusmessage_length);
+    VALUE_MEMBER(userstatus);
+    data += 3; // padding
+    VALUE_MEMBER(friendrequest_nospam);
+    VALUE_MEMBER(last_seen_time);
+
+#undef VALUE_MEMBER
+#undef ARRAY_MEMBER
+
+    return data;
 }
 
 static uint32_t friends_list_save(const Messenger *m, uint8_t *data)
 {
     uint32_t i;
     uint32_t num = 0;
+    uint8_t *cur_data = data;
 
     for (i = 0; i < m->numfriends; i++) {
         if (m->friendlist[i].status > 0) {
-            struct SAVED_FRIEND temp;
-            memset(&temp, 0, sizeof(struct SAVED_FRIEND));
+            struct SAVED_FRIEND temp = { 0 };
             temp.status = m->friendlist[i].status;
-            memcpy(temp.real_pk, m->friendlist[i].real_pk, crypto_box_PUBLICKEYBYTES);
+            memcpy(temp.real_pk, m->friendlist[i].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
 
             if (temp.status < 3) {
-                if (m->friendlist[i].info_size > SAVED_FRIEND_REQUEST_SIZE) {
-                    memcpy(temp.info, m->friendlist[i].info, SAVED_FRIEND_REQUEST_SIZE);
-                } else {
-                    memcpy(temp.info, m->friendlist[i].info, m->friendlist[i].info_size);
-                }
+                const size_t friendrequest_length =
+                    MIN(m->friendlist[i].info_size,
+                        MIN(SAVED_FRIEND_REQUEST_SIZE, MAX_FRIEND_REQUEST_DATA_SIZE));
+                memcpy(temp.info, m->friendlist[i].info, friendrequest_length);
 
-                temp.info_size = htons(m->friendlist[i].info_size);
+                temp.info_size = net_htons(m->friendlist[i].info_size);
                 temp.friendrequest_nospam = m->friendlist[i].friendrequest_nospam;
             } else {
                 memcpy(temp.name, m->friendlist[i].name, m->friendlist[i].name_length);
-                temp.name_length = htons(m->friendlist[i].name_length);
+                temp.name_length = net_htons(m->friendlist[i].name_length);
                 memcpy(temp.statusmessage, m->friendlist[i].statusmessage, m->friendlist[i].statusmessage_length);
-                temp.statusmessage_length = htons(m->friendlist[i].statusmessage_length);
+                temp.statusmessage_length = net_htons(m->friendlist[i].statusmessage_length);
                 temp.userstatus = m->friendlist[i].userstatus;
 
                 uint8_t last_seen_time[sizeof(uint64_t)];
@@ -2493,48 +2866,93 @@ static uint32_t friends_list_save(const Messenger *m, uint8_t *data)
                 memcpy(&temp.last_seen_time, last_seen_time, sizeof(uint64_t));
             }
 
-            memcpy(data + num * sizeof(struct SAVED_FRIEND), &temp, sizeof(struct SAVED_FRIEND));
+            uint8_t *next_data = friend_save(&temp, cur_data);
+            assert(next_data - cur_data == friend_size());
+#ifdef __LP64__
+            assert(memcmp(cur_data, &temp, friend_size()) == 0);
+#endif
+            cur_data = next_data;
             num++;
         }
     }
 
-    return num * sizeof(struct SAVED_FRIEND);
+    assert(cur_data - data == num * friend_size());
+    return cur_data - data;
+}
+
+static const uint8_t *friend_load(struct SAVED_FRIEND *temp, const uint8_t *data)
+{
+#define VALUE_MEMBER(NAME)                            \
+    memcpy(&temp->NAME, data, sizeof(temp->NAME));  \
+    data += sizeof(temp->NAME)
+
+#define ARRAY_MEMBER(NAME)                            \
+    memcpy(temp->NAME, data, sizeof(temp->NAME));   \
+    data += sizeof(temp->NAME)
+
+    // Exactly the same in friend_load, friend_save, and friend_size
+    VALUE_MEMBER(status);
+    ARRAY_MEMBER(real_pk);
+    ARRAY_MEMBER(info);
+    data++; // padding
+    VALUE_MEMBER(info_size);
+    ARRAY_MEMBER(name);
+    VALUE_MEMBER(name_length);
+    ARRAY_MEMBER(statusmessage);
+    data++; // padding
+    VALUE_MEMBER(statusmessage_length);
+    VALUE_MEMBER(userstatus);
+    data += 3; // padding
+    VALUE_MEMBER(friendrequest_nospam);
+    VALUE_MEMBER(last_seen_time);
+
+#undef VALUE_MEMBER
+#undef ARRAY_MEMBER
+
+    return data;
 }
 
 static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
 {
-    if (length % sizeof(struct SAVED_FRIEND) != 0) {
+    if (length % friend_size() != 0) {
         return -1;
     }
 
-    uint32_t num = length / sizeof(struct SAVED_FRIEND);
+    uint32_t num = length / friend_size();
     uint32_t i;
+    const uint8_t *cur_data = data;
 
     for (i = 0; i < num; ++i) {
-        struct SAVED_FRIEND temp;
-        memcpy(&temp, data + i * sizeof(struct SAVED_FRIEND), sizeof(struct SAVED_FRIEND));
+        struct SAVED_FRIEND temp = { 0 };
+        const uint8_t *next_data = friend_load(&temp, cur_data);
+        assert(next_data - cur_data == friend_size());
+#ifdef __LP64__
+        assert(memcmp(&temp, cur_data, friend_size()) == 0);
+#endif
+        cur_data = next_data;
 
         if (temp.status >= 3) {
             int fnum = m_addfriend_norequest(m, temp.real_pk);
 
-            if (fnum < 0)
+            if (fnum < 0) {
                 continue;
+            }
 
-            setfriendname(m, fnum, temp.name, ntohs(temp.name_length));
-            set_friend_statusmessage(m, fnum, temp.statusmessage, ntohs(temp.statusmessage_length));
+            setfriendname(m, fnum, temp.name, net_ntohs(temp.name_length));
+            set_friend_statusmessage(m, fnum, temp.statusmessage, net_ntohs(temp.statusmessage_length));
             set_friend_userstatus(m, fnum, temp.userstatus);
             uint8_t last_seen_time[sizeof(uint64_t)];
             memcpy(last_seen_time, &temp.last_seen_time, sizeof(uint64_t));
             net_to_host(last_seen_time, sizeof(uint64_t));
             memcpy(&m->friendlist[fnum].last_seen_time, last_seen_time, sizeof(uint64_t));
         } else if (temp.status != 0) {
-            /* TODO: This is not a good way to do this. */
+            /* TODO(irungentoo): This is not a good way to do this. */
             uint8_t address[FRIEND_ADDRESS_SIZE];
             id_copy(address, temp.real_pk);
-            memcpy(address + crypto_box_PUBLICKEYBYTES, &(temp.friendrequest_nospam), sizeof(uint32_t));
+            memcpy(address + CRYPTO_PUBLIC_KEY_SIZE, &temp.friendrequest_nospam, sizeof(uint32_t));
             uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
-            memcpy(address + crypto_box_PUBLICKEYBYTES + sizeof(uint32_t), &checksum, sizeof(checksum));
-            m_addfriend(m, address, temp.info, ntohs(temp.info_size));
+            memcpy(address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t), &checksum, sizeof(checksum));
+            m_addfriend(m, address, temp.info, net_ntohs(temp.info_size));
         }
     }
 
@@ -2546,18 +2964,18 @@ uint32_t messenger_size(const Messenger *m)
 {
     uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2;
     return   size32 * 2                                      // global cookie
-             + sizesubhead + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES
+             + sizesubhead + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE
              + sizesubhead + DHT_size(m->dht)                  // DHT
              + sizesubhead + saved_friendslist_size(m)         // Friendlist itself.
              + sizesubhead + m->name_length                    // Own nickname.
              + sizesubhead + m->statusmessage_length           // status message
              + sizesubhead + 1                                 // status
-             + sizesubhead + NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6) //TCP relays
-             + sizesubhead + NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6) //saved path nodes
+             + sizesubhead + NUM_SAVED_TCP_RELAYS * packed_node_size(net_family_tcp_ipv6) //TCP relays
+             + sizesubhead + NUM_SAVED_PATH_NODES * packed_node_size(net_family_tcp_ipv6) //saved path nodes
              + sizesubhead;
 }
 
-static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
+static uint8_t *messenger_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
 {
     host_to_lendian32(data, len);
     data += sizeof(uint32_t);
@@ -2580,91 +2998,90 @@ void messenger_save(const Messenger *m, uint8_t *data)
     host_to_lendian32(data, MESSENGER_STATE_COOKIE_GLOBAL);
     data += size32;
 
-#ifdef DEBUG
-    assert(sizeof(get_nospam(&(m->fr))) == sizeof(uint32_t));
-#endif
-    len = size32 + crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES;
+    assert(sizeof(get_nospam(m->fr)) == sizeof(uint32_t));
+    len = size32 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE;
     type = MESSENGER_STATE_TYPE_NOSPAMKEYS;
-    data = z_state_save_subheader(data, len, type);
-    *(uint32_t *)data = get_nospam(&(m->fr));
+    data = messenger_save_subheader(data, len, type);
+    *(uint32_t *)data = get_nospam(m->fr);
     save_keys(m->net_crypto, data + size32);
     data += len;
 
     len = saved_friendslist_size(m);
     type = MESSENGER_STATE_TYPE_FRIENDS;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     friends_list_save(m, data);
     data += len;
 
     len = m->name_length;
     type = MESSENGER_STATE_TYPE_NAME;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     memcpy(data, m->name, len);
     data += len;
 
     len = m->statusmessage_length;
     type = MESSENGER_STATE_TYPE_STATUSMESSAGE;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     memcpy(data, m->statusmessage, len);
     data += len;
 
     len = 1;
     type = MESSENGER_STATE_TYPE_STATUS;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     *data = m->userstatus;
     data += len;
 
     len = DHT_size(m->dht);
     type = MESSENGER_STATE_TYPE_DHT;
-    data = z_state_save_subheader(data, len, type);
+    data = messenger_save_subheader(data, len, type);
     DHT_save(m->dht, data);
     data += len;
 
     Node_format relays[NUM_SAVED_TCP_RELAYS];
     type = MESSENGER_STATE_TYPE_TCP_RELAY;
     uint8_t *temp_data = data;
-    data = z_state_save_subheader(temp_data, 0, type);
+    data = messenger_save_subheader(temp_data, 0, type);
     unsigned int num = copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS);
-    int l = pack_nodes(data, NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6), relays, num);
+    int l = pack_nodes(data, NUM_SAVED_TCP_RELAYS * packed_node_size(net_family_tcp_ipv6), relays, num);
 
     if (l > 0) {
         len = l;
-        data = z_state_save_subheader(temp_data, len, type);
+        data = messenger_save_subheader(temp_data, len, type);
         data += len;
     }
 
     Node_format nodes[NUM_SAVED_PATH_NODES];
     type = MESSENGER_STATE_TYPE_PATH_NODE;
     temp_data = data;
-    data = z_state_save_subheader(data, 0, type);
+    data = messenger_save_subheader(data, 0, type);
     memset(nodes, 0, sizeof(nodes));
     num = onion_backup_nodes(m->onion_c, nodes, NUM_SAVED_PATH_NODES);
-    l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6), nodes, num);
+    l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(net_family_tcp_ipv6), nodes, num);
 
     if (l > 0) {
         len = l;
-        data = z_state_save_subheader(temp_data, len, type);
+        data = messenger_save_subheader(temp_data, len, type);
         data += len;
     }
 
-    z_state_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
+    messenger_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
 }
 
 static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
 {
-    Messenger *m = outer;
+    Messenger *m = (Messenger *)outer;
 
     switch (type) {
         case MESSENGER_STATE_TYPE_NOSPAMKEYS:
-            if (length == crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES + sizeof(uint32_t)) {
-                set_nospam(&(m->fr), *(uint32_t *)data);
-                load_secret_key(m->net_crypto, (&data[sizeof(uint32_t)]) + crypto_box_PUBLICKEYBYTES);
+            if (length == CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE + sizeof(uint32_t)) {
+                set_nospam(m->fr, *(const uint32_t *)data);
+                load_secret_key(m->net_crypto, (&data[sizeof(uint32_t)]) + CRYPTO_PUBLIC_KEY_SIZE);
 
-                if (public_key_cmp((&data[sizeof(uint32_t)]), m->net_crypto->self_public_key) != 0) {
+                if (public_key_cmp((&data[sizeof(uint32_t)]), nc_get_self_public_key(m->net_crypto)) != 0) {
                     return -1;
                 }
-            } else
+            } else {
                 return -1;    /* critical */
+            }
 
             break;
 
@@ -2684,7 +3101,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
             break;
 
         case MESSENGER_STATE_TYPE_STATUSMESSAGE:
-            if ((length > 0) && (length < MAX_STATUSMESSAGE_LENGTH)) {
+            if ((length > 0) && (length <= MAX_STATUSMESSAGE_LENGTH)) {
                 m_set_statusmessage(m, data, length);
             }
 
@@ -2702,7 +3119,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
                 break;
             }
 
-            unpack_nodes(m->loaded_relays, NUM_SAVED_TCP_RELAYS, 0, data, length, 1);
+            unpack_nodes(m->loaded_relays, NUM_SAVED_TCP_RELAYS, nullptr, data, length, 1);
             m->has_added_relays = 0;
 
             break;
@@ -2715,7 +3132,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
                 break;
             }
 
-            int i, num = unpack_nodes(nodes, NUM_SAVED_PATH_NODES, 0, data, length, 0);
+            int i, num = unpack_nodes(nodes, NUM_SAVED_PATH_NODES, nullptr, data, length, 0);
 
             for (i = 0; i < num; ++i) {
                 onion_add_bs_path_node(m->onion_c, nodes[i].ip_port, nodes[i].public_key);
@@ -2730,16 +3147,12 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
             }
 
             return -2;
-            break;
         }
 
-#ifdef DEBUG
-
         default:
-            fprintf(stderr, "Load state: contains unrecognized part (len %u, type %u)\n",
-                    length, type);
+            LOGGER_ERROR(m->log, "Load state: contains unrecognized part (len %u, type %u)\n",
+                         length, type);
             break;
-#endif
     }
 
     return 0;
@@ -2751,17 +3164,19 @@ int messenger_load(Messenger *m, const uint8_t *data, uint32_t length)
     uint32_t data32[2];
     uint32_t cookie_len = sizeof(data32);
 
-    if (length < cookie_len)
+    if (length < cookie_len) {
         return -1;
+    }
 
     memcpy(data32, data, sizeof(uint32_t));
     lendian_to_host32(data32 + 1, data + sizeof(uint32_t));
 
-    if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL))
-        return load_state(messenger_load_state_callback, m, data + cookie_len,
+    if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL)) {
+        return load_state(messenger_load_state_callback, m->log, m, data + cookie_len,
                           length - cookie_len, MESSENGER_STATE_COOKIE_TYPE);
-    else
-        return -1;
+    }
+
+    return -1;
 }
 
 /* Return the number of friends in the instance m.
@@ -2788,8 +3203,9 @@ uint32_t count_friendlist(const Messenger *m)
  * of out_list will be truncated to list_size. */
 uint32_t copy_friendlist(Messenger const *m, uint32_t *out_list, uint32_t list_size)
 {
-    if (!out_list)
+    if (!out_list) {
         return 0;
+    }
 
     if (m->numfriends == 0) {
         return 0;
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 26704dd1..402eb916 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -1,40 +1,48 @@
-/* Messenger.h
- *
- * An implementation of a simple text chat only messenger on the tox network core.
- *
- * NOTE: All the text in the messages must be encoded using UTF-8
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
+/*
+ * An implementation of a simple text chat only messenger on the tox network
+ * core.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef MESSENGER_H
 #define MESSENGER_H
 
-#include "friend_requests.h"
 #include "friend_connection.h"
+#include "friend_requests.h"
+#include "logger.h"
 
 #define MAX_NAME_LENGTH 128
-/* TODO: this must depend on other variable. */
+/* TODO(irungentoo): this must depend on other variable. */
 #define MAX_STATUSMESSAGE_LENGTH 1007
+/* Used for TCP relays in Messenger struct (may need to be % 2 == 0)*/
+#define NUM_SAVED_TCP_RELAYS 8
+/* This cannot be bigger than 256 */
+#define MAX_CONCURRENT_FILE_PIPES 256
+
+#if !defined(__SPLINT__) && MAX_CONCURRENT_FILE_PIPES > UINT8_MAX + 1
+#error "uint8_t cannot represent all file transfer numbers"
+#endif
 
 
-#define FRIEND_ADDRESS_SIZE (crypto_box_PUBLICKEYBYTES + sizeof(uint32_t) + sizeof(uint16_t))
+#define FRIEND_ADDRESS_SIZE (CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
 
 enum {
     MESSAGE_NORMAL,
@@ -54,11 +62,11 @@ enum {
 #define PACKET_ID_FILE_SENDREQUEST 80
 #define PACKET_ID_FILE_CONTROL 81
 #define PACKET_ID_FILE_DATA 82
-#define PACKET_ID_INVITE_GROUPCHAT 96
+#define PACKET_ID_INVITE_CONFERENCE 96
 #define PACKET_ID_ONLINE_PACKET 97
-#define PACKET_ID_DIRECT_GROUPCHAT 98
-#define PACKET_ID_MESSAGE_GROUPCHAT 99
-#define PACKET_ID_LOSSY_GROUPCHAT 199
+#define PACKET_ID_DIRECT_CONFERENCE 98
+#define PACKET_ID_MESSAGE_CONFERENCE 99
+#define PACKET_ID_LOSSY_CONFERENCE 199
 
 /* All packets starting with a byte in this range can be used for anything. */
 #define PACKET_ID_LOSSLESS_RANGE_START 160
@@ -66,11 +74,17 @@ enum {
 #define PACKET_LOSSY_AV_RESERVED 8 /* Number of lossy packet types at start of range reserved for A/V. */
 
 typedef struct {
-    uint8_t ipv6enabled;
-    uint8_t udp_disabled;
+    bool ipv6enabled;
+    bool udp_disabled;
     TCP_Proxy_Info proxy_info;
     uint16_t port_range[2];
     uint16_t tcp_server_port;
+
+    bool hole_punching_enabled;
+    bool local_discovery_enabled;
+
+    logger_cb *log_callback;
+    void *log_user_data;
 } Messenger_Options;
 
 
@@ -152,9 +166,6 @@ enum {
     FILE_PAUSE_BOTH
 };
 
-/* This cannot be bigger than 256 */
-#define MAX_CONCURRENT_FILE_PIPES 256
-
 enum {
     FILECONTROL_ACCEPT,
     FILECONTROL_PAUSE,
@@ -171,7 +182,7 @@ enum {
 typedef struct Messenger Messenger;
 
 typedef struct {
-    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
     int friendcon_id;
 
     uint64_t friendrequest_lastsent; // Time at which the last friend request was sent.
@@ -195,7 +206,7 @@ typedef struct {
     uint64_t last_seen_time;
     uint8_t last_connection_udp_tcp;
     struct File_Transfers file_sending[MAX_CONCURRENT_FILE_PIPES];
-    unsigned int num_sending_files;
+    uint32_t num_sending_files;
     struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES];
 
     struct {
@@ -207,8 +218,8 @@ typedef struct {
     struct Receipts *receipts_end;
 } Friend;
 
-
 struct Messenger {
+    Logger *log;
 
     Networking_Core *net;
     Net_Crypto *net_crypto;
@@ -221,7 +232,7 @@ struct Messenger {
     Friend_Connections *fr_c;
 
     TCP_Server *tcp_server;
-    Friend_Requests fr;
+    Friend_Requests *fr;
     uint8_t name[MAX_NAME_LENGTH];
     uint16_t name_length;
 
@@ -233,51 +244,37 @@ struct Messenger {
     Friend *friendlist;
     uint32_t numfriends;
 
-#define NUM_SAVED_TCP_RELAYS 8
+    time_t lastdump;
+
     uint8_t has_added_relays; // If the first connection has occurred in do_messenger
     Node_format loaded_relays[NUM_SAVED_TCP_RELAYS]; // Relays loaded from config
 
     void (*friend_message)(struct Messenger *m, uint32_t, unsigned int, const uint8_t *, size_t, void *);
-    void *friend_message_userdata;
     void (*friend_namechange)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
-    void *friend_namechange_userdata;
     void (*friend_statusmessagechange)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
-    void *friend_statusmessagechange_userdata;
     void (*friend_userstatuschange)(struct Messenger *m, uint32_t, unsigned int, void *);
-    void *friend_userstatuschange_userdata;
-    void (*friend_typingchange)(struct Messenger *m, uint32_t, _Bool, void *);
-    void *friend_typingchange_userdata;
+    void (*friend_typingchange)(struct Messenger *m, uint32_t, bool, void *);
     void (*read_receipt)(struct Messenger *m, uint32_t, uint32_t, void *);
-    void *read_receipt_userdata;
     void (*friend_connectionstatuschange)(struct Messenger *m, uint32_t, unsigned int, void *);
-    void *friend_connectionstatuschange_userdata;
     void (*friend_connectionstatuschange_internal)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_connectionstatuschange_internal_userdata;
 
-    void *group_chat_object; /* Set by new_groupchats()*/
-    void (*group_invite)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t);
-    void (*group_message)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t);
+    void *conferences_object; /* Set by new_groupchats()*/
+    void (*conference_invite)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t, void *);
 
     void (*file_sendrequest)(struct Messenger *m, uint32_t, uint32_t, uint32_t, uint64_t, const uint8_t *, size_t,
                              void *);
-    void *file_sendrequest_userdata;
     void (*file_filecontrol)(struct Messenger *m, uint32_t, uint32_t, unsigned int, void *);
-    void *file_filecontrol_userdata;
     void (*file_filedata)(struct Messenger *m, uint32_t, uint32_t, uint64_t, const uint8_t *, size_t, void *);
-    void *file_filedata_userdata;
     void (*file_reqchunk)(struct Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *);
-    void *file_reqchunk_userdata;
 
     void (*msi_packet)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t, void *);
     void *msi_packet_userdata;
 
     void (*lossy_packethandler)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
-    void *lossy_packethandler_userdata;
     void (*lossless_packethandler)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
-    void *lossless_packethandler_userdata;
 
     void (*core_connection_change)(struct Messenger *m, unsigned int, void *);
-    void *core_connection_change_userdata;
     unsigned int last_connection_status;
 
     Messenger_Options options;
@@ -291,7 +288,9 @@ void getaddress(const Messenger *m, uint8_t *address);
 
 /* Add a friend.
  * Set the data that will be sent along with friend request.
- * address is the address of the friend (returned by getaddress of the friend you wish to add) it must be FRIEND_ADDRESS_SIZE bytes. TODO: add checksum.
+ * address is the address of the friend (returned by getaddress of the friend
+ *   you wish to add) it must be FRIEND_ADDRESS_SIZE bytes.
+ *   TODO(irungentoo): add checksum.
  * data is the data and length is the length.
  *
  *  return the friend number if success.
@@ -322,7 +321,7 @@ int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk);
 int32_t getfriend_id(const Messenger *m, const uint8_t *real_pk);
 
 /* Copies the public key associated to that friend id into real_pk buffer.
- * Make sure that real_pk is of size crypto_box_PUBLICKEYBYTES.
+ * Make sure that real_pk is of size CRYPTO_PUBLIC_KEY_SIZE.
  *
  *  return 0 if success
  *  return -1 if failure
@@ -470,43 +469,44 @@ int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing);
  */
 int m_get_istyping(const Messenger *m, int32_t friendnumber);
 
+/* Set the logger callback.
+ */
+void m_callback_log(Messenger *m, logger_cb *function, void *context, void *userdata);
+
 /* Set the function that will be executed when a friend request is received.
  *  Function format is function(uint8_t * public_key, uint8_t * data, size_t length)
  */
 void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, size_t,
-                              void *), void *userdata);
+                              void *));
 
 /* Set the function that will be executed when a message from a friend is received.
  *  Function format is: function(uint32_t friendnumber, unsigned int type, uint8_t * message, uint32_t length)
  */
 void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, const uint8_t *,
-                              size_t, void *), void *userdata);
+                              size_t, void *));
 
 /* Set the callback for name changes.
  *  Function(uint32_t friendnumber, uint8_t *newname, size_t length)
  *  You are not responsible for freeing newname.
  */
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
-                           void *userdata);
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *));
 
 /* Set the callback for status message changes.
  *  Function(uint32_t friendnumber, uint8_t *newstatus, size_t length)
  *
  *  You are not responsible for freeing newstatus
  */
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
-                              void *userdata);
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *));
 
 /* Set the callback for status type changes.
  *  Function(uint32_t friendnumber, USERSTATUS kind)
  */
-void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *),
-                           void *userdata);
+void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *));
 
 /* Set the callback for typing changes.
  *  Function(uint32_t friendnumber, uint8_t is_typing)
  */
-void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, _Bool, void *), void *userdata);
+void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, bool, void *));
 
 /* Set the callback for read receipts.
  *  Function(uint32_t friendnumber, uint32_t receipt)
@@ -517,7 +517,7 @@ void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_
  *  Since core doesn't track ids for you, receipt may not correspond to any message.
  *  In that case, you should discard it.
  */
-void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *), void *userdata);
+void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *));
 
 /* Set the callback for connection status changes.
  *  function(uint32_t friendnumber, uint8_t status)
@@ -530,8 +530,8 @@ void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32
  *  being previously online" part.
  *  It's assumed that when adding friends, their connection status is offline.
  */
-void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *),
-                                 void *userdata);
+void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, unsigned int, void *));
+
 /* Same as previous but for internal A/V core usage only */
 void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
         void *userdata);
@@ -540,22 +540,23 @@ void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Mess
 /* Set the callback for typing changes.
  *  Function(unsigned int connection_status (0 = not connected, 1 = TCP only, 2 = UDP + TCP))
  */
-void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, unsigned int, void *), void *userdata);
+void m_callback_core_connection(Messenger *m, void (*function)(Messenger *m, unsigned int, void *));
 
-/**********GROUP CHATS************/
+/**********CONFERENCES************/
 
-/* Set the callback for group invites.
+/* Set the callback for conference invites.
  *
- *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length)
+ *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t));
+void m_callback_conference_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t,
+                                  void *));
 
-/* Send a group invite packet.
+/* Send a conference invite packet.
  *
  *  return 1 on success
  *  return 0 on failure
  */
-int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length);
+int send_conference_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length);
 
 /****************FILE SENDING*****************/
 
@@ -565,7 +566,7 @@ int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uin
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint32_t filetype, uint64_t filesize, uint8_t *filename, size_t filename_length, void *userdata)
  */
 void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m,  uint32_t, uint32_t, uint32_t, uint64_t,
-                               const uint8_t *, size_t, void *), void *userdata);
+                               const uint8_t *, size_t, void *));
 
 
 /* Set the callback for file control requests.
@@ -573,8 +574,7 @@ void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m,  uin
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, unsigned int control_type, void *userdata)
  *
  */
-void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, unsigned int, void *),
-                           void *userdata);
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, unsigned int, void *));
 
 /* Set the callback for file data.
  *
@@ -582,15 +582,14 @@ void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t
  *
  */
 void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, const uint8_t *,
-                        size_t, void *), void *userdata);
+                        size_t, void *));
 
 /* Set the callback for file request chunk.
  *
  *  Function(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, size_t length, void *userdata)
  *
  */
-void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *),
-                            void *userdata);
+void callback_file_reqchunk(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, uint64_t, size_t, void *));
 
 
 /* Copy the file transfer file id to file_id
@@ -693,7 +692,7 @@ int m_callback_rtp_packet(Messenger *m, int32_t friendnumber, uint8_t byte, int
  *
  */
 void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
-        uint32_t friendnumber, const uint8_t *data, size_t len, void *object), void *object);
+        uint32_t friendnumber, const uint8_t *data, size_t len, void *object));
 
 /* High level function to send custom lossy packets.
  *
@@ -704,14 +703,14 @@ void custom_lossy_packet_registerhandler(Messenger *m, void (*packet_handler_cal
  * return -5 if packet failed to send because of other error.
  * return 0 on success.
  */
-int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length);
+int m_send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length);
 
 
 /* Set handlers for custom lossless packets.
  *
  */
 void custom_lossless_packet_registerhandler(Messenger *m, void (*packet_handler_callback)(Messenger *m,
-        uint32_t friendnumber, const uint8_t *data, size_t len, void *object), void *object);
+        uint32_t friendnumber, const uint8_t *data, size_t len, void *object));
 
 /* High level function to send custom lossless packets.
  *
@@ -747,7 +746,7 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error);
 void kill_messenger(Messenger *m);
 
 /* The main loop that needs to be run at least 20 times per second. */
-void do_messenger(Messenger *m);
+void do_messenger(Messenger *m, void *userdata);
 
 /* Return the time in milliseconds before do_messenger() should be called again
  * for optimal performance.
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index 752deecf..d1cd4d66 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -1,70 +1,131 @@
 /*
-* TCP_client.c -- Implementation of the TCP relay client part of Tox.
-*
-*  Copyright (C) 2014 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the TCP relay client part of Tox.
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "TCP_client.h"
 
-#if !defined(_WIN32) && !defined(__WIN32__) && !defined (WIN32)
-#include <sys/ioctl.h>
-#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "util.h"
 
+struct TCP_Client_Connection {
+    TCP_CLIENT_STATUS status;
+    Socket sock;
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* our public key */
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* public key of the server */
+    IP_Port ip_port; /* The ip and port of the server */
+    TCP_Proxy_Info proxy_info;
+    uint8_t recv_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of received packets. */
+    uint8_t sent_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of sent packets. */
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint16_t next_packet_length;
+
+    uint8_t temp_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    uint8_t last_packet[2 + MAX_PACKET_SIZE];
+    uint16_t last_packet_length;
+    uint16_t last_packet_sent;
+
+    TCP_Priority_List *priority_queue_start, *priority_queue_end;
+
+    uint64_t kill_at;
+
+    uint64_t last_pinged;
+    uint64_t ping_id;
+
+    uint64_t ping_response_id;
+    uint64_t ping_request_id;
+
+    struct {
+        uint8_t status; /* 0 if not used, 1 if other is offline, 2 if other is online. */
+        uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+        uint32_t number;
+    } connections[NUM_CLIENT_CONNECTIONS];
+    int (*response_callback)(void *object, uint8_t connection_id, const uint8_t *public_key);
+    void *response_callback_object;
+    int (*status_callback)(void *object, uint32_t number, uint8_t connection_id, uint8_t status);
+    void *status_callback_object;
+    int (*data_callback)(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length,
+                         void *userdata);
+    void *data_callback_object;
+    int (*oob_data_callback)(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata);
+    void *oob_data_callback_object;
+
+    int (*onion_callback)(void *object, const uint8_t *data, uint16_t length, void *userdata);
+    void *onion_callback_object;
+
+    /* Can be used by user. */
+    void *custom_object;
+    uint32_t custom_uint;
+};
+
+const uint8_t *tcp_con_public_key(const TCP_Client_Connection *con)
+{
+    return con->public_key;
+}
+
+IP_Port tcp_con_ip_port(const TCP_Client_Connection *con)
+{
+    return con->ip_port;
+}
+
+TCP_CLIENT_STATUS tcp_con_status(const TCP_Client_Connection *con)
+{
+    return con->status;
+}
+void *tcp_con_custom_object(const TCP_Client_Connection *con)
+{
+    return con->custom_object;
+}
+uint32_t tcp_con_custom_uint(const TCP_Client_Connection *con)
+{
+    return con->custom_uint;
+}
+void tcp_con_set_custom_object(TCP_Client_Connection *con, void *object)
+{
+    con->custom_object = object;
+}
+void tcp_con_set_custom_uint(TCP_Client_Connection *con, uint32_t value)
+{
+    con->custom_uint = value;
+}
+
 /* return 1 on success
  * return 0 on failure
  */
-static int connect_sock_to(sock_t sock, IP_Port ip_port, TCP_Proxy_Info *proxy_info)
+static int connect_sock_to(Socket sock, IP_Port ip_port, TCP_Proxy_Info *proxy_info)
 {
     if (proxy_info->proxy_type != TCP_PROXY_NONE) {
         ip_port = proxy_info->ip_port;
     }
 
-    struct sockaddr_storage addr = {0};
-
-    size_t addrsize;
-
-    if (ip_port.ip.family == AF_INET) {
-        struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
-
-        addrsize = sizeof(struct sockaddr_in);
-        addr4->sin_family = AF_INET;
-        addr4->sin_addr = ip_port.ip.ip4.in_addr;
-        addr4->sin_port = ip_port.port;
-    } else if (ip_port.ip.family == AF_INET6) {
-        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
-
-        addrsize = sizeof(struct sockaddr_in6);
-        addr6->sin6_family = AF_INET6;
-        addr6->sin6_addr = ip_port.ip.ip6.in6_addr;
-        addr6->sin6_port = ip_port.port;
-    } else {
-        return 0;
-    }
-
     /* nonblocking socket, connect will never return success */
-    connect(sock, (struct sockaddr *)&addr, addrsize);
+    net_connect(sock, ip_port);
     return 1;
 }
 
@@ -77,13 +138,13 @@ static int proxy_http_generate_connection_request(TCP_Client_Connection *TCP_con
     char two[] = " HTTP/1.1\nHost: ";
     char three[] = "\r\n\r\n";
 
-    char ip[INET6_ADDRSTRLEN];
+    char ip[TOX_INET6_ADDRSTRLEN];
 
     if (!ip_parse_addr(&TCP_conn->ip_port.ip, ip, sizeof(ip))) {
         return 0;
     }
 
-    const uint16_t port = ntohs(TCP_conn->ip_port.port);
+    const uint16_t port = net_ntohs(TCP_conn->ip_port.port);
     const int written = snprintf((char *)TCP_conn->last_packet, MAX_PACKET_SIZE, "%s%s:%hu%s%s:%hu%s", one, ip, port, two,
                                  ip, port, three);
 
@@ -116,10 +177,10 @@ static int proxy_http_read_connection_response(TCP_Client_Connection *TCP_conn)
 
     if (strstr((char *)data, success)) {
         // drain all data
-        unsigned int data_left = TCP_socket_data_recv_buffer(TCP_conn->sock);
+        unsigned int data_left = net_socket_data_recv_buffer(TCP_conn->sock);
 
         if (data_left) {
-            uint8_t temp_data[data_left];
+            VLA(uint8_t, temp_data, data_left);
             read_TCP_packet(TCP_conn->sock, temp_data, data_left);
         }
 
@@ -148,11 +209,13 @@ static int socks5_read_handshake_response(TCP_Client_Connection *TCP_conn)
     uint8_t data[2];
     int ret = read_TCP_packet(TCP_conn->sock, data, sizeof(data));
 
-    if (ret == -1)
+    if (ret == -1) {
         return 0;
+    }
 
-    if (data[0] == 5 && data[1] == 0) // FIXME magic numbers
+    if (data[0] == 5 && data[1] == 0) { // TODO(irungentoo): magic numbers
         return 1;
+    }
 
     return -1;
 }
@@ -164,15 +227,15 @@ static void proxy_socks5_generate_connection_request(TCP_Client_Connection *TCP_
     TCP_conn->last_packet[2] = 0; /* reserved, must be 0 */
     uint16_t length = 3;
 
-    if (TCP_conn->ip_port.ip.family == AF_INET) {
+    if (net_family_is_ipv4(TCP_conn->ip_port.ip.family)) {
         TCP_conn->last_packet[3] = 1; /* IPv4 address */
         ++length;
-        memcpy(TCP_conn->last_packet + length, TCP_conn->ip_port.ip.ip4.uint8, sizeof(IP4));
+        memcpy(TCP_conn->last_packet + length, TCP_conn->ip_port.ip.ip.v4.uint8, sizeof(IP4));
         length += sizeof(IP4);
     } else {
         TCP_conn->last_packet[3] = 4; /* IPv6 address */
         ++length;
-        memcpy(TCP_conn->last_packet + length, TCP_conn->ip_port.ip.ip6.uint8, sizeof(IP6));
+        memcpy(TCP_conn->last_packet + length, TCP_conn->ip_port.ip.ip.v6.uint8, sizeof(IP6));
         length += sizeof(IP6);
     }
 
@@ -189,25 +252,28 @@ static void proxy_socks5_generate_connection_request(TCP_Client_Connection *TCP_
  */
 static int proxy_socks5_read_connection_response(TCP_Client_Connection *TCP_conn)
 {
-    if (TCP_conn->ip_port.ip.family == AF_INET) {
+    if (net_family_is_ipv4(TCP_conn->ip_port.ip.family)) {
         uint8_t data[4 + sizeof(IP4) + sizeof(uint16_t)];
         int ret = read_TCP_packet(TCP_conn->sock, data, sizeof(data));
 
-        if (ret == -1)
+        if (ret == -1) {
             return 0;
+        }
 
-        if (data[0] == 5 && data[1] == 0)
+        if (data[0] == 5 && data[1] == 0) {
             return 1;
-
+        }
     } else {
         uint8_t data[4 + sizeof(IP6) + sizeof(uint16_t)];
         int ret = read_TCP_packet(TCP_conn->sock, data, sizeof(data));
 
-        if (ret == -1)
+        if (ret == -1) {
             return 0;
+        }
 
-        if (data[0] == 5 && data[1] == 0)
+        if (data[0] == 5 && data[1] == 0) {
             return 1;
+        }
     }
 
     return -1;
@@ -218,19 +284,20 @@ static int proxy_socks5_read_connection_response(TCP_Client_Connection *TCP_conn
  */
 static int generate_handshake(TCP_Client_Connection *TCP_conn)
 {
-    uint8_t plain[crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES];
-    crypto_box_keypair(plain, TCP_conn->temp_secret_key);
+    uint8_t plain[CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE];
+    crypto_new_keypair(plain, TCP_conn->temp_secret_key);
     random_nonce(TCP_conn->sent_nonce);
-    memcpy(plain + crypto_box_PUBLICKEYBYTES, TCP_conn->sent_nonce, crypto_box_NONCEBYTES);
-    memcpy(TCP_conn->last_packet, TCP_conn->self_public_key, crypto_box_PUBLICKEYBYTES);
-    new_nonce(TCP_conn->last_packet + crypto_box_PUBLICKEYBYTES);
-    int len = encrypt_data_symmetric(TCP_conn->shared_key, TCP_conn->last_packet + crypto_box_PUBLICKEYBYTES, plain,
-                                     sizeof(plain), TCP_conn->last_packet + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
+    memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, TCP_conn->sent_nonce, CRYPTO_NONCE_SIZE);
+    memcpy(TCP_conn->last_packet, TCP_conn->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    random_nonce(TCP_conn->last_packet + CRYPTO_PUBLIC_KEY_SIZE);
+    int len = encrypt_data_symmetric(TCP_conn->shared_key, TCP_conn->last_packet + CRYPTO_PUBLIC_KEY_SIZE, plain,
+                                     sizeof(plain), TCP_conn->last_packet + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
 
-    if (len != sizeof(plain) + crypto_box_MACBYTES)
+    if (len != sizeof(plain) + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    TCP_conn->last_packet_length = crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + sizeof(plain) + crypto_box_MACBYTES;
+    TCP_conn->last_packet_length = CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + sizeof(plain) + CRYPTO_MAC_SIZE;
     TCP_conn->last_packet_sent = 0;
     return 0;
 }
@@ -242,33 +309,35 @@ static int generate_handshake(TCP_Client_Connection *TCP_conn)
  */
 static int handle_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *data)
 {
-    uint8_t plain[crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES];
-    int len = decrypt_data_symmetric(TCP_conn->shared_key, data, data + crypto_box_NONCEBYTES,
-                                     TCP_SERVER_HANDSHAKE_SIZE - crypto_box_NONCEBYTES, plain);
+    uint8_t plain[CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE];
+    int len = decrypt_data_symmetric(TCP_conn->shared_key, data, data + CRYPTO_NONCE_SIZE,
+                                     TCP_SERVER_HANDSHAKE_SIZE - CRYPTO_NONCE_SIZE, plain);
 
-    if (len != sizeof(plain))
+    if (len != sizeof(plain)) {
         return -1;
+    }
 
-    memcpy(TCP_conn->recv_nonce, plain + crypto_box_PUBLICKEYBYTES, crypto_box_NONCEBYTES);
+    memcpy(TCP_conn->recv_nonce, plain + CRYPTO_PUBLIC_KEY_SIZE, CRYPTO_NONCE_SIZE);
     encrypt_precompute(plain, TCP_conn->temp_secret_key, TCP_conn->shared_key);
-    sodium_memzero(TCP_conn->temp_secret_key, crypto_box_SECRETKEYBYTES);
+    crypto_memzero(TCP_conn->temp_secret_key, CRYPTO_SECRET_KEY_SIZE);
     return 0;
 }
 
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data_nonpriority(TCP_Client_Connection *con)
+static int client_send_pending_data_nonpriority(TCP_Client_Connection *con)
 {
     if (con->last_packet_length == 0) {
         return 0;
     }
 
-    uint16_t left = con->last_packet_length - con->last_packet_sent;
-    int len = send(con->sock, con->last_packet + con->last_packet_sent, left, MSG_NOSIGNAL);
+    const uint16_t left = con->last_packet_length - con->last_packet_sent;
+    const int len = net_send(con->sock, con->last_packet + con->last_packet_sent, left);
 
-    if (len <= 0)
+    if (len <= 0) {
         return -1;
+    }
 
     if (len == left) {
         con->last_packet_length = 0;
@@ -283,18 +352,18 @@ static int send_pending_data_nonpriority(TCP_Client_Connection *con)
 /* return 0 if pending data was sent completely
  * return -1 if it wasn't
  */
-static int send_pending_data(TCP_Client_Connection *con)
+static int client_send_pending_data(TCP_Client_Connection *con)
 {
     /* finish sending current non-priority packet */
-    if (send_pending_data_nonpriority(con) == -1) {
+    if (client_send_pending_data_nonpriority(con) == -1) {
         return -1;
     }
 
     TCP_Priority_List *p = con->priority_queue_start;
 
     while (p) {
-        uint16_t left = p->size - p->sent;
-        int len = send(con->sock, p->data + p->sent, left, MSG_NOSIGNAL);
+        const uint16_t left = p->size - p->sent;
+        const int len = net_send(con->sock, p->data + p->sent, left);
 
         if (len != left) {
             if (len > 0) {
@@ -312,7 +381,7 @@ static int send_pending_data(TCP_Client_Connection *con)
     con->priority_queue_start = p;
 
     if (!p) {
-        con->priority_queue_end = NULL;
+        con->priority_queue_end = nullptr;
         return 0;
     }
 
@@ -322,27 +391,27 @@ static int send_pending_data(TCP_Client_Connection *con)
 /* return 0 on failure (only if malloc fails)
  * return 1 on success
  */
-static _Bool add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
+static bool client_add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
 {
-    TCP_Priority_List *p = con->priority_queue_end, *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 = nullptr;
+    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;
 }
 
@@ -355,22 +424,22 @@ static void wipe_priority_list(TCP_Client_Connection *con)
         p = p->next;
         free(pp);
     }
-
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
-        _Bool priority)
+static int write_packet_TCP_client_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
+        bool priority)
 {
-    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
+    if (length + CRYPTO_MAC_SIZE > MAX_PACKET_SIZE) {
         return -1;
+    }
 
-    _Bool sendpriority = 1;
+    bool sendpriority = 1;
 
-    if (send_pending_data(con) == -1) {
+    if (client_send_pending_data(con) == -1) {
         if (priority) {
             sendpriority = 0;
         } else {
@@ -378,17 +447,18 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
         }
     }
 
-    uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
+    VLA(uint8_t, packet, sizeof(uint16_t) + length + CRYPTO_MAC_SIZE);
 
-    uint16_t c_length = htons(length + crypto_box_MACBYTES);
+    uint16_t c_length = net_htons(length + CRYPTO_MAC_SIZE);
     memcpy(packet, &c_length, sizeof(uint16_t));
     int len = encrypt_data_symmetric(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
 
-    if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
+    if ((unsigned int)len != (SIZEOF_VLA(packet) - sizeof(uint16_t))) {
         return -1;
+    }
 
     if (priority) {
-        len = sendpriority ? send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL) : 0;
+        len = sendpriority ? net_send(con->sock, packet, SIZEOF_VLA(packet)) : 0;
 
         if (len <= 0) {
             len = 0;
@@ -396,25 +466,27 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
 
         increment_nonce(con->sent_nonce);
 
-        if ((unsigned int)len == sizeof(packet)) {
+        if ((unsigned int)len == SIZEOF_VLA(packet)) {
             return 1;
         }
 
-        return add_priority(con, packet, sizeof(packet), len);
+        return client_add_priority(con, packet, SIZEOF_VLA(packet), len);
     }
 
-    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
+    len = net_send(con->sock, packet, SIZEOF_VLA(packet));
 
-    if (len <= 0)
+    if (len <= 0) {
         return 0;
+    }
 
     increment_nonce(con->sent_nonce);
 
-    if ((unsigned int)len == sizeof(packet))
+    if ((unsigned int)len == SIZEOF_VLA(packet)) {
         return 1;
+    }
 
-    memcpy(con->last_packet, packet, sizeof(packet));
-    con->last_packet_length = sizeof(packet);
+    memcpy(con->last_packet, packet, SIZEOF_VLA(packet));
+    con->last_packet_length = SIZEOF_VLA(packet);
     con->last_packet_sent = len;
     return 1;
 }
@@ -425,10 +497,10 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
  */
 int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key)
 {
-    uint8_t packet[1 + crypto_box_PUBLICKEYBYTES];
+    uint8_t packet[1 + CRYPTO_PUBLIC_KEY_SIZE];
     packet[0] = TCP_PACKET_ROUTING_REQUEST;
-    memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
+    memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
@@ -445,8 +517,8 @@ void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(v
     con->status_callback_object = object;
 }
 
-static int send_ping_response(TCP_Client_Connection *con);
-static int send_ping_request(TCP_Client_Connection *con);
+static int tcp_send_ping_response(TCP_Client_Connection *con);
+static int tcp_send_ping_request(TCP_Client_Connection *con);
 
 /* return 1 on success.
  * return 0 if could not send packet.
@@ -454,19 +526,22 @@ static int send_ping_request(TCP_Client_Connection *con);
  */
 int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, uint16_t length)
 {
-    if (con_id >= NUM_CLIENT_CONNECTIONS)
+    if (con_id >= NUM_CLIENT_CONNECTIONS) {
         return -1;
+    }
 
-    if (con->connections[con_id].status != 2)
+    if (con->connections[con_id].status != 2) {
         return -1;
+    }
 
-    if (send_ping_response(con) == 0 || send_ping_request(con) == 0)
+    if (tcp_send_ping_response(con) == 0 || tcp_send_ping_request(con) == 0) {
         return 0;
+    }
 
-    uint8_t packet[1 + length];
+    VLA(uint8_t, packet, 1 + length);
     packet[0] = con_id + NUM_RESERVED_PORTS;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 /* return 1 on success.
@@ -475,14 +550,15 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, u
  */
 int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const uint8_t *data, uint16_t length)
 {
-    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH)
+    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH) {
         return -1;
+    }
 
-    uint8_t packet[1 + crypto_box_PUBLICKEYBYTES + length];
+    VLA(uint8_t, packet, 1 + CRYPTO_PUBLIC_KEY_SIZE + length);
     packet[0] = TCP_PACKET_OOB_SEND;
-    memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
+    memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, data, length);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 
@@ -495,25 +571,27 @@ int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const
  */
 int set_tcp_connection_number(TCP_Client_Connection *con, uint8_t con_id, uint32_t number)
 {
-    if (con_id >= NUM_CLIENT_CONNECTIONS)
+    if (con_id >= NUM_CLIENT_CONNECTIONS) {
         return -1;
+    }
 
-    if (con->connections[con_id].status == 0)
+    if (con->connections[con_id].status == 0) {
         return -1;
+    }
 
     con->connections[con_id].number = number;
     return 0;
 }
 
 void routing_data_handler(TCP_Client_Connection *con, int (*data_callback)(void *object, uint32_t number,
-                          uint8_t connection_id, const uint8_t *data, uint16_t length), void *object)
+                          uint8_t connection_id, const uint8_t *data, uint16_t length, void *userdata), void *object)
 {
     con->data_callback = data_callback;
     con->data_callback_object = object;
 }
 
 void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, const uint8_t *public_key,
-                      const uint8_t *data, uint16_t length), void *object)
+                      const uint8_t *data, uint16_t length, void *userdata), void *object)
 {
     con->oob_data_callback = oob_data_callback;
     con->oob_data_callback_object = object;
@@ -523,29 +601,30 @@ void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
+static int client_send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
 {
     uint8_t packet[1 + 1];
     packet[0] = TCP_PACKET_DISCONNECT_NOTIFICATION;
     packet[1] = id;
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
+    return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
 }
 
 /* return 1 on success.
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_request(TCP_Client_Connection *con)
+static int tcp_send_ping_request(TCP_Client_Connection *con)
 {
-    if (!con->ping_request_id)
+    if (!con->ping_request_id) {
         return 1;
+    }
 
     uint8_t packet[1 + sizeof(uint64_t)];
     packet[0] = TCP_PACKET_PING;
     memcpy(packet + 1, &con->ping_request_id, sizeof(uint64_t));
     int ret;
 
-    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+    if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
         con->ping_request_id = 0;
     }
 
@@ -556,17 +635,18 @@ static int send_ping_request(TCP_Client_Connection *con)
  * return 0 if could not send packet.
  * return -1 on failure (connection must be killed).
  */
-static int send_ping_response(TCP_Client_Connection *con)
+static int tcp_send_ping_response(TCP_Client_Connection *con)
 {
-    if (!con->ping_response_id)
+    if (!con->ping_response_id) {
         return 1;
+    }
 
     uint8_t packet[1 + sizeof(uint64_t)];
     packet[0] = TCP_PACKET_PONG;
     memcpy(packet + 1, &con->ping_response_id, sizeof(uint64_t));
     int ret;
 
-    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
+    if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
         con->ping_response_id = 0;
     }
 
@@ -579,12 +659,13 @@ static int send_ping_response(TCP_Client_Connection *con)
  */
 int send_disconnect_request(TCP_Client_Connection *con, uint8_t con_id)
 {
-    if (con_id >= NUM_CLIENT_CONNECTIONS)
+    if (con_id >= NUM_CLIENT_CONNECTIONS) {
         return -1;
+    }
 
     con->connections[con_id].status = 0;
     con->connections[con_id].number = 0;
-    return send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
+    return client_send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
 }
 
 /* return 1 on success.
@@ -593,14 +674,14 @@ int send_disconnect_request(TCP_Client_Connection *con, uint8_t con_id)
  */
 int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t length)
 {
-    uint8_t packet[1 + length];
+    VLA(uint8_t, packet, 1 + length);
     packet[0] = TCP_PACKET_ONION_REQUEST;
     memcpy(packet + 1, data, length);
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0);
+    return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
 }
 
 void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
-                            uint16_t length), void *object)
+                            uint16_t length, void *userdata), void *object)
 {
     con->onion_callback = onion_callback;
     con->onion_callback_object = object;
@@ -612,51 +693,52 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
         const uint8_t *self_secret_key, TCP_Proxy_Info *proxy_info)
 {
     if (networking_at_startup() != 0) {
-        return NULL;
+        return nullptr;
     }
 
-    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
-        return NULL;
-
-    uint8_t family = ip_port.ip.family;
+    if (!net_family_is_ipv4(ip_port.ip.family) && !net_family_is_ipv6(ip_port.ip.family)) {
+        return nullptr;
+    }
 
     TCP_Proxy_Info default_proxyinfo;
 
-    if (proxy_info == NULL) {
+    if (proxy_info == nullptr) {
         default_proxyinfo.proxy_type = TCP_PROXY_NONE;
         proxy_info = &default_proxyinfo;
     }
 
+    Family family = ip_port.ip.family;
+
     if (proxy_info->proxy_type != TCP_PROXY_NONE) {
         family = proxy_info->ip_port.ip.family;
     }
 
-    sock_t sock = socket(family, SOCK_STREAM, IPPROTO_TCP);
+    Socket sock = net_socket(family, TOX_SOCK_STREAM, TOX_PROTO_TCP);
 
     if (!sock_valid(sock)) {
-        return NULL;
+        return nullptr;
     }
 
     if (!set_socket_nosigpipe(sock)) {
         kill_sock(sock);
-        return 0;
+        return nullptr;
     }
 
     if (!(set_socket_nonblock(sock) && connect_sock_to(sock, ip_port, proxy_info))) {
         kill_sock(sock);
-        return NULL;
+        return nullptr;
     }
 
-    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) {
+    if (temp == nullptr) {
         kill_sock(sock);
-        return NULL;
+        return nullptr;
     }
 
     temp->sock = sock;
-    memcpy(temp->public_key, public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(temp->self_public_key, self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(temp->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(temp->self_public_key, self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     encrypt_precompute(temp->public_key, self_secret_key, temp->shared_key);
     temp->ip_port = ip_port;
     temp->proxy_info = *proxy_info;
@@ -678,7 +760,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
             if (generate_handshake(temp) == -1) {
                 kill_sock(sock);
                 free(temp);
-                return NULL;
+                return nullptr;
             }
 
             break;
@@ -692,93 +774,109 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
 /* return 0 on success
  * return -1 on failure
  */
-static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length)
+static int handle_TCP_client_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length <= 1)
+    if (length <= 1) {
         return -1;
+    }
 
     switch (data[0]) {
         case TCP_PACKET_ROUTING_RESPONSE: {
-            if (length != 1 + 1 + crypto_box_PUBLICKEYBYTES)
+            if (length != 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE) {
                 return -1;
+            }
 
-            if (data[1] < NUM_RESERVED_PORTS)
+            if (data[1] < NUM_RESERVED_PORTS) {
                 return 0;
+            }
 
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
-            if (conn->connections[con_id].status != 0)
+            if (conn->connections[con_id].status != 0) {
                 return 0;
+            }
 
             conn->connections[con_id].status = 1;
             conn->connections[con_id].number = ~0;
-            memcpy(conn->connections[con_id].public_key, data + 2, crypto_box_PUBLICKEYBYTES);
+            memcpy(conn->connections[con_id].public_key, data + 2, CRYPTO_PUBLIC_KEY_SIZE);
 
-            if (conn->response_callback)
+            if (conn->response_callback) {
                 conn->response_callback(conn->response_callback_object, con_id, conn->connections[con_id].public_key);
+            }
 
             return 0;
         }
 
         case TCP_PACKET_CONNECTION_NOTIFICATION: {
-            if (length != 1 + 1)
+            if (length != 1 + 1) {
                 return -1;
+            }
 
-            if (data[1] < NUM_RESERVED_PORTS)
+            if (data[1] < NUM_RESERVED_PORTS) {
                 return -1;
+            }
 
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
-            if (conn->connections[con_id].status != 1)
+            if (conn->connections[con_id].status != 1) {
                 return 0;
+            }
 
             conn->connections[con_id].status = 2;
 
-            if (conn->status_callback)
+            if (conn->status_callback) {
                 conn->status_callback(conn->status_callback_object, conn->connections[con_id].number, con_id,
                                       conn->connections[con_id].status);
+            }
 
             return 0;
         }
 
         case TCP_PACKET_DISCONNECT_NOTIFICATION: {
-            if (length != 1 + 1)
+            if (length != 1 + 1) {
                 return -1;
+            }
 
-            if (data[1] < NUM_RESERVED_PORTS)
+            if (data[1] < NUM_RESERVED_PORTS) {
                 return -1;
+            }
 
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
-            if (conn->connections[con_id].status == 0)
+            if (conn->connections[con_id].status == 0) {
                 return 0;
+            }
 
-            if (conn->connections[con_id].status != 2)
+            if (conn->connections[con_id].status != 2) {
                 return 0;
+            }
 
             conn->connections[con_id].status = 1;
 
-            if (conn->status_callback)
+            if (conn->status_callback) {
                 conn->status_callback(conn->status_callback_object, conn->connections[con_id].number, con_id,
                                       conn->connections[con_id].status);
+            }
 
             return 0;
         }
 
         case TCP_PACKET_PING: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
             conn->ping_response_id = ping_id;
-            send_ping_response(conn);
+            tcp_send_ping_response(conn);
             return 0;
         }
 
         case TCP_PACKET_PONG: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
@@ -789,58 +887,64 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
                 }
 
                 return 0;
-            } else {
-                return -1;
             }
+
+            return -1;
         }
 
         case TCP_PACKET_OOB_RECV: {
-            if (length <= 1 + crypto_box_PUBLICKEYBYTES)
+            if (length <= 1 + CRYPTO_PUBLIC_KEY_SIZE) {
                 return -1;
+            }
 
-            if (conn->oob_data_callback)
-                conn->oob_data_callback(conn->oob_data_callback_object, data + 1, data + 1 + crypto_box_PUBLICKEYBYTES,
-                                        length - (1 + crypto_box_PUBLICKEYBYTES));
+            if (conn->oob_data_callback) {
+                conn->oob_data_callback(conn->oob_data_callback_object, data + 1, data + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                        length - (1 + CRYPTO_PUBLIC_KEY_SIZE), userdata);
+            }
 
             return 0;
         }
 
         case TCP_PACKET_ONION_RESPONSE: {
-            conn->onion_callback(conn->onion_callback_object, data + 1, length - 1);
+            conn->onion_callback(conn->onion_callback_object, data + 1, length - 1, userdata);
             return 0;
         }
 
         default: {
-            if (data[0] < NUM_RESERVED_PORTS)
+            if (data[0] < NUM_RESERVED_PORTS) {
                 return -1;
+            }
 
             uint8_t con_id = data[0] - NUM_RESERVED_PORTS;
 
-            if (conn->data_callback)
-                conn->data_callback(conn->data_callback_object, conn->connections[con_id].number, con_id, data + 1, length - 1);
+            if (conn->data_callback) {
+                conn->data_callback(conn->data_callback_object, conn->connections[con_id].number, con_id, data + 1, length - 1,
+                                    userdata);
+            }
         }
     }
 
     return 0;
 }
 
-static int do_confirmed_TCP(TCP_Client_Connection *conn)
+static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
 {
-    send_pending_data(conn);
-    send_ping_response(conn);
-    send_ping_request(conn);
+    client_send_pending_data(conn);
+    tcp_send_ping_response(conn);
+    tcp_send_ping_request(conn);
 
     uint8_t packet[MAX_PACKET_SIZE];
     int len;
 
     if (is_timeout(conn->last_pinged, TCP_PING_FREQUENCY)) {
-        uint64_t ping_id = random_64b();
+        uint64_t ping_id = random_u64();
 
-        if (!ping_id)
+        if (!ping_id) {
             ++ping_id;
+        }
 
         conn->ping_request_id = conn->ping_id = ping_id;
-        send_ping_request(conn);
+        tcp_send_ping_request(conn);
         conn->last_pinged = unix_time();
     }
 
@@ -856,7 +960,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn)
             break;
         }
 
-        if (handle_TCP_packet(conn, packet, len) == -1) {
+        if (handle_TCP_client_packet(conn, packet, len, userdata) == -1) {
             conn->status = TCP_CLIENT_DISCONNECTED;
             break;
         }
@@ -867,7 +971,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn)
 
 /* Run the TCP connection
  */
-void do_TCP_connection(TCP_Client_Connection *TCP_connection)
+void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
 {
     unix_time_update();
 
@@ -876,7 +980,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_HTTP_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = proxy_http_read_connection_response(TCP_connection);
 
             if (ret == -1) {
@@ -892,7 +996,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = socks5_read_handshake_response(TCP_connection);
 
             if (ret == -1) {
@@ -908,7 +1012,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
     }
 
     if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             int ret = proxy_socks5_read_connection_response(TCP_connection);
 
             if (ret == -1) {
@@ -924,7 +1028,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
     }
 
     if (TCP_connection->status == TCP_CLIENT_CONNECTING) {
-        if (send_pending_data(TCP_connection) == 0) {
+        if (client_send_pending_data(TCP_connection) == 0) {
             TCP_connection->status = TCP_CLIENT_UNCONFIRMED;
         }
     }
@@ -945,7 +1049,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
     }
 
     if (TCP_connection->status == TCP_CLIENT_CONFIRMED) {
-        do_confirmed_TCP(TCP_connection);
+        do_confirmed_TCP(TCP_connection, userdata);
     }
 
     if (TCP_connection->kill_at <= unix_time()) {
@@ -957,11 +1061,12 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
  */
 void kill_TCP_connection(TCP_Client_Connection *TCP_connection)
 {
-    if (TCP_connection == NULL)
+    if (TCP_connection == nullptr) {
         return;
+    }
 
     wipe_priority_list(TCP_connection);
     kill_sock(TCP_connection->sock);
-    sodium_memzero(TCP_connection, sizeof(TCP_Client_Connection));
+    crypto_memzero(TCP_connection, sizeof(TCP_Client_Connection));
     free(TCP_connection);
 }
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index 722430e0..96e04d67 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -1,31 +1,31 @@
 /*
-* TCP_client.h -- Implementation of the TCP relay client part of Tox.
-*
-*  Copyright (C) 2014 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
-
+ * Implementation of the TCP relay client part of Tox.
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifndef TCP_CLIENT_H
 #define TCP_CLIENT_H
 
-#include "crypto_core.h"
 #include "TCP_server.h"
+#include "crypto_core.h"
 
 #define TCP_CONNECTION_TIMEOUT 10
 
@@ -40,7 +40,7 @@ typedef struct {
     uint8_t proxy_type; // a value from TCP_PROXY_TYPE
 } TCP_Proxy_Info;
 
-enum {
+typedef enum {
     TCP_CLIENT_NO_STATUS,
     TCP_CLIENT_PROXY_HTTP_CONNECTING,
     TCP_CLIENT_PROXY_SOCKS5_CONNECTING,
@@ -49,56 +49,17 @@ enum {
     TCP_CLIENT_UNCONFIRMED,
     TCP_CLIENT_CONFIRMED,
     TCP_CLIENT_DISCONNECTED,
-};
-typedef struct  {
-    uint8_t status;
-    sock_t  sock;
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; /* our public key */
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* public key of the server */
-    IP_Port ip_port; /* The ip and port of the server */
-    TCP_Proxy_Info proxy_info;
-    uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* Nonce of received packets. */
-    uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* Nonce of sent packets. */
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    uint16_t next_packet_length;
-
-    uint8_t temp_secret_key[crypto_box_SECRETKEYBYTES];
-
-    uint8_t last_packet[2 + MAX_PACKET_SIZE];
-    uint16_t last_packet_length;
-    uint16_t last_packet_sent;
-
-    TCP_Priority_List *priority_queue_start, *priority_queue_end;
-
-    uint64_t kill_at;
-
-    uint64_t last_pinged;
-    uint64_t ping_id;
-
-    uint64_t ping_response_id;
-    uint64_t ping_request_id;
-
-    struct {
-        uint8_t status; /* 0 if not used, 1 if other is offline, 2 if other is online. */
-        uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-        uint32_t number;
-    } connections[NUM_CLIENT_CONNECTIONS];
-    int (*response_callback)(void *object, uint8_t connection_id, const uint8_t *public_key);
-    void *response_callback_object;
-    int (*status_callback)(void *object, uint32_t number, uint8_t connection_id, uint8_t status);
-    void *status_callback_object;
-    int (*data_callback)(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length);
-    void *data_callback_object;
-    int (*oob_data_callback)(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length);
-    void *oob_data_callback_object;
-
-    int (*onion_callback)(void *object, const uint8_t *data, uint16_t length);
-    void *onion_callback_object;
-
-    /* Can be used by user. */
-    void *custom_object;
-    uint32_t custom_uint;
-} TCP_Client_Connection;
+} TCP_CLIENT_STATUS;
+typedef struct TCP_Client_Connection TCP_Client_Connection;
+
+const uint8_t *tcp_con_public_key(const TCP_Client_Connection *con);
+IP_Port tcp_con_ip_port(const TCP_Client_Connection *con);
+TCP_CLIENT_STATUS tcp_con_status(const TCP_Client_Connection *con);
+
+void *tcp_con_custom_object(const TCP_Client_Connection *con);
+uint32_t tcp_con_custom_uint(const TCP_Client_Connection *con);
+void tcp_con_set_custom_object(TCP_Client_Connection *con, void *object);
+void tcp_con_set_custom_uint(TCP_Client_Connection *con, uint32_t uint);
 
 /* Create new TCP connection to ip_port/public_key
  */
@@ -107,7 +68,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
 
 /* Run the TCP connection
  */
-void do_TCP_connection(TCP_Client_Connection *TCP_connection);
+void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata);
 
 /* Kill the TCP connection
  */
@@ -119,7 +80,7 @@ void kill_TCP_connection(TCP_Client_Connection *TCP_connection);
  */
 int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t length);
 void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
-                            uint16_t length), void *object);
+                            uint16_t length, void *userdata), void *object);
 
 /* return 1 on success.
  * return 0 if could not send packet.
@@ -152,7 +113,7 @@ int set_tcp_connection_number(TCP_Client_Connection *con, uint8_t con_id, uint32
  */
 int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, uint16_t length);
 void routing_data_handler(TCP_Client_Connection *con, int (*data_callback)(void *object, uint32_t number,
-                          uint8_t connection_id, const uint8_t *data, uint16_t length), void *object);
+                          uint8_t connection_id, const uint8_t *data, uint16_t length, void *userdata), void *object);
 
 /* return 1 on success.
  * return 0 if could not send packet.
@@ -160,7 +121,7 @@ void routing_data_handler(TCP_Client_Connection *con, int (*data_callback)(void
  */
 int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const uint8_t *data, uint16_t length);
 void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, const uint8_t *public_key,
-                      const uint8_t *data, uint16_t length), void *object);
+                      const uint8_t *data, uint16_t length, void *userdata), void *object);
 
 
 #endif
diff --git a/toxcore/TCP_connection.c b/toxcore/TCP_connection.c
index 027779dd..06cb6e34 100644
--- a/toxcore/TCP_connection.c
+++ b/toxcore/TCP_connection.c
@@ -1,54 +1,119 @@
-/* TCP_connection.c
- *
+/*
  * Handles TCP relay connections between two Tox clients.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2015 Tox project.
  *
- *  Copyright (C) 2015 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "TCP_connection.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
 
+
+struct TCP_Connections {
+    DHT *dht;
+
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    TCP_Connection_to *connections;
+    uint32_t connections_length; /* Length of connections array. */
+
+    TCP_con *tcp_connections;
+    uint32_t tcp_connections_length; /* Length of tcp_connections array. */
+
+    int (*tcp_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata);
+    void *tcp_data_callback_object;
+
+    int (*tcp_oob_callback)(void *object, const uint8_t *public_key, unsigned int tcp_connections_number,
+                            const uint8_t *data, uint16_t length, void *userdata);
+    void *tcp_oob_callback_object;
+
+    int (*tcp_onion_callback)(void *object, const uint8_t *data, uint16_t length, void *userdata);
+    void *tcp_onion_callback_object;
+
+    TCP_Proxy_Info proxy_info;
+
+    bool onion_status;
+    uint16_t onion_num_conns;
+};
+
+
+const uint8_t *tcp_connections_public_key(const TCP_Connections *tcp_c)
+{
+    return tcp_c->self_public_key;
+}
+
+
 /* Set the size of the array to num.
  *
  *  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 MAKE_REALLOC(T)                                         \
+static int realloc_##T(T **array, size_t num)                   \
+{                                                               \
+    if (!num) {                                                 \
+        free(*array);                                           \
+        *array = nullptr;                                       \
+        return 0;                                               \
+    }                                                           \
+                                                                \
+    T *temp_pointer = (T *)realloc(*array, num * sizeof(T));    \
+                                                                \
+    if (!temp_pointer) {                                        \
+        return -1;                                              \
+    }                                                           \
+                                                                \
+    *array = temp_pointer;                                      \
+                                                                \
+    return 0;                                                   \
+}
+
+MAKE_REALLOC(TCP_Connection_to)
+MAKE_REALLOC(TCP_con)
 
 
 /* return 1 if the connections_number is not valid.
  * return 0 if the connections_number is valid.
  */
-static _Bool connections_number_not_valid(const TCP_Connections *tcp_c, int connections_number)
+static bool connections_number_not_valid(const TCP_Connections *tcp_c, int connections_number)
 {
-    if ((unsigned int)connections_number >= tcp_c->connections_length)
+    if ((unsigned int)connections_number >= tcp_c->connections_length) {
         return 1;
+    }
 
-    if (tcp_c->connections == NULL)
+    if (tcp_c->connections == nullptr) {
         return 1;
+    }
 
-    if (tcp_c->connections[connections_number].status == TCP_CONN_NONE)
+    if (tcp_c->connections[connections_number].status == TCP_CONN_NONE) {
         return 1;
+    }
 
     return 0;
 }
@@ -56,16 +121,19 @@ static _Bool connections_number_not_valid(const TCP_Connections *tcp_c, int conn
 /* return 1 if the tcp_connections_number is not valid.
  * return 0 if the tcp_connections_number is valid.
  */
-static _Bool tcp_connections_number_not_valid(const TCP_Connections *tcp_c, int tcp_connections_number)
+static bool tcp_connections_number_not_valid(const TCP_Connections *tcp_c, int tcp_connections_number)
 {
-    if ((unsigned int)tcp_connections_number >= tcp_c->tcp_connections_length)
+    if ((unsigned int)tcp_connections_number >= tcp_c->tcp_connections_length) {
         return 1;
+    }
 
-    if (tcp_c->tcp_connections == NULL)
+    if (tcp_c->tcp_connections == nullptr) {
         return 1;
+    }
 
-    if (tcp_c->tcp_connections[tcp_connections_number].status == TCP_CONN_NONE)
+    if (tcp_c->tcp_connections[tcp_connections_number].status == TCP_CONN_NONE) {
         return 1;
+    }
 
     return 0;
 }
@@ -80,19 +148,17 @@ static int create_connection(TCP_Connections *tcp_c)
     uint32_t i;
 
     for (i = 0; i < tcp_c->connections_length; ++i) {
-        if (tcp_c->connections[i].status == TCP_CONN_NONE)
+        if (tcp_c->connections[i].status == TCP_CONN_NONE) {
             return i;
+        }
     }
 
     int id = -1;
 
-    TCP_Connection_to *temp_pointer;
-
-    if (realloc_tox_array(tcp_c->connections, sizeof(TCP_Connection_to), tcp_c->connections_length + 1,
-                          temp_pointer) == 0) {
+    if (realloc_TCP_Connection_to(&tcp_c->connections, tcp_c->connections_length + 1) == 0) {
         id = tcp_c->connections_length;
         ++tcp_c->connections_length;
-        memset(&(tcp_c->connections[id]), 0, sizeof(TCP_Connection_to));
+        memset(&tcp_c->connections[id], 0, sizeof(TCP_Connection_to));
     }
 
     return id;
@@ -108,18 +174,17 @@ static int create_tcp_connection(TCP_Connections *tcp_c)
     uint32_t i;
 
     for (i = 0; i < tcp_c->tcp_connections_length; ++i) {
-        if (tcp_c->tcp_connections[i].status == TCP_CONN_NONE)
+        if (tcp_c->tcp_connections[i].status == TCP_CONN_NONE) {
             return i;
+        }
     }
 
     int id = -1;
 
-    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_TCP_con(&tcp_c->tcp_connections, tcp_c->tcp_connections_length + 1) == 0) {
         id = tcp_c->tcp_connections_length;
         ++tcp_c->tcp_connections_length;
-        memset(&(tcp_c->tcp_connections[id]), 0, sizeof(TCP_con));
+        memset(&tcp_c->tcp_connections[id], 0, sizeof(TCP_con));
     }
 
     return id;
@@ -132,21 +197,22 @@ static int create_tcp_connection(TCP_Connections *tcp_c)
  */
 static int wipe_connection(TCP_Connections *tcp_c, int connections_number)
 {
-    if (connections_number_not_valid(tcp_c, connections_number))
+    if (connections_number_not_valid(tcp_c, connections_number)) {
         return -1;
+    }
 
     uint32_t i;
-    memset(&(tcp_c->connections[connections_number]), 0 , sizeof(TCP_Connection_to));
+    memset(&tcp_c->connections[connections_number], 0, sizeof(TCP_Connection_to));
 
     for (i = tcp_c->connections_length; i != 0; --i) {
-        if (tcp_c->connections[i - 1].status != TCP_CONN_NONE)
+        if (tcp_c->connections[i - 1].status != TCP_CONN_NONE) {
             break;
+        }
     }
 
     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_TCP_Connection_to(&tcp_c->connections, tcp_c->connections_length);
     }
 
     return 0;
@@ -159,21 +225,22 @@ static int wipe_connection(TCP_Connections *tcp_c, int connections_number)
  */
 static int wipe_tcp_connection(TCP_Connections *tcp_c, int tcp_connections_number)
 {
-    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number))
+    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number)) {
         return -1;
+    }
 
     uint32_t i;
-    memset(&(tcp_c->tcp_connections[tcp_connections_number]), 0 , sizeof(TCP_con));
+    memset(&tcp_c->tcp_connections[tcp_connections_number], 0, sizeof(TCP_con));
 
     for (i = tcp_c->tcp_connections_length; i != 0; --i) {
-        if (tcp_c->tcp_connections[i - 1].status != TCP_CONN_NONE)
+        if (tcp_c->tcp_connections[i - 1].status != TCP_CONN_NONE) {
             break;
+        }
     }
 
     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_TCP_con(&tcp_c->tcp_connections, tcp_c->tcp_connections_length);
     }
 
     return 0;
@@ -181,16 +248,18 @@ static int wipe_tcp_connection(TCP_Connections *tcp_c, int tcp_connections_numbe
 
 static TCP_Connection_to *get_connection(const TCP_Connections *tcp_c, int connections_number)
 {
-    if (connections_number_not_valid(tcp_c, connections_number))
-        return 0;
+    if (connections_number_not_valid(tcp_c, connections_number)) {
+        return nullptr;
+    }
 
     return &tcp_c->connections[connections_number];
 }
 
 static TCP_con *get_tcp_connection(const TCP_Connections *tcp_c, int tcp_connections_number)
 {
-    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number))
-        return 0;
+    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number)) {
+        return nullptr;
+    }
 
     return &tcp_c->tcp_connections[tcp_connections_number];
 }
@@ -208,12 +277,12 @@ int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, c
         return -1;
     }
 
-    //TODO: detect and kill bad relays.
-    //TODO: thread safety?
+    // TODO(irungentoo): detect and kill bad relays.
+    // TODO(irungentoo): thread safety?
     unsigned int i;
     int ret = -1;
 
-    _Bool limit_reached = 0;
+    bool limit_reached = 0;
 
     for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
         uint32_t tcp_con_num = con_to->connections[i].tcp_connection;
@@ -242,7 +311,9 @@ int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, c
 
     if (ret == 1) {
         return 0;
-    } else if (!limit_reached) {
+    }
+
+    if (!limit_reached) {
         ret = 0;
 
         /* Send oob packets to all relays tied to the connection. */
@@ -266,18 +337,18 @@ int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, c
 
         if (ret >= 1) {
             return 0;
-        } else {
-            return -1;
         }
-    } else {
+
         return -1;
     }
+
+    return -1;
 }
 
 /* Return a random TCP connection number for use in send_tcp_onion_request.
  *
- * TODO: This number is just the index of an array that the elements can
- * change without warning.
+ * TODO(irungentoo): This number is just the index of an array that the elements
+ * can change without warning.
  *
  * return TCP connection number on success.
  * return -1 on failure.
@@ -312,8 +383,9 @@ int tcp_send_onion_request(TCP_Connections *tcp_c, unsigned int tcp_connections_
     if (tcp_c->tcp_connections[tcp_connections_number].status == TCP_CONN_CONNECTED) {
         int ret = send_onion_request(tcp_c->tcp_connections[tcp_connections_number].connection, data, length);
 
-        if (ret == 1)
+        if (ret == 1) {
             return 0;
+        }
     }
 
     return -1;
@@ -329,16 +401,19 @@ int tcp_send_oob_packet(TCP_Connections *tcp_c, unsigned int tcp_connections_num
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    if (tcp_con->status != TCP_CONN_CONNECTED)
+    if (tcp_con->status != TCP_CONN_CONNECTED) {
         return -1;
+    }
 
     int ret = send_oob_packet(tcp_con->connection, public_key, packet, length);
 
-    if (ret == 1)
+    if (ret == 1) {
         return 0;
+    }
 
     return -1;
 }
@@ -346,7 +421,7 @@ int tcp_send_oob_packet(TCP_Connections *tcp_c, unsigned int tcp_connections_num
 /* Set the callback for TCP data packets.
  */
 void set_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_data_callback)(void *object, int id,
-                                        const uint8_t *data, uint16_t length), void *object)
+                                        const uint8_t *data, uint16_t length, void *userdata), void *object)
 {
     tcp_c->tcp_data_callback = tcp_data_callback;
     tcp_c->tcp_data_callback_object = object;
@@ -355,7 +430,8 @@ void set_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_data_c
 /* Set the callback for TCP onion packets.
  */
 void set_oob_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_oob_callback)(void *object,
-        const uint8_t *public_key, unsigned int tcp_connections_number, const uint8_t *data, uint16_t length), void *object)
+        const uint8_t *public_key, unsigned int tcp_connections_number, const uint8_t *data, uint16_t length, void *userdata),
+        void *object)
 {
     tcp_c->tcp_oob_callback = tcp_oob_callback;
     tcp_c->tcp_oob_callback_object = object;
@@ -364,7 +440,7 @@ void set_oob_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_oo
 /* Set the callback for TCP oob data packets.
  */
 void set_onion_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_onion_callback)(void *object,
-        const uint8_t *data, uint16_t length), void *object)
+        const uint8_t *data, uint16_t length, void *userdata), void *object)
 {
     tcp_c->tcp_onion_callback = tcp_onion_callback;
     tcp_c->tcp_onion_callback_object = object;
@@ -411,7 +487,7 @@ static int find_tcp_connection_relay(TCP_Connections *tcp_c, const uint8_t *rela
                     return i;
                 }
             } else {
-                if (public_key_cmp(tcp_con->connection->public_key, relay_pk) == 0) {
+                if (public_key_cmp(tcp_con_public_key(tcp_con->connection), relay_pk) == 0) {
                     return i;
                 }
             }
@@ -432,18 +508,20 @@ static int find_tcp_connection_relay(TCP_Connections *tcp_c, const uint8_t *rela
  */
 int new_tcp_connection_to(TCP_Connections *tcp_c, const uint8_t *public_key, int id)
 {
-    if (find_tcp_connection_to(tcp_c, public_key) != -1)
+    if (find_tcp_connection_to(tcp_c, public_key) != -1) {
         return -1;
+    }
 
     int connections_number = create_connection(tcp_c);
 
-    if (connections_number == -1)
+    if (connections_number == -1) {
         return -1;
+    }
 
     TCP_Connection_to *con_to = &tcp_c->connections[connections_number];
 
     con_to->status = TCP_CONN_VALID;
-    memcpy(con_to->public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(con_to->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     con_to->id = id;
 
     return connections_number;
@@ -456,8 +534,9 @@ int kill_tcp_connection_to(TCP_Connections *tcp_c, int connections_number)
 {
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (!con_to)
+    if (!con_to) {
         return -1;
+    }
 
     unsigned int i;
 
@@ -466,8 +545,9 @@ int kill_tcp_connection_to(TCP_Connections *tcp_c, int connections_number)
             unsigned int tcp_connections_number = con_to->connections[i].tcp_connection - 1;
             TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-            if (!tcp_con)
+            if (!tcp_con) {
                 continue;
+            }
 
             if (tcp_con->status == TCP_CONN_CONNECTED) {
                 send_disconnect_request(tcp_con->connection, con_to->connections[i].connection_id);
@@ -496,17 +576,19 @@ int kill_tcp_connection_to(TCP_Connections *tcp_c, int connections_number)
  * return 0 on success.
  * return -1 on failure.
  */
-int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number, _Bool status)
+int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number, bool status)
 {
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (!con_to)
+    if (!con_to) {
         return -1;
+    }
 
     if (status) {
-        /* Conection is unsleeping. */
-        if (con_to->status != TCP_CONN_SLEEPING)
+        /* Connection is unsleeping. */
+        if (con_to->status != TCP_CONN_SLEEPING) {
             return -1;
+        }
 
         unsigned int i;
 
@@ -515,8 +597,9 @@ int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number,
                 unsigned int tcp_connections_number = con_to->connections[i].tcp_connection - 1;
                 TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-                if (!tcp_con)
+                if (!tcp_con) {
                     continue;
+                }
 
                 if (tcp_con->status == TCP_CONN_SLEEPING) {
                     tcp_con->unsleep = 1;
@@ -526,33 +609,35 @@ int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number,
 
         con_to->status = TCP_CONN_VALID;
         return 0;
-    } else {
-        /* Conection is going to sleep. */
-        if (con_to->status != TCP_CONN_VALID)
-            return -1;
+    }
 
-        unsigned int i;
+    /* Connection is going to sleep. */
+    if (con_to->status != TCP_CONN_VALID) {
+        return -1;
+    }
 
-        for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
-            if (con_to->connections[i].tcp_connection) {
-                unsigned int tcp_connections_number = con_to->connections[i].tcp_connection - 1;
-                TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+    unsigned int i;
 
-                if (!tcp_con)
-                    continue;
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        if (con_to->connections[i].tcp_connection) {
+            unsigned int tcp_connections_number = con_to->connections[i].tcp_connection - 1;
+            TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-                if (con_to->connections[i].status == TCP_CONNECTIONS_STATUS_ONLINE) {
-                    ++tcp_con->sleep_count;
-                }
+            if (!tcp_con) {
+                continue;
             }
-        }
 
-        con_to->status = TCP_CONN_SLEEPING;
-        return 0;
+            if (con_to->connections[i].status == TCP_CONNECTIONS_STATUS_ONLINE) {
+                ++tcp_con->sleep_count;
+            }
+        }
     }
+
+    con_to->status = TCP_CONN_SLEEPING;
+    return 0;
 }
 
-static _Bool tcp_connection_in_conn(TCP_Connection_to *con_to, unsigned int tcp_connections_number)
+static bool tcp_connection_in_conn(TCP_Connection_to *con_to, unsigned int tcp_connections_number)
 {
     unsigned int i;
 
@@ -572,8 +657,9 @@ static int add_tcp_connection_to_conn(TCP_Connection_to *con_to, unsigned int tc
 {
     unsigned int i;
 
-    if (tcp_connection_in_conn(con_to, tcp_connections_number))
+    if (tcp_connection_in_conn(con_to, tcp_connections_number)) {
         return -1;
+    }
 
     for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
         if (con_to->connections[i].tcp_connection == 0) {
@@ -657,8 +743,9 @@ static int kill_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connections
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     unsigned int i;
 
@@ -683,15 +770,17 @@ static int reconnect_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connec
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    if (tcp_con->status == TCP_CONN_SLEEPING)
+    if (tcp_con->status == TCP_CONN_SLEEPING) {
         return -1;
+    }
 
-    IP_Port ip_port = tcp_con->connection->ip_port;
-    uint8_t relay_pk[crypto_box_PUBLICKEYBYTES];
-    memcpy(relay_pk, tcp_con->connection->public_key, crypto_box_PUBLICKEYBYTES);
+    IP_Port ip_port = tcp_con_ip_port(tcp_con->connection);
+    uint8_t relay_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    memcpy(relay_pk, tcp_con_public_key(tcp_con->connection), CRYPTO_PUBLIC_KEY_SIZE);
     kill_TCP_connection(tcp_con->connection);
     tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key,
                           &tcp_c->proxy_info);
@@ -729,20 +818,23 @@ static int sleep_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connection
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    if (tcp_con->status != TCP_CONN_CONNECTED)
+    if (tcp_con->status != TCP_CONN_CONNECTED) {
         return -1;
+    }
 
-    if (tcp_con->lock_count != tcp_con->sleep_count)
+    if (tcp_con->lock_count != tcp_con->sleep_count) {
         return -1;
+    }
 
-    tcp_con->ip_port = tcp_con->connection->ip_port;
-    memcpy(tcp_con->relay_pk, tcp_con->connection->public_key, crypto_box_PUBLICKEYBYTES);
+    tcp_con->ip_port = tcp_con_ip_port(tcp_con->connection);
+    memcpy(tcp_con->relay_pk, tcp_con_public_key(tcp_con->connection), CRYPTO_PUBLIC_KEY_SIZE);
 
     kill_TCP_connection(tcp_con->connection);
-    tcp_con->connection = NULL;
+    tcp_con->connection = nullptr;
 
     unsigned int i;
 
@@ -772,11 +864,13 @@ static int unsleep_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connecti
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    if (tcp_con->status != TCP_CONN_SLEEPING)
+    if (tcp_con->status != TCP_CONN_SLEEPING) {
         return -1;
+    }
 
     tcp_con->connection = new_TCP_connection(tcp_con->ip_port, tcp_con->relay_pk, tcp_c->self_public_key,
                           tcp_c->self_secret_key, &tcp_c->proxy_info);
@@ -803,41 +897,48 @@ static int send_tcp_relay_routing_request(TCP_Connections *tcp_c, int tcp_connec
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    if (tcp_con->status == TCP_CONN_SLEEPING)
+    if (tcp_con->status == TCP_CONN_SLEEPING) {
         return -1;
+    }
 
-    if (send_routing_request(tcp_con->connection, public_key) != 1)
+    if (send_routing_request(tcp_con->connection, public_key) != 1) {
         return -1;
+    }
 
     return 0;
 }
 
 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_con_custom_object(TCP_client_con);
 
-    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    unsigned int tcp_connections_number = tcp_con_custom_uint(TCP_client_con);
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     int connections_number = find_tcp_connection_to(tcp_c, public_key);
 
-    if (connections_number == -1)
+    if (connections_number == -1) {
         return -1;
+    }
 
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (con_to == NULL)
+    if (con_to == nullptr) {
         return -1;
+    }
 
-    if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1)
+    if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1) {
         return -1;
+    }
 
     set_tcp_connection_number(tcp_con->connection, connection_id, connections_number);
 
@@ -846,19 +947,21 @@ 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_con_custom_object(TCP_client_con);
 
-    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    unsigned int tcp_connections_number = tcp_con_custom_uint(TCP_client_con);
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
     TCP_Connection_to *con_to = get_connection(tcp_c, number);
 
-    if (!con_to || !tcp_con)
+    if (!con_to || !tcp_con) {
         return -1;
+    }
 
     if (status == 1) {
-        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1)
+        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1) {
             return -1;
+        }
 
         --tcp_con->lock_count;
 
@@ -866,8 +969,9 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
             --tcp_con->sleep_count;
         }
     } else if (status == 2) {
-        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_ONLINE, connection_id) == -1)
+        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_ONLINE, connection_id) == -1) {
             return -1;
+        }
 
         ++tcp_con->lock_count;
 
@@ -879,67 +983,76 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
     return 0;
 }
 
-static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length)
+static int tcp_conn_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data,
+                                  uint16_t length, void *userdata)
 {
-
-    if (length == 0)
+    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_con_custom_object(TCP_client_con);
 
-    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    unsigned int tcp_connections_number = tcp_con_custom_uint(TCP_client_con);
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     TCP_Connection_to *con_to = get_connection(tcp_c, number);
 
-    if (!con_to)
+    if (!con_to) {
         return -1;
+    }
 
-    if (tcp_c->tcp_data_callback)
-        tcp_c->tcp_data_callback(tcp_c->tcp_data_callback_object, con_to->id, data, length);
+    if (tcp_c->tcp_data_callback) {
+        tcp_c->tcp_data_callback(tcp_c->tcp_data_callback_object, con_to->id, data, length, userdata);
+    }
 
     return 0;
 }
 
-static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length)
+static int tcp_conn_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
+                                 void *userdata)
 {
-    if (length == 0)
+    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_con_custom_object(TCP_client_con);
 
-    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    unsigned int tcp_connections_number = tcp_con_custom_uint(TCP_client_con);
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
-    /* TODO: optimize */
+    /* TODO(irungentoo): optimize */
     int connections_number = find_tcp_connection_to(tcp_c, public_key);
 
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
     if (con_to && tcp_connection_in_conn(con_to, tcp_connections_number)) {
-        return tcp_data_callback(object, connections_number, 0, data, length);
-    } else {
-        if (tcp_c->tcp_oob_callback)
-            tcp_c->tcp_oob_callback(tcp_c->tcp_oob_callback_object, public_key, tcp_connections_number, data, length);
+        return tcp_conn_data_callback(object, connections_number, 0, data, length, userdata);
+    }
+
+    if (tcp_c->tcp_oob_callback) {
+        tcp_c->tcp_oob_callback(tcp_c->tcp_oob_callback_object, public_key, tcp_connections_number, data, length, userdata);
     }
 
     return 0;
 }
 
-static int tcp_onion_callback(void *object, const uint8_t *data, uint16_t length)
+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);
+    if (tcp_c->tcp_onion_callback) {
+        tcp_c->tcp_onion_callback(tcp_c->tcp_onion_callback_object, data, length, userdata);
+    }
 
     return 0;
 }
@@ -953,18 +1066,19 @@ static int tcp_relay_set_callbacks(TCP_Connections *tcp_c, int tcp_connections_n
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     TCP_Client_Connection *con = tcp_con->connection;
 
-    con->custom_object = tcp_c;
-    con->custom_uint = tcp_connections_number;
+    tcp_con_set_custom_object(con, tcp_c);
+    tcp_con_set_custom_uint(con, tcp_connections_number);
     onion_response_handler(con, &tcp_onion_callback, tcp_c);
     routing_response_handler(con, &tcp_response_callback, con);
     routing_status_handler(con, &tcp_status_callback, con);
-    routing_data_handler(con, &tcp_data_callback, con);
-    oob_data_handler(con, &tcp_oob_callback, con);
+    routing_data_handler(con, &tcp_conn_data_callback, con);
+    oob_data_handler(con, &tcp_conn_oob_callback, con);
 
     return 0;
 }
@@ -973,8 +1087,9 @@ static int tcp_relay_on_online(TCP_Connections *tcp_c, int tcp_connections_numbe
 {
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     unsigned int i, sent = 0;
 
@@ -1010,28 +1125,30 @@ static int tcp_relay_on_online(TCP_Connections *tcp_c, int tcp_connections_numbe
 
 static int add_tcp_relay_instance(TCP_Connections *tcp_c, IP_Port ip_port, const uint8_t *relay_pk)
 {
-    if (ip_port.ip.family == TCP_INET) {
-        ip_port.ip.family = AF_INET;
-    } else if (ip_port.ip.family == TCP_INET6) {
-        ip_port.ip.family = AF_INET6;
+    if (net_family_is_tcp_ipv4(ip_port.ip.family)) {
+        ip_port.ip.family = net_family_ipv4;
+    } else if (net_family_is_tcp_ipv6(ip_port.ip.family)) {
+        ip_port.ip.family = net_family_ipv6;
     }
 
-    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+    if (!net_family_is_ipv4(ip_port.ip.family) && !net_family_is_ipv6(ip_port.ip.family)) {
         return -1;
+    }
 
     int tcp_connections_number = create_tcp_connection(tcp_c);
 
-    if (tcp_connections_number == -1)
+    if (tcp_connections_number == -1) {
         return -1;
+    }
 
     TCP_con *tcp_con = &tcp_c->tcp_connections[tcp_connections_number];
 
-
     tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key,
                           &tcp_c->proxy_info);
 
-    if (!tcp_con->connection)
+    if (!tcp_con->connection) {
         return -1;
+    }
 
     tcp_con->status = TCP_CONN_VALID;
 
@@ -1047,11 +1164,13 @@ int add_tcp_relay_global(TCP_Connections *tcp_c, IP_Port ip_port, const uint8_t
 {
     int tcp_connections_number = find_tcp_connection_relay(tcp_c, relay_pk);
 
-    if (tcp_connections_number != -1)
+    if (tcp_connections_number != -1) {
         return -1;
+    }
 
-    if (add_tcp_relay_instance(tcp_c, ip_port, relay_pk) == -1)
+    if (add_tcp_relay_instance(tcp_c, ip_port, relay_pk) == -1) {
         return -1;
+    }
 
     return 0;
 }
@@ -1065,20 +1184,23 @@ int add_tcp_number_relay_connection(TCP_Connections *tcp_c, int connections_numb
 {
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (!con_to)
+    if (!con_to) {
         return -1;
+    }
 
     TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-    if (!tcp_con)
+    if (!tcp_con) {
         return -1;
+    }
 
     if (con_to->status != TCP_CONN_SLEEPING && tcp_con->status == TCP_CONN_SLEEPING) {
         tcp_con->unsleep = 1;
     }
 
-    if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1)
+    if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1) {
         return -1;
+    }
 
     if (tcp_con->status == TCP_CONN_CONNECTED) {
         if (send_tcp_relay_routing_request(tcp_c, tcp_connections_number, con_to->public_key) == 0) {
@@ -1100,31 +1222,33 @@ int add_tcp_relay_connection(TCP_Connections *tcp_c, int connections_number, IP_
 {
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (!con_to)
+    if (!con_to) {
         return -1;
+    }
 
     int tcp_connections_number = find_tcp_connection_relay(tcp_c, relay_pk);
 
     if (tcp_connections_number != -1) {
         return add_tcp_number_relay_connection(tcp_c, connections_number, tcp_connections_number);
-    } else {
-        if (online_tcp_connection_from_conn(con_to) >= RECOMMENDED_FRIEND_TCP_CONNECTIONS) {
-            return -1;
-        }
+    }
 
-        int tcp_connections_number = add_tcp_relay_instance(tcp_c, ip_port, relay_pk);
+    if (online_tcp_connection_from_conn(con_to) >= RECOMMENDED_FRIEND_TCP_CONNECTIONS) {
+        return -1;
+    }
 
-        TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+    tcp_connections_number = add_tcp_relay_instance(tcp_c, ip_port, relay_pk);
 
-        if (!tcp_con)
-            return -1;
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
 
-        if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1) {
-            return -1;
-        }
+    if (!tcp_con) {
+        return -1;
+    }
 
-        return 0;
+    if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1) {
+        return -1;
     }
+
+    return 0;
 }
 
 /* return number of online tcp relays tied to the connection on success.
@@ -1134,8 +1258,9 @@ unsigned int tcp_connection_to_online_tcp_relays(TCP_Connections *tcp_c, int con
 {
     TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
 
-    if (!con_to)
+    if (!con_to) {
         return 0;
+    }
 
     return online_tcp_connection_from_conn(con_to);
 }
@@ -1158,13 +1283,15 @@ unsigned int tcp_copy_connected_relays(TCP_Connections *tcp_c, Node_format *tcp_
         }
 
         if (tcp_con->status == TCP_CONN_CONNECTED) {
-            memcpy(tcp_relays[copied].public_key, tcp_con->connection->public_key, crypto_box_PUBLICKEYBYTES);
-            tcp_relays[copied].ip_port = tcp_con->connection->ip_port;
+            memcpy(tcp_relays[copied].public_key, tcp_con_public_key(tcp_con->connection), CRYPTO_PUBLIC_KEY_SIZE);
+            tcp_relays[copied].ip_port = tcp_con_ip_port(tcp_con->connection);
+
+            Family *const family = &tcp_relays[copied].ip_port.ip.family;
 
-            if (tcp_relays[copied].ip_port.ip.family == AF_INET) {
-                tcp_relays[copied].ip_port.ip.family = TCP_INET;
-            } else if (tcp_relays[copied].ip_port.ip.family == AF_INET6) {
-                tcp_relays[copied].ip_port.ip.family = TCP_INET6;
+            if (net_family_is_ipv4(*family)) {
+                *family = net_family_tcp_ipv4;
+            } else if (net_family_is_ipv6(*family)) {
+                *family = net_family_tcp_ipv6;
             }
 
             ++copied;
@@ -1181,10 +1308,11 @@ unsigned int tcp_copy_connected_relays(TCP_Connections *tcp_c, Node_format *tcp_
  * return 0 on success.
  * return -1 on failure.
  */
-int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status)
+int set_tcp_onion_status(TCP_Connections *tcp_c, bool status)
 {
-    if (tcp_c->onion_status == status)
+    if (tcp_c->onion_status == status) {
         return -1;
+    }
 
     if (status) {
         unsigned int i;
@@ -1199,8 +1327,9 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status)
                 }
             }
 
-            if (tcp_c->onion_num_conns >= NUM_ONION_TCP_CONNECTIONS)
+            if (tcp_c->onion_num_conns >= NUM_ONION_TCP_CONNECTIONS) {
                 break;
+            }
         }
 
         if (tcp_c->onion_num_conns < NUM_ONION_TCP_CONNECTIONS) {
@@ -1215,8 +1344,9 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status)
                     }
                 }
 
-                if (!wakeup)
+                if (!wakeup) {
                     break;
+                }
             }
         }
 
@@ -1250,22 +1380,24 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status)
  */
 TCP_Connections *new_tcp_connections(const uint8_t *secret_key, TCP_Proxy_Info *proxy_info)
 {
-    if (secret_key == NULL)
-        return NULL;
+    if (secret_key == nullptr) {
+        return nullptr;
+    }
 
-    TCP_Connections *temp = calloc(1, sizeof(TCP_Connections));
+    TCP_Connections *temp = (TCP_Connections *)calloc(1, sizeof(TCP_Connections));
 
-    if (temp == NULL)
-        return NULL;
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
-    memcpy(temp->self_secret_key, secret_key, crypto_box_SECRETKEYBYTES);
-    crypto_scalarmult_curve25519_base(temp->self_public_key, temp->self_secret_key);
+    memcpy(temp->self_secret_key, secret_key, CRYPTO_SECRET_KEY_SIZE);
+    crypto_derive_public_key(temp->self_public_key, temp->self_secret_key);
     temp->proxy_info = *proxy_info;
 
     return temp;
 }
 
-static void do_tcp_conns(TCP_Connections *tcp_c)
+static void do_tcp_conns(TCP_Connections *tcp_c, void *userdata)
 {
     unsigned int i;
 
@@ -1274,12 +1406,15 @@ static void do_tcp_conns(TCP_Connections *tcp_c)
 
         if (tcp_con) {
             if (tcp_con->status != TCP_CONN_SLEEPING) {
-                do_TCP_connection(tcp_con->connection);
+                do_TCP_connection(tcp_con->connection, userdata);
 
                 /* callbacks can change TCP connection address. */
                 tcp_con = get_tcp_connection(tcp_c, i);
 
-                if (tcp_con->connection->status == TCP_CLIENT_DISCONNECTED) {
+                // Make sure the TCP connection wasn't dropped in any of the callbacks.
+                assert(tcp_con != nullptr);
+
+                if (tcp_con_status(tcp_con->connection) == TCP_CLIENT_DISCONNECTED) {
                     if (tcp_con->status == TCP_CONN_CONNECTED) {
                         reconnect_tcp_relay_connection(tcp_c, i);
                     } else {
@@ -1289,7 +1424,7 @@ static void do_tcp_conns(TCP_Connections *tcp_c)
                     continue;
                 }
 
-                if (tcp_con->status == TCP_CONN_VALID && tcp_con->connection->status == TCP_CLIENT_CONFIRMED) {
+                if (tcp_con->status == TCP_CONN_VALID && tcp_con_status(tcp_con->connection) == TCP_CLIENT_CONFIRMED) {
                     tcp_relay_on_online(tcp_c, i);
                 }
 
@@ -1309,10 +1444,14 @@ static void do_tcp_conns(TCP_Connections *tcp_c)
 
 static void kill_nonused_tcp(TCP_Connections *tcp_c)
 {
-    if (tcp_c->tcp_connections_length == 0)
+    if (tcp_c->tcp_connections_length == 0) {
         return;
+    }
 
-    unsigned int i, num_online = 0, num_kill = 0, to_kill[tcp_c->tcp_connections_length];
+    unsigned int i;
+    unsigned int num_online = 0;
+    unsigned int num_kill = 0;
+    VLA(unsigned int, to_kill, tcp_c->tcp_connections_length);
 
     for (i = 0; i < tcp_c->tcp_connections_length; ++i) {
         TCP_con *tcp_con = get_tcp_connection(tcp_c, i);
@@ -1331,11 +1470,12 @@ static void kill_nonused_tcp(TCP_Connections *tcp_c)
 
     if (num_online <= RECOMMENDED_FRIEND_TCP_CONNECTIONS) {
         return;
-    } else {
-        unsigned int n = num_online - RECOMMENDED_FRIEND_TCP_CONNECTIONS;
+    }
+
+    unsigned int n = num_online - RECOMMENDED_FRIEND_TCP_CONNECTIONS;
 
-        if (n < num_kill)
-            num_kill = n;
+    if (n < num_kill) {
+        num_kill = n;
     }
 
     for (i = 0; i < num_kill; ++i) {
@@ -1343,9 +1483,9 @@ static void kill_nonused_tcp(TCP_Connections *tcp_c)
     }
 }
 
-void do_tcp_connections(TCP_Connections *tcp_c)
+void do_tcp_connections(TCP_Connections *tcp_c, void *userdata)
 {
-    do_tcp_conns(tcp_c);
+    do_tcp_conns(tcp_c, userdata);
     kill_nonused_tcp(tcp_c);
 }
 
@@ -1361,5 +1501,3 @@ void kill_tcp_connections(TCP_Connections *tcp_c)
     free(tcp_c->connections);
     free(tcp_c);
 }
-
-
diff --git a/toxcore/TCP_connection.h b/toxcore/TCP_connection.h
index 7bc34f86..a45129a7 100644
--- a/toxcore/TCP_connection.h
+++ b/toxcore/TCP_connection.h
@@ -1,26 +1,26 @@
-/* TCP_connection.h
- *
+/*
  * Handles TCP relay connections between two Tox clients.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2015 Tox project.
  *
- *  Copyright (C) 2015 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef TCP_CONNECTION_H
 #define TCP_CONNECTION_H
 
@@ -41,7 +41,7 @@
 
 #define MAX_FRIEND_TCP_CONNECTIONS 6
 
-/* Time until connection to friend gets killed (if it doesn't get locked withing that time) */
+/* Time until connection to friend gets killed (if it doesn't get locked within that time) */
 #define TCP_CONNECTION_ANNOUNCE_TIMEOUT (TCP_CONNECTION_TIMEOUT)
 
 /* The amount of recommended connections for each friend
@@ -53,7 +53,7 @@
 
 typedef struct {
     uint8_t status;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* The dht public key of the peer */
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The dht public key of the peer */
 
     struct {
         uint32_t tcp_connection;
@@ -70,41 +70,17 @@ typedef struct {
     uint64_t connected_time;
     uint32_t lock_count;
     uint32_t sleep_count;
-    _Bool onion;
+    bool onion;
 
     /* Only used when connection is sleeping. */
     IP_Port ip_port;
-    uint8_t relay_pk[crypto_box_PUBLICKEYBYTES];
-    _Bool unsleep; /* set to 1 to unsleep connection. */
+    uint8_t relay_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    bool unsleep; /* set to 1 to unsleep connection. */
 } TCP_con;
 
-typedef struct {
-    DHT *dht;
-
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-
-    TCP_Connection_to *connections;
-    uint32_t connections_length; /* Length of connections array. */
-
-    TCP_con *tcp_connections;
-    uint32_t tcp_connections_length; /* Length of tcp_connections array. */
-
-    int (*tcp_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
-    void *tcp_data_callback_object;
-
-    int (*tcp_oob_callback)(void *object, const uint8_t *public_key, unsigned int tcp_connections_number,
-                            const uint8_t *data, uint16_t length);
-    void *tcp_oob_callback_object;
-
-    int (*tcp_onion_callback)(void *object, const uint8_t *data, uint16_t length);
-    void *tcp_onion_callback_object;
-
-    TCP_Proxy_Info proxy_info;
+typedef struct TCP_Connections TCP_Connections;
 
-    _Bool onion_status;
-    uint16_t onion_num_conns;
-} TCP_Connections;
+const uint8_t *tcp_connections_public_key(const TCP_Connections *tcp_c);
 
 /* Send a packet to the TCP connection.
  *
@@ -115,8 +91,8 @@ int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, c
 
 /* Return a random TCP connection number for use in send_tcp_onion_request.
  *
- * TODO: This number is just the index of an array that the elements can
- * change without warning.
+ * TODO(irungentoo): This number is just the index of an array that the elements
+ * can change without warning.
  *
  * return TCP connection number on success.
  * return -1 on failure.
@@ -138,7 +114,7 @@ int tcp_send_onion_request(TCP_Connections *tcp_c, unsigned int tcp_connections_
  * return 0 on success.
  * return -1 on failure.
  */
-int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status);
+int set_tcp_onion_status(TCP_Connections *tcp_c, bool status);
 
 /* Send an oob packet via the TCP relay corresponding to tcp_connections_number.
  *
@@ -151,17 +127,18 @@ int tcp_send_oob_packet(TCP_Connections *tcp_c, unsigned int tcp_connections_num
 /* Set the callback for TCP data packets.
  */
 void set_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_data_callback)(void *object, int id,
-                                        const uint8_t *data, uint16_t length), void *object);
+                                        const uint8_t *data, uint16_t length, void *userdata), void *object);
 
 /* Set the callback for TCP onion packets.
  */
 void set_onion_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_onion_callback)(void *object,
-        const uint8_t *data, uint16_t length), void *object);
+        const uint8_t *data, uint16_t length, void *userdata), void *object);
 
 /* Set the callback for TCP oob data packets.
  */
 void set_oob_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_oob_callback)(void *object,
-        const uint8_t *public_key, unsigned int tcp_connections_number, const uint8_t *data, uint16_t length), void *object);
+        const uint8_t *public_key, unsigned int tcp_connections_number, const uint8_t *data, uint16_t length, void *userdata),
+        void *object);
 
 /* Create a new TCP connection to public_key.
  *
@@ -189,7 +166,7 @@ int kill_tcp_connection_to(TCP_Connections *tcp_c, int connections_number);
  * return 0 on success.
  * return -1 on failure.
  */
-int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number, _Bool status);
+int set_tcp_connection_to_status(TCP_Connections *tcp_c, int connections_number, bool status);
 
 /* return number of online tcp relays tied to the connection on success.
  * return 0 on failure.
@@ -239,7 +216,7 @@ unsigned int tcp_copy_connected_relays(TCP_Connections *tcp_c, Node_format *tcp_
  */
 TCP_Connections *new_tcp_connections(const uint8_t *secret_key, TCP_Proxy_Info *proxy_info);
 
-void do_tcp_connections(TCP_Connections *tcp_c);
+void do_tcp_connections(TCP_Connections *tcp_c, void *userdata);
 void kill_tcp_connections(TCP_Connections *tcp_c);
 
 #endif
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index d4944aed..65dc81c3 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -1,64 +1,117 @@
 /*
-* TCP_server.c -- Implementation of the TCP relay server part of Tox.
-*
-*  Copyright (C) 2014 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the TCP relay server part of Tox.
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "TCP_server.h"
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #if !defined(_WIN32) && !defined(__WIN32__) && !defined (WIN32)
 #include <sys/ioctl.h>
 #endif
 
+#ifdef TCP_SERVER_USE_EPOLL
+#include <sys/epoll.h>
+#include <unistd.h>
+#endif
+
 #include "util.h"
 
-/* return 1 on success
- * return 0 on failure
- */
-static int bind_to_port(sock_t sock, int family, uint16_t port)
-{
-    struct sockaddr_storage addr = {0};
-    size_t addrsize;
+typedef struct TCP_Secure_Connection {
+    Socket sock;
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t recv_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of received packets. */
+    uint8_t sent_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of sent packets. */
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint16_t next_packet_length;
+    struct {
+        uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+        uint32_t index;
+        uint8_t status; /* 0 if not used, 1 if other is offline, 2 if other is online. */
+        uint8_t other_id;
+    } connections[NUM_CLIENT_CONNECTIONS];
+    uint8_t last_packet[2 + MAX_PACKET_SIZE];
+    uint8_t status;
+    uint16_t last_packet_length;
+    uint16_t last_packet_sent;
 
-    if (family == AF_INET) {
-        struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
+    TCP_Priority_List *priority_queue_start, *priority_queue_end;
 
-        addrsize = sizeof(struct sockaddr_in);
-        addr4->sin_family = AF_INET;
-        addr4->sin_port = htons(port);
-    } else if (family == AF_INET6) {
-        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+    uint64_t identifier;
+
+    uint64_t last_pinged;
+    uint64_t ping_id;
+} TCP_Secure_Connection;
 
-        addrsize = sizeof(struct sockaddr_in6);
-        addr6->sin6_family = AF_INET6;
-        addr6->sin6_port = htons(port);
-    } else {
-        return 0;
-    }
 
-    return (bind(sock, (struct sockaddr *)&addr, addrsize) == 0);
+struct TCP_Server {
+    Onion *onion;
+
+#ifdef TCP_SERVER_USE_EPOLL
+    int efd;
+    uint64_t last_run_pinged;
+#endif
+    Socket *socks_listening;
+    unsigned int num_listening_socks;
+
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t secret_key[CRYPTO_SECRET_KEY_SIZE];
+    TCP_Secure_Connection incoming_connection_queue[MAX_INCOMING_CONNECTIONS];
+    uint16_t incoming_connection_queue_index;
+    TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMING_CONNECTIONS];
+    uint16_t unconfirmed_connection_queue_index;
+
+    TCP_Secure_Connection *accepted_connection_array;
+    uint32_t size_accepted_connections;
+    uint32_t num_accepted_connections;
+
+    uint64_t counter;
+
+    BS_LIST accepted_key_list;
+};
+
+const uint8_t *tcp_server_public_key(const TCP_Server *tcp_server)
+{
+    return tcp_server->public_key;
+}
+
+size_t tcp_server_listen_count(const TCP_Server *tcp_server)
+{
+    return tcp_server->num_listening_socks;
 }
 
+/* This is needed to compile on Android below API 21
+ */
+#ifdef TCP_SERVER_USE_EPOLL
+#ifndef EPOLLRDHUP
+#define EPOLLRDHUP 0x2000
+#endif
+#endif
+
 /* Set the size of the connection list to numfriends.
  *
  *  return -1 if realloc fails.
@@ -68,7 +121,7 @@ static int realloc_connection(TCP_Server *TCP_server, uint32_t num)
 {
     if (num == 0) {
         free(TCP_server->accepted_connection_array);
-        TCP_server->accepted_connection_array = NULL;
+        TCP_server->accepted_connection_array = nullptr;
         TCP_server->size_accepted_connections = 0;
         return 0;
     }
@@ -77,11 +130,13 @@ 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)
+    if (new_connections == nullptr) {
         return -1;
+    }
 
     if (num > TCP_server->size_accepted_connections) {
         uint32_t old_size = TCP_server->size_accepted_connections;
@@ -120,8 +175,9 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
     }
 
     if (TCP_server->size_accepted_connections == TCP_server->num_accepted_connections) {
-        if (realloc_connection(TCP_server, TCP_server->size_accepted_connections + 4) == -1)
+        if (realloc_connection(TCP_server, TCP_server->size_accepted_connections + 4) == -1) {
             return -1;
+        }
 
         index = TCP_server->num_accepted_connections;
     } else {
@@ -140,8 +196,9 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
         return -1;
     }
 
-    if (!bs_list_add(&TCP_server->accepted_key_list, con->public_key, index))
+    if (!bs_list_add(&TCP_server->accepted_key_list, con->public_key, index)) {
         return -1;
+    }
 
     memcpy(&TCP_server->accepted_connection_array[index], con, sizeof(TCP_Secure_Connection));
     TCP_server->accepted_connection_array[index].status = TCP_STATUS_CONFIRMED;
@@ -160,40 +217,28 @@ static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con
  */
 static int del_accepted(TCP_Server *TCP_server, int index)
 {
-    if ((uint32_t)index >= TCP_server->size_accepted_connections)
+    if ((uint32_t)index >= TCP_server->size_accepted_connections) {
         return -1;
+    }
 
-    if (TCP_server->accepted_connection_array[index].status == TCP_STATUS_NO_STATUS)
+    if (TCP_server->accepted_connection_array[index].status == TCP_STATUS_NO_STATUS) {
         return -1;
+    }
 
-    if (!bs_list_remove(&TCP_server->accepted_key_list, TCP_server->accepted_connection_array[index].public_key, index))
+    if (!bs_list_remove(&TCP_server->accepted_key_list, TCP_server->accepted_connection_array[index].public_key, index)) {
         return -1;
+    }
 
-    sodium_memzero(&TCP_server->accepted_connection_array[index], sizeof(TCP_Secure_Connection));
+    crypto_memzero(&TCP_server->accepted_connection_array[index], sizeof(TCP_Secure_Connection));
     --TCP_server->num_accepted_connections;
 
-    if (TCP_server->num_accepted_connections == 0)
+    if (TCP_server->num_accepted_connections == 0) {
         realloc_connection(TCP_server, 0);
+    }
 
     return 0;
 }
 
-/* return the amount of data in the tcp recv buffer.
- * return 0 on failure.
- */
-unsigned int TCP_socket_data_recv_buffer(sock_t sock)
-{
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-    unsigned long count = 0;
-    ioctlsocket(sock, FIONREAD, &count);
-#else
-    int count = 0;
-    ioctl(sock, FIONREAD, &count);
-#endif
-
-    return count;
-}
-
 /* Read the next two bytes in TCP stream then convert them to
  * length (host byte order).
  *
@@ -201,20 +246,20 @@ unsigned int TCP_socket_data_recv_buffer(sock_t sock)
  * return 0 if nothing has been read from socket.
  * return ~0 on failure.
  */
-uint16_t read_TCP_length(sock_t sock)
+uint16_t read_TCP_length(Socket sock)
 {
-    unsigned int count = TCP_socket_data_recv_buffer(sock);
+    const unsigned int count = net_socket_data_recv_buffer(sock);
 
     if (count >= sizeof(uint16_t)) {
         uint16_t length;
-        int len = recv(sock, (uint8_t *)&length, sizeof(uint16_t), MSG_NOSIGNAL);
+        const int len = net_recv(sock, &length, sizeof(uint16_t));
 
         if (len != sizeof(uint16_t)) {
             fprintf(stderr, "FAIL recv packet\n");
             return 0;
         }
 
-        length = ntohs(length);
+        length = net_ntohs(length);
 
         if (length > MAX_PACKET_SIZE) {
             return ~0;
@@ -231,12 +276,12 @@ uint16_t read_TCP_length(sock_t sock)
  * return length on success
  * return -1 on failure/no data in buffer.
  */
-int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length)
+int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length)
 {
-    unsigned int count = TCP_socket_data_recv_buffer(sock);
+    unsigned int count = net_socket_data_recv_buffer(sock);
 
     if (count >= length) {
-        int len = recv(sock, data, length, MSG_NOSIGNAL);
+        const int len = net_recv(sock, data, length);
 
         if (len != length) {
             fprintf(stderr, "FAIL recv packet\n");
@@ -253,36 +298,41 @@ int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length)
  * return 0 if could not read any packet.
  * return -1 on failure (connection must be killed).
  */
-int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, const uint8_t *shared_key,
+int read_packet_TCP_secure_connection(Socket sock, uint16_t *next_packet_length, const uint8_t *shared_key,
                                       uint8_t *recv_nonce, uint8_t *data, uint16_t max_len)
 {
     if (*next_packet_length == 0) {
         uint16_t len = read_TCP_length(sock);
 
-        if (len == (uint16_t)~0)
+        if (len == (uint16_t)~0) {
             return -1;
+        }
 
-        if (len == 0)
+        if (len == 0) {
             return 0;
+        }
 
         *next_packet_length = len;
     }
 
-    if (max_len + crypto_box_MACBYTES < *next_packet_length)
+    if (max_len + CRYPTO_MAC_SIZE < *next_packet_length) {
         return -1;
+    }
 
-    uint8_t data_encrypted[*next_packet_length];
+    VLA(uint8_t, data_encrypted, *next_packet_length);
     int len_packet = read_TCP_packet(sock, data_encrypted, *next_packet_length);
 
-    if (len_packet != *next_packet_length)
+    if (len_packet != *next_packet_length) {
         return 0;
+    }
 
     *next_packet_length = 0;
 
     int len = decrypt_data_symmetric(shared_key, recv_nonce, data_encrypted, len_packet, data);
 
-    if (len + crypto_box_MACBYTES != len_packet)
+    if (len + CRYPTO_MAC_SIZE != len_packet) {
         return -1;
+    }
 
     increment_nonce(recv_nonce);
 
@@ -298,11 +348,12 @@ static int send_pending_data_nonpriority(TCP_Secure_Connection *con)
         return 0;
     }
 
-    uint16_t left = con->last_packet_length - con->last_packet_sent;
-    int len = send(con->sock, con->last_packet + con->last_packet_sent, left, MSG_NOSIGNAL);
+    const uint16_t left = con->last_packet_length - con->last_packet_sent;
+    const int len = net_send(con->sock, con->last_packet + con->last_packet_sent, left);
 
-    if (len <= 0)
+    if (len <= 0) {
         return -1;
+    }
 
     if (len == left) {
         con->last_packet_length = 0;
@@ -312,7 +363,6 @@ static int send_pending_data_nonpriority(TCP_Secure_Connection *con)
 
     con->last_packet_sent += len;
     return -1;
-
 }
 
 /* return 0 if pending data was sent completely
@@ -328,8 +378,8 @@ static int send_pending_data(TCP_Secure_Connection *con)
     TCP_Priority_List *p = con->priority_queue_start;
 
     while (p) {
-        uint16_t left = p->size - p->sent;
-        int len = send(con->sock, p->data + p->sent, left, MSG_NOSIGNAL);
+        const uint16_t left = p->size - p->sent;
+        const int len = net_send(con->sock, p->data + p->sent, left);
 
         if (len != left) {
             if (len > 0) {
@@ -347,7 +397,7 @@ static int send_pending_data(TCP_Secure_Connection *con)
     con->priority_queue_start = p;
 
     if (!p) {
-        con->priority_queue_end = NULL;
+        con->priority_queue_end = nullptr;
         return 0;
     }
 
@@ -357,27 +407,27 @@ static int send_pending_data(TCP_Secure_Connection *con)
 /* return 0 on failure (only if malloc fails)
  * return 1 on success
  */
-static _Bool add_priority(TCP_Secure_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
+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 = nullptr;
+    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;
 }
 
@@ -386,12 +436,13 @@ static _Bool add_priority(TCP_Secure_Connection *con, const uint8_t *packet, uin
  * return -1 on failure (connection must be killed).
  */
 static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
-        _Bool priority)
+        bool priority)
 {
-    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
+    if (length + CRYPTO_MAC_SIZE > MAX_PACKET_SIZE) {
         return -1;
+    }
 
-    _Bool sendpriority = 1;
+    bool sendpriority = 1;
 
     if (send_pending_data(con) == -1) {
         if (priority) {
@@ -401,17 +452,18 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
         }
     }
 
-    uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
+    VLA(uint8_t, packet, sizeof(uint16_t) + length + CRYPTO_MAC_SIZE);
 
-    uint16_t c_length = htons(length + crypto_box_MACBYTES);
+    const uint16_t c_length = net_htons(length + CRYPTO_MAC_SIZE);
     memcpy(packet, &c_length, sizeof(uint16_t));
     int len = encrypt_data_symmetric(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
 
-    if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
+    if ((unsigned int)len != (SIZEOF_VLA(packet) - sizeof(uint16_t))) {
         return -1;
+    }
 
     if (priority) {
-        len = sendpriority ? send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL) : 0;
+        len = sendpriority ? net_send(con->sock, packet, SIZEOF_VLA(packet)) : 0;
 
         if (len <= 0) {
             len = 0;
@@ -419,35 +471,37 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
 
         increment_nonce(con->sent_nonce);
 
-        if ((unsigned int)len == sizeof(packet)) {
+        if ((unsigned int)len == SIZEOF_VLA(packet)) {
             return 1;
         }
 
-        return add_priority(con, packet, sizeof(packet), len);
+        return add_priority(con, packet, SIZEOF_VLA(packet), len);
     }
 
-    len = send(con->sock, packet, sizeof(packet), MSG_NOSIGNAL);
+    len = net_send(con->sock, packet, SIZEOF_VLA(packet));
 
-    if (len <= 0)
+    if (len <= 0) {
         return 0;
+    }
 
     increment_nonce(con->sent_nonce);
 
-    if ((unsigned int)len == sizeof(packet))
+    if ((unsigned int)len == SIZEOF_VLA(packet)) {
         return 1;
+    }
 
-    memcpy(con->last_packet, packet, sizeof(packet));
-    con->last_packet_length = sizeof(packet);
+    memcpy(con->last_packet, packet, SIZEOF_VLA(packet));
+    con->last_packet_length = SIZEOF_VLA(packet);
     con->last_packet_sent = len;
     return 1;
 }
 
 /* Kill a TCP_Secure_Connection
  */
-static void kill_TCP_connection(TCP_Secure_Connection *con)
+static void kill_TCP_secure_connection(TCP_Secure_Connection *con)
 {
     kill_sock(con->sock);
-    sodium_memzero(con, sizeof(TCP_Secure_Connection));
+    crypto_memzero(con, sizeof(TCP_Secure_Connection));
 }
 
 static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *con, uint8_t con_number);
@@ -459,8 +513,9 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
  */
 static int kill_accepted(TCP_Server *TCP_server, int index)
 {
-    if ((uint32_t)index >= TCP_server->size_accepted_connections)
+    if ((uint32_t)index >= TCP_server->size_accepted_connections) {
         return -1;
+    }
 
     uint32_t i;
 
@@ -468,10 +523,11 @@ static int kill_accepted(TCP_Server *TCP_server, int index)
         rm_connection_index(TCP_server, &TCP_server->accepted_connection_array[index], i);
     }
 
-    sock_t sock = TCP_server->accepted_connection_array[index].sock;
+    Socket sock = TCP_server->accepted_connection_array[index].sock;
 
-    if (del_accepted(TCP_server, index) != 0)
+    if (del_accepted(TCP_server, index) != 0) {
         return -1;
+    }
 
     kill_sock(sock);
     return 0;
@@ -483,40 +539,45 @@ static int kill_accepted(TCP_Server *TCP_server, int index)
 static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
                                 const uint8_t *self_secret_key)
 {
-    if (length != TCP_CLIENT_HANDSHAKE_SIZE)
+    if (length != TCP_CLIENT_HANDSHAKE_SIZE) {
         return -1;
+    }
 
-    if (con->status != TCP_STATUS_CONNECTED)
+    if (con->status != TCP_STATUS_CONNECTED) {
         return -1;
+    }
 
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
     encrypt_precompute(data, self_secret_key, shared_key);
     uint8_t plain[TCP_HANDSHAKE_PLAIN_SIZE];
-    int len = decrypt_data_symmetric(shared_key, data + crypto_box_PUBLICKEYBYTES,
-                                     data + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES, plain);
+    int len = decrypt_data_symmetric(shared_key, data + CRYPTO_PUBLIC_KEY_SIZE,
+                                     data + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, TCP_HANDSHAKE_PLAIN_SIZE + CRYPTO_MAC_SIZE, plain);
 
-    if (len != TCP_HANDSHAKE_PLAIN_SIZE)
+    if (len != TCP_HANDSHAKE_PLAIN_SIZE) {
         return -1;
+    }
 
-    memcpy(con->public_key, data, crypto_box_PUBLICKEYBYTES);
-    uint8_t temp_secret_key[crypto_box_SECRETKEYBYTES];
+    memcpy(con->public_key, data, CRYPTO_PUBLIC_KEY_SIZE);
+    uint8_t temp_secret_key[CRYPTO_SECRET_KEY_SIZE];
     uint8_t resp_plain[TCP_HANDSHAKE_PLAIN_SIZE];
-    crypto_box_keypair(resp_plain, temp_secret_key);
+    crypto_new_keypair(resp_plain, temp_secret_key);
     random_nonce(con->sent_nonce);
-    memcpy(resp_plain + crypto_box_PUBLICKEYBYTES, con->sent_nonce, crypto_box_NONCEBYTES);
-    memcpy(con->recv_nonce, plain + crypto_box_PUBLICKEYBYTES, crypto_box_NONCEBYTES);
+    memcpy(resp_plain + CRYPTO_PUBLIC_KEY_SIZE, con->sent_nonce, CRYPTO_NONCE_SIZE);
+    memcpy(con->recv_nonce, plain + CRYPTO_PUBLIC_KEY_SIZE, CRYPTO_NONCE_SIZE);
 
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
-    new_nonce(response);
+    random_nonce(response);
 
     len = encrypt_data_symmetric(shared_key, response, resp_plain, TCP_HANDSHAKE_PLAIN_SIZE,
-                                 response + crypto_box_NONCEBYTES);
+                                 response + CRYPTO_NONCE_SIZE);
 
-    if (len != TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES)
+    if (len != TCP_HANDSHAKE_PLAIN_SIZE + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    if (TCP_SERVER_HANDSHAKE_SIZE != send(con->sock, response, TCP_SERVER_HANDSHAKE_SIZE, MSG_NOSIGNAL))
+    if (TCP_SERVER_HANDSHAKE_SIZE != net_send(con->sock, response, TCP_SERVER_HANDSHAKE_SIZE)) {
         return -1;
+    }
 
     encrypt_precompute(plain, temp_secret_key, con->shared_key);
     con->status = TCP_STATUS_UNCONFIRMED;
@@ -545,10 +606,10 @@ static int read_connection_handshake(TCP_Secure_Connection *con, const uint8_t *
  */
 static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, const uint8_t *public_key)
 {
-    uint8_t data[1 + 1 + crypto_box_PUBLICKEYBYTES];
+    uint8_t data[1 + 1 + CRYPTO_PUBLIC_KEY_SIZE];
     data[0] = TCP_PACKET_ROUTING_RESPONSE;
     data[1] = rpid;
-    memcpy(data + 2, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(data + 2, public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
@@ -559,7 +620,7 @@ static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, const
  */
 static int send_connect_notification(TCP_Secure_Connection *con, uint8_t id)
 {
-    uint8_t data[2] = {TCP_PACKET_CONNECTION_NOTIFICATION, id + NUM_RESERVED_PORTS};
+    uint8_t data[2] = {TCP_PACKET_CONNECTION_NOTIFICATION, (uint8_t)(id + NUM_RESERVED_PORTS)};
     return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
 
@@ -569,7 +630,7 @@ static int send_connect_notification(TCP_Secure_Connection *con, uint8_t id)
  */
 static int send_disconnect_notification(TCP_Secure_Connection *con, uint8_t id)
 {
-    uint8_t data[2] = {TCP_PACKET_DISCONNECT_NOTIFICATION, id + NUM_RESERVED_PORTS};
+    uint8_t data[2] = {TCP_PACKET_DISCONNECT_NOTIFICATION, (uint8_t)(id + NUM_RESERVED_PORTS)};
     return write_packet_TCP_secure_connection(con, data, sizeof(data), 1);
 }
 
@@ -584,8 +645,9 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
 
     /* If person tries to cennect to himself we deny the request*/
     if (public_key_cmp(con->public_key, public_key) == 0) {
-        if (send_routing_response(con, 0, public_key) == -1)
+        if (send_routing_response(con, 0, public_key) == -1) {
             return -1;
+        }
 
         return 0;
     }
@@ -595,9 +657,9 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
             if (public_key_cmp(public_key, con->connections[i].public_key) == 0) {
                 if (send_routing_response(con, i + NUM_RESERVED_PORTS, public_key) == -1) {
                     return -1;
-                } else {
-                    return 0;
                 }
+
+                return 0;
             }
         } else if (index == (uint32_t)~0) {
             index = i;
@@ -605,22 +667,25 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
     }
 
     if (index == (uint32_t)~0) {
-        if (send_routing_response(con, 0, public_key) == -1)
+        if (send_routing_response(con, 0, public_key) == -1) {
             return -1;
+        }
 
         return 0;
     }
 
     int ret = send_routing_response(con, index + NUM_RESERVED_PORTS, public_key);
 
-    if (ret == 0)
+    if (ret == 0) {
         return 0;
+    }
 
-    if (ret == -1)
+    if (ret == -1) {
         return -1;
+    }
 
     con->connections[index].status = 1;
-    memcpy(con->connections[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(con->connections[index].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     int other_index = get_TCP_connection_index(TCP_server, public_key);
 
     if (other_index != -1) {
@@ -642,7 +707,7 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
             other_conn->connections[other_id].status = 2;
             other_conn->connections[other_id].index = con_id;
             other_conn->connections[other_id].other_id = index;
-            //TODO: return values?
+            // TODO(irungentoo): return values?
             send_connect_notification(con, index);
             send_connect_notification(other_conn, other_id);
         }
@@ -657,20 +722,21 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const
 static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *public_key, const uint8_t *data,
                                uint16_t length)
 {
-    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH)
+    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH) {
         return -1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[con_id];
 
     int other_index = get_TCP_connection_index(TCP_server, public_key);
 
     if (other_index != -1) {
-        uint8_t resp_packet[1 + crypto_box_PUBLICKEYBYTES + length];
+        VLA(uint8_t, resp_packet, 1 + CRYPTO_PUBLIC_KEY_SIZE + length);
         resp_packet[0] = TCP_PACKET_OOB_RECV;
-        memcpy(resp_packet + 1, con->public_key, crypto_box_PUBLICKEYBYTES);
-        memcpy(resp_packet + 1 + crypto_box_PUBLICKEYBYTES, data, length);
+        memcpy(resp_packet + 1, con->public_key, CRYPTO_PUBLIC_KEY_SIZE);
+        memcpy(resp_packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, data, length);
         write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[other_index], resp_packet,
-                                           sizeof(resp_packet), 0);
+                                           SIZEOF_VLA(resp_packet), 0);
     }
 
     return 0;
@@ -683,8 +749,9 @@ static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const ui
  */
 static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *con, uint8_t con_number)
 {
-    if (con_number >= NUM_CLIENT_CONNECTIONS)
+    if (con_number >= NUM_CLIENT_CONNECTIONS) {
         return -1;
+    }
 
     if (con->connections[con_number].status) {
         uint32_t index = con->connections[con_number].index;
@@ -692,13 +759,14 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
 
         if (con->connections[con_number].status == 2) {
 
-            if (index >= TCP_server->size_accepted_connections)
+            if (index >= TCP_server->size_accepted_connections) {
                 return -1;
+            }
 
             TCP_server->accepted_connection_array[index].connections[other_id].other_id = 0;
             TCP_server->accepted_connection_array[index].connections[other_id].index = 0;
             TCP_server->accepted_connection_array[index].connections[other_id].status = 1;
-            //TODO: return values?
+            // TODO(irungentoo): return values?
             send_disconnect_notification(&TCP_server->accepted_connection_array[index], other_id);
         }
 
@@ -706,30 +774,33 @@ static int rm_connection_index(TCP_Server *TCP_server, TCP_Secure_Connection *co
         con->connections[con_number].other_id = 0;
         con->connections[con_number].status = 0;
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data, uint16_t length)
 {
-    TCP_Server *TCP_server = object;
-    uint32_t index = dest.ip.ip6.uint32[0];
+    TCP_Server *TCP_server = (TCP_Server *)object;
+    uint32_t index = dest.ip.ip.v6.uint32[0];
 
-    if (index >= TCP_server->size_accepted_connections)
+    if (index >= TCP_server->size_accepted_connections) {
         return 1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[index];
 
-    if (con->identifier != dest.ip.ip6.uint64[1])
+    if (con->identifier != dest.ip.ip.v6.uint64[1]) {
         return 1;
+    }
 
-    uint8_t packet[1 + length];
+    VLA(uint8_t, packet, 1 + length);
     memcpy(packet + 1, data, length);
     packet[0] = TCP_PACKET_ONION_RESPONSE;
 
-    if (write_packet_TCP_secure_connection(con, packet, sizeof(packet), 0) != 1)
+    if (write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0) != 1) {
         return 1;
+    }
 
     return 0;
 }
@@ -739,36 +810,41 @@ static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data,
  */
 static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *data, uint16_t length)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     TCP_Secure_Connection *con = &TCP_server->accepted_connection_array[con_id];
 
     switch (data[0]) {
         case TCP_PACKET_ROUTING_REQUEST: {
-            if (length != 1 + crypto_box_PUBLICKEYBYTES)
+            if (length != 1 + CRYPTO_PUBLIC_KEY_SIZE) {
                 return -1;
+            }
 
             return handle_TCP_routing_req(TCP_server, con_id, data + 1);
         }
 
         case TCP_PACKET_CONNECTION_NOTIFICATION: {
-            if (length != 2)
+            if (length != 2) {
                 return -1;
+            }
 
             break;
         }
 
         case TCP_PACKET_DISCONNECT_NOTIFICATION: {
-            if (length != 2)
+            if (length != 2) {
                 return -1;
+            }
 
             return rm_connection_index(TCP_server, con, data[1] - NUM_RESERVED_PORTS);
         }
 
         case TCP_PACKET_PING: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint8_t response[1 + sizeof(uint64_t)];
             response[0] = TCP_PACKET_PONG;
@@ -778,8 +854,9 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
         }
 
         case TCP_PACKET_PONG: {
-            if (length != 1 + sizeof(uint64_t))
+            if (length != 1 + sizeof(uint64_t)) {
                 return -1;
+            }
 
             uint64_t ping_id;
             memcpy(&ping_id, data + 1, sizeof(uint64_t));
@@ -790,31 +867,33 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
                 }
 
                 return 0;
-            } else {
-                return -1;
             }
+
+            return -1;
         }
 
         case TCP_PACKET_OOB_SEND: {
-            if (length <= 1 + crypto_box_PUBLICKEYBYTES)
+            if (length <= 1 + CRYPTO_PUBLIC_KEY_SIZE) {
                 return -1;
+            }
 
-            return handle_TCP_oob_send(TCP_server, con_id, data + 1, data + 1 + crypto_box_PUBLICKEYBYTES,
-                                       length - (1 + crypto_box_PUBLICKEYBYTES));
+            return handle_TCP_oob_send(TCP_server, con_id, data + 1, data + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                       length - (1 + CRYPTO_PUBLIC_KEY_SIZE));
         }
 
         case TCP_PACKET_ONION_REQUEST: {
             if (TCP_server->onion) {
-                if (length <= 1 + crypto_box_NONCEBYTES + ONION_SEND_BASE * 2)
+                if (length <= 1 + CRYPTO_NONCE_SIZE + ONION_SEND_BASE * 2) {
                     return -1;
+                }
 
                 IP_Port source;
                 source.port = 0;  // dummy initialise
-                source.ip.family = TCP_ONION_FAMILY;
-                source.ip.ip6.uint32[0] = con_id;
-                source.ip.ip6.uint32[1] = 0;
-                source.ip.ip6.uint64[1] = con->identifier;
-                onion_send_1(TCP_server->onion, data + 1 + crypto_box_NONCEBYTES, length - (1 + crypto_box_NONCEBYTES), source,
+                source.ip.family = net_family_tcp_onion;
+                source.ip.ip.v6.uint32[0] = con_id;
+                source.ip.ip.v6.uint32[1] = 0;
+                source.ip.ip.v6.uint64[1] = con->identifier;
+                onion_send_1(TCP_server->onion, data + 1 + CRYPTO_NONCE_SIZE, length - (1 + CRYPTO_NONCE_SIZE), source,
                              data + 1);
             }
 
@@ -826,29 +905,34 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
         }
 
         default: {
-            if (data[0] < NUM_RESERVED_PORTS)
+            if (data[0] < NUM_RESERVED_PORTS) {
                 return -1;
+            }
 
             uint8_t c_id = data[0] - NUM_RESERVED_PORTS;
 
-            if (c_id >= NUM_CLIENT_CONNECTIONS)
+            if (c_id >= NUM_CLIENT_CONNECTIONS) {
                 return -1;
+            }
 
-            if (con->connections[c_id].status == 0)
+            if (con->connections[c_id].status == 0) {
                 return -1;
+            }
 
-            if (con->connections[c_id].status != 2)
+            if (con->connections[c_id].status != 2) {
                 return 0;
+            }
 
             uint32_t index = con->connections[c_id].index;
             uint8_t other_c_id = con->connections[c_id].other_id + NUM_RESERVED_PORTS;
-            uint8_t new_data[length];
+            VLA(uint8_t, new_data, length);
             memcpy(new_data, data, length);
             new_data[0] = other_c_id;
             int ret = write_packet_TCP_secure_connection(&TCP_server->accepted_connection_array[index], new_data, length, 0);
 
-            if (ret == -1)
+            if (ret == -1) {
                 return -1;
+            }
 
             return 0;
         }
@@ -864,11 +948,11 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
     int index = add_accepted(TCP_server, con);
 
     if (index == -1) {
-        kill_TCP_connection(con);
+        kill_TCP_secure_connection(con);
         return -1;
     }
 
-    sodium_memzero(con, sizeof(TCP_Secure_Connection));
+    crypto_memzero(con, sizeof(TCP_Secure_Connection));
 
     if (handle_TCP_packet(TCP_server, index, data, length) == -1) {
         kill_accepted(TCP_server, index);
@@ -881,10 +965,11 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
 /* return index on success
  * return -1 on failure
  */
-static int accept_connection(TCP_Server *TCP_server, sock_t sock)
+static int accept_connection(TCP_Server *TCP_server, Socket sock)
 {
-    if (!sock_valid(sock))
+    if (!sock_valid(sock)) {
         return -1;
+    }
 
     if (!set_socket_nonblock(sock)) {
         kill_sock(sock);
@@ -896,32 +981,33 @@ static int accept_connection(TCP_Server *TCP_server, sock_t sock)
         return -1;
     }
 
-    uint16_t index = TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
+    uint16_t index = TCP_server->incoming_connection_queue_index % MAX_INCOMING_CONNECTIONS;
 
-    TCP_Secure_Connection *conn = &TCP_server->incomming_connection_queue[index];
+    TCP_Secure_Connection *conn = &TCP_server->incoming_connection_queue[index];
 
-    if (conn->status != TCP_STATUS_NO_STATUS)
-        kill_TCP_connection(conn);
+    if (conn->status != TCP_STATUS_NO_STATUS) {
+        kill_TCP_secure_connection(conn);
+    }
 
     conn->status = TCP_STATUS_CONNECTED;
     conn->sock = sock;
     conn->next_packet_length = 0;
 
-    ++TCP_server->incomming_connection_queue_index;
+    ++TCP_server->incoming_connection_queue_index;
     return index;
 }
 
-static sock_t new_listening_TCP_socket(int family, uint16_t port)
+static Socket new_listening_TCP_socket(Family family, uint16_t port)
 {
-    sock_t sock = socket(family, SOCK_STREAM, IPPROTO_TCP);
+    Socket sock = net_socket(family, TOX_SOCK_STREAM, TOX_PROTO_TCP);
 
     if (!sock_valid(sock)) {
-        return ~0;
+        return net_invalid_socket;
     }
 
     int ok = set_socket_nonblock(sock);
 
-    if (ok && family == AF_INET6) {
+    if (ok && net_family_is_ipv6(family)) {
         ok = set_socket_dualstack(sock);
     }
 
@@ -929,11 +1015,11 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
         ok = set_socket_reuseaddr(sock);
     }
 
-    ok = ok && bind_to_port(sock, family, port) && (listen(sock, TCP_MAX_BACKLOG) == 0);
+    ok = ok && bind_to_port(sock, family, port) && (net_listen(sock, TCP_MAX_BACKLOG) == 0);
 
     if (!ok) {
         kill_sock(sock);
-        return ~0;
+        return net_invalid_socket;
     }
 
     return sock;
@@ -942,23 +1028,25 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
 TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *secret_key,
                            Onion *onion)
 {
-    if (num_sockets == 0 || ports == NULL)
-        return NULL;
+    if (num_sockets == 0 || ports == nullptr) {
+        return nullptr;
+    }
 
     if (networking_at_startup() != 0) {
-        return NULL;
+        return nullptr;
     }
 
-    TCP_Server *temp = calloc(1, sizeof(TCP_Server));
+    TCP_Server *temp = (TCP_Server *)calloc(1, sizeof(TCP_Server));
 
-    if (temp == NULL)
-        return NULL;
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
-    temp->socks_listening = calloc(num_sockets, sizeof(sock_t));
+    temp->socks_listening = (Socket *)calloc(num_sockets, sizeof(Socket));
 
-    if (temp->socks_listening == NULL) {
+    if (temp->socks_listening == nullptr) {
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
 #ifdef TCP_SERVER_USE_EPOLL
@@ -967,18 +1055,12 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
     if (temp->efd == -1) {
         free(temp->socks_listening);
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
 #endif
 
-    uint8_t family;
-
-    if (ipv6_enabled) {
-        family = AF_INET6;
-    } else {
-        family = AF_INET;
-    }
+    const Family family = ipv6_enabled ? net_family_ipv6 : net_family_ipv4;
 
     uint32_t i;
 #ifdef TCP_SERVER_USE_EPOLL
@@ -986,14 +1068,14 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
 #endif
 
     for (i = 0; i < num_sockets; ++i) {
-        sock_t sock = new_listening_TCP_socket(family, ports[i]);
+        Socket sock = new_listening_TCP_socket(family, ports[i]);
 
         if (sock_valid(sock)) {
 #ifdef TCP_SERVER_USE_EPOLL
             ev.events = EPOLLIN | EPOLLET;
-            ev.data.u64 = sock | ((uint64_t)TCP_SOCKET_LISTENING << 32);
+            ev.data.u64 = sock.socket | ((uint64_t)TCP_SOCKET_LISTENING << 32);
 
-            if (epoll_ctl(temp->efd, EPOLL_CTL_ADD, sock, &ev) == -1) {
+            if (epoll_ctl(temp->efd, EPOLL_CTL_ADD, sock.socket, &ev) == -1) {
                 continue;
             }
 
@@ -1007,7 +1089,7 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
     if (temp->num_listening_socks == 0) {
         free(temp->socks_listening);
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
     if (onion) {
@@ -1015,48 +1097,50 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
         set_callback_handle_recv_1(onion, &handle_onion_recv_1, temp);
     }
 
-    memcpy(temp->secret_key, secret_key, crypto_box_SECRETKEYBYTES);
-    crypto_scalarmult_curve25519_base(temp->public_key, temp->secret_key);
+    memcpy(temp->secret_key, secret_key, CRYPTO_SECRET_KEY_SIZE);
+    crypto_derive_public_key(temp->public_key, temp->secret_key);
 
-    bs_list_init(&temp->accepted_key_list, crypto_box_PUBLICKEYBYTES, 8);
+    bs_list_init(&temp->accepted_key_list, CRYPTO_PUBLIC_KEY_SIZE, 8);
 
     return temp;
 }
 
+#ifndef TCP_SERVER_USE_EPOLL
 static void do_TCP_accept_new(TCP_Server *TCP_server)
 {
     uint32_t i;
 
     for (i = 0; i < TCP_server->num_listening_socks; ++i) {
-        struct sockaddr_storage addr;
-        unsigned int addrlen = sizeof(addr);
-        sock_t sock;
+        Socket sock;
 
         do {
-            sock = accept(TCP_server->socks_listening[i], (struct sockaddr *)&addr, &addrlen);
+            sock = net_accept(TCP_server->socks_listening[i]);
         } while (accept_connection(TCP_server, sock) != -1);
     }
 }
+#endif
 
 static int do_incoming(TCP_Server *TCP_server, uint32_t i)
 {
-    if (TCP_server->incomming_connection_queue[i].status != TCP_STATUS_CONNECTED)
+    if (TCP_server->incoming_connection_queue[i].status != TCP_STATUS_CONNECTED) {
         return -1;
+    }
 
-    int ret = read_connection_handshake(&TCP_server->incomming_connection_queue[i], TCP_server->secret_key);
+    int ret = read_connection_handshake(&TCP_server->incoming_connection_queue[i], TCP_server->secret_key);
 
     if (ret == -1) {
-        kill_TCP_connection(&TCP_server->incomming_connection_queue[i]);
+        kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[i]);
     } else if (ret == 1) {
-        int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
-        TCP_Secure_Connection *conn_old = &TCP_server->incomming_connection_queue[i];
+        int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMING_CONNECTIONS;
+        TCP_Secure_Connection *conn_old = &TCP_server->incoming_connection_queue[i];
         TCP_Secure_Connection *conn_new = &TCP_server->unconfirmed_connection_queue[index_new];
 
-        if (conn_new->status != TCP_STATUS_NO_STATUS)
-            kill_TCP_connection(conn_new);
+        if (conn_new->status != TCP_STATUS_NO_STATUS) {
+            kill_TCP_secure_connection(conn_new);
+        }
 
         memcpy(conn_new, conn_old, sizeof(TCP_Secure_Connection));
-        sodium_memzero(conn_old, sizeof(TCP_Secure_Connection));
+        crypto_memzero(conn_old, sizeof(TCP_Secure_Connection));
         ++TCP_server->unconfirmed_connection_queue_index;
 
         return index_new;
@@ -1069,8 +1153,9 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
 {
     TCP_Secure_Connection *conn = &TCP_server->unconfirmed_connection_queue[i];
 
-    if (conn->status != TCP_STATUS_UNCONFIRMED)
+    if (conn->status != TCP_STATUS_UNCONFIRMED) {
         return -1;
+    }
 
     uint8_t packet[MAX_PACKET_SIZE];
     int len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key, conn->recv_nonce,
@@ -1078,12 +1163,14 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
 
     if (len == 0) {
         return -1;
-    } else if (len == -1) {
-        kill_TCP_connection(conn);
+    }
+
+    if (len == -1) {
+        kill_TCP_secure_connection(conn);
         return -1;
-    } else {
-        return confirm_TCP_connection(TCP_server, conn, packet, len);
     }
+
+    return confirm_TCP_connection(TCP_server, conn, packet, len);
 }
 
 static void do_confirmed_recv(TCP_Server *TCP_server, uint32_t i)
@@ -1107,11 +1194,12 @@ static void do_confirmed_recv(TCP_Server *TCP_server, uint32_t i)
     }
 }
 
-static void do_TCP_incomming(TCP_Server *TCP_server)
+#ifndef TCP_SERVER_USE_EPOLL
+static void do_TCP_incoming(TCP_Server *TCP_server)
 {
     uint32_t i;
 
-    for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
+    for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
         do_incoming(TCP_server, i);
     }
 }
@@ -1120,17 +1208,19 @@ static void do_TCP_unconfirmed(TCP_Server *TCP_server)
 {
     uint32_t i;
 
-    for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
+    for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
         do_unconfirmed(TCP_server, i);
     }
 }
+#endif
 
 static void do_TCP_confirmed(TCP_Server *TCP_server)
 {
 #ifdef TCP_SERVER_USE_EPOLL
 
-    if (TCP_server->last_run_pinged == unix_time())
+    if (TCP_server->last_run_pinged == unix_time()) {
         return;
+    }
 
     TCP_server->last_run_pinged = unix_time();
 #endif
@@ -1139,16 +1229,18 @@ static void do_TCP_confirmed(TCP_Server *TCP_server)
     for (i = 0; i < TCP_server->size_accepted_connections; ++i) {
         TCP_Secure_Connection *conn = &TCP_server->accepted_connection_array[i];
 
-        if (conn->status != TCP_STATUS_CONFIRMED)
+        if (conn->status != TCP_STATUS_CONFIRMED) {
             continue;
+        }
 
         if (is_timeout(conn->last_pinged, TCP_PING_FREQUENCY)) {
             uint8_t ping[1 + sizeof(uint64_t)];
             ping[0] = TCP_PACKET_PING;
-            uint64_t ping_id = random_64b();
+            uint64_t ping_id = random_u64();
 
-            if (!ping_id)
+            if (!ping_id) {
                 ++ping_id;
+            }
 
             memcpy(ping + 1, &ping_id, sizeof(uint64_t));
             int ret = write_packet_TCP_secure_connection(conn, ping, sizeof(ping), 1);
@@ -1190,8 +1282,9 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
         int n;
 
         for (n = 0; n < nfds; ++n) {
-            sock_t sock = events[n].data.u64 & 0xFFFFFFFF;
-            int status = (events[n].data.u64 >> 32) & 0xFF, index = (events[n].data.u64 >> 40);
+            const Socket sock = {(int)(events[n].data.u64 & 0xFFFFFFFF)};
+            const int status = (events[n].data.u64 >> 32) & 0xFF;
+            const int index = events[n].data.u64 >> 40;
 
             if ((events[n].events & EPOLLERR) || (events[n].events & EPOLLHUP) || (events[n].events & EPOLLRDHUP)) {
                 switch (status) {
@@ -1201,12 +1294,12 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                     }
 
                     case TCP_SOCKET_INCOMING: {
-                        kill_TCP_connection(&TCP_server->incomming_connection_queue[index]);
+                        kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index]);
                         break;
                     }
 
                     case TCP_SOCKET_UNCONFIRMED: {
-                        kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index]);
+                        kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index]);
                         break;
                     }
 
@@ -1227,11 +1320,8 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
             switch (status) {
                 case TCP_SOCKET_LISTENING: {
                     //socket is from socks_listening, accept connection
-                    struct sockaddr_storage addr;
-                    unsigned int addrlen = sizeof(addr);
-
                     while (1) {
-                        sock_t sock_new = accept(sock, (struct sockaddr *)&addr, &addrlen);
+                        Socket sock_new = net_accept(sock);
 
                         if (!sock_valid(sock_new)) {
                             break;
@@ -1245,11 +1335,11 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
 
                         struct epoll_event ev = {
                             .events = EPOLLIN | EPOLLET | EPOLLRDHUP,
-                            .data.u64 = sock_new | ((uint64_t)TCP_SOCKET_INCOMING << 32) | ((uint64_t)index_new << 40)
+                            .data.u64 = sock_new.socket | ((uint64_t)TCP_SOCKET_INCOMING << 32) | ((uint64_t)index_new << 40)
                         };
 
-                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new, &ev) == -1) {
-                            kill_TCP_connection(&TCP_server->incomming_connection_queue[index_new]);
+                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new.socket, &ev) == -1) {
+                            kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index_new]);
                             continue;
                         }
                     }
@@ -1262,10 +1352,10 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
 
                     if ((index_new = do_incoming(TCP_server, index)) != -1) {
                         events[n].events = EPOLLIN | EPOLLET | EPOLLRDHUP;
-                        events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_UNCONFIRMED << 32) | ((uint64_t)index_new << 40);
+                        events[n].data.u64 = sock.socket | ((uint64_t)TCP_SOCKET_UNCONFIRMED << 32) | ((uint64_t)index_new << 40);
 
-                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
-                            kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
+                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock.socket, &events[n]) == -1) {
+                            kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
                             break;
                         }
                     }
@@ -1278,9 +1368,9 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
 
                     if ((index_new = do_unconfirmed(TCP_server, index)) != -1) {
                         events[n].events = EPOLLIN | EPOLLET | EPOLLRDHUP;
-                        events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_CONFIRMED << 32) | ((uint64_t)index_new << 40);
+                        events[n].data.u64 = sock.socket | ((uint64_t)TCP_SOCKET_CONFIRMED << 32) | ((uint64_t)index_new << 40);
 
-                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
+                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock.socket, &events[n]) == -1) {
                             //remove from confirmed connections
                             kill_accepted(TCP_server, index_new);
                             break;
@@ -1311,7 +1401,7 @@ void do_TCP_server(TCP_Server *TCP_server)
 
 #else
     do_TCP_accept_new(TCP_server);
-    do_TCP_incomming(TCP_server);
+    do_TCP_incoming(TCP_server);
     do_TCP_unconfirmed(TCP_server);
 #endif
 
@@ -1327,7 +1417,7 @@ void kill_TCP_server(TCP_Server *TCP_server)
     }
 
     if (TCP_server->onion) {
-        set_callback_handle_recv_1(TCP_server->onion, NULL, NULL);
+        set_callback_handle_recv_1(TCP_server->onion, nullptr, nullptr);
     }
 
     bs_list_free(&TCP_server->accepted_key_list);
diff --git a/toxcore/TCP_server.h b/toxcore/TCP_server.h
index 3f6b18ae..c8cbeda0 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -1,49 +1,46 @@
 /*
-* TCP_server.h -- Implementation of the TCP relay server part of Tox.
-*
-*  Copyright (C) 2014 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the TCP relay server part of Tox.
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifndef TCP_SERVER_H
 #define TCP_SERVER_H
 
 #include "crypto_core.h"
-#include "onion.h"
 #include "list.h"
+#include "onion.h"
 
 #ifdef TCP_SERVER_USE_EPOLL
-#include "sys/epoll.h"
+#include <sys/epoll.h>
 #endif
 
-#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MACH__)
-#define MSG_NOSIGNAL 0
-#endif
-
-#define MAX_INCOMMING_CONNECTIONS 256
+#define MAX_INCOMING_CONNECTIONS 256
 
-#define TCP_MAX_BACKLOG MAX_INCOMMING_CONNECTIONS
+#define TCP_MAX_BACKLOG MAX_INCOMING_CONNECTIONS
 
 #define MAX_PACKET_SIZE 2048
 
-#define TCP_HANDSHAKE_PLAIN_SIZE (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES)
-#define TCP_SERVER_HANDSHAKE_SIZE (crypto_box_NONCEBYTES + TCP_HANDSHAKE_PLAIN_SIZE + crypto_box_MACBYTES)
-#define TCP_CLIENT_HANDSHAKE_SIZE (crypto_box_PUBLICKEYBYTES + TCP_SERVER_HANDSHAKE_SIZE)
+#define TCP_HANDSHAKE_PLAIN_SIZE (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE)
+#define TCP_SERVER_HANDSHAKE_SIZE (CRYPTO_NONCE_SIZE + TCP_HANDSHAKE_PLAIN_SIZE + CRYPTO_MAC_SIZE)
+#define TCP_CLIENT_HANDSHAKE_SIZE (CRYPTO_PUBLIC_KEY_SIZE + TCP_SERVER_HANDSHAKE_SIZE)
 #define TCP_MAX_OOB_DATA_LENGTH 1024
 
 #define NUM_RESERVED_PORTS 16
@@ -88,58 +85,10 @@ struct TCP_Priority_List {
     uint8_t data[];
 };
 
-typedef struct TCP_Secure_Connection {
-    uint8_t status;
-    sock_t  sock;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* Nonce of received packets. */
-    uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* Nonce of sent packets. */
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    uint16_t next_packet_length;
-    struct {
-        uint8_t status; /* 0 if not used, 1 if other is offline, 2 if other is online. */
-        uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-        uint32_t index;
-        uint8_t other_id;
-    } connections[NUM_CLIENT_CONNECTIONS];
-    uint8_t last_packet[2 + MAX_PACKET_SIZE];
-    uint16_t last_packet_length;
-    uint16_t last_packet_sent;
-
-    TCP_Priority_List *priority_queue_start, *priority_queue_end;
+typedef struct TCP_Server TCP_Server;
 
-    uint64_t identifier;
-
-    uint64_t last_pinged;
-    uint64_t ping_id;
-} TCP_Secure_Connection;
-
-
-typedef struct {
-    Onion *onion;
-
-#ifdef TCP_SERVER_USE_EPOLL
-    int efd;
-    uint64_t last_run_pinged;
-#endif
-    sock_t *socks_listening;
-    unsigned int num_listening_socks;
-
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t secret_key[crypto_box_SECRETKEYBYTES];
-    TCP_Secure_Connection incomming_connection_queue[MAX_INCOMMING_CONNECTIONS];
-    uint16_t incomming_connection_queue_index;
-    TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMMING_CONNECTIONS];
-    uint16_t unconfirmed_connection_queue_index;
-
-    TCP_Secure_Connection *accepted_connection_array;
-    uint32_t size_accepted_connections;
-    uint32_t num_accepted_connections;
-
-    uint64_t counter;
-
-    BS_LIST accepted_key_list;
-} TCP_Server;
+const uint8_t *tcp_server_public_key(const TCP_Server *tcp_server);
+size_t tcp_server_listen_count(const TCP_Server *tcp_server);
 
 /* Create new TCP server instance.
  */
@@ -154,11 +103,6 @@ void do_TCP_server(TCP_Server *TCP_server);
  */
 void kill_TCP_server(TCP_Server *TCP_server);
 
-/* return the amount of data in the tcp recv buffer.
- * return 0 on failure.
- */
-unsigned int TCP_socket_data_recv_buffer(sock_t sock);
-
 /* Read the next two bytes in TCP stream then convert them to
  * length (host byte order).
  *
@@ -166,20 +110,20 @@ unsigned int TCP_socket_data_recv_buffer(sock_t sock);
  * return 0 if nothing has been read from socket.
  * return ~0 on failure.
  */
-uint16_t read_TCP_length(sock_t sock);
+uint16_t read_TCP_length(Socket sock);
 
 /* Read length bytes from socket.
  *
  * return length on success
  * return -1 on failure/no data in buffer.
  */
-int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length);
+int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length);
 
 /* return length of received packet on success.
  * return 0 if could not read any packet.
  * return -1 on failure (connection must be killed).
  */
-int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, const uint8_t *shared_key,
+int read_packet_TCP_secure_connection(Socket sock, uint16_t *next_packet_length, const uint8_t *shared_key,
                                       uint8_t *recv_nonce, uint8_t *data, uint16_t max_len);
 
 
diff --git a/toxcore/assoc.c b/toxcore/assoc.c
deleted file mode 100644
index 932adc76..00000000
--- a/toxcore/assoc.c
+++ /dev/null
@@ -1,1031 +0,0 @@
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "logger.h"
-#include "DHT.h"
-#include "assoc.h"
-#include "ping.h"
-
-#include "LAN_discovery.h"
-
-#include <assert.h>
-#include "util.h"
-
-/*
- *        BASIC OVERVIEW:
- *
- * Hash: The client_id is hashed with a local hash function.
- * Hashes are used in multiple places for searching.
- * Bucket: The first n bits of the client_id are used to
- * select a bucket. This speeds up sorting, but the more
- * important reason is to enforce a spread in the space of
- * client_ids available.
- *
- *
- * Candidates:
- *
- * Candidates are kept in buckets of hash tables. The hash
- * function is calculated from the client_id. Up to
- * HASH_COLLIDE_COUNT alternative positions are tried if
- * the initial position is already used by a different entry.
- * The collision function is multiplicative, not additive.
- *
- * A new candidate can bump an existing candidate, if it is
- * more "desirable": Seen beats Heard.
- */
-
-/* candidates: alternative places for the same hash value */
-#define HASH_COLLIDE_COUNT 5
-
-/* bucket size shall be co-prime to this */
-#define HASH_COLLIDE_PRIME 101
-
-/* candidates: bump entries: timeout values for seen/heard to be considered of value */
-#define CANDIDATES_SEEN_TIMEOUT 1800
-#define CANDIDATES_HEARD_TIMEOUT 600
-
-/* distance/index: index size & access mask */
-#define DISTANCE_INDEX_INDEX_BITS (64 - DISTANCE_INDEX_DISTANCE_BITS)
-#define DISTANCE_INDEX_INDEX_MASK ((1 << DISTANCE_INDEX_INDEX_BITS) - 1)
-
-/* types to stay consistent */
-typedef uint16_t bucket_t;
-typedef uint32_t hash_t;
-typedef uint16_t usecnt_t;
-
-/* abbreviations ... */
-typedef Assoc_distance_relative_callback dist_rel_cb;
-typedef Assoc_distance_absolute_callback dist_abs_cb;
-
-/*
- * Client_data wrapped with additional data
- */
-typedef struct Client_entry {
-    hash_t             hash;
-
-    /* shortcuts & rumors: timers and data */
-    uint64_t           getnodes;
-    uint64_t           used_at;
-
-    uint64_t           seen_at;
-    uint64_t           heard_at;
-
-    uint16_t           seen_family;
-    uint16_t           heard_family;
-
-    IP_Port            assoc_heard4;
-    IP_Port            assoc_heard6;
-
-    Client_data        client;
-} Client_entry;
-
-typedef struct candidates_bucket {
-    Client_entry          *list;                               /* hashed list */
-} candidates_bucket;
-
-struct Assoc {
-    hash_t                 self_hash;                          /* hash of self_client_id */
-    uint8_t                self_client_id[crypto_box_PUBLICKEYBYTES];     /* don't store entries for this */
-
-    /* association centralization: clients not in use */
-    size_t                 candidates_bucket_bits;
-    size_t                 candidates_bucket_count;
-    size_t                 candidates_bucket_size;
-    candidates_bucket     *candidates;
-    uint64_t               getnodes;
-};
-
-/*****************************************************************************/
-/*                             HELPER FUNCTIONS                              */
-/*****************************************************************************/
-
-/* the complete distance would be crypto_box_PUBLICKEYBYTES long...
- * returns DISTANCE_INDEX_DISTANCE_BITS valid bits */
-static uint64_t id_distance(const Assoc *assoc, void *callback_data, const uint8_t *id_ref, const uint8_t *id_test)
-{
-    /* with BIG_ENDIAN, this would be a one-liner... */
-    uint64_t retval = 0;
-
-    uint8_t pos = 0, bits = DISTANCE_INDEX_DISTANCE_BITS;
-
-    while (bits > 8) {
-        uint8_t distance = abs((int8_t)id_ref[pos] ^ (int8_t)id_test[pos]);
-        retval = (retval << 8) | distance;
-        bits -= 8;
-        pos++;
-    }
-
-    return (retval << bits) | ((id_ref[pos] ^ id_test[pos]) >> (8 - bits));
-}
-
-/* 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;
-
-    if (*_a < *_b)
-        return -1;
-
-    if (*_a > *_b)
-        return 1;
-
-    return 0;
-}
-
-/* get actual entry to a distance_index */
-static Client_entry *dist_index_entry(Assoc *assoc, uint64_t dist_ind)
-{
-    if ((dist_ind & DISTANCE_INDEX_INDEX_MASK) == DISTANCE_INDEX_INDEX_MASK)
-        return NULL;
-
-    size_t total = assoc->candidates_bucket_count * assoc->candidates_bucket_size;
-    uint32_t index = dist_ind & DISTANCE_INDEX_INDEX_MASK;
-
-    if (index < total) {
-        bucket_t b_id = index / assoc->candidates_bucket_size;
-        candidates_bucket *cnd_bckt = &assoc->candidates[b_id];
-        size_t b_ix = index % assoc->candidates_bucket_size;
-        Client_entry *entry = &cnd_bckt->list[b_ix];
-
-        if (entry->hash)
-            return entry;
-    }
-
-    return NULL;
-}
-
-/* get actual entry's public_key to a distance_index */
-static uint8_t *dist_index_id(Assoc *assoc, uint64_t dist_ind)
-{
-    Client_entry *entry = dist_index_entry(assoc, dist_ind);
-
-    if (entry)
-        return entry->client.public_key;
-
-    return NULL;
-}
-
-/* sorts first .. last, i.e. last is included */
-static void dist_index_bubble(Assoc *assoc, uint64_t *dist_list, size_t first, size_t last, uint8_t *id,
-                              void *custom_data, Assoc_distance_relative_callback dist_rel_func)
-{
-    size_t i, k;
-
-    for (i = first; i <= last; i++) {
-        uint8_t *id1 = dist_index_id(assoc, dist_list[i]);
-
-        for (k = i + 1; k <= last; k++) {
-            uint8_t *id2 = dist_index_id(assoc, dist_list[k]);
-
-            if (id1 && id2)
-                if (dist_rel_func(assoc, custom_data, id, id1, id2) == 2) {
-                    uint64_t swap = dist_list[i];
-                    dist_list[i] = dist_list[k];
-                    dist_list[k] = swap;
-                }
-        }
-    }
-}
-
-/* TODO: Check that there isn't a function like this elsewhere hidden.
- * E.g. the one which creates a handshake_id isn't usable for this, it must
- * always map the same ID to the same hash.
- *
- * Result is NOT MAPPED to CANDIDATES_TO_KEEP range, i.e. map before using
- * it for list access. */
-static hash_t id_hash(const Assoc *assoc, const uint8_t *id)
-{
-    uint32_t i, res = 0x19a64e82;
-
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++)
-        res = ((res << 1) ^ id[i]) + (res >> 31);
-
-    /* can't have zero as hash, a) marks an unused spot,
-     * b) collision function is multiplicative */
-    if (!(res % assoc->candidates_bucket_size))
-        res++;
-
-    return res;
-}
-
-/* up to HASH_COLLIDE_COUNT calls to different spots,
- * result IS mapped to CANDIDATES_TO_KEEP range */
-static hash_t hash_collide(const Assoc *assoc, hash_t hash)
-{
-    uint64_t hash64 = hash % assoc->candidates_bucket_size;
-    hash64 = (hash64 * HASH_COLLIDE_PRIME) % assoc->candidates_bucket_size;
-
-    hash_t retval = hash64;
-
-    /* this should never happen when CANDIDATES_TO_KEEP is prime and hash not a multiple
-     * (id_hash() checks for a multiple and returns a different hash in that case)
-     *
-     * ( 1 .. (prime - 1) is a group over multiplication and every number has its inverse
-     *   in the group, so no multiplication should ever end on zero as long neither
-     *   of the two factors was zero-equivalent )
-     *
-     * BUT: because the usage of the word "never" invokes Murphy's law, catch it */
-    if (!retval) {
-#ifdef DEBUG
-        fprintf(stderr, "assoc::hash_collide: hash %u, bucket size %u => %u!", hash, (uint)assoc->candidates_bucket_size,
-                retval);
-        assert(retval != 0);
-#endif
-        retval = 1;
-    }
-
-    return retval;
-}
-
-/* returns the "seen" assoc related to the ipp */
-static IPPTsPng *entry_assoc(Client_entry *cl_entry, const IP_Port *ipp)
-{
-    if (!cl_entry)
-        return NULL;
-
-    if (ipp->ip.family == AF_INET)
-        return &cl_entry->client.assoc4;
-
-    if (ipp->ip.family == AF_INET6)
-        return &cl_entry->client.assoc6;
-
-    return NULL;
-}
-
-/* returns the "heard" assoc related to the ipp */
-static IP_Port *entry_heard_get(Client_entry *entry, const IP_Port *ipp)
-{
-    if (ipp->ip.family == AF_INET)
-        return &entry->assoc_heard4;
-    else if (ipp->ip.family == AF_INET6)
-        return &entry->assoc_heard6;
-    else
-        return NULL;
-}
-
-/* store a "heard" entry
- * overwrites empty entry, does NOT overwrite non-LAN ip with
- * LAN ip
- *
- * returns 1 if the entry did change */
-static int entry_heard_store(Client_entry *entry, const IPPTs *ippts)
-{
-    if (!entry || !ippts)
-        return 0;
-
-    if (!ipport_isset(&ippts->ip_port))
-        return 0;
-
-    IP_Port  *heard;
-    const IP_Port  *ipp = &ippts->ip_port;
-
-    if (ipp->ip.family == AF_INET)
-        heard = &entry->assoc_heard4;
-    else if (ipp->ip.family == AF_INET6)
-        heard = &entry->assoc_heard6;
-    else
-        return 0;
-
-    if (ipport_equal(ipp, heard))
-        return 0;
-
-    if (!ipport_isset(heard)) {
-        *heard = *ipp;
-        entry->heard_at = ippts->timestamp;
-        entry->heard_family = ipp->ip.family;
-        return 1;
-    }
-
-    /* don't destroy a good address with a crappy one
-     * (unless we're very timed out) */
-    uint8_t LAN_ipp = LAN_ip(ipp->ip) == 0;
-    uint8_t LAN_entry = LAN_ip(heard->ip) == 0;
-
-    if (LAN_ipp && !LAN_entry && !is_timeout(entry->heard_at, CANDIDATES_HEARD_TIMEOUT))
-        return 0;
-
-    *heard = *ipp;
-    entry->heard_at = ippts->timestamp;
-    entry->heard_family = ipp->ip.family;
-
-    return 1;
-}
-
-/* maps Assoc callback signature to id_closest() */
-static int assoc_id_closest(const Assoc *assoc, void *callback_data, const uint8_t *client_id,
-                            const uint8_t *client_id1, const uint8_t *client_id2)
-{
-    return id_closest(client_id, client_id1, client_id2);
-}
-
-static bucket_t id_bucket(const uint8_t *id, uint8_t bits)
-{
-    /* return the first "bits" bits of id */
-    bucket_t retval = 0;
-
-    uint8_t pos = 0;
-
-    while (bits > 8) {
-        retval = (retval << 8) | id[pos++];
-        bits -= 8;
-    }
-
-    return (retval << bits) | (id[pos] >> (8 - bits));
-}
-
-/*****************************************************************************/
-/*                          CANDIDATES FUNCTIONS                             */
-/*****************************************************************************/
-
-
-static bucket_t candidates_id_bucket(const Assoc *assoc, const uint8_t *id)
-{
-    return id_bucket(id, assoc->candidates_bucket_bits);
-}
-
-static uint8_t candidates_search(const Assoc *assoc, const uint8_t *id, hash_t hash, Client_entry **entryptr)
-{
-    bucket_t bucket = candidates_id_bucket(assoc, id);
-    candidates_bucket *cnd_bckt = &assoc->candidates[bucket];
-    size_t coll, pos = hash % assoc->candidates_bucket_size;
-
-    for (coll = 0; coll < HASH_COLLIDE_COUNT; pos = hash_collide(assoc, pos) , coll++) {
-        Client_entry *entry = &cnd_bckt->list[pos];
-
-        if (entry->hash == hash)
-            if (id_equal(entry->client.public_key, id)) {
-                *entryptr = entry;
-                return 1;
-            }
-    }
-
-    *entryptr = NULL;
-    return 0;
-}
-
-static void candidates_update_assoc(const Assoc *assoc, Client_entry *entry, uint8_t used, const IPPTs *ippts_send,
-                                    const IP_Port *ipp_recv)
-{
-    if (!assoc || !entry || !ippts_send)
-        return;
-
-    IPPTsPng *ipptsp = entry_assoc(entry, &ippts_send->ip_port);
-
-    if (!ipptsp)
-        return;
-
-    if (used)
-        entry->used_at = unix_time();
-
-    /* do NOT do anything related to wanted, that's handled outside,
-     * just update the assoc (in the most sensible way)
-     */
-    if (ipp_recv) {
-        ipptsp->ip_port = ippts_send->ip_port;
-        ipptsp->timestamp = ippts_send->timestamp;
-        ipptsp->ret_ip_port = *ipp_recv;
-        ipptsp->ret_timestamp = unix_time();
-
-        entry->seen_at = unix_time();
-        entry->seen_family = ippts_send->ip_port.ip.family;
-
-        return;
-    }
-
-    entry_heard_store(entry, ippts_send);
-}
-
-static uint8_t candidates_create_internal(const Assoc *assoc, hash_t const hash, const uint8_t *id, uint8_t seen,
-        uint8_t used, bucket_t *bucketptr, size_t *posptr)
-{
-    if (!assoc || !id || !bucketptr ||  !posptr)
-        return 0;
-
-    bucket_t bucket = candidates_id_bucket(assoc, id);
-    candidates_bucket *cnd_bckt = &assoc->candidates[bucket];
-
-    size_t coll, pos = hash % assoc->candidates_bucket_size, check;
-    size_t pos_check[6];
-
-    memset(pos_check, 0, sizeof(pos_check));
-
-    for (coll = 0; coll < HASH_COLLIDE_COUNT; pos = hash_collide(assoc, pos) , coll++) {
-        Client_entry *entry = &cnd_bckt->list[pos];
-
-        /* unset */
-        if (!entry->hash) {
-            *bucketptr = bucket;
-            *posptr = pos;
-
-            return 1;
-        }
-
-        /* 0. bad
-         * 1. seen bad, heard good
-         * 2. seen good
-         * 3. used */
-        // enumerated lists are superior to magic numbers
-        if (!is_timeout(entry->used_at, BAD_NODE_TIMEOUT))
-            check = USED;
-        else if (!is_timeout(entry->seen_at, CANDIDATES_SEEN_TIMEOUT))
-            check = SEENG;
-        else if (!is_timeout(entry->heard_at, CANDIDATES_HEARD_TIMEOUT))
-            check = SEENB_HEARDG;
-        else
-            check = BAD;
-
-        if (!pos_check[check])
-            pos_check[check] = pos + 1;
-    }
-
-    /* used > seen > heard > bad */
-    size_t i, pos_max = used ? USED : (seen ? SEENG : SEENB_HEARDG);
-
-    for (i = 0; i < pos_max; i++)
-        if (pos_check[i]) {
-            *bucketptr = bucket;
-            *posptr = pos_check[i] - 1;
-
-            return 1;
-        }
-
-    return 0;
-}
-
-static uint8_t candidates_create_new(const Assoc *assoc, hash_t hash, const uint8_t *id, uint8_t used,
-                                     const IPPTs *ippts_send, const IP_Port *ipp_recv)
-{
-    if (!assoc || !id || !ippts_send)
-        return 0;
-
-    bucket_t bucket;
-    size_t pos;
-
-    if (!candidates_create_internal(assoc, hash, id, ipp_recv != NULL, used, &bucket, &pos))
-        return 0;
-
-    candidates_bucket *cnd_bckt = &assoc->candidates[bucket];
-    Client_entry *entry = &cnd_bckt->list[pos];
-    memset(entry, 0, sizeof(*entry));
-    IPPTsPng *ipptsp = entry_assoc(entry, &ippts_send->ip_port);
-
-    if (!ipptsp)
-        return 0;
-
-    entry->hash = hash;
-    id_copy(entry->client.public_key, id);
-
-    if (used)
-        entry->used_at = unix_time();
-
-    if (ipp_recv && !ipport_isset(ipp_recv))
-        ipp_recv = NULL;
-
-    if (ipp_recv) {
-        entry->seen_at = ippts_send->timestamp;
-        entry->seen_family = ippts_send->ip_port.ip.family;
-
-        ipptsp->ip_port = ippts_send->ip_port;
-        ipptsp->timestamp = ippts_send->timestamp;
-        ipptsp->ret_ip_port = *ipp_recv;
-        ipptsp->ret_timestamp = unix_time();
-    } else {
-        IP_Port *heard = entry_heard_get(entry, &ippts_send->ip_port);
-
-        if (heard) {
-            entry->heard_at = ippts_send->timestamp;
-            entry->heard_family = ippts_send->ip_port.ip.family;
-
-            *heard = ippts_send->ip_port;
-        }
-    }
-
-    return 1;
-}
-
-/*****************************************************************************/
-
-static void client_id_self_update(Assoc *assoc)
-{
-    if (assoc->self_hash)
-        return;
-
-    size_t i, sum = 0;
-
-    for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++)
-        sum |= assoc->self_client_id[i];
-
-    if (!sum)
-        return;
-
-    assoc->self_hash = id_hash(assoc, assoc->self_client_id);
-
-    LOGGER_DEBUG("id is now set, purging cache of self-references");
-
-    /* if we already added some (or loaded some) entries,
-     * look and remove if we find a match
-     */
-    bucket_t b_id = candidates_id_bucket(assoc, assoc->self_client_id);
-    candidates_bucket *cnd_bckt = &assoc->candidates[b_id];
-    size_t pos = assoc->self_hash % assoc->candidates_bucket_size;
-
-    for (i = 0; i < HASH_COLLIDE_COUNT; pos = hash_collide(assoc, pos), i++) {
-        Client_entry *entry = &cnd_bckt->list[pos];
-
-        if (entry->hash == assoc->self_hash)
-            if (id_equal(entry->client.public_key, assoc->self_client_id))
-                entry->hash = 0;
-    }
-}
-
-/*****************************************************************************/
-/*                            TRIGGER FUNCTIONS                              */
-/*****************************************************************************/
-
-/* Central entry point for new associations: add a new candidate to the cache
- * seen should be 0 (zero), if the candidate was announced by someone else,
- * seen should be 1 (one), if there is confirmed connectivity (a definite response)
- */
-uint8_t Assoc_add_entry(Assoc *assoc, const uint8_t *id, const IPPTs *ippts_send, const IP_Port *ipp_recv, uint8_t used)
-{
-    if (!assoc || !id || !ippts_send)
-        return 0;
-
-    if (!assoc->self_hash) {
-        client_id_self_update(assoc);
-
-        if (!assoc->self_hash)
-            return 0;
-    }
-
-    if (!ipport_isset(&ippts_send->ip_port))
-        return 0;
-
-    if (ipp_recv && !ipport_isset(ipp_recv))
-        ipp_recv = NULL;
-
-    hash_t hash = id_hash(assoc, id);
-
-    if (hash == assoc->self_hash)
-        if (id_equal(id, assoc->self_client_id))
-            return 0;
-
-    /* if it's new:
-     * callback, if there's desire, add to clients, else to candidates
-     *
-     * if it's "old":
-     *    if it's client: refresh
-     *    if it's candidate:
-     *       if !ipp_recv, refresh
-     *       if ipp_recv: callback, if there's desire, move to candidates
-     */
-    Client_entry *cnd_entry;
-
-    if (!candidates_search(assoc, id, hash, &cnd_entry)) {
-        if (candidates_create_new(assoc, hash, id, used, ippts_send, ipp_recv))
-            return 1;
-        else
-            return 0;
-    } else {
-        candidates_update_assoc(assoc, cnd_entry, used, ippts_send, ipp_recv);
-        return 2;
-    }
-}
-
-/*****************************************************************************/
-/*                               MAIN USE                                    */
-/*****************************************************************************/
-
-uint8_t Assoc_get_close_entries(Assoc *assoc, Assoc_close_entries *state)
-{
-    if (!assoc || !state || !state->wanted_id || !state->result)
-        return 0;
-
-    if (!assoc->self_hash) {
-        client_id_self_update(assoc);
-
-        if (!assoc->self_hash)
-            return 0;
-    }
-
-    if (!state->distance_relative_func)
-        state->distance_relative_func = assoc_id_closest;
-
-    if (!state->distance_absolute_func)
-        state->distance_absolute_func = id_distance;
-
-    size_t dist_list_len = assoc->candidates_bucket_count * assoc->candidates_bucket_size;
-    uint64_t dist_list[dist_list_len];
-    memset(dist_list, ~0, dist_list_len * sizeof(dist_list[0]));
-    bucket_t b;
-    size_t i;
-
-    for (b = 0; b < assoc->candidates_bucket_count; b++) {
-        candidates_bucket *cnd_bckt = &assoc->candidates[b];
-
-        for (i = 0; i < assoc->candidates_bucket_size; i++) {
-            Client_entry *entry = &cnd_bckt->list[i];
-
-            if (entry->hash) {
-                if (state->flags & ProtoIPv4) {
-                    if (!ipport_isset(&entry->client.assoc4.ip_port))
-                        continue;
-
-                    if (!(state->flags & LANOk))
-                        if (!LAN_ip(entry->client.assoc4.ip_port.ip))
-                            continue;
-                }
-
-                if (state->flags & ProtoIPv6) {
-                    if (!ipport_isset(&entry->client.assoc6.ip_port))
-                        continue;
-
-                    if (!(state->flags & LANOk))
-                        if (!LAN_ip(entry->client.assoc6.ip_port.ip))
-                            continue;
-                }
-
-                uint64_t dist = state->distance_absolute_func(assoc, state->custom_data, state->wanted_id, entry->client.public_key);
-                uint32_t index = b * assoc->candidates_bucket_size + i;
-                dist_list[index] = (dist << DISTANCE_INDEX_INDEX_BITS) | index;
-            }
-        }
-    }
-
-    qsort(dist_list, dist_list_len, sizeof(dist_list[0]), dist_index_comp);
-
-    /* ok, ok, it's not *perfectly* sorted, because we used an absolute distance
-     * go over the result and see if we need to "smoothen things out"
-     * because those should be only very few and short streaks, the worst regularly
-     * used sorting function aka bubble sort is used */
-    uint64_t dist_prev = ~0;
-    size_t ind_prev = ~0, ind_curr;
-    size_t len = 1;
-
-    for (ind_curr = 0; ind_curr < dist_list_len; ind_curr++) {
-        /* sorted increasingly, so an invalid entry marks the end */
-        if ((dist_list[ind_curr] & DISTANCE_INDEX_INDEX_MASK) == DISTANCE_INDEX_INDEX_MASK)
-            break;
-
-        uint64_t dist_curr = dist_list[ind_curr] >> DISTANCE_INDEX_INDEX_BITS;
-
-        if (dist_prev == dist_curr)
-            len++;
-        else {
-            if (len > 1)
-                dist_index_bubble(assoc, dist_list, ind_prev, ind_curr - 1, state->wanted_id, state->custom_data,
-                                  state->distance_relative_func);
-
-            dist_prev = dist_curr;
-            ind_prev = ind_curr;
-            len = 1;
-        }
-    }
-
-    if (len > 1)
-        dist_index_bubble(assoc, dist_list, ind_prev, ind_curr - 1, state->wanted_id, state->custom_data,
-                          state->distance_relative_func);
-
-    /* ok, now dist_list is a strictly ascending sorted list of nodes
-     * a) extract CLOSE_QUOTA_USED clients, not timed out
-     * b) extract (1 - QUOTA) (better!) clients & candidates, not timed out
-     * c) save candidates which would be better, if contact can be established */
-    size_t client_quota_good = 0, pos = 0;
-    size_t client_quota_max = state->count_good;
-
-    ssize_t taken_last = - 1;
-
-    for (i = 0; (i < dist_list_len) && (pos < state->count); i++) {
-        /* sorted increasingly, so an invalid entry marks the end */
-        if ((dist_list[i] & DISTANCE_INDEX_INDEX_MASK) == DISTANCE_INDEX_INDEX_MASK)
-            break;
-
-        Client_entry *entry = dist_index_entry(assoc, dist_list[i]);
-
-        if (entry && entry->hash) {
-            if (client_quota_good >= client_quota_max) {
-                state->result[pos++] = &entry->client;
-                taken_last = i;
-            } else {
-                if (state->flags & (ProtoIPv4 | ProtoIPv6)) {
-                    if ((state->flags & ProtoIPv4) && is_timeout(entry->client.assoc4.timestamp, BAD_NODE_TIMEOUT))
-                        continue;
-
-                    if ((state->flags & ProtoIPv6) && is_timeout(entry->client.assoc6.timestamp, BAD_NODE_TIMEOUT))
-                        continue;
-                } else if (is_timeout(entry->seen_at, BAD_NODE_TIMEOUT))
-                    continue;
-
-                state->result[pos++] = &entry->client;
-                client_quota_good++;
-                taken_last = i;
-            }
-        }
-    }
-
-    /* if we had not enough valid entries the list might still not be filled.
-     *
-     * start again from last taken client, but leave out any requirement
-     */
-    if (pos < state->count) {
-        for (i = taken_last + 1; (i < dist_list_len) && (pos < state->count); i++) {
-            /* sorted increasingly, so an invalid entry marks the end */
-            if ((dist_list[i] & DISTANCE_INDEX_INDEX_MASK) == DISTANCE_INDEX_INDEX_MASK)
-                break;
-
-            Client_entry *entry = dist_index_entry(assoc, dist_list[i]);
-
-            if (entry && entry->hash)
-                state->result[pos++] = &entry->client;
-        }
-    }
-
-    return pos;
-}
-
-/*****************************************************************************/
-/*                     GLOBAL STRUCTURE FUNCTIONS                            */
-/*****************************************************************************/
-
-static uint8_t odd_min9_is_prime(size_t value)
-{
-    size_t i = 3;
-
-    while (i * i <= value) {
-        if (!(value % i))
-            return 0;
-
-        i += 2;
-    }
-
-    return 1;
-}
-
-static size_t prime_upto_min9(size_t limit)
-{
-    /* even => odd */
-    limit = limit - (1 - (limit % 2));
-
-    while (!odd_min9_is_prime(limit))
-        limit -= 2;
-
-    return limit;
-}
-
-/* create */
-Assoc *new_Assoc(size_t bits, size_t entries, const uint8_t *public_id)
-{
-    if (!public_id)
-        return NULL;
-
-    Assoc *assoc = calloc(1, sizeof(*assoc));
-
-    if (!assoc)
-        return NULL;
-
-    /*
-     * bits must be in [ 2 .. 15 ]
-     * entries must be a prime
-     */
-    if (bits < 2)
-        bits = 2;
-    else if (bits > 15)
-        bits = 15;
-
-    assoc->candidates_bucket_bits = bits;
-    assoc->candidates_bucket_count = 1U << bits;
-
-    if (entries < 25) {
-        if (entries <= 6)
-            entries = 5;
-        else {
-            entries = entries - (1 - (entries % 2)); /* even => odd */
-
-            /* 7..23: all odds but 9&15 are prime */
-            if (!(entries % 3)) /* 9, 15 */
-                entries -= 2;   /* 7, 13 */
-        }
-    } else if (entries > ((1 << 17) - 1)) /* 130k+ */
-        entries = (1 << 17) - 1;
-    else {
-        /* 9+: test and find a prime less or equal */
-        size_t entries_test = prime_upto_min9(entries);
-
-        if (entries_test == HASH_COLLIDE_PRIME) /* disallowed */
-            entries_test = prime_upto_min9(entries_test - 1);
-
-        if (entries_test != entries) {
-
-            LOGGER_DEBUG("trimmed %i to %i.\n", (int)entries, (int)entries_test);
-            entries = (size_t)entries_test;
-        }
-    }
-
-    assoc->candidates_bucket_size = entries;
-
-    /* allocation: preferably few blobs */
-    size_t bckt, cix;
-    Client_entry *clients = 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);
-
-    if (!lists) {
-        free(assoc);
-        free(clients);
-        return NULL;
-    }
-
-    for (bckt = 0; bckt < assoc->candidates_bucket_count; bckt++) {
-        candidates_bucket *list = &lists[bckt];
-
-        list->list = &clients[bckt * assoc->candidates_bucket_size];
-
-        for (cix = 0; cix < assoc->candidates_bucket_size; cix++)
-            list->list[cix].hash = 0;
-    }
-
-    assoc->candidates = lists;
-    assoc->getnodes = unix_time();
-
-    id_copy(assoc->self_client_id, public_id);
-    client_id_self_update(assoc);
-
-    return assoc;
-}
-
-Assoc *new_Assoc_default(const uint8_t *public_id)
-{
-    /* original 8, 251 averages to ~32k entries... probably the whole DHT :D
-     * 320 entries is fine, hopefully */
-    return new_Assoc(6, 15, public_id);
-}
-
-/* own client_id, assocs for this have to be ignored */
-void Assoc_self_client_id_changed(Assoc *assoc, const uint8_t *id)
-{
-    if (assoc && id) {
-        assoc->self_hash = 0;
-        id_copy(assoc->self_client_id, id);
-        client_id_self_update(assoc);
-    }
-}
-
-#ifdef TOX_LOGGER
-static char *idpart2str(uint8_t *id, size_t len);
-#endif /* TOX_LOGGER */
-
-/* refresh buckets */
-void do_Assoc(Assoc *assoc, DHT *dht)
-{
-    if (is_timeout(assoc->getnodes, ASSOC_BUCKET_REFRESH)) {
-        assoc->getnodes = unix_time();
-
-        size_t candidate = (rand() % assoc->candidates_bucket_count) + assoc->candidates_bucket_count;
-
-        /* in that bucket or the buckets closest to it:
-         * find the best heard candidate
-         * find the best seen candidate
-         * send getnode() requests to both */
-        uint8_t *target_id = NULL;
-        Client_entry *heard = NULL, *seen = NULL;
-        size_t i, k, m;
-
-        for (i = 1; i < assoc->candidates_bucket_count; i++) {
-            if (i % 2)
-                k = - (i >> 1);
-            else
-                k = i >> 1;
-
-            size_t bckt = (candidate + k) % assoc->candidates_bucket_count;
-
-            for (m = 0; m < assoc->candidates_bucket_size; m++)
-                if (assoc->candidates[bckt].list[m].hash) {
-                    Client_entry *entry = &assoc->candidates[bckt].list[m];
-
-                    if (!is_timeout(entry->getnodes, CANDIDATES_SEEN_TIMEOUT))
-                        continue;
-
-                    if (!target_id)
-                        target_id = entry->client.public_key;
-
-                    if (entry->seen_at) {
-                        if (!seen)
-                            if (!is_timeout(entry->seen_at, CANDIDATES_SEEN_TIMEOUT))
-                                seen = entry;
-                    }
-
-                    if (entry->heard_at) {
-                        if (!heard)
-                            if (!is_timeout(entry->heard_at, CANDIDATES_HEARD_TIMEOUT))
-                                heard = entry;
-                    }
-
-                    if (seen && heard)
-                        break;
-                }
-
-            if (seen && heard)
-                break;
-        }
-
-        if (seen) {
-            IPPTsPng *ippts = seen->seen_family == AF_INET ? &seen->client.assoc4 : &seen->client.assoc6;
-
-            LOGGER_DEBUG("[%u] => S[%s...] %s:%u", (uint32_t)(candidate % assoc->candidates_bucket_count),
-                         idpart2str(seen->client.public_key, 8), ip_ntoa(&ippts->ip_port.ip), htons(ippts->ip_port.port));
-
-            DHT_getnodes(dht, &ippts->ip_port, seen->client.public_key, target_id);
-            seen->getnodes = unix_time();
-        }
-
-        if (heard && (heard != seen)) {
-            IP_Port *ipp = heard->heard_family == AF_INET ? &heard->assoc_heard4 : &heard->assoc_heard6;
-
-            LOGGER_DEBUG("[%u] => H[%s...] %s:%u", (uint32_t)(candidate % assoc->candidates_bucket_count),
-                         idpart2str(heard->client.public_key, 8), ip_ntoa(&ipp->ip), htons(ipp->port));
-
-            DHT_getnodes(dht, ipp, heard->client.public_key, target_id);
-            heard->getnodes = unix_time();
-        }
-
-        LOGGER_SCOPE (
-
-            if ( !heard && !seen )
-            LOGGER_DEBUG("[%u] => no nodes to talk to??", (uint32_t)(candidate % assoc->candidates_bucket_count));
-        );
-    }
-}
-
-/* destroy */
-void kill_Assoc(Assoc *assoc)
-{
-    if (assoc) {
-        free(assoc->candidates->list);
-        free(assoc->candidates);
-        free(assoc);
-    }
-}
-
-#ifdef TOX_LOGGER
-
-static char buffer[crypto_box_PUBLICKEYBYTES * 2 + 1];
-static char *idpart2str(uint8_t *id, size_t len)
-{
-    if (len > crypto_box_PUBLICKEYBYTES)
-        len = crypto_box_PUBLICKEYBYTES;
-
-    size_t i;
-
-    for (i = 0; i < len; i++)
-        sprintf(buffer + i * 2, "%02hhx", id[i]);
-
-    buffer[len * 2] = 0;
-    return buffer;
-}
-
-void Assoc_status(const Assoc *assoc)
-{
-    if (!assoc) {
-        LOGGER_TRACE("Assoc status: no assoc");
-        return;
-    }
-
-    LOGGER_TRACE("[b:p] hash => [id...] used, seen, heard");
-
-    size_t bid, cid, total = 0;
-
-    for (bid = 0; bid < assoc->candidates_bucket_count; bid++) {
-        candidates_bucket *bucket = &assoc->candidates[bid];
-
-        for (cid = 0; cid < assoc->candidates_bucket_size; cid++) {
-            Client_entry *entry = &bucket->list[cid];
-
-            if (entry->hash) {
-                total++;
-
-                LOGGER_TRACE("[%3i:%3i] %08x => [%s...] %i, %i(%c), %i(%c)\n",
-                             (int)bid, (int)cid, entry->hash, idpart2str(entry->client.public_key, 8),
-                             entry->used_at ? (int)(unix_time() - entry->used_at) : 0,
-                             entry->seen_at ? (int)(unix_time() - entry->seen_at) : 0,
-                             entry->seen_at ? (entry->seen_family == AF_INET ? '4' : (entry->seen_family == AF_INET6 ? '6' : '?')) : '?',
-                             entry->heard_at ? (int)(unix_time() - entry->heard_at) : 0,
-                             entry->heard_at ? (entry->heard_family == AF_INET ? '4' : (entry->heard_family == AF_INET6 ? '6' : '?')) : '?');
-            }
-        }
-    }
-
-    if (total) {
-        LOGGER_TRACE("Total: %i entries, table usage %i%%.\n", (int)total,
-                     (int)(total * 100 / (assoc->candidates_bucket_count * assoc->candidates_bucket_size)));
-    }
-}
-
-#endif /* TOX_LOGGER */
diff --git a/toxcore/assoc.h b/toxcore/assoc.h
deleted file mode 100644
index 65a2745d..00000000
--- a/toxcore/assoc.h
+++ /dev/null
@@ -1,104 +0,0 @@
-
-#ifndef __ASSOC_H__
-#define __ASSOC_H__
-
-/* used by rendezvous */
-#define ASSOC_AVAILABLE
-
-/* For the legalese parts, see tox.h. */
-
-/* enumerated lists are superior to magic numbers */
-enum NODE_STATUS { BAD, SEENB_HEARDG, SEENG, USED };
-
-/*
- * Module to store currently unused ID <=> IP associations
- * for a potential future use
- */
-
-typedef struct Assoc Assoc;
-
-/*****************************************************************************/
-
-/* custom distance handler, if it's not ID-distance based
- * return values exactly like id_closest() */
-typedef int (*Assoc_distance_relative_callback)(const Assoc *assoc, void *callback_data, const uint8_t *client_id,
-        const uint8_t *client_id1, const uint8_t *client_id2);
-
-#define DISTANCE_INDEX_DISTANCE_BITS 44
-
-/* absolute distance: can be same for different client_id_check values
- * return value should have DISTANCE_INDEX_DISTANCE_BITS valid bits */
-typedef uint64_t (*Assoc_distance_absolute_callback)(const Assoc *assoc, void *callback_data,
-        const uint8_t *client_id_ref, const uint8_t *client_id_check);
-
-/*****************************************************************************/
-
-/* Central entry point for new associations: add a new candidate to the cache
- * returns 1 if entry is stored, 2 if existing entry was updated, 0 else */
-uint8_t Assoc_add_entry(Assoc *assoc, const uint8_t *id, const IPPTs *ippts_send, const IP_Port *ipp_recv,
-                        uint8_t used);
-
-/*****************************************************************************/
-
-typedef enum AssocCloseEntriesFlags {
-    ProtoIPv4 = 1,
-    ProtoIPv6 = 2,
-    LANOk     = 4,
-} AssocCloseEntriesFlags;
-
-typedef struct Assoc_close_entries {
-    void                              *custom_data;        /* given to distance functions */
-    uint8_t                           *wanted_id;          /* the target client_id */
-    uint8_t                            flags;              /* additional flags */
-
-    Assoc_distance_relative_callback   distance_relative_func;
-    Assoc_distance_absolute_callback   distance_absolute_func;
-
-    uint8_t                            count_good;   /* that many should be "good" w.r.t. timeout */
-    uint8_t                            count;        /* allocated number of close_indices */
-    Client_data                      **result;
-} Assoc_close_entries;
-
-/* find up to close_count nodes to put into close_nodes_used of ID_Nodes
- * the distance functions can be NULL, then standard distance functions will be used
- * the caller is responsible for allocating close_indices of sufficient size
- *
- * returns 0 on error
- * returns the number of found nodes and the list of indices usable by Assoc_client()
- *    the caller is assumed to be registered from Assoc_register_callback()
- *    if they aren't, they should copy the Client_data and call Assoc_client_drop()
- */
-uint8_t Assoc_get_close_entries(Assoc *assoc, Assoc_close_entries *close_entries);
-
-/*****************************************************************************/
-
-/* create: default sizes (6, 5 => 320 entries) */
-Assoc *new_Assoc_default(const uint8_t *public_id);
-
-/* create: customized sizes
- * total is (2^bits) * entries
- * bits should be between 2 and 15 (else it's trimmed)
- * entries will be reduced to the closest prime smaller or equal
- *
- * preferably bits should be large and entries small to ensure spread
- * in the search space (e. g. 5, 5 is preferable to 2, 41) */
-Assoc *new_Assoc(size_t bits, size_t entries, const uint8_t *public_id);
-
-/* public_id changed (loaded), update which entry isn't stored */
-void Assoc_self_client_id_changed(Assoc *assoc, const uint8_t *public_id);
-
-/* every 45s send out a getnodes() for a "random" bucket */
-#define ASSOC_BUCKET_REFRESH 45
-
-/* refresh bucket's data from time to time
- * this must be called only from DHT */
-void do_Assoc(Assoc *assoc, DHT *dht);
-
-/* destroy */
-void kill_Assoc(Assoc *assoc);
-
-#ifdef TOX_LOGGER
-void Assoc_status(const Assoc *assoc);
-#endif /* TOX_LOGGER */
-
-#endif /* !__ASSOC_H__ */
diff --git a/toxcore/ccompat.h b/toxcore/ccompat.h
new file mode 100644
index 00000000..f4aa1d89
--- /dev/null
+++ b/toxcore/ccompat.h
@@ -0,0 +1,51 @@
+/*
+ * C language compatibility macros for varying compiler support.
+ */
+#ifndef CCOMPAT_H
+#define CCOMPAT_H
+
+// Variable length arrays.
+// VLA(type, name, size) allocates a variable length array with automatic
+// storage duration. VLA_SIZE(name) evaluates to the runtime size of that array
+// in bytes.
+//
+// If C99 VLAs are not available, an emulation using alloca (stack allocation
+// "function") is used. Note the semantic difference: alloca'd memory does not
+// get freed at the end of the declaration's scope. Do not use VLA() in loops or
+// you may run out of stack space.
+#if !defined(_MSC_VER) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+// C99 VLAs.
+#define VLA(type, name, size) type name[size]
+#define SIZEOF_VLA sizeof
+#else
+
+// Emulation using alloca.
+#ifdef _WIN32
+#include <malloc.h>
+#elif defined(__linux__)
+#include <alloca.h>
+#else
+#include <stdlib.h>
+#if !defined(alloca) && defined(__GNUC__)
+#define alloca __builtin_alloca
+#endif
+#endif
+
+#define VLA(type, name, size)                           \
+  const size_t name##_size = (size) * sizeof(type);     \
+  type *const name = (type *)alloca(name##_size)
+#define SIZEOF_VLA(name) name##_size
+
+#endif
+
+#ifndef __cplusplus
+#define nullptr NULL
+#endif
+
+#ifdef __GNUC__
+#define GNU_PRINTF(f, a) __attribute__((__format__(__printf__, f, a)))
+#else
+#define GNU_PRINTF(f, a)
+#endif
+
+#endif /* CCOMPAT_H */
diff --git a/toxcore/crypto_core.api.h b/toxcore/crypto_core.api.h
new file mode 100644
index 00000000..4b40860d
--- /dev/null
+++ b/toxcore/crypto_core.api.h
@@ -0,0 +1,268 @@
+%{
+/*
+ * Functions for the core crypto.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef CRYPTO_CORE_H
+#define CRYPTO_CORE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+%}
+
+/**
+ * The number of bytes in a Tox public key.
+ */
+const CRYPTO_PUBLIC_KEY_SIZE = 32;
+
+/**
+ * The number of bytes in a Tox secret key.
+ */
+const CRYPTO_SECRET_KEY_SIZE = 32;
+
+/**
+ * The number of bytes in a shared key computed from public and secret keys.
+ */
+const CRYPTO_SHARED_KEY_SIZE = 32;
+
+/**
+ * The number of bytes in a symmetric key.
+ */
+const CRYPTO_SYMMETRIC_KEY_SIZE = CRYPTO_SHARED_KEY_SIZE;
+
+/**
+ * The number of bytes needed for the MAC (message authentication code) in an
+ * encrypted message.
+ */
+const CRYPTO_MAC_SIZE = 16;
+
+/**
+ * The number of bytes in a nonce used for encryption/decryption.
+ */
+const CRYPTO_NONCE_SIZE = 24;
+
+/**
+ * The number of bytes in a SHA256 hash.
+ */
+const CRYPTO_SHA256_SIZE = 32;
+
+/**
+ * The number of bytes in a SHA512 hash.
+ */
+const CRYPTO_SHA512_SIZE = 64;
+
+/**
+ * A `memcmp`-like function whose running time does not depend on the input
+ * bytes, only on the input length. Useful to compare sensitive data where
+ * timing attacks could reveal that data.
+ *
+ * This means for instance that comparing "aaaa" and "aaaa" takes 4 time, and
+ * "aaaa" and "baaa" also takes 4 time. With a regular `memcmp`, the latter may
+ * take 1 time, because it immediately knows that the two strings are not equal.
+ */
+static int32_t crypto_memcmp(const void *p1, const void *p2, size_t length);
+
+/**
+ * A `bzero`-like function which won't be optimised away by the compiler. Some
+ * compilers will inline `bzero` or `memset` if they can prove that there will
+ * be no reads to the written data. Use this function if you want to be sure the
+ * memory is indeed zeroed.
+ */
+static void crypto_memzero(void *data, size_t length);
+
+/**
+ * Compute a SHA256 hash (32 bytes).
+ */
+static void crypto_sha256(uint8_t[CRYPTO_SHA256_SIZE] hash, const uint8_t[length] data);
+
+/**
+ * Compute a SHA512 hash (64 bytes).
+ */
+static void crypto_sha512(uint8_t[CRYPTO_SHA512_SIZE] hash, const uint8_t[length] data);
+
+/**
+ * Compare 2 public keys of length CRYPTO_PUBLIC_KEY_SIZE, not vulnerable to
+ * timing attacks.
+ *
+ * @return 0 if both mem locations of length are equal, -1 if they are not.
+ */
+static int32_t public_key_cmp(
+    const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] pk1,
+    const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] pk2);
+
+namespace random {
+
+/**
+ * Return a random 8 bit integer.
+ */
+static uint8_t u08();
+
+/**
+ * Return a random 16 bit integer.
+ */
+static uint16_t u16();
+
+/**
+ * Return a random 32 bit integer.
+ */
+static uint32_t u32();
+
+/**
+ * Return a random 64 bit integer.
+ */
+static uint64_t u64();
+
+/**
+ * Fill the given nonce with random bytes.
+ */
+static void nonce(uint8_t[CRYPTO_NONCE_SIZE] nonce);
+
+/**
+ * Fill an array of bytes with random values.
+ */
+static void bytes(uint8_t[length] bytes);
+
+}
+
+/**
+ * Check if a Tox public key CRYPTO_PUBLIC_KEY_SIZE is valid or not. This
+ * should only be used for input validation.
+ *
+ * @return false if it isn't, true if it is.
+ */
+static bool public_key_valid(const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key);
+
+/**
+ * Generate a new random keypair. Every call to this function is likely to
+ * generate a different keypair.
+ */
+static int32_t crypto_new_keypair(
+    uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key,
+    uint8_t[CRYPTO_SECRET_KEY_SIZE] secret_key);
+
+/**
+ * Derive the public key from a given secret key.
+ */
+static void crypto_derive_public_key(
+    uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key,
+    const uint8_t[CRYPTO_SECRET_KEY_SIZE] secret_key);
+
+/**
+ * Encrypt plain text of the given length to encrypted of length +
+ * $CRYPTO_MAC_SIZE using the public key ($CRYPTO_PUBLIC_KEY_SIZE bytes) of the
+ * receiver and the secret key of the sender and a $CRYPTO_NONCE_SIZE byte
+ * nonce.
+ *
+ * @return -1 if there was a problem, length of encrypted data if everything
+ * was fine.
+ */
+static int32_t encrypt_data(
+    const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key,
+    const uint8_t[CRYPTO_SECRET_KEY_SIZE] secret_key,
+    const uint8_t[CRYPTO_NONCE_SIZE] nonce,
+    const uint8_t[length] plain,
+    uint8_t *encrypted);
+
+
+/**
+ * Decrypt encrypted text of the given length to plain text of the given length
+ * - $CRYPTO_MAC_SIZE using the public key ($CRYPTO_PUBLIC_KEY_SIZE bytes) of
+ * the sender, the secret key of the receiver and a $CRYPTO_NONCE_SIZE byte
+ * nonce.
+ *
+ * @return -1 if there was a problem (decryption failed), length of plain text
+ * data if everything was fine.
+ */
+static int32_t decrypt_data(
+    const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key,
+    const uint8_t[CRYPTO_SECRET_KEY_SIZE] secret_key,
+    const uint8_t[CRYPTO_NONCE_SIZE] nonce,
+    const uint8_t[length] encrypted,
+    uint8_t *plain);
+
+/**
+ * Fast encrypt/decrypt operations. Use if this is not a one-time communication.
+ * $encrypt_precompute does the shared-key generation once so it does not have
+ * to be preformed on every encrypt/decrypt.
+ */
+static int32_t encrypt_precompute(
+    const uint8_t[CRYPTO_PUBLIC_KEY_SIZE] public_key,
+    const uint8_t[CRYPTO_SECRET_KEY_SIZE] secret_key,
+    uint8_t[CRYPTO_SHARED_KEY_SIZE] shared_key);
+
+/**
+ * Encrypts plain of length length to encrypted of length + $CRYPTO_MAC_SIZE
+ * using a shared key $CRYPTO_SYMMETRIC_KEY_SIZE big and a $CRYPTO_NONCE_SIZE
+ * byte nonce.
+ *
+ * @return -1 if there was a problem, length of encrypted data if everything
+ * was fine.
+ */
+static int32_t encrypt_data_symmetric(
+    const uint8_t[CRYPTO_SHARED_KEY_SIZE] shared_key,
+    const uint8_t[CRYPTO_NONCE_SIZE] nonce,
+    const uint8_t[length] plain,
+    uint8_t *encrypted);
+
+/**
+ * Decrypts encrypted of length length to plain of length length -
+ * $CRYPTO_MAC_SIZE using a shared key CRYPTO_SHARED_KEY_SIZE big and a
+ * $CRYPTO_NONCE_SIZE byte nonce.
+ *
+ * @return -1 if there was a problem (decryption failed), length of plain data
+ * if everything was fine.
+ */
+static int32_t decrypt_data_symmetric(
+    const uint8_t[CRYPTO_SHARED_KEY_SIZE] shared_key,
+    const uint8_t[CRYPTO_NONCE_SIZE] nonce,
+    const uint8_t[length] encrypted,
+    uint8_t *plain);
+
+/**
+ * Increment the given nonce by 1 in big endian (rightmost byte incremented
+ * first).
+ */
+static void increment_nonce(uint8_t[CRYPTO_NONCE_SIZE] nonce);
+
+/**
+ * Increment the given nonce by a given number. The number should be in host
+ * byte order.
+ */
+static void increment_nonce_number(uint8_t[CRYPTO_NONCE_SIZE] nonce, uint32_t host_order_num);
+
+/**
+ * Fill a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes.
+ */
+static void new_symmetric_key(uint8_t[CRYPTO_SYMMETRIC_KEY_SIZE] key);
+
+%{
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif /* CRYPTO_CORE_H */
+%}
diff --git a/toxcore/crypto_core.c b/toxcore/crypto_core.c
index a733c38e..b2f0e5f0 100644
--- a/toxcore/crypto_core.c
+++ b/toxcore/crypto_core.c
@@ -1,72 +1,124 @@
-/* net_crypto.c
- *
+/*
  * Functions for the core crypto.
  *
  * NOTE: This code has to be perfect. We don't mess around with encryption.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
+#include "ccompat.h"
 #include "crypto_core.h"
 
-#if crypto_box_PUBLICKEYBYTES != 32
-#error crypto_box_PUBLICKEYBYTES is required to be 32 bytes for public_key_cmp to work,
+#include <string.h>
+
+#ifndef VANILLA_NACL
+/* We use libsodium by default. */
+#include <sodium.h>
+#else
+#include <crypto_box.h>
+#include <crypto_hash_sha256.h>
+#include <crypto_hash_sha512.h>
+#include <crypto_scalarmult_curve25519.h>
+#include <crypto_verify_16.h>
+#include <crypto_verify_32.h>
+#include <randombytes.h>
+#define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
+#endif
+
+#if CRYPTO_PUBLIC_KEY_SIZE != crypto_box_PUBLICKEYBYTES
+#error CRYPTO_PUBLIC_KEY_SIZE should be equal to crypto_box_PUBLICKEYBYTES
+#endif
+
+#if CRYPTO_SECRET_KEY_SIZE != crypto_box_SECRETKEYBYTES
+#error CRYPTO_SECRET_KEY_SIZE should be equal to crypto_box_SECRETKEYBYTES
+#endif
+
+#if CRYPTO_SHARED_KEY_SIZE != crypto_box_BEFORENMBYTES
+#error CRYPTO_SHARED_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES
+#endif
+
+#if CRYPTO_SYMMETRIC_KEY_SIZE != crypto_box_BEFORENMBYTES
+#error CRYPTO_SYMMETRIC_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES
+#endif
+
+#if CRYPTO_MAC_SIZE != crypto_box_MACBYTES
+#error CRYPTO_MAC_SIZE should be equal to crypto_box_MACBYTES
+#endif
+
+#if CRYPTO_NONCE_SIZE != crypto_box_NONCEBYTES
+#error CRYPTO_NONCE_SIZE should be equal to crypto_box_NONCEBYTES
 #endif
 
-/* compare 2 public keys of length crypto_box_PUBLICKEYBYTES, not vulnerable to timing attacks.
-   returns 0 if both mem locations of length are equal,
-   return -1 if they are not. */
-int public_key_cmp(const uint8_t *pk1, const uint8_t *pk2)
+#if CRYPTO_SHA256_SIZE != crypto_hash_sha256_BYTES
+#error CRYPTO_SHA256_SIZE should be equal to crypto_hash_sha256_BYTES
+#endif
+
+#if CRYPTO_SHA512_SIZE != crypto_hash_sha512_BYTES
+#error CRYPTO_SHA512_SIZE should be equal to crypto_hash_sha512_BYTES
+#endif
+
+int32_t public_key_cmp(const uint8_t *pk1, const uint8_t *pk2)
 {
+#if CRYPTO_PUBLIC_KEY_SIZE != 32
+#error CRYPTO_PUBLIC_KEY_SIZE is required to be 32 bytes for public_key_cmp to work,
+#endif
     return crypto_verify_32(pk1, pk2);
 }
 
-/*  return a random number.
- */
-uint32_t random_int(void)
+uint8_t random_u08(void)
+{
+    uint8_t randnum;
+    randombytes(&randnum, 1);
+    return randnum;
+}
+
+uint16_t random_u16(void)
+{
+    uint16_t randnum;
+    randombytes((uint8_t *)&randnum, sizeof(randnum));
+    return randnum;
+}
+
+uint32_t random_u32(void)
 {
     uint32_t randnum;
-    randombytes((uint8_t *)&randnum , sizeof(randnum));
+    randombytes((uint8_t *)&randnum, sizeof(randnum));
     return randnum;
 }
 
-uint64_t random_64b(void)
+uint64_t random_u64(void)
 {
     uint64_t randnum;
     randombytes((uint8_t *)&randnum, sizeof(randnum));
     return randnum;
 }
 
-/* Check if a Tox public key crypto_box_PUBLICKEYBYTES is valid or not.
- * This should only be used for input validation.
- *
- * return 0 if it isn't.
- * return 1 if it is.
- */
-int public_key_valid(const uint8_t *public_key)
+bool public_key_valid(const uint8_t *public_key)
 {
-    if (public_key[31] >= 128) /* Last bit of key is always zero. */
+    if (public_key[31] >= 128) { /* Last bit of key is always zero. */
         return 0;
+    }
 
     return 1;
 }
@@ -74,75 +126,81 @@ int public_key_valid(const uint8_t *public_key)
 /* Precomputes the shared key from their public_key and our secret_key.
  * This way we can avoid an expensive elliptic curve scalar multiply for each
  * encrypt/decrypt operation.
- * enc_key has to be crypto_box_BEFORENMBYTES bytes long.
+ * shared_key has to be crypto_box_BEFORENMBYTES bytes long.
  */
-void encrypt_precompute(const uint8_t *public_key, const uint8_t *secret_key, uint8_t *enc_key)
+int32_t encrypt_precompute(const uint8_t *public_key, const uint8_t *secret_key, uint8_t *shared_key)
 {
-    crypto_box_beforenm(enc_key, public_key, secret_key);
+    return crypto_box_beforenm(shared_key, public_key, secret_key);
 }
 
-int encrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *plain, uint32_t length,
-                           uint8_t *encrypted)
+int32_t encrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *plain, size_t length,
+                               uint8_t *encrypted)
 {
-    if (length == 0 || !secret_key || !nonce || !plain || !encrypted)
+    if (length == 0 || !secret_key || !nonce || !plain || !encrypted) {
         return -1;
+    }
 
-    uint8_t temp_plain[length + crypto_box_ZEROBYTES];
-    uint8_t temp_encrypted[length + crypto_box_MACBYTES + crypto_box_BOXZEROBYTES];
+    VLA(uint8_t, temp_plain, length + crypto_box_ZEROBYTES);
+    VLA(uint8_t, temp_encrypted, length + crypto_box_MACBYTES + crypto_box_BOXZEROBYTES);
 
     memset(temp_plain, 0, crypto_box_ZEROBYTES);
     memcpy(temp_plain + crypto_box_ZEROBYTES, plain, length); // Pad the message with 32 0 bytes.
 
-    if (crypto_box_afternm(temp_encrypted, temp_plain, length + crypto_box_ZEROBYTES, nonce, secret_key) != 0)
+    if (crypto_box_afternm(temp_encrypted, temp_plain, length + crypto_box_ZEROBYTES, nonce, secret_key) != 0) {
         return -1;
+    }
 
     /* Unpad the encrypted message. */
     memcpy(encrypted, temp_encrypted + crypto_box_BOXZEROBYTES, length + crypto_box_MACBYTES);
     return length + crypto_box_MACBYTES;
 }
 
-int decrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *encrypted, uint32_t length,
-                           uint8_t *plain)
+int32_t decrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *encrypted, size_t length,
+                               uint8_t *plain)
 {
-    if (length <= crypto_box_BOXZEROBYTES || !secret_key || !nonce || !encrypted || !plain)
+    if (length <= crypto_box_BOXZEROBYTES || !secret_key || !nonce || !encrypted || !plain) {
         return -1;
+    }
 
-    uint8_t temp_plain[length + crypto_box_ZEROBYTES];
-    uint8_t temp_encrypted[length + crypto_box_BOXZEROBYTES];
+    VLA(uint8_t, temp_plain, length + crypto_box_ZEROBYTES);
+    VLA(uint8_t, temp_encrypted, length + crypto_box_BOXZEROBYTES);
 
     memset(temp_encrypted, 0, crypto_box_BOXZEROBYTES);
     memcpy(temp_encrypted + crypto_box_BOXZEROBYTES, encrypted, length); // Pad the message with 16 0 bytes.
 
-    if (crypto_box_open_afternm(temp_plain, temp_encrypted, length + crypto_box_BOXZEROBYTES, nonce, secret_key) != 0)
+    if (crypto_box_open_afternm(temp_plain, temp_encrypted, length + crypto_box_BOXZEROBYTES, nonce, secret_key) != 0) {
         return -1;
+    }
 
     memcpy(plain, temp_plain + crypto_box_ZEROBYTES, length - crypto_box_MACBYTES);
     return length - crypto_box_MACBYTES;
 }
 
-int encrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
-                 const uint8_t *plain, uint32_t length, uint8_t *encrypted)
+int32_t encrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
+                     const uint8_t *plain, size_t length, uint8_t *encrypted)
 {
-    if (!public_key || !secret_key)
+    if (!public_key || !secret_key) {
         return -1;
+    }
 
     uint8_t k[crypto_box_BEFORENMBYTES];
     encrypt_precompute(public_key, secret_key, k);
     int ret = encrypt_data_symmetric(k, nonce, plain, length, encrypted);
-    sodium_memzero(k, sizeof k);
+    crypto_memzero(k, sizeof k);
     return ret;
 }
 
-int decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
-                 const uint8_t *encrypted, uint32_t length, uint8_t *plain)
+int32_t decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
+                     const uint8_t *encrypted, size_t length, uint8_t *plain)
 {
-    if (!public_key || !secret_key)
+    if (!public_key || !secret_key) {
         return -1;
+    }
 
     uint8_t k[crypto_box_BEFORENMBYTES];
     encrypt_precompute(public_key, secret_key, k);
     int ret = decrypt_data_symmetric(k, nonce, encrypted, length, plain);
-    sodium_memzero(k, sizeof k);
+    crypto_memzero(k, sizeof k);
     return ret;
 }
 
@@ -150,7 +208,7 @@ int decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uin
 /* Increment the given nonce by 1. */
 void increment_nonce(uint8_t *nonce)
 {
-    /* FIXME use increment_nonce_number(nonce, 1) or sodium_increment (change to little endian)
+    /* TODO(irungentoo): use increment_nonce_number(nonce, 1) or sodium_increment (change to little endian)
      * NOTE don't use breaks inside this loop
      * In particular, make sure, as far as possible,
      * that loop bounds and their potential underflow or overflow
@@ -165,6 +223,20 @@ void increment_nonce(uint8_t *nonce)
         carry >>= 8;
     }
 }
+
+static uint32_t host_to_network(uint32_t x)
+{
+#if !defined(BYTE_ORDER) || BYTE_ORDER == LITTLE_ENDIAN
+    return
+        ((x >> 24) & 0x000000FF) | // move byte 3 to byte 0
+        ((x >> 8)  & 0x0000FF00) | // move byte 2 to byte 1
+        ((x << 8)  & 0x00FF0000) | // move byte 1 to byte 2
+        ((x << 24) & 0xFF000000);  // move byte 0 to byte 3
+#else
+    return x;
+#endif
+}
+
 /* increment the given nonce by num */
 void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num)
 {
@@ -173,7 +245,7 @@ void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num)
      * that loop bounds and their potential underflow or overflow
      * are independent of user-controlled input (you may have heard of the Heartbleed bug).
      */
-    const uint32_t big_endian_num = htonl(host_order_num);
+    const uint32_t big_endian_num = host_to_network(host_order_num);
     const uint8_t *const num_vec = (const uint8_t *) &big_endian_num;
     uint8_t num_as_nonce[crypto_box_NONCEBYTES] = {0};
     num_as_nonce[crypto_box_NONCEBYTES - 4] = num_vec[0];
@@ -197,87 +269,33 @@ void random_nonce(uint8_t *nonce)
     randombytes(nonce, crypto_box_NONCEBYTES);
 }
 
-/* Fill a key crypto_box_KEYBYTES big with random bytes */
+/* Fill a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes */
 void new_symmetric_key(uint8_t *key)
 {
-    randombytes(key, crypto_box_KEYBYTES);
+    randombytes(key, CRYPTO_SYMMETRIC_KEY_SIZE);
 }
 
-/* Gives a nonce guaranteed to be different from previous ones.*/
-void new_nonce(uint8_t *nonce)
+int32_t crypto_new_keypair(uint8_t *public_key, uint8_t *secret_key)
 {
-    random_nonce(nonce);
+    return crypto_box_keypair(public_key, secret_key);
 }
 
-/* Create a request to peer.
- * send_public_key and send_secret_key are the pub/secret keys of the sender.
- * recv_public_key is public key of receiver.
- * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
- * Data represents the data we send with the request with length being the length of the data.
- * request_id is the id of the request (32 = friend request, 254 = ping request).
- *
- *  return -1 on failure.
- *  return the length of the created packet on success.
- */
-int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_key, uint8_t *packet,
-                   const uint8_t *recv_public_key, const uint8_t *data, uint32_t length, uint8_t request_id)
+void crypto_derive_public_key(uint8_t *public_key, const uint8_t *secret_key)
 {
-    if (!send_public_key || !packet || !recv_public_key || !data)
-        return -1;
-
-    if (MAX_CRYPTO_REQUEST_SIZE < length + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 +
-            crypto_box_MACBYTES)
-        return -1;
-
-    uint8_t *nonce = packet + 1 + crypto_box_PUBLICKEYBYTES * 2;
-    new_nonce(nonce);
-    uint8_t temp[MAX_CRYPTO_REQUEST_SIZE]; // FIXME sodium_memzero before exit function
-    memcpy(temp + 1, data, length);
-    temp[0] = request_id;
-    int len = encrypt_data(recv_public_key, send_secret_key, nonce, temp, length + 1,
-                           1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + packet);
-
-    if (len == -1)
-        return -1;
-
-    packet[0] = NET_PACKET_CRYPTO;
-    memcpy(packet + 1, recv_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, send_public_key, crypto_box_PUBLICKEYBYTES);
-
-    return len + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES;
+    crypto_scalarmult_curve25519_base(public_key, secret_key);
 }
 
-/* Puts the senders public key in the request in public_key, the data from the request
- * in data if a friend or ping request was sent to us and returns the length of the data.
- * packet is the request packet and length is its length.
- *
- *  return -1 if not valid request.
- */
-int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data,
-                   uint8_t *request_id, const uint8_t *packet, uint16_t length)
+void crypto_sha256(uint8_t *hash, const uint8_t *data, size_t length)
 {
-    if (!self_public_key || !public_key || !data || !request_id || !packet)
-        return -1;
-
-    if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
-            length > MAX_CRYPTO_REQUEST_SIZE)
-        return -1;
-
-    if (public_key_cmp(packet + 1, self_public_key) != 0)
-        return -1;
-
-    memcpy(public_key, packet + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
-    const uint8_t *nonce = packet + 1 + crypto_box_PUBLICKEYBYTES * 2;
-    uint8_t temp[MAX_CRYPTO_REQUEST_SIZE]; // FIXME sodium_memzero before exit function
-    int len1 = decrypt_data(public_key, self_secret_key, nonce,
-                            packet + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES,
-                            length - (crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1), temp);
+    crypto_hash_sha256(hash, data, length);
+}
 
-    if (len1 == -1 || len1 == 0)
-        return -1;
+void crypto_sha512(uint8_t *hash, const uint8_t *data, size_t length)
+{
+    crypto_hash_sha512(hash, data, length);
+}
 
-    request_id[0] = temp[0];
-    --len1;
-    memcpy(data, temp + 1, len1);
-    return len1;
+void random_bytes(uint8_t *data, size_t length)
+{
+    randombytes(data, length);
 }
diff --git a/toxcore/crypto_core.h b/toxcore/crypto_core.h
index ab509f09..18c1339e 100644
--- a/toxcore/crypto_core.h
+++ b/toxcore/crypto_core.h
@@ -1,153 +1,252 @@
-/* crypto_core.h
- *
+/*
  * Functions for the core crypto.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef CORE_CRYPTO_H
-#define CORE_CRYPTO_H
-
-#include "network.h"
-
-#ifndef VANILLA_NACL
-/* We use libsodium by default. */
-#include <sodium.h>
-#else
-#include <crypto_box.h>
-#include <randombytes.h>
-#include <crypto_hash_sha256.h>
-#include <crypto_hash_sha512.h>
-#include <crypto_verify_16.h>
-#include <crypto_verify_32.h>
-#include <crypto_scalarmult_curve25519.h>
-#define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
-/* I know */
-#define sodium_memcmp(a, b, c) memcmp(a, b, c)
-#define sodium_memzero(a, c) memset(a, 0, c)
+#ifndef CRYPTO_CORE_H
+#define CRYPTO_CORE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-#define crypto_box_KEYBYTES (crypto_box_BEFORENMBYTES)
+/**
+ * The number of bytes in a Tox public key.
+ */
+#define CRYPTO_PUBLIC_KEY_SIZE         32
 
-/* compare 2 public keys of length crypto_box_PUBLICKEYBYTES, not vulnerable to timing attacks.
-   returns 0 if both mem locations of length are equal,
-   return -1 if they are not. */
-int public_key_cmp(const uint8_t *pk1, const uint8_t *pk2);
+uint32_t crypto_public_key_size(void);
 
-/*  return a random number.
- *
- * random_int for a 32bin int.
- * random_64b for a 64bit int.
+/**
+ * The number of bytes in a Tox secret key.
  */
-uint32_t random_int(void);
-uint64_t random_64b(void);
+#define CRYPTO_SECRET_KEY_SIZE         32
 
-/* Check if a Tox public key crypto_box_PUBLICKEYBYTES is valid or not.
- * This should only be used for input validation.
- *
- * return 0 if it isn't.
- * return 1 if it is.
+uint32_t crypto_secret_key_size(void);
+
+/**
+ * The number of bytes in a shared key computed from public and secret keys.
  */
-int public_key_valid(const uint8_t *public_key);
+#define CRYPTO_SHARED_KEY_SIZE         32
 
-/* Encrypts plain of length length to encrypted of length + 16 using the
- * public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce.
- *
- *  return -1 if there was a problem.
- *  return length of encrypted data if everything was fine.
+uint32_t crypto_shared_key_size(void);
+
+/**
+ * The number of bytes in a symmetric key.
  */
-int encrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
-                 const uint8_t *plain, uint32_t length, uint8_t *encrypted);
+#define CRYPTO_SYMMETRIC_KEY_SIZE      CRYPTO_SHARED_KEY_SIZE
 
+uint32_t crypto_symmetric_key_size(void);
 
-/* Decrypts encrypted of length length to plain of length length - 16 using the
- * public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce.
- *
- *  return -1 if there was a problem (decryption failed).
- *  return length of plain data if everything was fine.
+/**
+ * The number of bytes needed for the MAC (message authentication code) in an
+ * encrypted message.
  */
-int decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
-                 const uint8_t *encrypted, uint32_t length, uint8_t *plain);
+#define CRYPTO_MAC_SIZE                16
 
-/* Fast encrypt/decrypt operations. Use if this is not a one-time communication.
-   encrypt_precompute does the shared-key generation once so it does not have
-   to be preformed on every encrypt/decrypt. */
-void encrypt_precompute(const uint8_t *public_key, const uint8_t *secret_key, uint8_t *enc_key);
+uint32_t crypto_mac_size(void);
+
+/**
+ * The number of bytes in a nonce used for encryption/decryption.
+ */
+#define CRYPTO_NONCE_SIZE              24
 
-/* Encrypts plain of length length to encrypted of length + 16 using a
- * secret key crypto_box_KEYBYTES big and a 24 byte nonce.
+uint32_t crypto_nonce_size(void);
+
+/**
+ * The number of bytes in a SHA256 hash.
+ */
+#define CRYPTO_SHA256_SIZE             32
+
+uint32_t crypto_sha256_size(void);
+
+/**
+ * The number of bytes in a SHA512 hash.
+ */
+#define CRYPTO_SHA512_SIZE             64
+
+uint32_t crypto_sha512_size(void);
+
+/**
+ * A `memcmp`-like function whose running time does not depend on the input
+ * bytes, only on the input length. Useful to compare sensitive data where
+ * timing attacks could reveal that data.
  *
- *  return -1 if there was a problem.
- *  return length of encrypted data if everything was fine.
+ * This means for instance that comparing "aaaa" and "aaaa" takes 4 time, and
+ * "aaaa" and "baaa" also takes 4 time. With a regular `memcmp`, the latter may
+ * take 1 time, because it immediately knows that the two strings are not equal.
  */
-int encrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *plain, uint32_t length,
-                           uint8_t *encrypted);
+int32_t crypto_memcmp(const void *p1, const void *p2, size_t length);
 
-/* Decrypts encrypted of length length to plain of length length - 16 using a
- * secret key crypto_box_KEYBYTES big and a 24 byte nonce.
+/**
+ * A `bzero`-like function which won't be optimised away by the compiler. Some
+ * compilers will inline `bzero` or `memset` if they can prove that there will
+ * be no reads to the written data. Use this function if you want to be sure the
+ * memory is indeed zeroed.
+ */
+void crypto_memzero(void *data, size_t length);
+
+/**
+ * Compute a SHA256 hash (32 bytes).
+ */
+void crypto_sha256(uint8_t *hash, const uint8_t *data, size_t length);
+
+/**
+ * Compute a SHA512 hash (64 bytes).
+ */
+void crypto_sha512(uint8_t *hash, const uint8_t *data, size_t length);
+
+/**
+ * Compare 2 public keys of length CRYPTO_PUBLIC_KEY_SIZE, not vulnerable to
+ * timing attacks.
  *
- *  return -1 if there was a problem (decryption failed).
- *  return length of plain data if everything was fine.
+ * @return 0 if both mem locations of length are equal, -1 if they are not.
  */
-int decrypt_data_symmetric(const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *encrypted, uint32_t length,
-                           uint8_t *plain);
+int32_t public_key_cmp(const uint8_t *pk1, const uint8_t *pk2);
 
-/* Increment the given nonce by 1. */
-void increment_nonce(uint8_t *nonce);
+/**
+ * Return a random 8 bit integer.
+ */
+uint8_t random_u08(void);
 
-/* increment the given nonce by num */
-void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num);
+/**
+ * Return a random 16 bit integer.
+ */
+uint16_t random_u16(void);
+
+/**
+ * Return a random 32 bit integer.
+ */
+uint32_t random_u32(void);
 
-/* Fill the given nonce with random bytes. */
+/**
+ * Return a random 64 bit integer.
+ */
+uint64_t random_u64(void);
+
+/**
+ * Fill the given nonce with random bytes.
+ */
 void random_nonce(uint8_t *nonce);
 
-/* Fill a key crypto_box_KEYBYTES big with random bytes */
-void new_symmetric_key(uint8_t *key);
+/**
+ * Fill an array of bytes with random values.
+ */
+void random_bytes(uint8_t *bytes, size_t length);
 
-/*Gives a nonce guaranteed to be different from previous ones.*/
-void new_nonce(uint8_t *nonce);
+/**
+ * Check if a Tox public key CRYPTO_PUBLIC_KEY_SIZE is valid or not. This
+ * should only be used for input validation.
+ *
+ * @return false if it isn't, true if it is.
+ */
+bool public_key_valid(const uint8_t *public_key);
 
-#define MAX_CRYPTO_REQUEST_SIZE 1024
+/**
+ * Generate a new random keypair. Every call to this function is likely to
+ * generate a different keypair.
+ */
+int32_t crypto_new_keypair(uint8_t *public_key, uint8_t *secret_key);
 
-#define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
-#define CRYPTO_PACKET_HARDENING     48  /* Hardening crypto packet ID. */
-#define CRYPTO_PACKET_DHTPK         156
-#define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
+/**
+ * Derive the public key from a given secret key.
+ */
+void crypto_derive_public_key(uint8_t *public_key, const uint8_t *secret_key);
 
-/* Create a request to peer.
- * send_public_key and send_secret_key are the pub/secret keys of the sender.
- * recv_public_key is public key of receiver.
- * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
- * Data represents the data we send with the request with length being the length of the data.
- * request_id is the id of the request (32 = friend request, 254 = ping request).
+/**
+ * Encrypt plain text of the given length to encrypted of length +
+ * CRYPTO_MAC_SIZE using the public key (CRYPTO_PUBLIC_KEY_SIZE bytes) of the
+ * receiver and the secret key of the sender and a CRYPTO_NONCE_SIZE byte
+ * nonce.
+ *
+ * @return -1 if there was a problem, length of encrypted data if everything
+ * was fine.
+ */
+int32_t encrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce, const uint8_t *plain,
+                     size_t length, uint8_t *encrypted);
+
+/**
+ * Decrypt encrypted text of the given length to plain text of the given length
+ * - CRYPTO_MAC_SIZE using the public key (CRYPTO_PUBLIC_KEY_SIZE bytes) of
+ * the sender, the secret key of the receiver and a CRYPTO_NONCE_SIZE byte
+ * nonce.
  *
- * return -1 on failure.
- * return the length of the created packet on success.
+ * @return -1 if there was a problem (decryption failed), length of plain text
+ * data if everything was fine.
  */
-int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_key, uint8_t *packet,
-                   const uint8_t *recv_public_key, const uint8_t *data, uint32_t length, uint8_t request_id);
+int32_t decrypt_data(const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *nonce,
+                     const uint8_t *encrypted, size_t length, uint8_t *plain);
 
-/* puts the senders public key in the request in public_key, the data from the request
-   in data if a friend or ping request was sent to us and returns the length of the data.
-   packet is the request packet and length is its length
-   return -1 if not valid request. */
-int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data,
-                   uint8_t *request_id, const uint8_t *packet, uint16_t length);
+/**
+ * Fast encrypt/decrypt operations. Use if this is not a one-time communication.
+ * encrypt_precompute does the shared-key generation once so it does not have
+ * to be preformed on every encrypt/decrypt.
+ */
+int32_t encrypt_precompute(const uint8_t *public_key, const uint8_t *secret_key, uint8_t *shared_key);
 
+/**
+ * Encrypts plain of length length to encrypted of length + CRYPTO_MAC_SIZE
+ * using a shared key CRYPTO_SYMMETRIC_KEY_SIZE big and a CRYPTO_NONCE_SIZE
+ * byte nonce.
+ *
+ * @return -1 if there was a problem, length of encrypted data if everything
+ * was fine.
+ */
+int32_t encrypt_data_symmetric(const uint8_t *shared_key, const uint8_t *nonce, const uint8_t *plain, size_t length,
+                               uint8_t *encrypted);
+
+/**
+ * Decrypts encrypted of length length to plain of length length -
+ * CRYPTO_MAC_SIZE using a shared key CRYPTO_SHARED_KEY_SIZE big and a
+ * CRYPTO_NONCE_SIZE byte nonce.
+ *
+ * @return -1 if there was a problem (decryption failed), length of plain data
+ * if everything was fine.
+ */
+int32_t decrypt_data_symmetric(const uint8_t *shared_key, const uint8_t *nonce, const uint8_t *encrypted, size_t length,
+                               uint8_t *plain);
+
+/**
+ * Increment the given nonce by 1 in big endian (rightmost byte incremented
+ * first).
+ */
+void increment_nonce(uint8_t *nonce);
 
+/**
+ * Increment the given nonce by a given number. The number should be in host
+ * byte order.
+ */
+void increment_nonce_number(uint8_t *nonce, uint32_t host_order_num);
+
+/**
+ * Fill a key CRYPTO_SYMMETRIC_KEY_SIZE big with random bytes.
+ */
+void new_symmetric_key(uint8_t *key);
+
+#ifdef __cplusplus
+}  // extern "C"
 #endif
+
+#endif /* CRYPTO_CORE_H */
diff --git a/toxcore/crypto_core_mem.c b/toxcore/crypto_core_mem.c
new file mode 100644
index 00000000..b8f4223e
--- /dev/null
+++ b/toxcore/crypto_core_mem.c
@@ -0,0 +1,87 @@
+/*
+ * ISC License
+ *
+ * Copyright (c) 2013-2016
+ * Frank Denis <j at pureftpd dot org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "crypto_core.h"
+
+#ifndef VANILLA_NACL
+/* We use libsodium by default. */
+#include <sodium.h>
+#else
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+#include <windows.h>
+#include <wincrypt.h>
+#endif
+#endif
+
+
+void crypto_memzero(void *data, size_t length)
+{
+#ifndef VANILLA_NACL
+    sodium_memzero(data, length);
+#else
+#ifdef _WIN32
+    SecureZeroMemory(data, length);
+#elif defined(HAVE_MEMSET_S)
+
+    if (length > 0U) {
+        errno_t code = memset_s(data, (rsize_t) length, 0, (rsize_t) length);
+
+        if (code != 0) {
+            abort(); /* LCOV_EXCL_LINE */
+        }
+    }
+
+#elif defined(HAVE_EXPLICIT_BZERO)
+    explicit_bzero(data, length);
+#else
+    volatile unsigned char *volatile pnt =
+        (volatile unsigned char *volatile) data;
+    size_t i = (size_t) 0U;
+
+    while (i < length) {
+        pnt[i++] = 0U;
+    }
+
+#endif
+#endif
+}
+
+int32_t crypto_memcmp(const void *p1, const void *p2, size_t length)
+{
+#ifndef VANILLA_NACL
+    return sodium_memcmp(p1, p2, length);
+#else
+    const volatile unsigned char *volatile b1 =
+        (const volatile unsigned char *volatile) p1;
+    const volatile unsigned char *volatile b2 =
+        (const volatile unsigned char *volatile) p2;
+
+    size_t i;
+    unsigned char d = (unsigned char) 0U;
+
+    for (i = 0U; i < length; i++) {
+        d |= b1[i] ^ b2[i];
+    }
+
+    return (1 & ((d - 1) >> 8)) - 1;
+#endif
+}
diff --git a/toxcore/crypto_core_test.cpp b/toxcore/crypto_core_test.cpp
new file mode 100644
index 00000000..8f91dce8
--- /dev/null
+++ b/toxcore/crypto_core_test.cpp
@@ -0,0 +1,96 @@
+#include "crypto_core.h"
+
+#include <algorithm>
+
+#include <gtest/gtest.h>
+
+namespace
+{
+
+enum {
+    /**
+     * The size of the arrays to compare. This was chosen to take around 2000
+     * CPU clocks on x86_64.
+     */
+    CRYPTO_TEST_MEMCMP_SIZE = 1024 * 1024, // 1 MiB
+    /**
+     * The number of times we run memcmp in the test.
+     *
+     * We compute the median time taken to reduce error margins.
+     */
+    CRYPTO_TEST_MEMCMP_ITERATIONS = 500,
+    /**
+     * The margin of error (in clocks) we allow for this test.
+     *
+     * Should be within 0.5% of ~2000 CPU clocks. In reality, the code is much
+     * more precise and is usually within 1 CPU clock.
+     */
+    CRYPTO_TEST_MEMCMP_EPS = 10,
+};
+
+clock_t memcmp_time(void *a, void *b, size_t len)
+{
+    clock_t start = clock();
+    crypto_memcmp(a, b, len);
+    return clock() - start;
+}
+
+/**
+ * This function performs the actual timing. It interleaves comparison of
+ * equal and non-equal arrays to reduce the influence of external effects
+ * such as the machine being a little more busy 1 second later.
+ */
+void memcmp_median(void *src, void *same, void *not_same, size_t len,
+                   clock_t *same_median, clock_t *not_same_median)
+{
+    clock_t same_results[CRYPTO_TEST_MEMCMP_ITERATIONS];
+    clock_t not_same_results[CRYPTO_TEST_MEMCMP_ITERATIONS];
+
+    for (size_t i = 0; i < CRYPTO_TEST_MEMCMP_ITERATIONS; i++) {
+        same_results[i] = memcmp_time(src, same, len);
+        not_same_results[i] = memcmp_time(src, not_same, len);
+    }
+
+    std::sort(same_results, same_results + CRYPTO_TEST_MEMCMP_ITERATIONS);
+    *same_median = same_results[CRYPTO_TEST_MEMCMP_ITERATIONS / 2];
+    std::sort(not_same_results, not_same_results + CRYPTO_TEST_MEMCMP_ITERATIONS);
+    *not_same_median = not_same_results[CRYPTO_TEST_MEMCMP_ITERATIONS / 2];
+}
+
+/**
+ * This test checks whether crypto_memcmp takes the same time for equal and
+ * non-equal chunks of memory.
+ */
+TEST(CryptoCore, MemcmpTimingIsDataIndependent)
+{
+    // A random piece of memory.
+    uint8_t *src = new uint8_t[CRYPTO_TEST_MEMCMP_SIZE];
+    random_bytes(src, CRYPTO_TEST_MEMCMP_SIZE);
+
+    // A separate piece of memory containing the same data.
+    uint8_t *same = new uint8_t[CRYPTO_TEST_MEMCMP_SIZE];
+    memcpy(same, src, CRYPTO_TEST_MEMCMP_SIZE);
+
+    // Another piece of memory containing different data.
+    uint8_t *not_same = new uint8_t[CRYPTO_TEST_MEMCMP_SIZE];
+    random_bytes(not_same, CRYPTO_TEST_MEMCMP_SIZE);
+
+    clock_t same_median;
+    clock_t not_same_median;
+    memcmp_median(src, same, not_same, CRYPTO_TEST_MEMCMP_SIZE, &same_median, &not_same_median);
+
+    delete[] not_same;
+    delete[] same;
+    delete[] src;
+
+    clock_t const delta = same_median > not_same_median
+                          ? same_median - not_same_median
+                          : not_same_median - same_median;
+
+    EXPECT_LT(delta, CRYPTO_TEST_MEMCMP_EPS)
+            << "Delta time is too long (" << delta << " >= " << CRYPTO_TEST_MEMCMP_EPS << ")\n"
+            << "Time of the same data comparation: " << same_median << " clocks\n"
+            << "Time of the different data comparation: " << not_same_median << " clocks";
+}
+
+}  // namespace
diff --git a/toxcore/friend_connection.c b/toxcore/friend_connection.c
index e7c8432b..fd5e3078 100644
--- a/toxcore/friend_connection.c
+++ b/toxcore/friend_connection.c
@@ -1,71 +1,129 @@
-/* friend_connection.c
- *
+/*
  * Connection to friends.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "friend_connection.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
 
-/* return 1 if the friendcon_id is not valid.
- * return 0 if the friendcon_id is valid.
- */
-static uint8_t friendconn_id_not_valid(const Friend_Connections *fr_c, int friendcon_id)
-{
-    if ((unsigned int)friendcon_id >= fr_c->num_cons)
-        return 1;
+#define PORTS_PER_DISCOVERY 10
 
-    if (fr_c->conns == NULL)
-        return 1;
+typedef struct {
+    uint8_t status;
 
-    if (fr_c->conns[friendcon_id].status == FRIENDCONN_STATUS_NONE)
-        return 1;
+    uint8_t real_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t dht_temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    uint16_t dht_lock;
+    IP_Port dht_ip_port;
+    uint64_t dht_pk_lastrecv, dht_ip_port_lastrecv;
 
-    return 0;
+    int onion_friendnum;
+    int crypt_connection_id;
+
+    uint64_t ping_lastrecv, ping_lastsent;
+    uint64_t share_relays_lastsent;
+
+    struct {
+        int (*status_callback)(void *object, int id, uint8_t status, void *userdata);
+        int (*data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata);
+        int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata);
+
+        void *callback_object;
+        int callback_id;
+    } callbacks[MAX_FRIEND_CONNECTION_CALLBACKS];
+
+    uint16_t lock_count;
+
+    Node_format tcp_relays[FRIEND_MAX_STORED_TCP_RELAYS];
+    uint16_t tcp_relay_counter;
+
+    bool hosting_tcp_relay;
+} Friend_Conn;
+
+
+struct Friend_Connections {
+    Net_Crypto *net_crypto;
+    DHT *dht;
+    Onion_Client *onion_c;
+
+    Friend_Conn *conns;
+    uint32_t num_cons;
+
+    int (*fr_request_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t len,
+                               void *userdata);
+    void *fr_request_object;
+
+    uint64_t last_LANdiscovery;
+    uint16_t next_LANport;
+
+    bool local_discovery_enabled;
+};
+
+Net_Crypto *friendconn_net_crypto(const Friend_Connections *fr_c)
+{
+    return fr_c->net_crypto;
+}
+
+
+/* return true if the friendcon_id is valid.
+ * return false if the friendcon_id is not valid.
+ */
+static bool friendconn_id_valid(const Friend_Connections *fr_c, int friendcon_id)
+{
+    return (unsigned int)friendcon_id < fr_c->num_cons &&
+           fr_c->conns != nullptr &&
+           fr_c->conns[friendcon_id].status != FRIENDCONN_STATUS_NONE;
 }
 
 
 /* Set the size of the friend connections list to num.
  *
- *  return -1 if realloc fails.
- *  return 0 if it succeeds.
+ *  return false if realloc fails.
+ *  return true if it succeeds.
  */
-static int realloc_friendconns(Friend_Connections *fr_c, uint32_t num)
+static bool realloc_friendconns(Friend_Connections *fr_c, uint32_t num)
 {
     if (num == 0) {
         free(fr_c->conns);
-        fr_c->conns = NULL;
-        return 0;
+        fr_c->conns = nullptr;
+        return true;
     }
 
-    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;
+    if (newgroup_cons == nullptr) {
+        return false;
+    }
 
     fr_c->conns = newgroup_cons;
-    return 0;
+    return true;
 }
 
 /* Create a new empty friend connection.
@@ -75,21 +133,20 @@ static int realloc_friendconns(Friend_Connections *fr_c, uint32_t num)
  */
 static int create_friend_conn(Friend_Connections *fr_c)
 {
-    uint32_t i;
-
-    for (i = 0; i < fr_c->num_cons; ++i) {
-        if (fr_c->conns[i].status == FRIENDCONN_STATUS_NONE)
+    for (uint32_t i = 0; i < fr_c->num_cons; ++i) {
+        if (fr_c->conns[i].status == FRIENDCONN_STATUS_NONE) {
             return i;
+        }
     }
 
-    int id = -1;
-
-    if (realloc_friendconns(fr_c, fr_c->num_cons + 1) == 0) {
-        id = fr_c->num_cons;
-        ++fr_c->num_cons;
-        memset(&(fr_c->conns[id]), 0, sizeof(Friend_Conn));
+    if (!realloc_friendconns(fr_c, fr_c->num_cons + 1)) {
+        return -1;
     }
 
+    const int id = fr_c->num_cons;
+    ++fr_c->num_cons;
+    memset(&fr_c->conns[id], 0, sizeof(Friend_Conn));
+
     return id;
 }
 
@@ -100,15 +157,18 @@ static int create_friend_conn(Friend_Connections *fr_c)
  */
 static int wipe_friend_conn(Friend_Connections *fr_c, int friendcon_id)
 {
-    if (friendconn_id_not_valid(fr_c, friendcon_id))
+    if (!friendconn_id_valid(fr_c, friendcon_id)) {
         return -1;
+    }
+
+    memset(&fr_c->conns[friendcon_id], 0, sizeof(Friend_Conn));
 
     uint32_t i;
-    memset(&(fr_c->conns[friendcon_id]), 0 , sizeof(Friend_Conn));
 
     for (i = fr_c->num_cons; i != 0; --i) {
-        if (fr_c->conns[i - 1].status != FRIENDCONN_STATUS_NONE)
+        if (fr_c->conns[i - 1].status != FRIENDCONN_STATUS_NONE) {
             break;
+        }
     }
 
     if (fr_c->num_cons != i) {
@@ -121,8 +181,9 @@ static int wipe_friend_conn(Friend_Connections *fr_c, int friendcon_id)
 
 static Friend_Conn *get_conn(const Friend_Connections *fr_c, int friendcon_id)
 {
-    if (friendconn_id_not_valid(fr_c, friendcon_id))
-        return 0;
+    if (!friendconn_id_valid(fr_c, friendcon_id)) {
+        return nullptr;
+    }
 
     return &fr_c->conns[friendcon_id];
 }
@@ -132,14 +193,13 @@ static Friend_Conn *get_conn(const Friend_Connections *fr_c, int friendcon_id)
  */
 int getfriend_conn_id_pk(Friend_Connections *fr_c, const uint8_t *real_pk)
 {
-    uint32_t i;
-
-    for (i = 0; i < fr_c->num_cons; ++i) {
+    for (uint32_t i = 0; i < fr_c->num_cons; ++i) {
         Friend_Conn *friend_con = get_conn(fr_c, i);
 
         if (friend_con) {
-            if (public_key_cmp(friend_con->real_public_key, real_pk) == 0)
+            if (public_key_cmp(friend_con->real_public_key, real_pk) == 0) {
                 return i;
+            }
         }
     }
 
@@ -153,33 +213,32 @@ int getfriend_conn_id_pk(Friend_Connections *fr_c, const uint8_t *real_pk)
  */
 int friend_add_tcp_relay(Friend_Connections *fr_c, int friendcon_id, IP_Port ip_port, const uint8_t *public_key)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     /* Local ip and same pk means that they are hosting a TCP relay. */
-    if (Local_ip(ip_port.ip) && public_key_cmp(friend_con->dht_temp_pk, public_key) == 0) {
-        if (friend_con->dht_ip_port.ip.family != 0) {
+    if (ip_is_local(ip_port.ip) && public_key_cmp(friend_con->dht_temp_pk, public_key) == 0) {
+        if (!net_family_is_unspec(friend_con->dht_ip_port.ip.family)) {
             ip_port.ip = friend_con->dht_ip_port.ip;
         } else {
             friend_con->hosting_tcp_relay = 0;
         }
     }
 
-    unsigned int i;
-
-    uint16_t index = friend_con->tcp_relay_counter % FRIEND_MAX_STORED_TCP_RELAYS;
+    const uint16_t index = friend_con->tcp_relay_counter % FRIEND_MAX_STORED_TCP_RELAYS;
 
-    for (i = 0; i < FRIEND_MAX_STORED_TCP_RELAYS; ++i) {
-        if (friend_con->tcp_relays[i].ip_port.ip.family != 0
+    for (unsigned i = 0; i < FRIEND_MAX_STORED_TCP_RELAYS; ++i) {
+        if (!net_family_is_unspec(friend_con->tcp_relays[i].ip_port.ip.family)
                 && public_key_cmp(friend_con->tcp_relays[i].public_key, public_key) == 0) {
             memset(&friend_con->tcp_relays[i], 0, sizeof(Node_format));
         }
     }
 
     friend_con->tcp_relays[index].ip_port = ip_port;
-    memcpy(friend_con->tcp_relays[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(friend_con->tcp_relays[index].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     ++friend_con->tcp_relay_counter;
 
     return add_tcp_relay_peer(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port, public_key);
@@ -188,17 +247,16 @@ int friend_add_tcp_relay(Friend_Connections *fr_c, int friendcon_id, IP_Port ip_
 /* Connect to number saved relays for friend. */
 static void connect_to_saved_tcp_relays(Friend_Connections *fr_c, int friendcon_id, unsigned int number)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    const Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return;
+    }
 
-    unsigned int i;
-
-    for (i = 0; (i < FRIEND_MAX_STORED_TCP_RELAYS) && (number != 0); ++i) {
-        uint16_t index = (friend_con->tcp_relay_counter - (i + 1)) % FRIEND_MAX_STORED_TCP_RELAYS;
+    for (unsigned i = 0; (i < FRIEND_MAX_STORED_TCP_RELAYS) && (number != 0); ++i) {
+        const uint16_t index = (friend_con->tcp_relay_counter - (i + 1)) % FRIEND_MAX_STORED_TCP_RELAYS;
 
-        if (friend_con->tcp_relays[index].ip_port.ip.family) {
+        if (!net_family_is_unspec(friend_con->tcp_relays[index].ip_port.ip.family)) {
             if (add_tcp_relay_peer(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->tcp_relays[index].ip_port,
                                    friend_con->tcp_relays[index].public_key) == 0) {
                 --number;
@@ -209,29 +267,28 @@ static void connect_to_saved_tcp_relays(Friend_Connections *fr_c, int friendcon_
 
 static unsigned int send_relays(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return 0;
+    }
 
     Node_format nodes[MAX_SHARED_RELAYS];
     uint8_t data[1024];
-    int n, length;
-
-    n = copy_connected_tcp_relays(fr_c->net_crypto, nodes, MAX_SHARED_RELAYS);
 
-    int i;
+    const int n = copy_connected_tcp_relays(fr_c->net_crypto, nodes, MAX_SHARED_RELAYS);
 
-    for (i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i) {
         /* Associated the relays being sent with this connection.
            On receiving the peer will do the same which will establish the connection. */
         friend_add_tcp_relay(fr_c, friendcon_id, nodes[i].ip_port, nodes[i].public_key);
     }
 
-    length = pack_nodes(data + 1, sizeof(data) - 1, nodes, n);
+    int length = pack_nodes(data + 1, sizeof(data) - 1, nodes, n);
 
-    if (length <= 0)
+    if (length <= 0) {
         return 0;
+    }
 
     data[0] = PACKET_ID_SHARE_RELAYS;
     ++length;
@@ -247,28 +304,30 @@ 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_Conn *friend_con = get_conn(fr_c, number);
+    Friend_Connections *fr_c = (Friend_Connections *)object;
+    const Friend_Conn *friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     if (friend_con->crypt_connection_id != -1) {
         return friend_add_tcp_relay(fr_c, number, ip_port, public_key);
-    } else {
-        return add_tcp_relay(fr_c->net_crypto, ip_port, public_key);
     }
+
+    return add_tcp_relay(fr_c->net_crypto, ip_port, public_key);
 }
 
 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_Conn *friend_con = get_conn(fr_c, number);
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
+    Friend_Conn *const friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return;
+    }
 
     if (friend_con->crypt_connection_id == -1) {
         friend_new_connection(fr_c, number);
@@ -286,10 +345,11 @@ static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
 
 static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_public_key)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return;
+    }
 
     friend_con->dht_pk_lastrecv = unix_time();
 
@@ -303,18 +363,19 @@ static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint
     }
 
     DHT_addfriend(fr_c->dht, dht_public_key, dht_ip_callback, fr_c, friendcon_id, &friend_con->dht_lock);
-    memcpy(friend_con->dht_temp_pk, dht_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(friend_con->dht_temp_pk, dht_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 }
 
-static int handle_status(void *object, int number, uint8_t status)
+static int handle_status(void *object, int number, uint8_t status, void *userdata)
 {
-    Friend_Connections *fr_c = object;
-    Friend_Conn *friend_con = get_conn(fr_c, number);
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
+    Friend_Conn *const friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    _Bool call_cb = 0;
+    bool call_cb = 0;
 
     if (status) {  /* Went online. */
         call_cb = 1;
@@ -338,9 +399,11 @@ static int handle_status(void *object, int number, uint8_t status)
         unsigned int i;
 
         for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
-            if (friend_con->callbacks[i].status_callback)
-                friend_con->callbacks[i].status_callback(friend_con->callbacks[i].status_callback_object,
-                        friend_con->callbacks[i].status_callback_id, status);
+            if (friend_con->callbacks[i].status_callback) {
+                friend_con->callbacks[i].status_callback(
+                    friend_con->callbacks[i].callback_object,
+                    friend_con->callbacks[i].callback_id, status, userdata);
+            }
         }
     }
 
@@ -348,16 +411,18 @@ static int handle_status(void *object, int number, uint8_t status)
 }
 
 /* Callback for dht public key changes. */
-static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key)
+static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key, void *userdata)
 {
-    Friend_Connections *fr_c = object;
-    Friend_Conn *friend_con = get_conn(fr_c, number);
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
+    Friend_Conn *const friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return;
+    }
 
-    if (public_key_cmp(friend_con->dht_temp_pk, dht_public_key) == 0)
+    if (public_key_cmp(friend_con->dht_temp_pk, dht_public_key) == 0) {
         return;
+    }
 
     change_dht_pk(fr_c, number, dht_public_key);
 
@@ -365,86 +430,96 @@ static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_pub
     if (friend_con->crypt_connection_id != -1) {
         crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id);
         friend_con->crypt_connection_id = -1;
-        handle_status(object, number, 0); /* Going offline. */
+        handle_status(object, number, 0, userdata); /* Going offline. */
     }
 
     friend_new_connection(fr_c, number);
     onion_set_friend_DHT_pubkey(fr_c->onion_c, friend_con->onion_friendnum, dht_public_key);
 }
 
-static int handle_packet(void *object, int number, uint8_t *data, uint16_t length)
+static int handle_packet(void *object, int number, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
-    Friend_Connections *fr_c = object;
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
     Friend_Conn *friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     if (data[0] == PACKET_ID_FRIEND_REQUESTS) {
-        if (fr_c->fr_request_callback)
-            fr_c->fr_request_callback(fr_c->fr_request_object, friend_con->real_public_key, data, length);
+        if (fr_c->fr_request_callback) {
+            fr_c->fr_request_callback(fr_c->fr_request_object, friend_con->real_public_key, data, length, userdata);
+        }
 
         return 0;
-    } else if (data[0] == PACKET_ID_ALIVE) {
+    }
+
+    if (data[0] == PACKET_ID_ALIVE) {
         friend_con->ping_lastrecv = unix_time();
         return 0;
-    } else if (data[0] == PACKET_ID_SHARE_RELAYS) {
+    }
+
+    if (data[0] == PACKET_ID_SHARE_RELAYS) {
         Node_format nodes[MAX_SHARED_RELAYS];
-        int n;
+        const int n = unpack_nodes(nodes, MAX_SHARED_RELAYS, nullptr, data + 1, length - 1, 1);
 
-        if ((n = unpack_nodes(nodes, MAX_SHARED_RELAYS, NULL, data + 1, length - 1, 1)) == -1)
+        if (n == -1) {
             return -1;
+        }
 
-        int j;
-
-        for (j = 0; j < n; j++) {
+        for (int j = 0; j < n; j++) {
             friend_add_tcp_relay(fr_c, number, nodes[j].ip_port, nodes[j].public_key);
         }
 
         return 0;
     }
 
-    unsigned int i;
-
-    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
-        if (friend_con->callbacks[i].data_callback)
-            friend_con->callbacks[i].data_callback(friend_con->callbacks[i].data_callback_object,
-                                                   friend_con->callbacks[i].data_callback_id, data, length);
+    for (unsigned i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
+        if (friend_con->callbacks[i].data_callback) {
+            friend_con->callbacks[i].data_callback(
+                friend_con->callbacks[i].callback_object,
+                friend_con->callbacks[i].callback_id, data, length, userdata);
+        }
 
         friend_con = get_conn(fr_c, number);
 
-        if (!friend_con)
+        if (!friend_con) {
             return -1;
+        }
     }
 
     return 0;
 }
 
-static int handle_lossy_packet(void *object, int number, const uint8_t *data, uint16_t length)
+static int handle_lossy_packet(void *object, int number, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
-    Friend_Connections *fr_c = object;
-    Friend_Conn *friend_con = get_conn(fr_c, number);
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
+    const Friend_Conn *friend_con = get_conn(fr_c, number);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    unsigned int i;
-
-    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
-        if (friend_con->callbacks[i].lossy_data_callback)
-            friend_con->callbacks[i].lossy_data_callback(friend_con->callbacks[i].lossy_data_callback_object,
-                    friend_con->callbacks[i].lossy_data_callback_id, data, length);
+    for (unsigned i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
+        if (friend_con->callbacks[i].lossy_data_callback) {
+            friend_con->callbacks[i].lossy_data_callback(
+                friend_con->callbacks[i].callback_object,
+                friend_con->callbacks[i].callback_id, data, length, userdata);
+        }
 
         friend_con = get_conn(fr_c, number);
 
-        if (!friend_con)
+        if (!friend_con) {
             return -1;
+        }
     }
 
     return 0;
@@ -452,50 +527,51 @@ 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;
-    int friendcon_id = getfriend_conn_id_pk(fr_c, n_c->public_key);
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Connections *const fr_c = (Friend_Connections *)object;
+    const int friendcon_id = getfriend_conn_id_pk(fr_c, n_c->public_key);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (friend_con) {
-
-        if (friend_con->crypt_connection_id != -1)
-            return -1;
+    if (!friend_con) {
+        return -1;
+    }
 
-        int id = accept_crypto_connection(fr_c->net_crypto, n_c);
+    if (friend_con->crypt_connection_id != -1) {
+        return -1;
+    }
 
-        if (id == -1) {
-            return -1;
-        }
+    const int id = accept_crypto_connection(fr_c->net_crypto, n_c);
 
-        connection_status_handler(fr_c->net_crypto, id, &handle_status, fr_c, friendcon_id);
-        connection_data_handler(fr_c->net_crypto, id, &handle_packet, fr_c, friendcon_id);
-        connection_lossy_data_handler(fr_c->net_crypto, id, &handle_lossy_packet, fr_c, friendcon_id);
-        friend_con->crypt_connection_id = id;
+    if (id == -1) {
+        return -1;
+    }
 
-        if (n_c->source.ip.family != AF_INET && n_c->source.ip.family != AF_INET6) {
-            set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port, 0);
-        } else {
-            friend_con->dht_ip_port = n_c->source;
-            friend_con->dht_ip_port_lastrecv = unix_time();
-        }
+    connection_status_handler(fr_c->net_crypto, id, &handle_status, fr_c, friendcon_id);
+    connection_data_handler(fr_c->net_crypto, id, &handle_packet, fr_c, friendcon_id);
+    connection_lossy_data_handler(fr_c->net_crypto, id, &handle_lossy_packet, fr_c, friendcon_id);
+    friend_con->crypt_connection_id = id;
 
-        if (public_key_cmp(friend_con->dht_temp_pk, n_c->dht_public_key) != 0) {
-            change_dht_pk(fr_c, friendcon_id, n_c->dht_public_key);
-        }
+    if (!net_family_is_ipv4(n_c->source.ip.family) && !net_family_is_ipv6(n_c->source.ip.family)) {
+        set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port, 0);
+    } else {
+        friend_con->dht_ip_port = n_c->source;
+        friend_con->dht_ip_port_lastrecv = unix_time();
+    }
 
-        nc_dht_pk_callback(fr_c->net_crypto, id, &dht_pk_callback, fr_c, friendcon_id);
-        return 0;
+    if (public_key_cmp(friend_con->dht_temp_pk, n_c->dht_public_key) != 0) {
+        change_dht_pk(fr_c, friendcon_id, n_c->dht_public_key);
     }
 
-    return -1;
+    nc_dht_pk_callback(fr_c->net_crypto, id, &dht_pk_callback, fr_c, friendcon_id);
+    return 0;
 }
 
 static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     if (friend_con->crypt_connection_id != -1) {
         return -1;
@@ -506,10 +582,11 @@ static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id)
         return -1;
     }
 
-    int id = new_crypto_connection(fr_c->net_crypto, friend_con->real_public_key, friend_con->dht_temp_pk);
+    const int id = new_crypto_connection(fr_c->net_crypto, friend_con->real_public_key, friend_con->dht_temp_pk);
 
-    if (id == -1)
+    if (id == -1) {
         return -1;
+    }
 
     friend_con->crypt_connection_id = id;
     connection_status_handler(fr_c->net_crypto, id, &handle_status, fr_c, friendcon_id);
@@ -522,13 +599,14 @@ static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id)
 
 static int send_ping(const Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    uint8_t ping = PACKET_ID_ALIVE;
-    int64_t ret = write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, &ping, sizeof(ping), 0);
+    const uint8_t ping = PACKET_ID_ALIVE;
+    const int64_t ret = write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, &ping, sizeof(ping), 0);
 
     if (ret != -1) {
         friend_con->ping_lastsent = unix_time();
@@ -545,10 +623,11 @@ static int send_ping(const Friend_Connections *fr_c, int friendcon_id)
  */
 int friend_connection_lock(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     ++friend_con->lock_count;
     return 0;
@@ -560,10 +639,11 @@ int friend_connection_lock(Friend_Connections *fr_c, int friendcon_id)
  */
 unsigned int friend_con_connected(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    const Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return 0;
+    }
 
     return friend_con->status;
 }
@@ -575,25 +655,28 @@ unsigned int friend_con_connected(Friend_Connections *fr_c, int friendcon_id)
  */
 int get_friendcon_public_keys(uint8_t *real_pk, uint8_t *dht_temp_pk, Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    const Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    if (real_pk)
-        memcpy(real_pk, friend_con->real_public_key, crypto_box_PUBLICKEYBYTES);
+    if (real_pk) {
+        memcpy(real_pk, friend_con->real_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    }
 
-    if (dht_temp_pk)
-        memcpy(dht_temp_pk, friend_con->dht_temp_pk, crypto_box_PUBLICKEYBYTES);
+    if (dht_temp_pk) {
+        memcpy(dht_temp_pk, friend_con->dht_temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    }
 
     return 0;
 }
 
 /* Set temp dht key for connection.
  */
-void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk)
+void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk, void *userdata)
 {
-    dht_pk_callback(fr_c, friendcon_id, dht_temp_pk);
+    dht_pk_callback(fr_c, friendcon_id, dht_temp_pk, userdata);
 }
 
 /* Set the callbacks for the friend connection.
@@ -603,29 +686,28 @@ void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *
  * return -1 on failure
  */
 int friend_connection_callbacks(Friend_Connections *fr_c, int friendcon_id, unsigned int index,
-                                int (*status_callback)(void *object, int id, uint8_t status), int (*data_callback)(void *object, int id, uint8_t *data,
-                                        uint16_t length), int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
-                                int number)
+                                int (*status_callback)(void *object, int id, uint8_t status, void *userdata),
+                                int (*data_callback)(void *object, int id, const uint8_t *data, uint16_t len, void *userdata),
+                                int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata),
+                                void *object, int number)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    if (index >= MAX_FRIEND_CONNECTION_CALLBACKS)
+    if (index >= MAX_FRIEND_CONNECTION_CALLBACKS) {
         return -1;
+    }
 
     friend_con->callbacks[index].status_callback = status_callback;
     friend_con->callbacks[index].data_callback = data_callback;
     friend_con->callbacks[index].lossy_data_callback = lossy_data_callback;
 
-    friend_con->callbacks[index].status_callback_object =
-        friend_con->callbacks[index].data_callback_object =
-            friend_con->callbacks[index].lossy_data_callback_object = object;
+    friend_con->callbacks[index].callback_object = object;
+    friend_con->callbacks[index].callback_id = number;
 
-    friend_con->callbacks[index].status_callback_id =
-        friend_con->callbacks[index].data_callback_id =
-            friend_con->callbacks[index].lossy_data_callback_id = number;
     return 0;
 }
 
@@ -636,10 +718,11 @@ int friend_connection_callbacks(Friend_Connections *fr_c, int friendcon_id, unsi
  */
 int friend_connection_crypt_connection_id(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    const Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     return friend_con->crypt_connection_id;
 }
@@ -661,19 +744,21 @@ int new_friend_connection(Friend_Connections *fr_c, const uint8_t *real_public_k
 
     friendcon_id = create_friend_conn(fr_c);
 
-    if (friendcon_id == -1)
+    if (friendcon_id == -1) {
         return -1;
+    }
 
-    int32_t onion_friendnum = onion_addfriend(fr_c->onion_c, real_public_key);
+    const int32_t onion_friendnum = onion_addfriend(fr_c->onion_c, real_public_key);
 
-    if (onion_friendnum == -1)
+    if (onion_friendnum == -1) {
         return -1;
+    }
 
-    Friend_Conn *friend_con = &fr_c->conns[friendcon_id];
+    Friend_Conn *const friend_con = &fr_c->conns[friendcon_id];
 
     friend_con->crypt_connection_id = -1;
     friend_con->status = FRIENDCONN_STATUS_CONNECTING;
-    memcpy(friend_con->real_public_key, real_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(friend_con->real_public_key, real_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     friend_con->onion_friendnum = onion_friendnum;
 
     recv_tcp_relay_handler(fr_c->onion_c, onion_friendnum, &tcp_relay_node_callback, fr_c, friendcon_id);
@@ -689,10 +774,11 @@ int new_friend_connection(Friend_Connections *fr_c, const uint8_t *real_public_k
  */
 int kill_friend_connection(Friend_Connections *fr_c, int friendcon_id)
 {
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
     if (friend_con->lock_count) {
         --friend_con->lock_count;
@@ -715,7 +801,7 @@ int kill_friend_connection(Friend_Connections *fr_c, int friendcon_id)
  * This function will be called every time a friend request packet is received.
  */
 void set_friend_request_callback(Friend_Connections *fr_c, int (*fr_request_callback)(void *, const uint8_t *,
-                                 const uint8_t *, uint16_t), void *object)
+                                 const uint8_t *, uint16_t, void *), void *object)
 {
     fr_c->fr_request_callback = fr_request_callback;
     fr_c->fr_request_object = object;
@@ -731,49 +817,60 @@ void set_friend_request_callback(Friend_Connections *fr_c, int (*fr_request_call
 int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint32_t nospam_num, const uint8_t *data,
                                uint16_t length)
 {
-    if (1 + sizeof(nospam_num) + length > ONION_CLIENT_MAX_DATA_SIZE || length == 0)
+    if (1 + sizeof(nospam_num) + length > ONION_CLIENT_MAX_DATA_SIZE || length == 0) {
         return -1;
+    }
 
-    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+    const Friend_Conn *const friend_con = get_conn(fr_c, friendcon_id);
 
-    if (!friend_con)
+    if (!friend_con) {
         return -1;
+    }
 
-    uint8_t packet[1 + sizeof(nospam_num) + length];
+    VLA(uint8_t, packet, 1 + sizeof(nospam_num) + length);
     memcpy(packet + 1, &nospam_num, sizeof(nospam_num));
     memcpy(packet + 1 + sizeof(nospam_num), data, length);
 
     if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) {
         packet[0] = PACKET_ID_FRIEND_REQUESTS;
-        return write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, packet, sizeof(packet), 0) != -1;
-    } else {
-        packet[0] = CRYPTO_PACKET_FRIEND_REQ;
-        int num = send_onion_data(fr_c->onion_c, friend_con->onion_friendnum, packet, sizeof(packet));
+        return write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, packet, SIZEOF_VLA(packet), 0) != -1;
+    }
 
-        if (num <= 0)
-            return -1;
+    packet[0] = CRYPTO_PACKET_FRIEND_REQ;
+    const int num = send_onion_data(fr_c->onion_c, friend_con->onion_friendnum, packet, SIZEOF_VLA(packet));
 
-        return num;
+    if (num <= 0) {
+        return -1;
     }
+
+    return num;
 }
 
 /* Create new friend_connections instance. */
-Friend_Connections *new_friend_connections(Onion_Client *onion_c)
+Friend_Connections *new_friend_connections(Onion_Client *onion_c, bool local_discovery_enabled)
 {
-    if (!onion_c)
-        return NULL;
+    if (onion_c == nullptr) {
+        return nullptr;
+    }
 
-    Friend_Connections *temp = calloc(1, sizeof(Friend_Connections));
+    Friend_Connections *const temp = (Friend_Connections *)calloc(1, sizeof(Friend_Connections));
 
-    if (temp == NULL)
-        return NULL;
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
-    temp->dht = onion_c->dht;
-    temp->net_crypto = onion_c->c;
+    temp->dht = onion_get_dht(onion_c);
+    temp->net_crypto = onion_get_net_crypto(onion_c);
     temp->onion_c = onion_c;
+    temp->local_discovery_enabled = local_discovery_enabled;
+    // Don't include default port in port range
+    temp->next_LANport = TOX_PORTRANGE_FROM + 1;
 
     new_connection_handler(temp->net_crypto, &handle_new_connections, temp);
-    LANdiscovery_init(temp->dht);
+
+    if (temp->local_discovery_enabled) {
+        lan_discovery_init(temp->dht);
+    }
 
     return temp;
 }
@@ -782,19 +879,31 @@ Friend_Connections *new_friend_connections(Onion_Client *onion_c)
 static void LANdiscovery(Friend_Connections *fr_c)
 {
     if (fr_c->last_LANdiscovery + LAN_DISCOVERY_INTERVAL < unix_time()) {
-        send_LANdiscovery(htons(TOX_PORT_DEFAULT), fr_c->dht);
+        const uint16_t first = fr_c->next_LANport;
+        uint16_t last = first + PORTS_PER_DISCOVERY;
+        last = last > TOX_PORTRANGE_TO ? TOX_PORTRANGE_TO : last;
+
+        // Always send to default port
+        lan_discovery_send(net_htons(TOX_PORT_DEFAULT), fr_c->dht);
+
+        // And check some extra ports
+        for (uint16_t port = first; port < last; port++) {
+            lan_discovery_send(net_htons(port), fr_c->dht);
+        }
+
+        // Don't include default port in port range
+        fr_c->next_LANport = last != TOX_PORTRANGE_TO ? last : TOX_PORTRANGE_FROM + 1;
         fr_c->last_LANdiscovery = unix_time();
     }
 }
 
 /* main friend_connections loop. */
-void do_friend_connections(Friend_Connections *fr_c)
+void do_friend_connections(Friend_Connections *fr_c, void *userdata)
 {
-    uint32_t i;
-    uint64_t temp_time = unix_time();
+    const uint64_t temp_time = unix_time();
 
-    for (i = 0; i < fr_c->num_cons; ++i) {
-        Friend_Conn *friend_con = get_conn(fr_c, i);
+    for (uint32_t i = 0; i < fr_c->num_cons; ++i) {
+        Friend_Conn *const friend_con = get_conn(fr_c, i);
 
         if (friend_con) {
             if (friend_con->status == FRIENDCONN_STATUS_CONNECTING) {
@@ -802,11 +911,12 @@ void do_friend_connections(Friend_Connections *fr_c)
                     if (friend_con->dht_lock) {
                         DHT_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock);
                         friend_con->dht_lock = 0;
+                        memset(friend_con->dht_temp_pk, 0, CRYPTO_PUBLIC_KEY_SIZE);
                     }
                 }
 
                 if (friend_con->dht_ip_port_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) {
-                    friend_con->dht_ip_port.ip.family = 0;
+                    friend_con->dht_ip_port.ip.family = net_family_unspec;
                 }
 
                 if (friend_con->dht_lock) {
@@ -815,7 +925,6 @@ void do_friend_connections(Friend_Connections *fr_c)
                         connect_to_saved_tcp_relays(fr_c, i, (MAX_FRIEND_TCP_CONNECTIONS / 2)); /* Only fill it half up. */
                     }
                 }
-
             } else if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) {
                 if (friend_con->ping_lastsent + FRIEND_PING_INTERVAL < temp_time) {
                     send_ping(fr_c, i);
@@ -829,27 +938,31 @@ void do_friend_connections(Friend_Connections *fr_c)
                     /* If we stopped receiving ping packets, kill it. */
                     crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id);
                     friend_con->crypt_connection_id = -1;
-                    handle_status(fr_c, i, 0); /* Going offline. */
+                    handle_status(fr_c, i, 0, userdata); /* Going offline. */
                 }
             }
         }
     }
 
-    LANdiscovery(fr_c);
+    if (fr_c->local_discovery_enabled) {
+        LANdiscovery(fr_c);
+    }
 }
 
 /* Free everything related with friend_connections. */
 void kill_friend_connections(Friend_Connections *fr_c)
 {
-    if (!fr_c)
+    if (!fr_c) {
         return;
+    }
 
-    uint32_t i;
-
-    for (i = 0; i < fr_c->num_cons; ++i) {
+    for (uint32_t i = 0; i < fr_c->num_cons; ++i) {
         kill_friend_connection(fr_c, i);
     }
 
-    LANdiscovery_kill(fr_c->dht);
+    if (fr_c->local_discovery_enabled) {
+        lan_discovery_kill(fr_c->dht);
+    }
+
     free(fr_c);
 }
diff --git a/toxcore/friend_connection.h b/toxcore/friend_connection.h
index 044b8d7f..f4d53c7a 100644
--- a/toxcore/friend_connection.h
+++ b/toxcore/friend_connection.h
@@ -1,36 +1,34 @@
-/* friend_connection.h
- *
+/*
  * Connection to friends.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-
 #ifndef FRIEND_CONNECTION_H
 #define FRIEND_CONNECTION_H
 
-#include "net_crypto.h"
 #include "DHT.h"
 #include "LAN_discovery.h"
+#include "net_crypto.h"
 #include "onion_client.h"
 
-
 #define MAX_FRIEND_CONNECTION_CALLBACKS 2
 #define MESSENGER_CALLBACK_INDEX 0
 #define GROUPCHAT_CALLBACK_INDEX 1
@@ -63,57 +61,9 @@ enum {
     FRIENDCONN_STATUS_CONNECTED
 };
 
-typedef struct {
-    uint8_t status;
-
-    uint8_t real_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
-    uint16_t dht_lock;
-    IP_Port dht_ip_port;
-    uint64_t dht_pk_lastrecv, dht_ip_port_lastrecv;
-
-    int onion_friendnum;
-    int crypt_connection_id;
-
-    uint64_t ping_lastrecv, ping_lastsent;
-    uint64_t share_relays_lastsent;
-
-    struct {
-        int (*status_callback)(void *object, int id, uint8_t status);
-        void *status_callback_object;
-        int status_callback_id;
-
-        int (*data_callback)(void *object, int id, uint8_t *data, uint16_t length);
-        void *data_callback_object;
-        int data_callback_id;
-
-        int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
-        void *lossy_data_callback_object;
-        int lossy_data_callback_id;
-    } callbacks[MAX_FRIEND_CONNECTION_CALLBACKS];
-
-    uint16_t lock_count;
-
-    Node_format tcp_relays[FRIEND_MAX_STORED_TCP_RELAYS];
-    uint16_t tcp_relay_counter;
-
-    _Bool hosting_tcp_relay;
-} Friend_Conn;
-
-
-typedef struct {
-    Net_Crypto *net_crypto;
-    DHT *dht;
-    Onion_Client *onion_c;
-
-    Friend_Conn *conns;
-    uint32_t num_cons;
-
-    int (*fr_request_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t len);
-    void *fr_request_object;
+typedef struct Friend_Connections Friend_Connections;
 
-    uint64_t last_LANdiscovery;
-} Friend_Connections;
+Net_Crypto *friendconn_net_crypto(const Friend_Connections *fr_c);
 
 /* return friendcon_id corresponding to the real public key on success.
  * return -1 on failure.
@@ -142,7 +92,7 @@ int get_friendcon_public_keys(uint8_t *real_pk, uint8_t *dht_temp_pk, Friend_Con
 
 /* Set temp dht key for connection.
  */
-void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk);
+void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk, void *userdata);
 
 /* Add a TCP relay associated to the friend.
  *
@@ -158,9 +108,10 @@ int friend_add_tcp_relay(Friend_Connections *fr_c, int friendcon_id, IP_Port ip_
  * return -1 on failure
  */
 int friend_connection_callbacks(Friend_Connections *fr_c, int friendcon_id, unsigned int index,
-                                int (*status_callback)(void *object, int id, uint8_t status), int (*data_callback)(void *object, int id, uint8_t *data,
-                                        uint16_t length), int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
-                                int number);
+                                int (*status_callback)(void *object, int id, uint8_t status, void *userdata),
+                                int (*data_callback)(void *object, int id, const uint8_t *data, uint16_t len, void *userdata),
+                                int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata),
+                                void *object, int number);
 
 /* return the crypt_connection_id for the connection.
  *
@@ -198,13 +149,13 @@ int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint3
  * This function will be called every time a friend request is received.
  */
 void set_friend_request_callback(Friend_Connections *fr_c, int (*fr_request_callback)(void *, const uint8_t *,
-                                 const uint8_t *, uint16_t), void *object);
+                                 const uint8_t *, uint16_t, void *), void *object);
 
 /* Create new friend_connections instance. */
-Friend_Connections *new_friend_connections(Onion_Client *onion_c);
+Friend_Connections *new_friend_connections(Onion_Client *onion_c, bool local_discovery_enabled);
 
 /* main friend_connections loop. */
-void do_friend_connections(Friend_Connections *fr_c);
+void do_friend_connections(Friend_Connections *fr_c, void *userdata);
 
 /* Free everything related with friend_connections. */
 void kill_friend_connections(Friend_Connections *fr_c);
diff --git a/toxcore/friend_requests.c b/toxcore/friend_requests.c
index 7d4fecd1..3123e4ff 100644
--- a/toxcore/friend_requests.c
+++ b/toxcore/friend_requests.c
@@ -1,33 +1,54 @@
-/* friend_requests.c
- *
+/*
  * Handle friend requests.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "friend_requests.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
 
+struct Friend_Requests {
+    uint32_t nospam;
+    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, size_t, void *);
+    uint8_t handle_friendrequest_isset;
+    void *handle_friendrequest_object;
+
+    int (*filter_function)(const uint8_t *, void *);
+    void *filter_function_userdata;
+    /* NOTE: The following is just a temporary fix for the multiple friend requests received at the same time problem.
+     * TODO(irungentoo): Make this better (This will most likely tie in with the way we will handle spam.)
+     */
+
+#define MAX_RECEIVED_STORED 32
+
+    uint8_t received_requests[MAX_RECEIVED_STORED][CRYPTO_PUBLIC_KEY_SIZE];
+    uint16_t received_requests_index;
+};
 
 /* Set and get the nospam variable used to prevent one type of friend request spam. */
 void set_nospam(Friend_Requests *fr, uint32_t num)
@@ -43,13 +64,13 @@ uint32_t get_nospam(const Friend_Requests *fr)
 
 /* Set the function that will be executed when a friend request is received. */
 void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, size_t,
-                            void *), void *object, void *userdata)
+                            void *), void *object)
 {
     fr->handle_friendrequest = function;
     fr->handle_friendrequest_isset = 1;
     fr->handle_friendrequest_object = object;
-    fr->handle_friendrequest_userdata = userdata;
 }
+
 /* Set the function used to check if a friend request should be displayed to the user or not. */
 void set_filter_function(Friend_Requests *fr, int (*function)(const uint8_t *, void *), void *userdata)
 {
@@ -60,8 +81,9 @@ void set_filter_function(Friend_Requests *fr, int (*function)(const uint8_t *, v
 /* Add to list of received friend requests. */
 static void addto_receivedlist(Friend_Requests *fr, const uint8_t *real_pk)
 {
-    if (fr->received_requests_index >= MAX_RECEIVED_STORED)
+    if (fr->received_requests_index >= MAX_RECEIVED_STORED) {
         fr->received_requests_index = 0;
+    }
 
     id_copy(fr->received_requests[fr->received_requests_index], real_pk);
     ++fr->received_requests_index;
@@ -69,18 +91,18 @@ static void addto_receivedlist(Friend_Requests *fr, const uint8_t *real_pk)
 
 /* Check if a friend request was already received.
  *
- *  return 0 if it did not.
- *  return 1 if it did.
+ *  return false if it did not.
+ *  return true if it did.
  */
-static int request_received(Friend_Requests *fr, const uint8_t *real_pk)
+static bool request_received(const Friend_Requests *fr, const uint8_t *real_pk)
 {
-    uint32_t i;
-
-    for (i = 0; i < MAX_RECEIVED_STORED; ++i)
-        if (id_equal(fr->received_requests[i], real_pk))
-            return 1;
+    for (uint32_t i = 0; i < MAX_RECEIVED_STORED; ++i) {
+        if (id_equal(fr->received_requests[i], real_pk)) {
+            return true;
+        }
+    }
 
-    return 0;
+    return false;
 }
 
 /* Remove real pk from received_requests list.
@@ -90,11 +112,9 @@ static int request_received(Friend_Requests *fr, const uint8_t *real_pk)
  */
 int remove_request_received(Friend_Requests *fr, const uint8_t *real_pk)
 {
-    uint32_t i;
-
-    for (i = 0; i < MAX_RECEIVED_STORED; ++i) {
+    for (uint32_t i = 0; i < MAX_RECEIVED_STORED; ++i) {
         if (id_equal(fr->received_requests[i], real_pk)) {
-            sodium_memzero(fr->received_requests[i], crypto_box_PUBLICKEYBYTES);
+            crypto_memzero(fr->received_requests[i], CRYPTO_PUBLIC_KEY_SIZE);
             return 0;
         }
     }
@@ -103,38 +123,44 @@ 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)
+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 *const fr = (Friend_Requests *)object;
 
-    if (length <= 1 + sizeof(fr->nospam) || length > ONION_CLIENT_MAX_DATA_SIZE)
+    if (length <= 1 + sizeof(fr->nospam) || length > ONION_CLIENT_MAX_DATA_SIZE) {
         return 1;
+    }
 
     ++packet;
     --length;
 
-    if (fr->handle_friendrequest_isset == 0)
+    if (fr->handle_friendrequest_isset == 0) {
         return 1;
+    }
 
-    if (request_received(fr, source_pubkey))
+    if (request_received(fr, source_pubkey)) {
         return 1;
+    }
 
-    if (memcmp(packet, &fr->nospam, sizeof(fr->nospam)) != 0)
+    if (memcmp(packet, &fr->nospam, sizeof(fr->nospam)) != 0) {
         return 1;
+    }
 
-    if (fr->filter_function)
-        if ((*fr->filter_function)(source_pubkey, fr->filter_function_userdata) != 0)
+    if (fr->filter_function) {
+        if (fr->filter_function(source_pubkey, fr->filter_function_userdata) != 0) {
             return 1;
+        }
+    }
 
     addto_receivedlist(fr, source_pubkey);
 
-    uint32_t message_len = length - sizeof(fr->nospam);
-    uint8_t message[message_len + 1];
+    const uint32_t message_len = length - sizeof(fr->nospam);
+    VLA(uint8_t, message, message_len + 1);
     memcpy(message, packet + sizeof(fr->nospam), message_len);
-    message[sizeof(message) - 1] = 0; /* Be sure the message is null terminated. */
+    message[SIZEOF_VLA(message) - 1] = 0; /* Be sure the message is null terminated. */
 
-    (*fr->handle_friendrequest)(fr->handle_friendrequest_object, source_pubkey, message, message_len,
-                                fr->handle_friendrequest_userdata);
+    fr->handle_friendrequest(fr->handle_friendrequest_object, source_pubkey, message, message_len, userdata);
     return 0;
 }
 
@@ -142,3 +168,13 @@ void friendreq_init(Friend_Requests *fr, Friend_Connections *fr_c)
 {
     set_friend_request_callback(fr_c, &friendreq_handlepacket, fr);
 }
+
+Friend_Requests *friendreq_new(void)
+{
+    return (Friend_Requests *)calloc(1, sizeof(Friend_Requests));
+}
+
+void friendreq_kill(Friend_Requests *fr)
+{
+    free(fr);
+}
diff --git a/toxcore/friend_requests.h b/toxcore/friend_requests.h
index ae21f7dc..e6948b6c 100644
--- a/toxcore/friend_requests.h
+++ b/toxcore/friend_requests.h
@@ -1,26 +1,26 @@
-/* friend_requests.h
- *
+/*
  * Handle friend requests.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef FRIEND_REQUESTS_H
 #define FRIEND_REQUESTS_H
 
@@ -28,24 +28,7 @@
 
 #define MAX_FRIEND_REQUEST_DATA_SIZE (ONION_CLIENT_MAX_DATA_SIZE - (1 + sizeof(uint32_t)))
 
-typedef struct {
-    uint32_t nospam;
-    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, size_t, void *);
-    uint8_t handle_friendrequest_isset;
-    void *handle_friendrequest_object;
-    void *handle_friendrequest_userdata;
-
-    int (*filter_function)(const uint8_t *, void *);
-    void *filter_function_userdata;
-    /* NOTE: The following is just a temporary fix for the multiple friend requests received at the same time problem.
-     *  TODO: Make this better (This will most likely tie in with the way we will handle spam.)
-     */
-
-#define MAX_RECEIVED_STORED 32
-
-    uint8_t received_requests[MAX_RECEIVED_STORED][crypto_box_PUBLICKEYBYTES];
-    uint16_t received_requests_index;
-} Friend_Requests;
+typedef struct Friend_Requests Friend_Requests;
 
 /* Set and get the nospam variable used to prevent one type of friend request spam. */
 void set_nospam(Friend_Requests *fr, uint32_t num);
@@ -62,7 +45,7 @@ int remove_request_received(Friend_Requests *fr, const uint8_t *real_pk);
  *  Function format is function(uint8_t * public_key, uint8_t * data, size_t length, void * userdata)
  */
 void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, size_t,
-                            void *), void *object, void *userdata);
+                            void *), void *object);
 
 /* Set the function used to check if a friend request should be displayed to the user or not.
  * Function format is int function(uint8_t * public_key, void * userdata)
@@ -73,5 +56,7 @@ void set_filter_function(Friend_Requests *fr, int (*function)(const uint8_t *, v
 /* Sets up friendreq packet handlers. */
 void friendreq_init(Friend_Requests *fr, Friend_Connections *fr_c);
 
+Friend_Requests *friendreq_new(void);
+void friendreq_kill(Friend_Requests *fr);
 
 #endif
diff --git a/toxcore/group.c b/toxcore/group.c
index 9313a24b..b77ae38a 100644
--- a/toxcore/group.c
+++ b/toxcore/group.c
@@ -1,46 +1,53 @@
-/* group.c
- *
+/*
  * Slightly better groupchats implementation.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "group.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
 
 /* return 1 if the groupnumber is not valid.
  * return 0 if the groupnumber is valid.
  */
-static uint8_t groupnumber_not_valid(const Group_Chats *g_c, int groupnumber)
+static uint8_t groupnumber_not_valid(const Group_Chats *g_c, uint32_t groupnumber)
 {
-    if ((unsigned int)groupnumber >= g_c->num_chats)
+    if (groupnumber >= g_c->num_chats) {
         return 1;
+    }
 
-    if (g_c->chats == NULL)
+    if (g_c->chats == nullptr) {
         return 1;
+    }
 
-    if (g_c->chats[groupnumber].status == GROUPCHAT_STATUS_NONE)
+    if (g_c->chats[groupnumber].status == GROUPCHAT_STATUS_NONE) {
         return 1;
+    }
 
     return 0;
 }
@@ -55,14 +62,15 @@ static int realloc_groupchats(Group_Chats *g_c, uint32_t num)
 {
     if (num == 0) {
         free(g_c->chats);
-        g_c->chats = NULL;
+        g_c->chats = nullptr;
         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)
+    if (newgroup_chats == nullptr) {
         return -1;
+    }
 
     g_c->chats = newgroup_chats;
     return 0;
@@ -79,8 +87,9 @@ static int create_group_chat(Group_Chats *g_c)
     uint32_t i;
 
     for (i = 0; i < g_c->num_chats; ++i) {
-        if (g_c->chats[i].status == GROUPCHAT_STATUS_NONE)
+        if (g_c->chats[i].status == GROUPCHAT_STATUS_NONE) {
             return i;
+        }
     }
 
     int id = -1;
@@ -88,7 +97,7 @@ static int create_group_chat(Group_Chats *g_c)
     if (realloc_groupchats(g_c, g_c->num_chats + 1) == 0) {
         id = g_c->num_chats;
         ++g_c->num_chats;
-        memset(&(g_c->chats[id]), 0, sizeof(Group_c));
+        memset(&g_c->chats[id], 0, sizeof(Group_c));
     }
 
     return id;
@@ -100,17 +109,19 @@ static int create_group_chat(Group_Chats *g_c)
  * return -1 on failure.
  * return 0 on success.
  */
-static int wipe_group_chat(Group_Chats *g_c, int groupnumber)
+static int wipe_group_chat(Group_Chats *g_c, uint32_t groupnumber)
 {
-    if (groupnumber_not_valid(g_c, groupnumber))
+    if (groupnumber_not_valid(g_c, groupnumber)) {
         return -1;
+    }
 
     uint32_t i;
-    sodium_memzero(&(g_c->chats[groupnumber]), sizeof(Group_c));
+    crypto_memzero(&g_c->chats[groupnumber], sizeof(Group_c));
 
     for (i = g_c->num_chats; i != 0; --i) {
-        if (g_c->chats[i - 1].status != GROUPCHAT_STATUS_NONE)
+        if (g_c->chats[i - 1].status != GROUPCHAT_STATUS_NONE) {
             break;
+        }
     }
 
     if (g_c->num_chats != i) {
@@ -121,10 +132,11 @@ static int wipe_group_chat(Group_Chats *g_c, int groupnumber)
     return 0;
 }
 
-static Group_c *get_group_c(const Group_Chats *g_c, int groupnumber)
+static Group_c *get_group_c(const Group_Chats *g_c, uint32_t groupnumber)
 {
-    if (groupnumber_not_valid(g_c, groupnumber))
-        return 0;
+    if (groupnumber_not_valid(g_c, groupnumber)) {
+        return nullptr;
+    }
 
     return &g_c->chats[groupnumber];
 }
@@ -135,16 +147,18 @@ static Group_c *get_group_c(const Group_Chats *g_c, int groupnumber)
  * return peer index if peer is in chat.
  * return -1 if peer is not in chat.
  *
- * TODO: make this more efficient.
+ * TODO(irungentoo): make this more efficient.
  */
 
 static int peer_in_chat(const Group_c *chat, const uint8_t *real_pk)
 {
     uint32_t i;
 
-    for (i = 0; i < chat->numpeers; ++i)
-        if (id_equal(chat->group[i].real_pk, real_pk))
+    for (i = 0; i < chat->numpeers; ++i) {
+        if (id_equal(chat->group[i].real_pk, real_pk)) {
             return i;
+        }
+    }
 
     return -1;
 }
@@ -155,15 +169,17 @@ static int peer_in_chat(const Group_c *chat, const uint8_t *real_pk)
  * return group number if peer is in list.
  * return -1 if group is not in list.
  *
- * TODO: make this more efficient and maybe use constant time comparisons?
+ * TODO(irungentoo): make this more efficient and maybe use constant time comparisons?
  */
 static int get_group_num(const Group_Chats *g_c, const uint8_t *identifier)
 {
     uint32_t i;
 
-    for (i = 0; i < g_c->num_chats; ++i)
-        if (sodium_memcmp(g_c->chats[i].identifier, identifier, GROUP_IDENTIFIER_LENGTH) == 0)
+    for (i = 0; i < g_c->num_chats; ++i) {
+        if (crypto_memcmp(g_c->chats[i].identifier, identifier, GROUP_IDENTIFIER_LENGTH) == 0) {
             return i;
+        }
+    }
 
     return -1;
 }
@@ -174,15 +190,17 @@ static int get_group_num(const Group_Chats *g_c, const uint8_t *identifier)
  * return peer number if peer is in chat.
  * return -1 if peer is not in chat.
  *
- * TODO: make this more efficient.
+ * TODO(irungentoo): make this more efficient.
  */
 static int get_peer_index(Group_c *g, uint16_t peer_number)
 {
     uint32_t i;
 
-    for (i = 0; i < g->numpeers; ++i)
-        if (g->group[i].peer_number == peer_number)
+    for (i = 0; i < g->numpeers; ++i) {
+        if (g->group[i].peer_number == peer_number) {
             return i;
+        }
+    }
 
     return -1;
 }
@@ -209,17 +227,20 @@ enum {
 };
 
 static int friend_in_close(Group_c *g, int friendcon_id);
-static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnumber, uint8_t closest, uint8_t lock);
+static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, uint32_t groupnumber, uint8_t closest,
+                                 uint8_t lock);
 
-static int add_to_closest(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk)
+static int add_to_closest(Group_Chats *g_c, uint32_t groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    if (public_key_cmp(g->real_pk, real_pk) == 0)
+    if (public_key_cmp(g->real_pk, real_pk) == 0) {
         return -1;
+    }
 
     unsigned int i;
     unsigned int index = DESIRED_CLOSE_CONNECTIONS;
@@ -267,26 +288,27 @@ static int add_to_closest(Group_Chats *g_c, int groupnumber, const uint8_t *real
         return -1;
     }
 
-    uint8_t old_real_pk[crypto_box_PUBLICKEYBYTES];
-    uint8_t old_temp_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t old_real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t old_temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t old = 0;
 
     if (g->closest_peers[index].entry) {
-        memcpy(old_real_pk, g->closest_peers[index].real_pk, crypto_box_PUBLICKEYBYTES);
-        memcpy(old_temp_pk, g->closest_peers[index].temp_pk, crypto_box_PUBLICKEYBYTES);
+        memcpy(old_real_pk, g->closest_peers[index].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+        memcpy(old_temp_pk, g->closest_peers[index].temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
         old = 1;
     }
 
     g->closest_peers[index].entry = 1;
-    memcpy(g->closest_peers[index].real_pk, real_pk, crypto_box_PUBLICKEYBYTES);
-    memcpy(g->closest_peers[index].temp_pk, temp_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(g->closest_peers[index].real_pk, real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(g->closest_peers[index].temp_pk, temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
 
     if (old) {
         add_to_closest(g_c, groupnumber, old_real_pk, old_temp_pk);
     }
 
-    if (!g->changed)
+    if (!g->changed) {
         g->changed = GROUPCHAT_CLOSEST_ADDED;
+    }
 
     return 0;
 }
@@ -296,12 +318,13 @@ static unsigned int pk_in_closest_peers(Group_c *g, uint8_t *real_pk)
     unsigned int i;
 
     for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
-        if (!g->closest_peers[i].entry)
+        if (!g->closest_peers[i].entry) {
             continue;
+        }
 
-        if (public_key_cmp(g->closest_peers[i].real_pk, real_pk) == 0)
+        if (public_key_cmp(g->closest_peers[i].real_pk, real_pk) == 0) {
             return 1;
-
+        }
     }
 
     return 0;
@@ -309,15 +332,17 @@ static unsigned int pk_in_closest_peers(Group_c *g, uint8_t *real_pk)
 
 static int send_packet_online(Friend_Connections *fr_c, int friendcon_id, uint16_t group_num, uint8_t *identifier);
 
-static int connect_to_closest(Group_Chats *g_c, int groupnumber)
+static int connect_to_closest(Group_Chats *g_c, uint32_t groupnumber, void *userdata)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    if (!g->changed)
+    if (!g->changed) {
         return 0;
+    }
 
     unsigned int i;
 
@@ -328,14 +353,16 @@ static int connect_to_closest(Group_Chats *g_c, int groupnumber)
     }
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
             continue;
+        }
 
-        if (!g->close[i].closest)
+        if (!g->close[i].closest) {
             continue;
+        }
 
-        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
-        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+        uint8_t dht_temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
         get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[i].number);
 
         if (!pk_in_closest_peers(g, real_pk)) {
@@ -345,8 +372,9 @@ static int connect_to_closest(Group_Chats *g_c, int groupnumber)
     }
 
     for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
-        if (!g->closest_peers[i].entry)
+        if (!g->closest_peers[i].entry) {
             continue;
+        }
 
         int friendcon_id = getfriend_conn_id_pk(g_c->fr_c, g->closest_peers[i].real_pk);
 
@@ -360,7 +388,7 @@ static int connect_to_closest(Group_Chats *g_c, int groupnumber)
                 continue;
             }
 
-            set_dht_temp_pk(g_c->fr_c, friendcon_id, g->closest_peers[i].temp_pk);
+            set_dht_temp_pk(g_c->fr_c, friendcon_id, g->closest_peers[i].temp_pk, userdata);
         }
 
         add_conn_to_groupchat(g_c, friendcon_id, groupnumber, 1, lock);
@@ -375,44 +403,50 @@ static int connect_to_closest(Group_Chats *g_c, int groupnumber)
     return 0;
 }
 
-/*
- * Add a peer to the group chat.
+/* Add a peer to the group chat.
+ *
+ * do_gc_callback indicates whether we want to trigger callbacks set by the client
+ * via the public API. This should be set to false if this function is called
+ * from outside of the tox_iterate() loop.
  *
  * return peer_index if success or peer already in chat.
  * return -1 if error.
  */
-static int addpeer(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk,
-                   uint16_t peer_number)
+static int addpeer(Group_Chats *g_c, uint32_t groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk,
+                   uint16_t peer_number, void *userdata, bool do_gc_callback)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    //TODO
+    // TODO(irungentoo):
     int peer_index = peer_in_chat(g, real_pk);
 
     if (peer_index != -1) {
         id_copy(g->group[peer_index].temp_pk, temp_pk);
 
-        if (g->group[peer_index].peer_number != peer_number)
+        if (g->group[peer_index].peer_number != peer_number) {
             return -1;
+        }
 
         return peer_index;
     }
 
     peer_index = get_peer_index(g, peer_number);
 
-    if (peer_index != -1)
+    if (peer_index != -1) {
         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)
+    if (temp == nullptr) {
         return -1;
+    }
 
-    memset(&(temp[g->numpeers]), 0, sizeof(Group_Peer));
+    memset(&temp[g->numpeers], 0, sizeof(Group_Peer));
     g->group = temp;
 
     id_copy(g->group[g->numpeers].real_pk, real_pk);
@@ -424,28 +458,31 @@ static int addpeer(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, co
 
     add_to_closest(g_c, groupnumber, real_pk, temp_pk);
 
-    if (g_c->peer_namelistchange)
-        g_c->peer_namelistchange(g_c->m, groupnumber, g->numpeers - 1, CHAT_CHANGE_PEER_ADD,
-                                 g_c->group_namelistchange_userdata);
+    if (do_gc_callback && g_c->peer_list_changed_callback) {
+        g_c->peer_list_changed_callback(g_c->m, groupnumber, userdata);
+    }
 
-    if (g->peer_on_join)
+    if (g->peer_on_join) {
         g->peer_on_join(g->object, groupnumber, g->numpeers - 1);
+    }
 
     return (g->numpeers - 1);
 }
 
-static int remove_close_conn(Group_Chats *g_c, int groupnumber, int friendcon_id)
+static int remove_close_conn(Group_Chats *g_c, uint32_t groupnumber, int friendcon_id)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     uint32_t i;
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
             continue;
+        }
 
         if (g->close[i].number == (unsigned int)friendcon_id) {
             g->close[i].type = GROUPCHAT_CLOSE_NONE;
@@ -464,12 +501,13 @@ static int remove_close_conn(Group_Chats *g_c, int groupnumber, int friendcon_id
  * return 0 if success
  * return -1 if error.
  */
-static int delpeer(Group_Chats *g_c, int groupnumber, int peer_index)
+static int delpeer(Group_Chats *g_c, uint32_t groupnumber, int peer_index, void *userdata)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     uint32_t i;
 
@@ -487,99 +525,126 @@ static int delpeer(Group_Chats *g_c, int groupnumber, int peer_index)
         remove_close_conn(g_c, groupnumber, friendcon_id);
     }
 
-    Group_Peer *temp;
     --g->numpeers;
 
     void *peer_object = g->group[peer_index].object;
 
     if (g->numpeers == 0) {
         free(g->group);
-        g->group = NULL;
+        g->group = nullptr;
     } else {
-        if (g->numpeers != (uint32_t)peer_index)
+        if (g->numpeers != (uint32_t)peer_index) {
             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)
+        if (temp == nullptr) {
             return -1;
+        }
 
         g->group = temp;
     }
 
-    if (g_c->peer_namelistchange)
-        g_c->peer_namelistchange(g_c->m, groupnumber, peer_index, CHAT_CHANGE_PEER_DEL, g_c->group_namelistchange_userdata);
+    if (g_c->peer_list_changed_callback) {
+        g_c->peer_list_changed_callback(g_c->m, groupnumber, userdata);
+    }
 
-    if (g->peer_on_leave)
+    if (g->peer_on_leave) {
         g->peer_on_leave(g->object, groupnumber, peer_index, peer_object);
+    }
 
     return 0;
 }
 
-static int setnick(Group_Chats *g_c, int groupnumber, int peer_index, const uint8_t *nick, uint16_t nick_len)
+/* Set the nick for a peer.
+ *
+ * do_gc_callback indicates whether we want to trigger callbacks set by the client
+ * via the public API. This should be set to false if this function is called
+ * from outside of the tox_iterate() loop.
+ *
+ * return 0 on success.
+ * return -1 if error.
+ */
+static int setnick(Group_Chats *g_c, uint32_t groupnumber, int peer_index, const uint8_t *nick, uint16_t nick_len,
+                   void *userdata, bool do_gc_callback)
 {
-    if (nick_len > MAX_NAME_LENGTH)
+    if (nick_len > MAX_NAME_LENGTH) {
         return -1;
+    }
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     /* same name as already stored? */
-    if (g->group[peer_index].nick_len == nick_len)
-        if (nick_len == 0 || !memcmp(g->group[peer_index].nick, nick, nick_len))
+    if (g->group[peer_index].nick_len == nick_len) {
+        if (nick_len == 0 || !memcmp(g->group[peer_index].nick, nick, nick_len)) {
             return 0;
+        }
+    }
 
-    if (nick_len)
+    if (nick_len) {
         memcpy(g->group[peer_index].nick, nick, nick_len);
+    }
 
     g->group[peer_index].nick_len = nick_len;
 
-    if (g_c->peer_namelistchange)
-        g_c->peer_namelistchange(g_c->m, groupnumber, peer_index, CHAT_CHANGE_PEER_NAME, g_c->group_namelistchange_userdata);
+    if (do_gc_callback && g_c->peer_name_callback) {
+        g_c->peer_name_callback(g_c->m, groupnumber, peer_index, nick, nick_len, userdata);
+    }
 
     return 0;
 }
 
-static int settitle(Group_Chats *g_c, int groupnumber, int peer_index, const uint8_t *title, uint8_t title_len)
+static int settitle(Group_Chats *g_c, uint32_t groupnumber, int peer_index, const uint8_t *title, uint8_t title_len,
+                    void *userdata)
 {
-    if (title_len > MAX_NAME_LENGTH || title_len == 0)
+    if (title_len > MAX_NAME_LENGTH || title_len == 0) {
         return -1;
+    }
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     /* same as already set? */
-    if (g->title_len == title_len && !memcmp(g->title, title, title_len))
+    if (g->title_len == title_len && !memcmp(g->title, title, title_len)) {
         return 0;
+    }
 
     memcpy(g->title, title, title_len);
     g->title_len = title_len;
 
-    if (g_c->title_callback)
-        g_c->title_callback(g_c->m, groupnumber, peer_index, title, title_len, g_c->title_callback_userdata);
+    if (g_c->title_callback) {
+        g_c->title_callback(g_c->m, groupnumber, peer_index, title, title_len, userdata);
+    }
 
     return 0;
 }
 
-static void set_conns_type_close(Group_Chats *g_c, int groupnumber, int friendcon_id, uint8_t type)
+static void set_conns_type_close(Group_Chats *g_c, uint32_t groupnumber, int friendcon_id, uint8_t type)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return;
+    }
 
     uint32_t i;
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
             continue;
+        }
 
-        if (g->close[i].number != (unsigned int)friendcon_id)
+        if (g->close[i].number != (unsigned int)friendcon_id) {
             continue;
+        }
 
         if (type == GROUPCHAT_CLOSE_ONLINE) {
             send_packet_online(g_c->fr_c, friendcon_id, groupnumber, g->identifier);
@@ -598,34 +663,36 @@ 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)
+static int g_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);
     } else { /* Went offline */
         set_conns_status_groups(g_c, friendcon_id, GROUPCHAT_CLOSE_CONNECTION);
-        //TODO remove timedout connections?
+        // TODO(irungentoo): remove timedout connections?
     }
 
     return 0;
 }
 
-static int handle_packet(void *object, int friendcon_id, uint8_t *data, uint16_t length);
-static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length);
+static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
+static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
 
 /* Add friend to group chat.
  *
  * return close index on success
  * return -1 on failure.
  */
-static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnumber, uint8_t closest, uint8_t lock)
+static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, uint32_t groupnumber, uint8_t closest,
+                                 uint8_t lock)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     uint16_t i, ind = MAX_GROUP_CONNECTIONS;
 
@@ -641,17 +708,19 @@ static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnu
         }
     }
 
-    if (ind == MAX_GROUP_CONNECTIONS)
+    if (ind == MAX_GROUP_CONNECTIONS) {
         return -1;
+    }
 
-    if (lock)
+    if (lock) {
         friend_connection_lock(g_c->fr_c, friendcon_id);
+    }
 
     g->close[ind].type = GROUPCHAT_CLOSE_CONNECTION;
     g->close[ind].number = friendcon_id;
     g->close[ind].closest = closest;
-    //TODO
-    friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &handle_status, &handle_packet,
+    // TODO(irungentoo):
+    friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &g_handle_status, &g_handle_packet,
                                 &handle_lossy, g_c, friendcon_id);
 
     return ind;
@@ -668,8 +737,9 @@ int add_groupchat(Group_Chats *g_c, uint8_t type)
 {
     int groupnumber = create_group_chat(g_c);
 
-    if (groupnumber == -1)
+    if (groupnumber == -1) {
         return -1;
+    }
 
     Group_c *g = &g_c->chats[groupnumber];
 
@@ -678,95 +748,129 @@ int add_groupchat(Group_Chats *g_c, uint8_t type)
     new_symmetric_key(g->identifier + 1);
     g->identifier[0] = type;
     g->peer_number = 0; /* Founder is peer 0. */
-    memcpy(g->real_pk, g_c->m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
-    int peer_index = addpeer(g_c, groupnumber, g->real_pk, g_c->m->dht->self_public_key, 0);
+    memcpy(g->real_pk, nc_get_self_public_key(g_c->m->net_crypto), CRYPTO_PUBLIC_KEY_SIZE);
+    int peer_index = addpeer(g_c, groupnumber, g->real_pk, dht_get_self_public_key(g_c->m->dht), 0, nullptr, false);
 
     if (peer_index == -1) {
         return -1;
     }
 
-    setnick(g_c, groupnumber, peer_index, g_c->m->name, g_c->m->name_length);
+    setnick(g_c, groupnumber, peer_index, g_c->m->name, g_c->m->name_length, nullptr, false);
 
     return groupnumber;
 }
 
-static int group_kill_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num);
+static int group_kill_peer_send(const Group_Chats *g_c, uint32_t groupnumber, uint16_t peer_num);
 /* Delete a groupchat from the chats array.
  *
  * return 0 on success.
- * return -1 if failure.
+ * return -1 if groupnumber is invalid.
  */
-int del_groupchat(Group_Chats *g_c, int groupnumber)
+int del_groupchat(Group_Chats *g_c, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     group_kill_peer_send(g_c, groupnumber, g->peer_number);
 
     unsigned int i;
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
             continue;
+        }
 
         g->close[i].type = GROUPCHAT_CLOSE_NONE;
         kill_friend_connection(g_c->fr_c, g->close[i].number);
     }
 
     for (i = 0; i < g->numpeers; ++i) {
-        if (g->peer_on_leave)
+        if (g->peer_on_leave) {
             g->peer_on_leave(g->object, groupnumber, i, g->group[i].object);
+        }
     }
 
     free(g->group);
 
-    if (g->group_on_delete)
+    if (g->group_on_delete) {
         g->group_on_delete(g->object, groupnumber);
+    }
 
     return wipe_group_chat(g_c, groupnumber);
 }
 
 /* Copy the public key of peernumber who is in groupnumber to pk.
- * pk must be crypto_box_PUBLICKEYBYTES long.
+ * pk must be CRYPTO_PUBLIC_KEY_SIZE long.
  *
- * returns 0 on success
- * returns -1 on failure
+ * return 0 on success
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
  */
-int group_peer_pubkey(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *pk)
+int group_peer_pubkey(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, uint8_t *pk)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    if ((uint32_t)peernumber >= g->numpeers)
-        return -1;
+    if ((uint32_t)peernumber >= g->numpeers) {
+        return -2;
+    }
 
-    memcpy(pk, g->group[peernumber].real_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(pk, g->group[peernumber].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
     return 0;
 }
 
+/*
+ * Return the size of peernumber's name.
+ *
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
+ */
+int group_peername_size(const Group_Chats *g_c, uint32_t groupnumber, int peernumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g) {
+        return -1;
+    }
+
+    if ((uint32_t)peernumber >= g->numpeers) {
+        return -2;
+    }
+
+    if (g->group[peernumber].nick_len == 0) {
+        return 0;
+    }
+
+    return g->group[peernumber].nick_len;
+}
+
 /* Copy the name of peernumber who is in groupnumber to name.
  * name must be at least MAX_NAME_LENGTH long.
  *
  * return length of name if success
- * return -1 if failure
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
  */
-int group_peername(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *name)
+int group_peername(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, uint8_t *name)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    if ((uint32_t)peernumber >= g->numpeers)
-        return -1;
+    if ((uint32_t)peernumber >= g->numpeers) {
+        return -2;
+    }
 
     if (g->group[peernumber].nick_len == 0) {
-        memcpy(name, "Tox User", 8);
-        return 8;
+        return 0;
     }
 
     memcpy(name, g->group[peernumber].nick, g->group[peernumber].nick_len);
@@ -783,13 +887,14 @@ int group_peername(const Group_Chats *g_c, int groupnumber, int peernumber, uint
  *
  * return -1 on failure.
  */
-int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
+int group_names(const Group_Chats *g_c, uint32_t groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
                 uint16_t length)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     unsigned int i;
 
@@ -801,33 +906,40 @@ int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAM
 }
 
 /* Return the number of peers in the group chat on success.
- * return -1 on failure
+ * return -1 if groupnumber is invalid.
  */
-int group_number_peers(const Group_Chats *g_c, int groupnumber)
+int group_number_peers(const Group_Chats *g_c, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     return g->numpeers;
 }
 
 /* return 1 if the peernumber corresponds to ours.
- * return 0 on failure.
+ * return 0 if the peernumber is not ours.
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
+ * return -3 if we are not connected to the group chat.
  */
-unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, int peernumber)
+int group_peernumber_is_ours(const Group_Chats *g_c, uint32_t groupnumber, int peernumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return 0;
+    if (!g) {
+        return -1;
+    }
 
-    if (g->status != GROUPCHAT_STATUS_CONNECTED)
-        return 0;
+    if ((uint32_t)peernumber >= g->numpeers) {
+        return -2;
+    }
 
-    if ((uint32_t)peernumber >= g->numpeers)
-        return 0;
+    if (g->status != GROUPCHAT_STATUS_CONNECTED) {
+        return -3;
+    }
 
     return g->peer_number == g->group[peernumber].peer_number;
 }
@@ -837,12 +949,13 @@ unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, i
  * return -1 on failure.
  * return type on success.
  */
-int group_get_type(const Group_Chats *g_c, int groupnumber)
+int group_get_type(const Group_Chats *g_c, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     return g->identifier[0];
 }
@@ -855,16 +968,17 @@ int group_get_type(const Group_Chats *g_c, int groupnumber)
 static unsigned int send_packet_group_peer(Friend_Connections *fr_c, int friendcon_id, uint8_t packet_id,
         uint16_t group_num, const uint8_t *data, uint16_t length)
 {
-    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE)
+    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE) {
         return 0;
+    }
 
-    group_num = htons(group_num);
-    uint8_t packet[1 + sizeof(uint16_t) + length];
+    group_num = net_htons(group_num);
+    VLA(uint8_t, packet, 1 + sizeof(uint16_t) + length);
     packet[0] = packet_id;
     memcpy(packet + 1, &group_num, sizeof(uint16_t));
     memcpy(packet + 1 + sizeof(uint16_t), data, length);
-    return write_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
-                             sizeof(packet), 0) != -1;
+    return write_cryptpacket(friendconn_net_crypto(fr_c), friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
+                             SIZEOF_VLA(packet), 0) != -1;
 }
 
 /* Send a group lossy packet to friendcon_id.
@@ -875,16 +989,17 @@ static unsigned int send_packet_group_peer(Friend_Connections *fr_c, int friendc
 static unsigned int send_lossy_group_peer(Friend_Connections *fr_c, int friendcon_id, uint8_t packet_id,
         uint16_t group_num, const uint8_t *data, uint16_t length)
 {
-    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE)
+    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE) {
         return 0;
+    }
 
-    group_num = htons(group_num);
-    uint8_t packet[1 + sizeof(uint16_t) + length];
+    group_num = net_htons(group_num);
+    VLA(uint8_t, packet, 1 + sizeof(uint16_t) + length);
     packet[0] = packet_id;
     memcpy(packet + 1, &group_num, sizeof(uint16_t));
     memcpy(packet + 1 + sizeof(uint16_t), data, length);
-    return send_lossy_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
-                                  sizeof(packet)) != -1;
+    return send_lossy_cryptpacket(friendconn_net_crypto(fr_c), friend_connection_crypt_connection_id(fr_c, friendcon_id),
+                                  packet, SIZEOF_VLA(packet)) != -1;
 }
 
 #define INVITE_PACKET_SIZE (1 + sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH)
@@ -893,29 +1008,32 @@ static unsigned int send_lossy_group_peer(Friend_Connections *fr_c, int friendco
 #define INVITE_RESPONSE_PACKET_SIZE (1 + sizeof(uint16_t) * 2 + GROUP_IDENTIFIER_LENGTH)
 #define INVITE_RESPONSE_ID 1
 
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
+/* invite friendnumber to groupnumber.
+ *
+ * return 0 on success.
+ * return -1 if groupnumber is invalid.
+ * return -2 if invite packet failed to send.
  */
-int invite_friend(Group_Chats *g_c, int32_t friendnumber, int groupnumber)
+int invite_friend(Group_Chats *g_c, uint32_t friendnumber, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     uint8_t invite[INVITE_PACKET_SIZE];
     invite[0] = INVITE_ID;
-    uint16_t groupchat_num = htons((uint16_t)groupnumber);
+    uint16_t groupchat_num = net_htons((uint16_t)groupnumber);
     memcpy(invite + 1, &groupchat_num, sizeof(groupchat_num));
     memcpy(invite + 1 + sizeof(groupchat_num), g->identifier, GROUP_IDENTIFIER_LENGTH);
 
-    if (send_group_invite_packet(g_c->m, friendnumber, invite, sizeof(invite))) {
+    if (send_conference_invite_packet(g_c->m, friendnumber, invite, sizeof(invite))) {
         return 0;
-    } else {
-        wipe_group_chat(g_c, groupnumber);
-        return -1;
     }
+
+    wipe_group_chat(g_c, groupnumber);
+    return -2;
 }
 
 static unsigned int send_peer_query(Group_Chats *g_c, int friendcon_id, uint16_t group_num);
@@ -924,46 +1042,56 @@ static unsigned int send_peer_query(Group_Chats *g_c, int friendcon_id, uint16_t
  *
  * expected_type is the groupchat type we expect the chat we are joining is.
  *
- * returns group number on success
- * returns -1 on failure.
+ * return group number on success.
+ * return -1 if data length is invalid.
+ * return -2 if group is not the expected type.
+ * return -3 if friendnumber is invalid.
+ * return -4 if client is already in this group.
+ * return -5 if group instance failed to initialize.
+ * return -6 if join packet fails to send.
  */
-int join_groupchat(Group_Chats *g_c, int32_t friendnumber, uint8_t expected_type, const uint8_t *data, uint16_t length)
+int join_groupchat(Group_Chats *g_c, uint32_t friendnumber, uint8_t expected_type, const uint8_t *data, uint16_t length)
 {
-    if (length != sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH)
+    if (length != sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH) {
         return -1;
+    }
 
-    if (data[sizeof(uint16_t)] != expected_type)
-        return -1;
+    if (data[sizeof(uint16_t)] != expected_type) {
+        return -2;
+    }
 
     int friendcon_id = getfriendcon_id(g_c->m, friendnumber);
 
-    if (friendcon_id == -1)
-        return -1;
+    if (friendcon_id == -1) {
+        return -3;
+    }
 
-    if (get_group_num(g_c, data + sizeof(uint16_t)) != -1)
-        return -1;
+    if (get_group_num(g_c, data + sizeof(uint16_t)) != -1) {
+        return -4;
+    }
 
     int groupnumber = create_group_chat(g_c);
 
-    if (groupnumber == -1)
-        return -1;
+    if (groupnumber == -1) {
+        return -5;
+    }
 
     Group_c *g = &g_c->chats[groupnumber];
 
-    uint16_t group_num = htons(groupnumber);
+    uint16_t group_num = net_htons(groupnumber);
     g->status = GROUPCHAT_STATUS_VALID;
     g->number_joined = -1;
-    memcpy(g->real_pk, g_c->m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(g->real_pk, nc_get_self_public_key(g_c->m->net_crypto), CRYPTO_PUBLIC_KEY_SIZE);
 
     uint8_t response[INVITE_RESPONSE_PACKET_SIZE];
     response[0] = INVITE_RESPONSE_ID;
     memcpy(response + 1, &group_num, sizeof(uint16_t));
     memcpy(response + 1 + sizeof(uint16_t), data, sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH);
 
-    if (send_group_invite_packet(g_c->m, friendnumber, response, sizeof(response))) {
+    if (send_conference_invite_packet(g_c->m, friendnumber, response, sizeof(response))) {
         uint16_t other_groupnum;
         memcpy(&other_groupnum, data, sizeof(other_groupnum));
-        other_groupnum = ntohs(other_groupnum);
+        other_groupnum = net_ntohs(other_groupnum);
         memcpy(g->identifier, data + sizeof(uint16_t), GROUP_IDENTIFIER_LENGTH);
         int close_index = add_conn_to_groupchat(g_c, friendcon_id, groupnumber, 0, 1);
 
@@ -975,96 +1103,96 @@ int join_groupchat(Group_Chats *g_c, int32_t friendnumber, uint8_t expected_type
 
         send_peer_query(g_c, friendcon_id, other_groupnum);
         return groupnumber;
-    } else {
-        g->status = GROUPCHAT_STATUS_NONE;
-        return -1;
     }
+
+    g->status = GROUPCHAT_STATUS_NONE;
+    return -6;
 }
 
-/* Set the callback for group invites.
+/* Set handlers for custom lossy packets.
  *
- *  Function(Group_Chats *g_c, int32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
+ * NOTE: Handler must return 0 if packet is to be relayed, -1 if the packet should not be relayed.
  *
- *  data of length is what needs to be passed to join_groupchat().
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber, uint32_t friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
  */
-void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *,
-                             uint16_t, void *), void *userdata)
+void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, uint32_t, uint32_t,
+                                        void *,
+                                        const uint8_t *, uint16_t))
 {
-    g_c->invite_callback = function;
-    g_c->invite_callback_userdata = userdata;
+    g_c->lossy_packethandlers[byte].function = function;
 }
 
-/* Set the callback for group messages.
+/* Set the callback for group invites.
+ *
+ *  Function(Group_Chats *g_c, int32_t friendnumber, uint8_t type, uint8_t *data, size_t length, void *userdata)
  *
- *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ *  data of length is what needs to be passed to join_groupchat().
  */
-void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
-                              void *), void *userdata)
+void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, int, const uint8_t *,
+                             size_t, void *))
 {
-    g_c->message_callback = function;
-    g_c->message_callback_userdata = userdata;
+    g_c->invite_callback = function;
 }
 
-/* Set the callback for group actions.
+// TODO(sudden6): function signatures in comments are incorrect
+/* Set the callback for group messages.
  *
- *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, uint32_t friendgroupnumber, uint8_t * message, size_t length, void *userdata)
  */
-void g_callback_group_action(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
-                             void *), void *userdata)
+void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, int, const uint8_t *,
+                              size_t, void *))
 {
-    g_c->action_callback = function;
-    g_c->action_callback_userdata = userdata;
+    g_c->message_callback = function;
 }
 
-/* Set handlers for custom lossy packets.
- *
- * NOTE: Handler must return 0 if packet is to be relayed, -1 if the packet should not be relayed.
+/* Set callback function for peer nickname changes.
  *
- * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
+ * It gets called every time a peer changes their nickname.
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, uint32_t peernumber, const uint8_t *nick, size_t nick_len, void *userdata)
  */
-void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, int, int, void *,
-                                        const uint8_t *, uint16_t))
+void g_callback_peer_name(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, const uint8_t *,
+                          size_t, void *))
 {
-    g_c->lossy_packethandlers[byte].function = function;
+    g_c->peer_name_callback = function;
 }
 
-/* Set callback function for peer name list changes.
+/* Set callback function for peer list changes.
  *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Group_Chats *g_c, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
+ * It gets called every time the name list changes(new peer, deleted peer)
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, void *userdata)
  */
-void g_callback_group_namelistchange(Group_Chats *g_c, void (*function)(Messenger *m, int, int, uint8_t, void *),
-                                     void *userdata)
+void g_callback_peer_list_changed(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, void *))
 {
-    g_c->peer_namelistchange = function;
-    g_c->group_namelistchange_userdata = userdata;
+    g_c->peer_list_changed_callback = function;
 }
 
+// TODO(sudden6): function signatures are incorrect
 /* Set callback function for title changes.
  *
  * Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * title, uint8_t length, void *userdata)
  * if friendgroupnumber == -1, then author is unknown (e.g. initial joining the group)
  */
-void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint8_t,
-                            void *), void *userdata)
+void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, const uint8_t *,
+                            size_t, void *))
 {
     g_c->title_callback = function;
-    g_c->title_callback_userdata = userdata;
 }
 
 /* Set a function to be called when a new peer joins a group chat.
  *
- * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber)
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber, uint32_t friendgroupnumber)
  *
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_peer_new(const Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int))
+int callback_groupchat_peer_new(const Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t,
+                                uint32_t))
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     g->peer_on_join = function;
     return 0;
@@ -1072,17 +1200,19 @@ int callback_groupchat_peer_new(const Group_Chats *g_c, int groupnumber, void (*
 
 /* Set a function to be called when a peer leaves a group chat.
  *
- * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object))
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber, uint32_t friendgroupnumber, void *group peer object (set with group_peer_set_object))
  *
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_peer_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int, void *))
+int callback_groupchat_peer_delete(Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t, uint32_t,
+                                   void *))
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     g->peer_on_leave = function;
     return 0;
@@ -1095,51 +1225,52 @@ int callback_groupchat_peer_delete(Group_Chats *g_c, int groupnumber, void (*fun
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int))
+int callback_groupchat_delete(Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t))
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     g->group_on_delete = function;
     return 0;
 }
 
-static unsigned int send_message_group(const Group_Chats *g_c, int groupnumber, uint8_t message_id, const uint8_t *data,
-                                       uint16_t len);
+static int send_message_group(const Group_Chats *g_c, uint32_t groupnumber, uint8_t message_id, const uint8_t *data,
+                              uint16_t len);
 
 #define GROUP_MESSAGE_PING_ID 0
-int group_ping_send(const Group_Chats *g_c, int groupnumber)
+static int group_ping_send(const Group_Chats *g_c, uint32_t groupnumber)
 {
-    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_PING_ID, 0, 0)) {
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_PING_ID, nullptr, 0) > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 #define GROUP_MESSAGE_NEW_PEER_ID 16
-#define GROUP_MESSAGE_NEW_PEER_LENGTH (sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2)
+#define GROUP_MESSAGE_NEW_PEER_LENGTH (sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE * 2)
 /* send a new_peer message
  * return 0 on success
  * return -1 on failure
  */
-int group_new_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num, const uint8_t *real_pk,
-                        uint8_t *temp_pk)
+static int group_new_peer_send(const Group_Chats *g_c, uint32_t groupnumber, uint16_t peer_num, const uint8_t *real_pk,
+                               uint8_t *temp_pk)
 {
     uint8_t packet[GROUP_MESSAGE_NEW_PEER_LENGTH];
 
-    peer_num = htons(peer_num);
+    peer_num = net_htons(peer_num);
     memcpy(packet, &peer_num, sizeof(uint16_t));
-    memcpy(packet + sizeof(uint16_t), real_pk, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES, temp_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + sizeof(uint16_t), real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE, temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NEW_PEER_ID, packet, sizeof(packet))) {
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NEW_PEER_ID, packet, sizeof(packet)) > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 #define GROUP_MESSAGE_KILL_PEER_ID 17
@@ -1149,18 +1280,18 @@ int group_new_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_n
  * return 0 on success
  * return -1 on failure
  */
-static int group_kill_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num)
+static int group_kill_peer_send(const Group_Chats *g_c, uint32_t groupnumber, uint16_t peer_num)
 {
     uint8_t packet[GROUP_MESSAGE_KILL_PEER_LENGTH];
 
-    peer_num = htons(peer_num);
+    peer_num = net_htons(peer_num);
     memcpy(packet, &peer_num, sizeof(uint16_t));
 
-    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_KILL_PEER_ID, packet, sizeof(packet))) {
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_KILL_PEER_ID, packet, sizeof(packet)) > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 #define GROUP_MESSAGE_NAME_ID 48
@@ -1169,94 +1300,124 @@ static int group_kill_peer_send(const Group_Chats *g_c, int groupnumber, uint16_
  * return 0 on success
  * return -1 on failure
  */
-static int group_name_send(const Group_Chats *g_c, int groupnumber, const uint8_t *nick, uint16_t nick_len)
+static int group_name_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *nick, uint16_t nick_len)
 {
-    if (nick_len > MAX_NAME_LENGTH)
+    if (nick_len > MAX_NAME_LENGTH) {
         return -1;
+    }
 
-    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NAME_ID, nick, nick_len)) {
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NAME_ID, nick, nick_len) > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 #define GROUP_MESSAGE_TITLE_ID 49
 
 /* set the group's title, limited to MAX_NAME_LENGTH
  * return 0 on success
- * return -1 on failure
+ * return -1 if groupnumber is invalid.
+ * return -2 if title is too long or empty.
+ * return -3 if packet fails to send.
  */
-int group_title_send(const Group_Chats *g_c, int groupnumber, const uint8_t *title, uint8_t title_len)
+int group_title_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *title, uint8_t title_len)
 {
-    if (title_len > MAX_NAME_LENGTH || title_len == 0)
-        return -1;
-
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
+
+    if (title_len > MAX_NAME_LENGTH || title_len == 0) {
+        return -2;
+    }
 
     /* same as already set? */
-    if (g->title_len == title_len && !memcmp(g->title, title, title_len))
+    if (g->title_len == title_len && !memcmp(g->title, title, title_len)) {
         return 0;
+    }
 
     memcpy(g->title, title, title_len);
     g->title_len = title_len;
 
-    if (g->numpeers == 1)
+    if (g->numpeers == 1) {
         return 0;
+    }
 
-    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_TITLE_ID, title, title_len))
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_TITLE_ID, title, title_len) > 0) {
         return 0;
-    else
+    }
+
+    return -3;
+}
+
+/* return the group's title size.
+ * return -1 of groupnumber is invalid.
+ * return -2 if title is too long or empty.
+ */
+int group_title_get_size(const Group_Chats *g_c, uint32_t groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g) {
         return -1;
+    }
+
+    if (g->title_len == 0 || g->title_len > MAX_NAME_LENGTH) {
+        return -2;
+    }
+
+    return g->title_len;
 }
 
 /* Get group title from groupnumber and put it in title.
- * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
+ * Title needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes.
  *
- *  return length of copied title if success.
- *  return -1 if failure.
+ * return length of copied title if success.
+ * return -1 if groupnumber is invalid.
+ * return -2 if title is too long or empty.
  */
-int group_title_get(const Group_Chats *g_c, int groupnumber, uint8_t *title, uint32_t max_length)
+int group_title_get(const Group_Chats *g_c, uint32_t groupnumber, uint8_t *title)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return -1;
-
-    if (g->title_len == 0 || g->title_len > MAX_NAME_LENGTH)
+    if (!g) {
         return -1;
+    }
 
-    if (max_length > g->title_len)
-        max_length = g->title_len;
+    if (g->title_len == 0 || g->title_len > MAX_NAME_LENGTH) {
+        return -2;
+    }
 
-    memcpy(title, g->title, max_length);
-    return max_length;
+    memcpy(title, g->title, g->title_len);
+    return g->title_len;
 }
 
-static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length)
+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->conferences_object;
 
-    if (length <= 1)
+    if (length <= 1) {
         return;
+    }
 
     const uint8_t *invite_data = data + 1;
     uint16_t invite_length = length - 1;
 
     switch (data[0]) {
         case INVITE_ID: {
-            if (length != INVITE_PACKET_SIZE)
+            if (length != INVITE_PACKET_SIZE) {
                 return;
+            }
 
             int groupnumber = get_group_num(g_c, data + 1 + sizeof(uint16_t));
 
             if (groupnumber == -1) {
-                if (g_c->invite_callback)
-                    g_c->invite_callback(m, friendnumber, *(invite_data + sizeof(uint16_t)), invite_data, invite_length,
-                                         g_c->invite_callback_userdata);
+                if (g_c->invite_callback) {
+                    g_c->invite_callback(m, friendnumber, *(invite_data + sizeof(uint16_t)), invite_data, invite_length, userdata);
+                }
 
                 return;
             }
@@ -1265,23 +1426,27 @@ static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, con
         }
 
         case INVITE_RESPONSE_ID: {
-            if (length != INVITE_RESPONSE_PACKET_SIZE)
+            if (length != INVITE_RESPONSE_PACKET_SIZE) {
                 return;
+            }
 
             uint16_t other_groupnum, groupnum;
             memcpy(&groupnum, data + 1 + sizeof(uint16_t), sizeof(uint16_t));
-            groupnum = ntohs(groupnum);
+            groupnum = net_ntohs(groupnum);
 
             Group_c *g = get_group_c(g_c, groupnum);
 
-            if (!g)
+            if (!g) {
                 return;
+            }
 
-            if (sodium_memcmp(data + 1 + sizeof(uint16_t) * 2, g->identifier, GROUP_IDENTIFIER_LENGTH) != 0)
+            if (crypto_memcmp(data + 1 + sizeof(uint16_t) * 2, g->identifier, GROUP_IDENTIFIER_LENGTH) != 0) {
                 return;
+            }
 
-            uint16_t peer_number = rand(); /* TODO: what if two people enter the group at the same time and
-  are given the same peer_number by different nodes? */
+            /* TODO(irungentoo): what if two people enter the group at the same time and
+               are given the same peer_number by different nodes? */
+            uint16_t peer_number = rand();
 
             unsigned int tries = 0;
 
@@ -1289,18 +1454,19 @@ static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, con
                 peer_number = rand();
                 ++tries;
 
-                if (tries > 32)
+                if (tries > 32) {
                     return;
+                }
             }
 
             memcpy(&other_groupnum, data + 1, sizeof(uint16_t));
-            other_groupnum = ntohs(other_groupnum);
+            other_groupnum = net_ntohs(other_groupnum);
 
             int friendcon_id = getfriendcon_id(m, friendnumber);
-            uint8_t real_pk[crypto_box_PUBLICKEYBYTES], temp_pk[crypto_box_PUBLICKEYBYTES];
+            uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE], temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
             get_friendcon_public_keys(real_pk, temp_pk, g_c->fr_c, friendcon_id);
 
-            addpeer(g_c, groupnum, real_pk, temp_pk, peer_number);
+            addpeer(g_c, groupnum, real_pk, temp_pk, peer_number, userdata, true);
             int close_index = add_conn_to_groupchat(g_c, friendcon_id, groupnum, 0, 1);
 
             if (close_index != -1) {
@@ -1327,11 +1493,13 @@ static int friend_in_close(Group_c *g, int friendcon_id)
     unsigned int i;
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
             continue;
+        }
 
-        if (g->close[i].number != (uint32_t)friendcon_id)
+        if (g->close[i].number != (uint32_t)friendcon_id) {
             continue;
+        }
 
         return i;
     }
@@ -1359,35 +1527,43 @@ static unsigned int count_close_connected(Group_c *g)
 static int send_packet_online(Friend_Connections *fr_c, int friendcon_id, uint16_t group_num, uint8_t *identifier)
 {
     uint8_t packet[1 + ONLINE_PACKET_DATA_SIZE];
-    group_num = htons(group_num);
+    group_num = net_htons(group_num);
     packet[0] = PACKET_ID_ONLINE_PACKET;
     memcpy(packet + 1, &group_num, sizeof(uint16_t));
     memcpy(packet + 1 + sizeof(uint16_t), identifier, GROUP_IDENTIFIER_LENGTH);
-    return write_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
+    return write_cryptpacket(friendconn_net_crypto(fr_c), friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
                              sizeof(packet), 0) != -1;
 }
 
 static unsigned int send_peer_kill(Group_Chats *g_c, int friendcon_id, uint16_t group_num);
 
-static int handle_packet_online(Group_Chats *g_c, int friendcon_id, uint8_t *data, uint16_t length)
+static int handle_packet_online(Group_Chats *g_c, int friendcon_id, const uint8_t *data, uint16_t length)
 {
-    if (length != ONLINE_PACKET_DATA_SIZE)
+    if (length != ONLINE_PACKET_DATA_SIZE) {
         return -1;
+    }
 
     int groupnumber = get_group_num(g_c, data + sizeof(uint16_t));
+
+    if (groupnumber == -1) {
+        return -1;
+    }
+
     uint16_t other_groupnum;
     memcpy(&other_groupnum, data, sizeof(uint16_t));
-    other_groupnum = ntohs(other_groupnum);
+    other_groupnum = net_ntohs(other_groupnum);
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     int index = friend_in_close(g, friendcon_id);
 
-    if (index == -1)
+    if (index == -1) {
         return -1;
+    }
 
     if (g->close[index].type == GROUPCHAT_CLOSE_ONLINE) {
         return -1;
@@ -1404,8 +1580,9 @@ static int handle_packet_online(Group_Chats *g_c, int friendcon_id, uint8_t *dat
     if (g->number_joined != -1 && count_close_connected(g) >= DESIRED_CLOSE_CONNECTIONS) {
         int fr_close_index = friend_in_close(g, g->number_joined);
 
-        if (fr_close_index == -1)
+        if (fr_close_index == -1) {
             return -1;
+        }
 
         if (!g->close[fr_close_index].closest) {
             g->close[fr_close_index].type = GROUPCHAT_CLOSE_NONE;
@@ -1431,7 +1608,7 @@ static unsigned int send_peer_kill(Group_Chats *g_c, int friendcon_id, uint16_t
 {
     uint8_t packet[1];
     packet[0] = PEER_KILL_ID;
-    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, sizeof(packet));
+    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_CONFERENCE, group_num, packet, sizeof(packet));
 }
 
 
@@ -1442,18 +1619,19 @@ static unsigned int send_peer_query(Group_Chats *g_c, int friendcon_id, uint16_t
 {
     uint8_t packet[1];
     packet[0] = PEER_QUERY_ID;
-    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, sizeof(packet));
+    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_CONFERENCE, group_num, packet, sizeof(packet));
 }
 
 /* return number of peers sent on success.
  * return 0 on failure.
  */
-static unsigned int send_peers(Group_Chats *g_c, int groupnumber, int friendcon_id, uint16_t group_num)
+static unsigned int send_peers(Group_Chats *g_c, uint32_t groupnumber, int friendcon_id, uint16_t group_num)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return -1;
+    if (!g) {
+        return 0;
+    }
 
     uint8_t packet[MAX_CRYPTO_DATA_SIZE - (1 + sizeof(uint16_t))];
     packet[0] = PEER_RESPONSE_ID;
@@ -1463,8 +1641,8 @@ static unsigned int send_peers(Group_Chats *g_c, int groupnumber, int friendcon_
     unsigned int i;
 
     for (i = 0; i < g->numpeers; ++i) {
-        if ((p - packet) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1 + g->group[i].nick_len > sizeof(packet)) {
-            if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, (p - packet))) {
+        if ((p - packet) + sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE * 2 + 1 + g->group[i].nick_len > sizeof(packet)) {
+            if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_CONFERENCE, group_num, packet, (p - packet))) {
                 sent = i;
             } else {
                 return sent;
@@ -1473,13 +1651,13 @@ static unsigned int send_peers(Group_Chats *g_c, int groupnumber, int friendcon_
             p = packet + 1;
         }
 
-        uint16_t peer_num = htons(g->group[i].peer_number);
+        uint16_t peer_num = net_htons(g->group[i].peer_number);
         memcpy(p, &peer_num, sizeof(peer_num));
         p += sizeof(peer_num);
-        memcpy(p, g->group[i].real_pk, crypto_box_PUBLICKEYBYTES);
-        p += crypto_box_PUBLICKEYBYTES;
-        memcpy(p, g->group[i].temp_pk, crypto_box_PUBLICKEYBYTES);
-        p += crypto_box_PUBLICKEYBYTES;
+        memcpy(p, g->group[i].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+        p += CRYPTO_PUBLIC_KEY_SIZE;
+        memcpy(p, g->group[i].temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+        p += CRYPTO_PUBLIC_KEY_SIZE;
         *p = g->group[i].nick_len;
         p += 1;
         memcpy(p, g->group[i].nick, g->group[i].nick_len);
@@ -1487,76 +1665,83 @@ static unsigned int send_peers(Group_Chats *g_c, int groupnumber, int friendcon_
     }
 
     if (sent != i) {
-        if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, (p - packet))) {
+        if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_CONFERENCE, group_num, packet, (p - packet))) {
             sent = i;
         }
     }
 
     if (g->title_len) {
-        uint8_t Packet[1 + g->title_len];
+        VLA(uint8_t, Packet, 1 + g->title_len);
         Packet[0] = PEER_TITLE_ID;
         memcpy(Packet + 1, g->title, g->title_len);
-        send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, Packet, sizeof(Packet));
+        send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_CONFERENCE, group_num, Packet, SIZEOF_VLA(Packet));
     }
 
     return sent;
 }
 
-static int handle_send_peers(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length)
+static int handle_send_peers(Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data, uint16_t length,
+                             void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     const uint8_t *d = data;
 
-    while ((unsigned int)(length - (d - data)) >= sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1) {
+    while ((unsigned int)(length - (d - data)) >= sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE * 2 + 1) {
         uint16_t peer_num;
         memcpy(&peer_num, d, sizeof(peer_num));
-        peer_num = ntohs(peer_num);
+        peer_num = net_ntohs(peer_num);
         d += sizeof(uint16_t);
-        int peer_index = addpeer(g_c, groupnumber, d, d + crypto_box_PUBLICKEYBYTES, peer_num);
+        int peer_index = addpeer(g_c, groupnumber, d, d + CRYPTO_PUBLIC_KEY_SIZE, peer_num, userdata, true);
 
-        if (peer_index == -1)
+        if (peer_index == -1) {
             return -1;
+        }
 
         if (g->status == GROUPCHAT_STATUS_VALID
-                && public_key_cmp(d, g_c->m->net_crypto->self_public_key) == 0) {
+                && public_key_cmp(d, nc_get_self_public_key(g_c->m->net_crypto)) == 0) {
             g->peer_number = peer_num;
             g->status = GROUPCHAT_STATUS_CONNECTED;
             group_name_send(g_c, groupnumber, g_c->m->name, g_c->m->name_length);
         }
 
-        d += crypto_box_PUBLICKEYBYTES * 2;
+        d += CRYPTO_PUBLIC_KEY_SIZE * 2;
         uint8_t name_length = *d;
         d += 1;
 
-        if (name_length > (length - (d - data)) || name_length > MAX_NAME_LENGTH)
+        if (name_length > (length - (d - data)) || name_length > MAX_NAME_LENGTH) {
             return -1;
+        }
 
-        setnick(g_c, groupnumber, peer_index, d, name_length);
+        setnick(g_c, groupnumber, peer_index, d, name_length, userdata, true);
         d += name_length;
     }
 
     return 0;
 }
 
-static void handle_direct_packet(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
-                                 int close_index)
+static void handle_direct_packet(Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data, uint16_t length,
+                                 int close_index, void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return;
+    }
 
     switch (data[0]) {
         case PEER_KILL_ID: {
             Group_c *g = get_group_c(g_c, groupnumber);
 
-            if (!g)
+            if (!g) {
                 return;
+            }
 
             if (!g->close[close_index].closest) {
                 g->close[close_index].type = GROUPCHAT_CLOSE_NONE;
@@ -1569,8 +1754,9 @@ static void handle_direct_packet(Group_Chats *g_c, int groupnumber, const uint8_
         case PEER_QUERY_ID: {
             Group_c *g = get_group_c(g_c, groupnumber);
 
-            if (!g)
+            if (!g) {
                 return;
+            }
 
             send_peers(g_c, groupnumber, g->close[close_index].number, g->close[close_index].group_number);
         }
@@ -1578,13 +1764,13 @@ static void handle_direct_packet(Group_Chats *g_c, int groupnumber, const uint8_
         break;
 
         case PEER_RESPONSE_ID: {
-            handle_send_peers(g_c, groupnumber, data + 1, length - 1);
+            handle_send_peers(g_c, groupnumber, data + 1, length - 1, userdata);
         }
 
         break;
 
         case PEER_TITLE_ID: {
-            settitle(g_c, groupnumber, -1, data + 1, length - 1);
+            settitle(g_c, groupnumber, -1, data + 1, length - 1, userdata);
         }
 
         break;
@@ -1598,26 +1784,30 @@ static void handle_direct_packet(Group_Chats *g_c, int groupnumber, const uint8_
  *
  * return number of messages sent.
  */
-static unsigned int send_message_all_close(const Group_Chats *g_c, int groupnumber, const uint8_t *data,
+static unsigned int send_message_all_close(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data,
         uint16_t length, int receiver)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return 0;
+    }
 
     uint16_t i, sent = 0;
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE)
+        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE) {
             continue;
+        }
 
-        if ((int)i == receiver)
+        if ((int)i == receiver) {
             continue;
+        }
 
-        if (send_packet_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_MESSAGE_GROUPCHAT, g->close[i].group_number, data,
-                                   length))
+        if (send_packet_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_MESSAGE_CONFERENCE, g->close[i].group_number, data,
+                                   length)) {
             ++sent;
+        }
     }
 
     return sent;
@@ -1628,22 +1818,26 @@ static unsigned int send_message_all_close(const Group_Chats *g_c, int groupnumb
  *
  * return number of messages sent.
  */
-static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
+static unsigned int send_lossy_all_close(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data,
+        uint16_t length,
         int receiver)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return 0;
+    }
 
     unsigned int i, sent = 0, num_connected_closest = 0, connected_closest[DESIRED_CLOSE_CONNECTIONS];
 
     for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
-        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE)
+        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE) {
             continue;
+        }
 
-        if ((int)i == receiver)
+        if ((int)i == receiver) {
             continue;
+        }
 
         if (g->close[i].closest) {
             connected_closest[num_connected_closest] = i;
@@ -1651,9 +1845,10 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
             continue;
         }
 
-        if (send_lossy_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_LOSSY_GROUPCHAT, g->close[i].group_number, data,
-                                  length))
+        if (send_lossy_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_LOSSY_CONFERENCE, g->close[i].group_number, data,
+                                  length)) {
             ++sent;
+        }
     }
 
     if (!num_connected_closest) {
@@ -1664,8 +1859,8 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
     uint64_t comp_val_old = ~0;
 
     for (i = 0; i < num_connected_closest; ++i) {
-        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
-        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE] = {0};
+        uint8_t dht_temp_pk[CRYPTO_PUBLIC_KEY_SIZE] = {0};
         get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[connected_closest[i]].number);
         uint64_t comp_val = calculate_comp_value(g->real_pk, real_pk);
 
@@ -1675,7 +1870,7 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
         }
     }
 
-    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send].number, PACKET_ID_LOSSY_GROUPCHAT,
+    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send].number, PACKET_ID_LOSSY_CONFERENCE,
                               g->close[to_send].group_number, data, length)) {
         ++sent;
     }
@@ -1684,8 +1879,8 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
     comp_val_old = ~0;
 
     for (i = 0; i < num_connected_closest; ++i) {
-        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
-        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE] = {0};
+        uint8_t dht_temp_pk[CRYPTO_PUBLIC_KEY_SIZE] = {0};
         get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[connected_closest[i]].number);
         uint64_t comp_val = calculate_comp_value(real_pk, g->real_pk);
 
@@ -1699,7 +1894,7 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
         return sent;
     }
 
-    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send_other].number, PACKET_ID_LOSSY_GROUPCHAT,
+    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send_other].number, PACKET_ID_LOSSY_CONFERENCE,
                               g->close[to_send_other].group_number, data, length)) {
         ++sent;
     }
@@ -1712,66 +1907,80 @@ static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber
 /* Send data of len with message_id to groupnumber.
  *
  * return number of peers it was sent to on success.
- * return 0 on failure.
+ * return -1 if groupnumber is invalid.
+ * return -2 if message is too long.
+ * return -3 if we are not connected to the group.
+ * reutrn -4 if message failed to send.
  */
-static unsigned int send_message_group(const Group_Chats *g_c, int groupnumber, uint8_t message_id, const uint8_t *data,
-                                       uint16_t len)
+static int send_message_group(const Group_Chats *g_c, uint32_t groupnumber, uint8_t message_id, const uint8_t *data,
+                              uint16_t len)
 {
-    if (len > MAX_GROUP_MESSAGE_DATA_LEN)
-        return 0;
-
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return 0;
+    if (!g) {
+        return -1;
+    }
 
-    if (g->status != GROUPCHAT_STATUS_CONNECTED)
-        return 0;
+    if (len > MAX_GROUP_MESSAGE_DATA_LEN) {
+        return -2;
+    }
+
+    if (g->status != GROUPCHAT_STATUS_CONNECTED) {
+        return -3;
+    }
 
-    uint8_t packet[sizeof(uint16_t) + sizeof(uint32_t) + 1 + len];
-    uint16_t peer_num = htons(g->peer_number);
+    VLA(uint8_t, packet, sizeof(uint16_t) + sizeof(uint32_t) + 1 + len);
+    uint16_t peer_num = net_htons(g->peer_number);
     memcpy(packet, &peer_num, sizeof(peer_num));
 
     ++g->message_number;
 
-    if (!g->message_number)
+    if (!g->message_number) {
         ++g->message_number;
+    }
 
-    uint32_t message_num = htonl(g->message_number);
+    uint32_t message_num = net_htonl(g->message_number);
     memcpy(packet + sizeof(uint16_t), &message_num, sizeof(message_num));
 
     packet[sizeof(uint16_t) + sizeof(uint32_t)] = message_id;
 
-    if (len)
+    if (len) {
         memcpy(packet + sizeof(uint16_t) + sizeof(uint32_t) + 1, data, len);
+    }
 
-    return send_message_all_close(g_c, groupnumber, packet, sizeof(packet), -1);
+    unsigned int ret = send_message_all_close(g_c, groupnumber, packet, SIZEOF_VLA(packet), -1);
+
+    return (ret == 0) ? -4 : ret;
 }
 
 /* send a group message
  * return 0 on success
- * return -1 on failure
+ * see: send_message_group() for error codes.
  */
-int group_message_send(const Group_Chats *g_c, int groupnumber, const uint8_t *message, uint16_t length)
+int group_message_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *message, uint16_t length)
 {
-    if (send_message_group(g_c, groupnumber, PACKET_ID_MESSAGE, message, length)) {
+    int ret = send_message_group(g_c, groupnumber, PACKET_ID_MESSAGE, message, length);
+
+    if (ret > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return ret;
 }
 
 /* send a group action
  * return 0 on success
- * return -1 on failure
+ * see: send_message_group() for error codes.
  */
-int group_action_send(const Group_Chats *g_c, int groupnumber, const uint8_t *action, uint16_t length)
+int group_action_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *action, uint16_t length)
 {
-    if (send_message_group(g_c, groupnumber, PACKET_ID_ACTION, action, length)) {
+    int ret = send_message_group(g_c, groupnumber, PACKET_ID_ACTION, action, length);
+
+    if (ret > 0) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return ret;
 }
 
 /* High level function to send custom lossy packets.
@@ -1779,22 +1988,23 @@ int group_action_send(const Group_Chats *g_c, int groupnumber, const uint8_t *ac
  * return -1 on failure.
  * return 0 on success.
  */
-int send_group_lossy_packet(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length)
+int send_group_lossy_packet(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data, uint16_t length)
 {
-    //TODO: length check here?
+    // TODO(irungentoo): length check here?
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    uint8_t packet[sizeof(uint16_t) * 2 + length];
-    uint16_t peer_number = htons(g->peer_number);
+    VLA(uint8_t, packet, sizeof(uint16_t) * 2 + length);
+    uint16_t peer_number = net_htons(g->peer_number);
     memcpy(packet, &peer_number, sizeof(uint16_t));
-    uint16_t message_num = htons(g->lossy_message_number);
+    uint16_t message_num = net_htons(g->lossy_message_number);
     memcpy(packet + sizeof(uint16_t), &message_num, sizeof(uint16_t));
     memcpy(packet + sizeof(uint16_t) * 2, data, length);
 
-    if (send_lossy_all_close(g_c, groupnumber, packet, sizeof(packet), -1) == 0) {
+    if (send_lossy_all_close(g_c, groupnumber, packet, SIZEOF_VLA(packet), -1) == 0) {
         return -1;
     }
 
@@ -1802,20 +2012,22 @@ int send_group_lossy_packet(const Group_Chats *g_c, int groupnumber, const uint8
     return 0;
 }
 
-static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
-                                        int close_index)
+static void handle_message_packet_group(Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data, uint16_t length,
+                                        int close_index, void *userdata)
 {
-    if (length < sizeof(uint16_t) + sizeof(uint32_t) + 1)
+    if (length < sizeof(uint16_t) + sizeof(uint32_t) + 1) {
         return;
+    }
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return;
+    }
 
     uint16_t peer_number;
     memcpy(&peer_number, data, sizeof(uint16_t));
-    peer_number = ntohs(peer_number);
+    peer_number = net_ntohs(peer_number);
 
     int index = get_peer_index(g, peer_number);
 
@@ -1828,7 +2040,7 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
 
     uint32_t message_number;
     memcpy(&message_number, data + sizeof(uint16_t), sizeof(message_number));
-    message_number = ntohl(message_number);
+    message_number = net_ntohl(message_number);
 
     if (g->group[index].last_message_number == 0) {
         g->group[index].last_message_number = message_number;
@@ -1845,80 +2057,89 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
 
     switch (message_id) {
         case GROUP_MESSAGE_PING_ID: {
-            if (msg_data_len != 0)
+            if (msg_data_len != 0) {
                 return;
+            }
 
             g->group[index].last_recv = unix_time();
         }
         break;
 
         case GROUP_MESSAGE_NEW_PEER_ID: {
-            if (msg_data_len != GROUP_MESSAGE_NEW_PEER_LENGTH)
+            if (msg_data_len != GROUP_MESSAGE_NEW_PEER_LENGTH) {
                 return;
+            }
 
             uint16_t new_peer_number;
             memcpy(&new_peer_number, msg_data, sizeof(uint16_t));
-            new_peer_number = ntohs(new_peer_number);
-            addpeer(g_c, groupnumber, msg_data + sizeof(uint16_t), msg_data + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES,
-                    new_peer_number);
+            new_peer_number = net_ntohs(new_peer_number);
+            addpeer(g_c, groupnumber, msg_data + sizeof(uint16_t), msg_data + sizeof(uint16_t) + CRYPTO_PUBLIC_KEY_SIZE,
+                    new_peer_number, userdata, true);
         }
         break;
 
         case GROUP_MESSAGE_KILL_PEER_ID: {
-            if (msg_data_len != GROUP_MESSAGE_KILL_PEER_LENGTH)
+            if (msg_data_len != GROUP_MESSAGE_KILL_PEER_LENGTH) {
                 return;
+            }
 
             uint16_t kill_peer_number;
             memcpy(&kill_peer_number, msg_data, sizeof(uint16_t));
-            kill_peer_number = ntohs(kill_peer_number);
+            kill_peer_number = net_ntohs(kill_peer_number);
 
             if (peer_number == kill_peer_number) {
-                delpeer(g_c, groupnumber, index);
+                delpeer(g_c, groupnumber, index, userdata);
             } else {
                 return;
-                //TODO
+                // TODO(irungentoo):
             }
         }
         break;
 
         case GROUP_MESSAGE_NAME_ID: {
-            if (setnick(g_c, groupnumber, index, msg_data, msg_data_len) == -1)
+            if (setnick(g_c, groupnumber, index, msg_data, msg_data_len, userdata, true) == -1) {
                 return;
+            }
         }
         break;
 
         case GROUP_MESSAGE_TITLE_ID: {
-            if (settitle(g_c, groupnumber, index, msg_data, msg_data_len) == -1)
+            if (settitle(g_c, groupnumber, index, msg_data, msg_data_len, userdata) == -1) {
                 return;
+            }
         }
         break;
 
         case PACKET_ID_MESSAGE: {
-            if (msg_data_len == 0)
+            if (msg_data_len == 0) {
                 return;
+            }
 
-            uint8_t newmsg[msg_data_len + 1];
+            VLA(uint8_t, newmsg, msg_data_len + 1);
             memcpy(newmsg, msg_data, msg_data_len);
             newmsg[msg_data_len] = 0;
 
-            //TODO
-            if (g_c->message_callback)
-                g_c->message_callback(g_c->m, groupnumber, index, newmsg, msg_data_len, g_c->message_callback_userdata);
+            // TODO(irungentoo):
+            if (g_c->message_callback) {
+                g_c->message_callback(g_c->m, groupnumber, index, 0, newmsg, msg_data_len, userdata);
+            }
 
             break;
         }
 
         case PACKET_ID_ACTION: {
-            if (msg_data_len == 0)
+            if (msg_data_len == 0) {
                 return;
+            }
 
-            uint8_t newmsg[msg_data_len + 1];
+            VLA(uint8_t, newmsg, msg_data_len + 1);
             memcpy(newmsg, msg_data, msg_data_len);
             newmsg[msg_data_len] = 0;
 
-            //TODO
-            if (g_c->action_callback)
-                g_c->action_callback(g_c->m, groupnumber, index, newmsg, msg_data_len, g_c->action_callback_userdata);
+            // TODO(irungentoo):
+            if (g_c->message_callback) {
+                g_c->message_callback(g_c->m, groupnumber, index, 1, newmsg, msg_data_len, userdata);
+            }
 
             break;
         }
@@ -1927,44 +2148,49 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
             return;
     }
 
-    send_message_all_close(g_c, groupnumber, data, length, -1/*TODO close_index*/);
+    send_message_all_close(g_c, groupnumber, data, length, -1/* TODO(irungentoo) close_index */);
 }
 
-static int handle_packet(void *object, int friendcon_id, uint8_t *data, uint16_t length)
+static int g_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)
+    if (length < 1 + sizeof(uint16_t) + 1) {
         return -1;
+    }
 
     if (data[0] == PACKET_ID_ONLINE_PACKET) {
         return handle_packet_online(g_c, friendcon_id, data + 1, length - 1);
     }
 
-    if (data[0] != PACKET_ID_DIRECT_GROUPCHAT && data[0] != PACKET_ID_MESSAGE_GROUPCHAT)
+    if (data[0] != PACKET_ID_DIRECT_CONFERENCE && data[0] != PACKET_ID_MESSAGE_CONFERENCE) {
         return -1;
+    }
 
     uint16_t groupnumber;
     memcpy(&groupnumber, data + 1, sizeof(uint16_t));
-    groupnumber = ntohs(groupnumber);
+    groupnumber = net_ntohs(groupnumber);
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     int index = friend_in_close(g, friendcon_id);
 
-    if (index == -1)
+    if (index == -1) {
         return -1;
+    }
 
     switch (data[0]) {
-        case PACKET_ID_DIRECT_GROUPCHAT: {
-            handle_direct_packet(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index);
+        case PACKET_ID_DIRECT_CONFERENCE: {
+            handle_direct_packet(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index, userdata);
             break;
         }
 
-        case PACKET_ID_MESSAGE_GROUPCHAT: {
-            handle_message_packet_group(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index);
+        case PACKET_ID_MESSAGE_CONFERENCE: {
+            handle_message_packet_group(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index,
+                                        userdata);
             break;
         }
 
@@ -1982,12 +2208,14 @@ static int handle_packet(void *object, int friendcon_id, uint8_t *data, uint16_t
  * return 0 if packet was not received.
  * return 1 if packet was received.
  *
- * TODO: test this
+ * TODO(irungentoo): test this
  */
 static unsigned int lossy_packet_not_received(Group_c *g, int peer_index, uint16_t message_number)
 {
-    if (peer_index == -1)
+    if (peer_index == -1) {
+        // TODO(sudden6): invalid return value
         return -1;
+    }
 
     if (g->group[peer_index].bottom_lossy_number == g->group[peer_index].top_lossy_number) {
         g->group[peer_index].top_lossy_number = message_number;
@@ -2005,20 +2233,21 @@ static unsigned int lossy_packet_not_received(Group_c *g, int peer_index, uint16
         return 0;
     }
 
-    if ((uint16_t)(message_number - g->group[peer_index].bottom_lossy_number) > (1 << 15))
+    if ((uint16_t)(message_number - g->group[peer_index].bottom_lossy_number) > (1 << 15)) {
+        // TODO(sudden6): invalid return value
         return -1;
+    }
 
     uint16_t top_distance = message_number - g->group[peer_index].top_lossy_number;
 
     if (top_distance >= MAX_LOSSY_COUNT) {
-        sodium_memzero(g->group[peer_index].recv_lossy, sizeof(g->group[peer_index].recv_lossy));
+        crypto_memzero(g->group[peer_index].recv_lossy, sizeof(g->group[peer_index].recv_lossy));
         g->group[peer_index].top_lossy_number = message_number;
         g->group[peer_index].bottom_lossy_number = (message_number - MAX_LOSSY_COUNT) + 1;
         g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
-        return 0;
-    }
 
-    if (top_distance < MAX_LOSSY_COUNT) {
+        return 0;
+    } else {  // top_distance < MAX_LOSSY_COUNT
         unsigned int i;
 
         for (i = g->group[peer_index].bottom_lossy_number; i != (g->group[peer_index].bottom_lossy_number + top_distance);
@@ -2029,50 +2258,56 @@ static unsigned int lossy_packet_not_received(Group_c *g, int peer_index, uint16
         g->group[peer_index].top_lossy_number = message_number;
         g->group[peer_index].bottom_lossy_number = (message_number - MAX_LOSSY_COUNT) + 1;
         g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
+
         return 0;
     }
-
-    return -1;
 }
 
-static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length)
+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)
+    if (length < 1 + sizeof(uint16_t) * 3 + 1) {
         return -1;
+    }
 
-    if (data[0] != PACKET_ID_LOSSY_GROUPCHAT)
+    if (data[0] != PACKET_ID_LOSSY_CONFERENCE) {
         return -1;
+    }
 
     uint16_t groupnumber, peer_number, message_number;
     memcpy(&groupnumber, data + 1, sizeof(uint16_t));
     memcpy(&peer_number, data + 1 + sizeof(uint16_t), sizeof(uint16_t));
     memcpy(&message_number, data + 1 + sizeof(uint16_t) * 2, sizeof(uint16_t));
-    groupnumber = ntohs(groupnumber);
-    peer_number = ntohs(peer_number);
-    message_number = ntohs(message_number);
+    groupnumber = net_ntohs(groupnumber);
+    peer_number = net_ntohs(peer_number);
+    message_number = net_ntohs(message_number);
 
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     int index = friend_in_close(g, friendcon_id);
 
-    if (index == -1)
+    if (index == -1) {
         return -1;
+    }
 
-    if (peer_number == g->peer_number)
+    if (peer_number == g->peer_number) {
         return -1;
+    }
 
     int peer_index = get_peer_index(g, peer_number);
 
-    if (peer_index == -1)
+    if (peer_index == -1) {
         return -1;
+    }
 
-    if (lossy_packet_not_received(g, peer_index, message_number))
+    if (lossy_packet_not_received(g, peer_index, message_number)) {
         return -1;
+    }
 
     const uint8_t *lossy_data = data + 1 + sizeof(uint16_t) * 3;
     uint16_t lossy_length = length - (1 + sizeof(uint16_t) * 3);
@@ -2098,12 +2333,13 @@ static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uin
  * return 0 on success.
  * return -1 on failure
  */
-int group_set_object(const Group_Chats *g_c, int groupnumber, void *object)
+int group_set_object(const Group_Chats *g_c, uint32_t groupnumber, void *object)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     g->object = object;
     return 0;
@@ -2114,15 +2350,17 @@ int group_set_object(const Group_Chats *g_c, int groupnumber, void *object)
  * return 0 on success.
  * return -1 on failure
  */
-int group_peer_set_object(const Group_Chats *g_c, int groupnumber, int peernumber, void *object)
+int group_peer_set_object(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, void *object)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
-    if ((uint32_t)peernumber >= g->numpeers)
+    if ((uint32_t)peernumber >= g->numpeers) {
         return -1;
+    }
 
     g->group[peernumber].object = object;
     return 0;
@@ -2133,12 +2371,13 @@ int group_peer_set_object(const Group_Chats *g_c, int groupnumber, int peernumbe
  * return NULL on failure.
  * return object on success.
  */
-void *group_get_object(const Group_Chats *g_c, int groupnumber)
+void *group_get_object(const Group_Chats *g_c, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return NULL;
+    if (!g) {
+        return nullptr;
+    }
 
     return g->object;
 }
@@ -2148,15 +2387,17 @@ void *group_get_object(const Group_Chats *g_c, int groupnumber)
  * return NULL on failure.
  * return object on success.
  */
-void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernumber)
+void *group_peer_get_object(const Group_Chats *g_c, uint32_t groupnumber, int peernumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
-        return NULL;
+    if (!g) {
+        return nullptr;
+    }
 
-    if ((uint32_t)peernumber >= g->numpeers)
-        return NULL;
+    if ((uint32_t)peernumber >= g->numpeers) {
+        return nullptr;
+    }
 
     return g->group[peernumber].object;
 }
@@ -2164,37 +2405,41 @@ void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernum
 /* Interval in seconds to send ping messages */
 #define GROUP_PING_INTERVAL 20
 
-static int ping_groupchat(Group_Chats *g_c, int groupnumber)
+static int ping_groupchat(Group_Chats *g_c, uint32_t groupnumber)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     if (is_timeout(g->last_sent_ping, GROUP_PING_INTERVAL)) {
-        if (group_ping_send(g_c, groupnumber) != -1) /* Ping */
+        if (group_ping_send(g_c, groupnumber) != -1) { /* Ping */
             g->last_sent_ping = unix_time();
+        }
     }
 
     return 0;
 }
 
-static int groupchat_clear_timedout(Group_Chats *g_c, int groupnumber)
+static int groupchat_clear_timedout(Group_Chats *g_c, uint32_t groupnumber, void *userdata)
 {
     Group_c *g = get_group_c(g_c, groupnumber);
 
-    if (!g)
+    if (!g) {
         return -1;
+    }
 
     uint32_t i;
 
     for (i = 0; i < g->numpeers; ++i) {
         if (g->peer_number != g->group[i].peer_number && is_timeout(g->group[i].last_recv, GROUP_PING_INTERVAL * 3)) {
-            delpeer(g_c, groupnumber, i);
+            delpeer(g_c, groupnumber, i, userdata);
         }
 
-        if (g->group == NULL || i >= g->numpeers)
+        if (g->group == nullptr || i >= g->numpeers) {
             break;
+        }
     }
 
     return 0;
@@ -2209,8 +2454,9 @@ void send_name_all_groups(Group_Chats *g_c)
     for (i = 0; i < g_c->num_chats; ++i) {
         Group_c *g = get_group_c(g_c, i);
 
-        if (!g)
+        if (!g) {
             continue;
+        }
 
         if (g->status == GROUPCHAT_STATUS_CONNECTED) {
             group_name_send(g_c, i, g_c->m->name, g_c->m->name_length);
@@ -2221,41 +2467,44 @@ void send_name_all_groups(Group_Chats *g_c)
 /* Create new groupchat instance. */
 Group_Chats *new_groupchats(Messenger *m)
 {
-    if (!m)
-        return NULL;
+    if (!m) {
+        return nullptr;
+    }
 
-    Group_Chats *temp = calloc(1, sizeof(Group_Chats));
+    Group_Chats *temp = (Group_Chats *)calloc(1, sizeof(Group_Chats));
 
-    if (temp == NULL)
-        return NULL;
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
     temp->m = m;
     temp->fr_c = m->fr_c;
-    m->group_chat_object = temp;
-    m_callback_group_invite(m, &handle_friend_invite_packet);
+    m->conferences_object = temp;
+    m_callback_conference_invite(m, &handle_friend_invite_packet);
 
     return temp;
 }
 
 /* main groupchats loop. */
-void do_groupchats(Group_Chats *g_c)
+void do_groupchats(Group_Chats *g_c, void *userdata)
 {
     unsigned int i;
 
     for (i = 0; i < g_c->num_chats; ++i) {
         Group_c *g = get_group_c(g_c, i);
 
-        if (!g)
+        if (!g) {
             continue;
+        }
 
         if (g->status == GROUPCHAT_STATUS_CONNECTED) {
-            connect_to_closest(g_c, i);
+            connect_to_closest(g_c, i, userdata);
             ping_groupchat(g_c, i);
-            groupchat_clear_timedout(g_c, i);
+            groupchat_clear_timedout(g_c, i, userdata);
         }
     }
 
-    //TODO
+    // TODO(irungentoo):
 }
 
 /* Free everything related with group chats. */
@@ -2267,8 +2516,8 @@ void kill_groupchats(Group_Chats *g_c)
         del_groupchat(g_c, i);
     }
 
-    m_callback_group_invite(g_c->m, NULL);
-    g_c->m->group_chat_object = 0;
+    m_callback_conference_invite(g_c->m, nullptr);
+    g_c->m->conferences_object = nullptr;
     free(g_c);
 }
 
@@ -2295,7 +2544,7 @@ uint32_t count_chatlist(Group_Chats *g_c)
  * Otherwise, returns the number of elements copied.
  * If the array was too small, the contents
  * of out_list will be truncated to list_size. */
-uint32_t copy_chatlist(Group_Chats *g_c, int32_t *out_list, uint32_t list_size)
+uint32_t copy_chatlist(Group_Chats *g_c, uint32_t *out_list, uint32_t list_size)
 {
     if (!out_list) {
         return 0;
diff --git a/toxcore/group.h b/toxcore/group.h
index 8ae0e40e..a81dac39 100644
--- a/toxcore/group.h
+++ b/toxcore/group.h
@@ -1,27 +1,26 @@
-/* group.h
- *
+/*
  * Slightly better groupchats implementation.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-
 #ifndef GROUP_H
 #define GROUP_H
 
@@ -41,8 +40,8 @@ enum {
 #define MAX_LOSSY_COUNT 256
 
 typedef struct {
-    uint8_t     real_pk[crypto_box_PUBLICKEYBYTES];
-    uint8_t     temp_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t     real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t     temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
 
     uint64_t    last_recv;
     uint32_t    last_message_number;
@@ -60,7 +59,7 @@ typedef struct {
 
 #define DESIRED_CLOSE_CONNECTIONS 4
 #define MAX_GROUP_CONNECTIONS 16
-#define GROUP_IDENTIFIER_LENGTH (1 + crypto_box_KEYBYTES) /* type + crypto_box_KEYBYTES so we can use new_symmetric_key(...) to fill it */
+#define GROUP_IDENTIFIER_LENGTH (1 + CRYPTO_SYMMETRIC_KEY_SIZE) /* type + CRYPTO_SYMMETRIC_KEY_SIZE so we can use new_symmetric_key(...) to fill it */
 
 enum {
     GROUPCHAT_CLOSE_NONE,
@@ -81,11 +80,11 @@ typedef struct {
         uint16_t group_number;
     } close[MAX_GROUP_CONNECTIONS];
 
-    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
     struct {
         uint8_t entry;
-        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
-        uint8_t temp_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+        uint8_t temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
     } closest_peers[DESIRED_CLOSE_CONNECTIONS];
     uint8_t changed;
 
@@ -104,9 +103,9 @@ typedef struct {
 
     void *object;
 
-    void (*peer_on_join)(void *, int, int);
-    void (*peer_on_leave)(void *, int, int, void *);
-    void (*group_on_delete)(void *, int);
+    void (*peer_on_join)(void *, uint32_t, uint32_t);
+    void (*peer_on_leave)(void *, uint32_t, uint32_t, void *);
+    void (*group_on_delete)(void *, uint32_t);
 } Group_c;
 
 typedef struct {
@@ -116,65 +115,56 @@ typedef struct {
     Group_c *chats;
     uint32_t num_chats;
 
-    void (*invite_callback)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t, void *);
-    void *invite_callback_userdata;
-    void (*message_callback)(Messenger *m, int, int, const uint8_t *, uint16_t, void *);
-    void *message_callback_userdata;
-    void (*action_callback)(Messenger *m, int, int, const uint8_t *, uint16_t, void *);
-    void *action_callback_userdata;
-    void (*peer_namelistchange)(Messenger *m, int, int, uint8_t, void *);
-    void *group_namelistchange_userdata;
-    void (*title_callback)(Messenger *m, int, int, const uint8_t *, uint8_t, void *);
-    void *title_callback_userdata;
+    void (*invite_callback)(Messenger *m, uint32_t, int, const uint8_t *, size_t, void *);
+    void (*message_callback)(Messenger *m, uint32_t, uint32_t, int, const uint8_t *, size_t, void *);
+    void (*peer_name_callback)(Messenger *m, uint32_t, uint32_t, const uint8_t *, size_t, void *);
+    void (*peer_list_changed_callback)(Messenger *m, uint32_t, void *);
+    void (*title_callback)(Messenger *m, uint32_t, uint32_t, const uint8_t *, size_t, void *);
 
     struct {
-        int (*function)(void *, int, int, void *, const uint8_t *, uint16_t);
+        int (*function)(void *, uint32_t, uint32_t, void *, const uint8_t *, uint16_t);
     } lossy_packethandlers[256];
 } Group_Chats;
 
 /* Set the callback for group invites.
  *
- *  Function(Group_Chats *g_c, int32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Group_Chats *g_c, uint32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
  *
  *  data of length is what needs to be passed to join_groupchat().
  */
-void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *,
-                             uint16_t, void *), void *userdata);
+void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, int, const uint8_t *,
+                             size_t, void *));
 
 /* Set the callback for group messages.
  *
- *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, uint32_t friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
  */
-void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
-                              void *), void *userdata);
+void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, int, const uint8_t *,
+                              size_t, void *));
 
-/* Set the callback for group actions.
- *
- *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void g_callback_group_action(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
-                             void *), void *userdata);
 
 /* Set callback function for title changes.
  *
- * Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * title, uint8_t length, void *userdata)
+ * Function(Group_Chats *g_c, uint32_t groupnumber, uint32_t friendgroupnumber, uint8_t * title, uint8_t length, void *userdata)
  * if friendgroupnumber == -1, then author is unknown (e.g. initial joining the group)
  */
-void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint8_t,
-                            void *), void *userdata);
+void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, const uint8_t *,
+                            size_t, void *));
 
-/* Set callback function for peer name list changes.
+/* Set callback function for peer nickname changes.
  *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Group_Chats *g_c, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
+ * It gets called every time a peer changes their nickname.
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, uint32_t peernumber, const uint8_t *nick, size_t nick_len, void *userdata)
  */
-enum {
-    CHAT_CHANGE_PEER_ADD,
-    CHAT_CHANGE_PEER_DEL,
-    CHAT_CHANGE_PEER_NAME,
-};
-void g_callback_group_namelistchange(Group_Chats *g_c, void (*function)(Messenger *m, int, int, uint8_t, void *),
-                                     void *userdata);
+void g_callback_peer_name(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, uint32_t, const uint8_t *,
+                          size_t, void *));
+
+/* Set callback function for peer list changes.
+ *
+ * It gets called every time the name list changes(new peer, deleted peer)
+ *  Function(Group_Chats *g_c, uint32_t groupnumber, void *userdata)
+ */
+void g_callback_peer_list_changed(Group_Chats *g_c, void (*function)(Messenger *m, uint32_t, void *));
 
 /* Creates a new groupchat and puts it in the chats array.
  *
@@ -188,77 +178,107 @@ int add_groupchat(Group_Chats *g_c, uint8_t type);
 /* Delete a groupchat from the chats array.
  *
  * return 0 on success.
- * return -1 if failure.
+ * return -1 if groupnumber is invalid.
  */
-int del_groupchat(Group_Chats *g_c, int groupnumber);
+int del_groupchat(Group_Chats *g_c, uint32_t groupnumber);
 
 /* Copy the public key of peernumber who is in groupnumber to pk.
- * pk must be crypto_box_PUBLICKEYBYTES long.
+ * pk must be CRYPTO_PUBLIC_KEY_SIZE long.
  *
- * returns 0 on success
- * returns -1 on failure
+ * return 0 on success
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
  */
-int group_peer_pubkey(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *pk);
+int group_peer_pubkey(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, uint8_t *pk);
+
+/*
+ * Return the size of peernumber's name.
+ *
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
+ */
+int group_peername_size(const Group_Chats *g_c, uint32_t groupnumber, int32_t peernumber);
 
 /* Copy the name of peernumber who is in groupnumber to name.
  * name must be at least MAX_NAME_LENGTH long.
  *
  * return length of name if success
- * return -1 if failure
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
  */
-int group_peername(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *name);
+int group_peername(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, uint8_t *name);
 
 /* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
+ *
+ * return 0 on success.
+ * return -1 if groupnumber is invalid.
+ * return -2 if invite packet failed to send.
  */
-int invite_friend(Group_Chats *g_c, int32_t friendnumber, int groupnumber);
+int invite_friend(Group_Chats *g_c, uint32_t friendnumber, uint32_t groupnumber);
 
 /* Join a group (you need to have been invited first.)
  *
  * expected_type is the groupchat type we expect the chat we are joining is.
  *
- * returns group number on success
- * returns -1 on failure.
+ * return group number on success.
+ * return -1 if data length is invalid.
+ * return -2 if group is not the expected type.
+ * return -3 if friendnumber is invalid.
+ * return -4 if client is already in this group.
+ * return -5 if group instance failed to initialize.
+ * return -6 if join packet fails to send.
  */
-int join_groupchat(Group_Chats *g_c, int32_t friendnumber, uint8_t expected_type, const uint8_t *data, uint16_t length);
+int join_groupchat(Group_Chats *g_c, uint32_t friendnumber, uint8_t expected_type, const uint8_t *data,
+                   uint16_t length);
 
 /* send a group message
  * return 0 on success
- * return -1 on failure
+ * see: send_message_group() for error codes.
  */
-int group_message_send(const Group_Chats *g_c, int groupnumber, const uint8_t *message, uint16_t length);
+int group_message_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *message, uint16_t length);
 
 /* send a group action
  * return 0 on success
- * return -1 on failure
+ * see: send_message_group() for error codes.
  */
-int group_action_send(const Group_Chats *g_c, int groupnumber, const uint8_t *action, uint16_t length);
+int group_action_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *action, uint16_t length);
 
 /* set the group's title, limited to MAX_NAME_LENGTH
  * return 0 on success
- * return -1 on failure
+ * return -1 if groupnumber is invalid.
+ * return -2 if title is too long or empty.
+ * return -3 if packet fails to send.
  */
-int group_title_send(const Group_Chats *g_c, int groupnumber, const uint8_t *title, uint8_t title_len);
+int group_title_send(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *title, uint8_t title_len);
 
 
+/* return the group's title size.
+ * return -1 of groupnumber is invalid.
+ * return -2 if title is too long or empty.
+ */
+int group_title_get_size(const Group_Chats *g_c, uint32_t groupnumber);
+
 /* Get group title from groupnumber and put it in title.
- * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
+ * Title needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes.
  *
- *  return length of copied title if success.
- *  return -1 if failure.
+ * return length of copied title if success.
+ * return -1 if groupnumber is invalid.
+ * return -2 if title is too long or empty.
  */
-int group_title_get(const Group_Chats *g_c, int groupnumber, uint8_t *title, uint32_t max_length);
+int group_title_get(const Group_Chats *g_c, uint32_t groupnumber, uint8_t *title);
 
 /* Return the number of peers in the group chat on success.
- * return -1 on failure
+ * return -1 if groupnumber is invalid.
  */
-int group_number_peers(const Group_Chats *g_c, int groupnumber);
+int group_number_peers(const Group_Chats *g_c, uint32_t groupnumber);
 
 /* return 1 if the peernumber corresponds to ours.
- * return 0 on failure.
+ * return 0 if the peernumber is not ours.
+ * return -1 if groupnumber is invalid.
+ * return -2 if peernumber is invalid.
+ * return -3 if we are not connected to the group chat.
  */
-unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, int peernumber);
+int group_peernumber_is_ours(const Group_Chats *g_c, uint32_t groupnumber, int peernumber);
 
 /* List all the peers in the group chat.
  *
@@ -270,16 +290,17 @@ unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, i
  *
  * return -1 on failure.
  */
-int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
+int group_names(const Group_Chats *g_c, uint32_t groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
                 uint16_t length);
 
 /* Set handlers for custom lossy packets.
  *
  * NOTE: Handler must return 0 if packet is to be relayed, -1 if the packet should not be relayed.
  *
- * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber, uint32_t friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
  */
-void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, int, int, void *,
+void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, uint32_t, uint32_t,
+                                        void *,
                                         const uint8_t *, uint16_t));
 
 /* High level function to send custom lossy packets.
@@ -287,7 +308,7 @@ void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*fu
  * return -1 on failure.
  * return 0 on success.
  */
-int send_group_lossy_packet(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length);
+int send_group_lossy_packet(const Group_Chats *g_c, uint32_t groupnumber, const uint8_t *data, uint16_t length);
 
 /* Return the number of chats in the instance m.
  * You should use this to determine how much memory to allocate
@@ -300,14 +321,14 @@ uint32_t count_chatlist(Group_Chats *g_c);
  * Otherwise, returns the number of elements copied.
  * If the array was too small, the contents
  * of out_list will be truncated to list_size. */
-uint32_t copy_chatlist(Group_Chats *g_c, int32_t *out_list, uint32_t list_size);
+uint32_t copy_chatlist(Group_Chats *g_c, uint32_t *out_list, uint32_t list_size);
 
 /* return the type of groupchat (GROUPCHAT_TYPE_) that groupnumber is.
  *
  * return -1 on failure.
  * return type on success.
  */
-int group_get_type(const Group_Chats *g_c, int groupnumber);
+int group_get_type(const Group_Chats *g_c, uint32_t groupnumber);
 
 /* Send current name (set in messenger) to all online groups.
  */
@@ -318,28 +339,28 @@ void send_name_all_groups(Group_Chats *g_c);
  * return 0 on success.
  * return -1 on failure
  */
-int group_set_object(const Group_Chats *g_c, int groupnumber, void *object);
+int group_set_object(const Group_Chats *g_c, uint32_t groupnumber, void *object);
 
 /* Set the object that is tied to the group peer.
  *
  * return 0 on success.
  * return -1 on failure
  */
-int group_peer_set_object(const Group_Chats *g_c, int groupnumber, int peernumber, void *object);
+int group_peer_set_object(const Group_Chats *g_c, uint32_t groupnumber, int peernumber, void *object);
 
 /* Return the object tide to the group chat previously set by group_set_object.
  *
  * return NULL on failure.
  * return object on success.
  */
-void *group_get_object(const Group_Chats *g_c, int groupnumber);
+void *group_get_object(const Group_Chats *g_c, uint32_t groupnumber);
 
 /* Return the object tide to the group chat peer previously set by group_peer_set_object.
  *
  * return NULL on failure.
  * return object on success.
  */
-void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernumber);
+void *group_peer_get_object(const Group_Chats *g_c, uint32_t groupnumber, int peernumber);
 
 /* Set a function to be called when a new peer joins a group chat.
  *
@@ -348,31 +369,33 @@ void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernum
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_peer_new(const Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int));
+int callback_groupchat_peer_new(const Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t,
+                                uint32_t));
 
 /* Set a function to be called when a peer leaves a group chat.
  *
- * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object))
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber, uint32_t friendgroupnumber, void *group peer object (set with group_peer_set_object))
  *
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_peer_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int, void *));
+int callback_groupchat_peer_delete(Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t, uint32_t,
+                                   void *));
 
 /* Set a function to be called when the group chat is deleted.
  *
- * Function(void *group object (set with group_set_object), int groupnumber)
+ * Function(void *group object (set with group_set_object), uint32_t groupnumber)
  *
  * return 0 on success.
  * return -1 on failure.
  */
-int callback_groupchat_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int));
+int callback_groupchat_delete(Group_Chats *g_c, uint32_t groupnumber, void (*function)(void *, uint32_t));
 
 /* Create new groupchat instance. */
 Group_Chats *new_groupchats(Messenger *m);
 
 /* main groupchats loop. */
-void do_groupchats(Group_Chats *g_c);
+void do_groupchats(Group_Chats *g_c, void *userdata);
 
 /* Free everything related with group chats. */
 void kill_groupchats(Group_Chats *g_c);
diff --git a/toxcore/list.c b/toxcore/list.c
index b97727f8..7b65e184 100644
--- a/toxcore/list.c
+++ b/toxcore/list.c
@@ -1,30 +1,39 @@
-/* list.h
- *
+/*
  * Simple struct with functions to create a list which associates ids with data
  * -Allows for finding ids associated with data such as IPs or public keys in a short time
  * -Should only be used if there are relatively few add/remove calls to the list
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include "list.h"
 
+#include <stdlib.h>
+#include <string.h>
+
+#include "ccompat.h"
+
 /* Basically, the elements in the list are placed in order so that they can be searched for easily
  * -each element is seen as a big-endian integer when ordering them
  * -the ids array is maintained so that each id always matches
@@ -113,24 +122,27 @@ static int find(const BS_LIST *list, const uint8_t *data)
  */
 static int resize(BS_LIST *list, uint32_t new_size)
 {
-    void *p;
+    if (new_size == 0) {
+        bs_list_free(list);
+        return 1;
+    }
 
-    p = realloc(list->data, list->element_size * new_size);
+    uint8_t *data = (uint8_t *)realloc(list->data, list->element_size * new_size);
 
-    if (!p) {
+    if (!data) {
         return 0;
-    } else {
-        list->data = p;
     }
 
-    p = realloc(list->ids, sizeof(int) * new_size);
+    list->data = data;
+
+    int *ids = (int *)realloc(list->ids, sizeof(int) * new_size);
 
-    if (!p) {
+    if (!ids) {
         return 0;
-    } else {
-        list->ids = p;
     }
 
+    list->ids = ids;
+
     return 1;
 }
 
@@ -141,8 +153,8 @@ int bs_list_init(BS_LIST *list, uint32_t element_size, uint32_t initial_capacity
     list->n = 0;
     list->element_size = element_size;
     list->capacity = 0;
-    list->data = NULL;
-    list->ids = NULL;
+    list->data = nullptr;
+    list->ids = nullptr;
 
     if (initial_capacity != 0) {
         if (!resize(list, initial_capacity)) {
@@ -159,7 +171,10 @@ void bs_list_free(BS_LIST *list)
 {
     //free both arrays
     free(list->data);
+    list->data = nullptr;
+
     free(list->ids);
+    list->ids = nullptr;
 }
 
 int bs_list_find(const BS_LIST *list, const uint8_t *data)
diff --git a/toxcore/list.h b/toxcore/list.h
index b04177e1..9ad8f44d 100644
--- a/toxcore/list.h
+++ b/toxcore/list.h
@@ -1,34 +1,32 @@
-/* list.h
- *
+/*
  * Simple struct with functions to create a list which associates ids with data
  * -Allows for finding ids associated with data such as IPs or public keys in a short time
  * -Should only be used if there are relatively few add/remove calls to the list
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef LIST_H
 #define LIST_H
 
-#include <stdlib.h>
 #include <stdint.h>
-#include <string.h>
 
 typedef struct {
     uint32_t n; //number of elements
diff --git a/toxcore/logger.c b/toxcore/logger.c
index f19f76b1..edde806f 100644
--- a/toxcore/logger.c
+++ b/toxcore/logger.c
@@ -1,237 +1,135 @@
-/*  logger.c
- *
- *  Copyright (C) 2013, 2015 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
+/*
+ * Text logging abstraction.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013,2015 Tox project.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif /* HAVE_CONFIG_H */
+#endif
 
 #include "logger.h"
-#include "crypto_core.h" /* for random_int() */
 
+#include <assert.h>
+#include <stdarg.h>
 #include <stdio.h>
-#include <errno.h>
 #include <stdlib.h>
-#include <stdarg.h>
-#include <inttypes.h>
-#include <time.h>
-#include <pthread.h>
-
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-#   define getpid() ((unsigned) GetCurrentProcessId())
-#   define SFILE(FILE__M) (strrchr(FILE__M, '\\') ? strrchr(FILE__M, '\\') + 1 : FILE__M)
-#   define WIN_CR "\r"
-#else
-#   define SFILE(FILE__M) (strrchr(FILE__M, '/') ? strrchr(FILE__M, '/') + 1 : FILE__M)
-#   define WIN_CR ""
-#endif
+#include <string.h>
 
 
 struct Logger {
-    FILE *log_file;
-    LOG_LEVEL level;
-    uint64_t start_time; /* Time when lib loaded */
-    char *id;
-
-    /* Allocate these once */
-    char *tstr;
-    char *posstr;
-    char *msg;
-
-    /* For thread synchronisation */
-    pthread_mutex_t mutex[1];
-};
-
-Logger *global = NULL;
-
-const char *LOG_LEVEL_STR [] = {
-    [LOG_TRACE]   = "TRACE",
-    [LOG_DEBUG]   = "DEBUG",
-    [LOG_INFO]    = "INFO" ,
-    [LOG_WARNING] = "WARN" ,
-    [LOG_ERROR]   = "ERROR",
+    logger_cb *callback;
+    void *context;
+    void *userdata;
 };
 
-char *strtime(char *dest, size_t max_len)
-{
-    time_t timer;
-    struct tm *tm_info;
-
-    time(&timer);
-    tm_info = localtime(&timer);
-
-    strftime(dest, max_len, "%m:%d %H:%M:%S", tm_info);
-    return dest;
-}
-
-
-/**
- * Public Functions
- */
-Logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
+#ifdef USE_STDERR_LOGGER
+static const char *logger_level_name(LOGGER_LEVEL level)
 {
-#ifndef TOX_LOGGER /* Disabled */
-    return NULL;
-#endif
-
-    Logger *retu = calloc(1, sizeof(Logger));
+    switch (level) {
+        case LOG_TRACE:
+            return "TRACE";
 
-    if (!retu)
-        return NULL;
+        case LOG_DEBUG:
+            return "DEBUG";
 
-    if (pthread_mutex_init(retu->mutex, NULL) != 0) {
-        free(retu);
-        return NULL;
-    }
-
-    if (!(retu->log_file = fopen(file_name, "ab"))) {
-        fprintf(stderr, "Error opening logger file: %s; info: %s" WIN_CR "\n", file_name, strerror(errno));
-        free(retu);
-        pthread_mutex_destroy(retu->mutex);
-        return NULL;
-    }
-
-    if (!(retu->tstr = calloc(16, sizeof (char))) ||
-            !(retu->posstr = calloc(300, sizeof (char))) ||
-            !(retu->msg = calloc(4096, sizeof (char))))
-        goto FAILURE;
+        case LOG_INFO:
+            return "INFO";
 
-    if (id) {
-        if (!(retu->id = calloc(strlen(id) + 1, 1)))
-            goto FAILURE;
+        case LOG_WARNING:
+            return "WARNING";
 
-        strcpy(retu->id, id);
-    } else {
-        if (!(retu->id = malloc(8)))
-            goto FAILURE;
-
-        snprintf(retu->id, 8, "%u", random_int());
+        case LOG_ERROR:
+            return "ERROR";
     }
 
-    retu->level = level;
-    retu->start_time = current_time_monotonic();
-
-    fprintf(retu->log_file, "Successfully created and running logger id: %s; time: %s" WIN_CR "\n",
-            retu->id, strtime(retu->tstr, 16));
-
-    return retu;
-
-FAILURE:
-    fprintf(stderr, "Failed to create logger!" WIN_CR "\n");
-    pthread_mutex_destroy(retu->mutex);
-    fclose(retu->log_file);
-    free(retu->tstr);
-    free(retu->posstr);
-    free(retu->msg);
-    free(retu->id);
-    free(retu);
-    return NULL;
+    return "<unknown>";
 }
 
-void logger_kill(Logger *log)
+static void logger_stderr_handler(void *context, LOGGER_LEVEL level, const char *file, int line, const char *func,
+                                  const char *message, void *userdata)
 {
-#ifndef TOX_LOGGER /* Disabled */
-    return;
-#endif
-
-    if (!log)
-        return;
-
-    pthread_mutex_lock(log->mutex);
-    free(log->id);
-    free(log->tstr);
-    free(log->posstr);
-    free(log->msg);
-
-    if (fclose(log->log_file) != 0)
-        perror("Could not close log file");
-
-    pthread_mutex_unlock(log->mutex);
-    pthread_mutex_destroy(log->mutex);
-
-    free(log);
+    // GL stands for "global logger".
+    fprintf(stderr, "[GL] %s %s:%d(%s): %s\n", logger_level_name(level), file, line, func, message);
 }
 
-void logger_kill_global(void)
+static const Logger logger_stderr = {
+    logger_stderr_handler,
+    nullptr,
+    nullptr,
+};
+#endif
+
+/**
+ * Public Functions
+ */
+Logger *logger_new(void)
 {
-    logger_kill(global);
-    global = NULL;
+    return (Logger *)calloc(1, sizeof(Logger));
 }
 
-void logger_set_global(Logger *log)
+void logger_kill(Logger *log)
 {
-#ifndef TOX_LOGGER /* Disabled */
-    return;
-#endif
-
-    global = log;
+    free(log);
 }
 
-Logger *logger_get_global(void)
+void logger_callback_log(Logger *log, logger_cb *function, void *context, void *userdata)
 {
-#ifndef TOX_LOGGER /* Disabled */
-    return NULL;
-#endif
-
-    return global;
+    log->callback = function;
+    log->context  = context;
+    log->userdata = userdata;
 }
 
-void logger_write (Logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...)
+void logger_write(const Logger *log, LOGGER_LEVEL level, const char *file, int line, const char *func,
+                  const char *format, ...)
 {
-#ifndef TOX_LOGGER /* Disabled */
-    return;
+    if (!log) {
+#ifdef USE_STDERR_LOGGER
+        log = &logger_stderr;
+#else
+        assert(!"NULL logger not permitted");
 #endif
+    }
 
-    static const char *logger_format =
-        "%s  "          /* Logger id string */
-        "%-16s"         /* Time string of format: %m:%d %H:%M:%S */
-        "%-12u "        /* Thread id */
-        "%-5s  "        /* Logger lever string */
-        "%-20s "        /* File:line string */
-        "- %s"          /* Output message */
-        WIN_CR "\n";    /* Every new print new line */
-
-
-    Logger *this_log = log ? log : global;
-
-    if (!this_log)
-        return;
-
-    /* Don't print levels lesser than set one */
-    if (this_log->level > level)
+    if (!log->callback) {
         return;
+    }
 
-    pthread_mutex_lock(this_log->mutex);
-
-    /* Set position str */
-    snprintf(this_log->posstr, 300, "%s:%d", SFILE(file), line);
+    // Only pass the file name, not the entire file path, for privacy reasons.
+    // The full path may contain PII of the person compiling toxcore (their
+    // username and directory layout).
+    const char *filename = strrchr(file, '/');
+    file = filename ? filename + 1 : file;
+#if defined(_WIN32) || defined(__CYGWIN__)
+    // On Windows, the path separator *may* be a backslash, so we look for that
+    // one too.
+    const char *windows_filename = strrchr(file, '\\');
+    file = windows_filename ? windows_filename + 1 : file;
+#endif
 
-    /* Set message */
+    // Format message
+    char msg[1024];
     va_list args;
-    va_start (args, format);
-    vsnprintf(this_log->msg, 4096, format, args);
-    va_end (args);
-
-    fprintf(this_log->log_file, logger_format, this_log->id, strtime(this_log->tstr, 16), pthread_self(),
-            LOG_LEVEL_STR[level], this_log->posstr, this_log->msg);
-    fflush(this_log->log_file);
+    va_start(args, format);
+    vsnprintf(msg, sizeof msg, format, args);
+    va_end(args);
 
-    pthread_mutex_unlock(this_log->mutex);
+    log->callback(log->context, level, file, line, func, msg, log->userdata);
 }
diff --git a/toxcore/logger.h b/toxcore/logger.h
index 4d3e3b54..acd21fb8 100644
--- a/toxcore/logger.h
+++ b/toxcore/logger.h
@@ -1,94 +1,93 @@
-/*  logger.h
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
+/*
+ * Logger abstraction backed by callbacks for writing.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-
 #ifndef TOXLOGGER_H
 #define TOXLOGGER_H
 
-#include <string.h>
+#include <stdint.h>
 
-/* In case these are undefined; define 'empty' */
-#ifndef LOGGER_OUTPUT_FILE
-#   define LOGGER_OUTPUT_FILE ""
-#endif
+#include "ccompat.h"
 
-#ifndef LOGGER_LEVEL
-#   define LOGGER_LEVEL LOG_ERROR
+#ifndef MIN_LOGGER_LEVEL
+#define MIN_LOGGER_LEVEL LOG_INFO
 #endif
 
-
 typedef enum {
     LOG_TRACE,
     LOG_DEBUG,
     LOG_INFO,
     LOG_WARNING,
     LOG_ERROR
-} LOG_LEVEL;
+} LOGGER_LEVEL;
 
 typedef struct Logger Logger;
 
+typedef void logger_cb(void *context, LOGGER_LEVEL level, const char *file, int line,
+                       const char *func, const char *message, void *userdata);
+
 /**
- * Set 'level' as the lowest printable level. If id == NULL, random number is used.
+ * Creates a new logger with logging disabled (callback is NULL) by default.
  */
-Logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id);
+Logger *logger_new(void);
 
-void logger_kill (Logger *log);
-void logger_kill_global (void);
+/**
+ * Frees all resources associated with the logger.
+ */
+void logger_kill(Logger *log);
 
 /**
- * Global logger setter and getter.
+ * Sets the logger callback. Disables logging if set to NULL.
+ * The context parameter is passed to the callback as first argument.
  */
-void logger_set_global (Logger *log);
-Logger *logger_get_global (void);
+void logger_callback_log(Logger *log, logger_cb *function, void *context, void *userdata);
 
 /**
- * Main write function. If logging disabled does nothing. If log == NULL uses global logger.
+ * Main write function. If logging is disabled, this does nothing.
+ *
+ * If the logger is NULL, this writes to stderr. This behaviour should not be
+ * used in production code, but can be useful for temporarily debugging a
+ * function that does not have a logger available. It's essentially
+ * fprintf(stderr, ...), but with timestamps and source location. Toxcore must
+ * be built with -DUSE_STDERR_LOGGER for this to work. It will cause an
+ * assertion failure otherwise.
  */
-void logger_write (Logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...);
+void logger_write(
+    const Logger *log, LOGGER_LEVEL level, const char *file, int line, const char *func,
+    const char *format, ...) GNU_PRINTF(6, 7);
 
 
-/* To do some checks or similar only when logging, use this */
-#ifdef TOX_LOGGER
-#   define LOGGER_SCOPE(__SCOPE_DO__) do { __SCOPE_DO__ } while(0)
-#   define LOGGER_WRITE(log, level, format, ...) \
-            logger_write(log, level, __FILE__, __LINE__, format, ##__VA_ARGS__)
-#else
-/* #   warning "Logging disabled" */
-#   define LOGGER_SCOPE(__SCOPE_DO__) do {} while(0)
-#   define LOGGER_WRITE(log, level, format, ...) do {} while(0)
-#endif /* TOX_LOGGER */
+#define LOGGER_WRITE(log, level, ...) \
+    do { \
+        if (level >= MIN_LOGGER_LEVEL) { \
+            logger_write(log, level, __FILE__, __LINE__, __func__, __VA_ARGS__); \
+        } \
+    } while (0)
 
 /* To log with an logger */
-#define LOGGER_TRACE_(log, format, ...) LOGGER_WRITE(log, LOG_TRACE, format, ##__VA_ARGS__)
-#define LOGGER_DEBUG_(log, format, ...) LOGGER_WRITE(log, LOG_DEBUG, format, ##__VA_ARGS__)
-#define LOGGER_INFO_(log, format, ...) LOGGER_WRITE(log, LOG_INFO, format, ##__VA_ARGS__)
-#define LOGGER_WARNING_(log, format, ...) LOGGER_WRITE(log, LOG_WARNING, format, ##__VA_ARGS__)
-#define LOGGER_ERROR_(log, format, ...) LOGGER_WRITE(log, LOG_ERROR, format, ##__VA_ARGS__)
-
-/* To log with the global logger */
-#define LOGGER_TRACE(format, ...) LOGGER_TRACE_(NULL, format, ##__VA_ARGS__)
-#define LOGGER_DEBUG(format, ...) LOGGER_DEBUG_(NULL, format, ##__VA_ARGS__)
-#define LOGGER_INFO(format, ...) LOGGER_INFO_(NULL, format, ##__VA_ARGS__)
-#define LOGGER_WARNING(format, ...) LOGGER_WARNING_(NULL, format, ##__VA_ARGS__)
-#define LOGGER_ERROR(format, ...) LOGGER_ERROR_(NULL, format, ##__VA_ARGS__)
-
+#define LOGGER_TRACE(log, ...)   LOGGER_WRITE(log, LOG_TRACE  , __VA_ARGS__)
+#define LOGGER_DEBUG(log, ...)   LOGGER_WRITE(log, LOG_DEBUG  , __VA_ARGS__)
+#define LOGGER_INFO(log, ...)    LOGGER_WRITE(log, LOG_INFO   , __VA_ARGS__)
+#define LOGGER_WARNING(log, ...) LOGGER_WRITE(log, LOG_WARNING, __VA_ARGS__)
+#define LOGGER_ERROR(log, ...)   LOGGER_WRITE(log, LOG_ERROR  , __VA_ARGS__)
 
 #endif /* TOXLOGGER_H */
diff --git a/toxcore/misc_tools.h b/toxcore/misc_tools.h
deleted file mode 100644
index 543338b5..00000000
--- a/toxcore/misc_tools.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* misc_tools.h
- *
- * Miscellaneous functions and data structures for doing random things.
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef MISC_TOOLS_H
-#define MISC_TOOLS_H
-
-/****************************Algorithms***************************
- * Macro/generic definitions for useful algorithms
- *****************************************************************/
-
-/* Creates a new quick_sort implementation for arrays of the specified type.
- * For a type T (eg: int, char), creates a function named T_quick_sort.
- *
- * Quick Sort: Complexity O(nlogn)
- * arr   - the array to sort
- * n     - the sort index (should be called with n = length(arr))
- * cmpfn - a function that compares two values of type type.
- *         Must return -1, 0, 1 for a < b, a == b, and a > b respectively.
- */
-/* Must be called in the header file. */
-#define declare_quick_sort(type) \
-void type##_quick_sort(type *arr, int n, int (*cmpfn)(type, type));
-
-/* Must be called in the C file. */
-#define make_quick_sort(type) \
-void type##_quick_sort(type *arr, int n, int (*cmpfn)(type, type)) \
-{ \
-    if ((n) < 2) \
-        return; \
-    type _p_ = (arr)[(n) / 2]; \
-    type *_l_ = (arr); \
-    type *_r_ = (arr) + n - 1; \
-    while (_l_ <= _r_) { \
-        if (cmpfn(*_l_, _p_) == -1) { \
-            ++_l_; \
-            continue; \
-        } \
-        if (cmpfn(*_r_, _p_) == 1) { \
-            --_r_; \
-            continue; \
-        } \
-        type _t_ = *_l_; \
-        *_l_++ = *_r_; \
-        *_r_-- = _t_; \
-    } \
-    type##_quick_sort((arr), _r_ - (arr) + 1, cmpfn); \
-    type##_quick_sort(_l_, (arr) + n - _l_, cmpfn); \
-}
-
-#endif // MISC_TOOLS_H
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index f8a85adf..ead5a04c 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -1,60 +1,207 @@
-/* net_crypto.c
- *
+/*
  * Functions for the core network crypto.
  *
  * NOTE: This code has to be perfect. We don't mess around with encryption.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "net_crypto.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
-#include "math.h"
-#include "logger.h"
+
+typedef struct {
+    uint64_t sent_time;
+    uint16_t length;
+    uint8_t data[MAX_CRYPTO_DATA_SIZE];
+} Packet_Data;
+
+typedef struct {
+    Packet_Data *buffer[CRYPTO_PACKET_BUFFER_SIZE];
+    uint32_t  buffer_start;
+    uint32_t  buffer_end; /* packet numbers in array: {buffer_start, buffer_end) */
+} Packets_Array;
+
+typedef struct {
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The real public key of the peer. */
+    uint8_t recv_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of received packets. */
+    uint8_t sent_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of sent packets. */
+    uint8_t sessionpublic_key[CRYPTO_PUBLIC_KEY_SIZE]; /* Our public key for this session. */
+    uint8_t sessionsecret_key[CRYPTO_SECRET_KEY_SIZE]; /* Our private key for this session. */
+    uint8_t peersessionpublic_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The public key of the peer. */
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE]; /* The precomputed shared key from encrypt_precompute. */
+    uint8_t status; /* 0 if no connection, 1 we are sending cookie request packets,
+                     * 2 if we are sending handshake packets
+                     * 3 if connection is not confirmed yet (we have received a handshake but no data packets yet),
+                     * 4 if the connection is established.
+                     */
+    uint64_t cookie_request_number; /* number used in the cookie request packets for this connection */
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The dht public key of the peer */
+
+    uint8_t *temp_packet; /* Where the cookie request/handshake packet is stored while it is being sent. */
+    uint16_t temp_packet_length;
+    uint64_t temp_packet_sent_time; /* The time at which the last temp_packet was sent in ms. */
+    uint32_t temp_packet_num_sent;
+
+    IP_Port ip_portv4; /* The ip and port to contact this guy directly.*/
+    IP_Port ip_portv6;
+    uint64_t direct_lastrecv_timev4; /* The Time at which we last received a direct packet in ms. */
+    uint64_t direct_lastrecv_timev6;
+
+    uint64_t last_tcp_sent; /* Time the last TCP packet was sent. */
+
+    Packets_Array send_array;
+    Packets_Array recv_array;
+
+    int (*connection_status_callback)(void *object, int id, uint8_t status, void *userdata);
+    void *connection_status_callback_object;
+    int connection_status_callback_id;
+
+    int (*connection_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata);
+    void *connection_data_callback_object;
+    int connection_data_callback_id;
+
+    int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata);
+    void *connection_lossy_data_callback_object;
+    int connection_lossy_data_callback_id;
+
+    uint64_t last_request_packet_sent;
+    uint64_t direct_send_attempt_time;
+
+    uint32_t packet_counter;
+    double packet_recv_rate;
+    uint64_t packet_counter_set;
+
+    double packet_send_rate;
+    uint32_t packets_left;
+    uint64_t last_packets_left_set;
+    double last_packets_left_rem;
+
+    double packet_send_rate_requested;
+    uint32_t packets_left_requested;
+    uint64_t last_packets_left_requested_set;
+    double last_packets_left_requested_rem;
+
+    uint32_t last_sendqueue_size[CONGESTION_QUEUE_ARRAY_SIZE], last_sendqueue_counter;
+    long signed int last_num_packets_sent[CONGESTION_LAST_SENT_ARRAY_SIZE],
+         last_num_packets_resent[CONGESTION_LAST_SENT_ARRAY_SIZE];
+    uint32_t packets_sent, packets_resent;
+    uint64_t last_congestion_event;
+    uint64_t rtt_time;
+
+    /* TCP_connection connection_number */
+    unsigned int connection_number_tcp;
+
+    uint8_t maximum_speed_reached;
+
+    pthread_mutex_t mutex;
+
+    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key, void *userdata);
+    void *dht_pk_callback_object;
+    uint32_t dht_pk_callback_number;
+} Crypto_Connection;
+
+struct Net_Crypto {
+    Logger *log;
+
+    DHT *dht;
+    TCP_Connections *tcp_c;
+
+    Crypto_Connection *crypto_connections;
+    pthread_mutex_t tcp_mutex;
+
+    pthread_mutex_t connections_mutex;
+    unsigned int connection_use_counter;
+
+    uint32_t crypto_connections_length; /* Length of connections array. */
+
+    /* Our public and secret keys. */
+    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    /* The secret key used for cookies */
+    uint8_t secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE];
+
+    int (*new_connection_callback)(void *object, New_Connection *n_c);
+    void *new_connection_callback_object;
+
+    /* The current optimal sleep time */
+    uint32_t current_sleep_time;
+
+    BS_LIST ip_port_list;
+};
+
+const uint8_t *nc_get_self_public_key(const Net_Crypto *c)
+{
+    return c->self_public_key;
+}
+
+const uint8_t *nc_get_self_secret_key(const Net_Crypto *c)
+{
+    return c->self_secret_key;
+}
+
+TCP_Connections *nc_get_tcp_c(const Net_Crypto *c)
+{
+    return c->tcp_c;
+}
+
+DHT *nc_get_dht(const Net_Crypto *c)
+{
+    return c->dht;
+}
 
 static uint8_t crypt_connection_id_not_valid(const Net_Crypto *c, int crypt_connection_id)
 {
-    if ((uint32_t)crypt_connection_id >= c->crypto_connections_length)
+    if ((uint32_t)crypt_connection_id >= c->crypto_connections_length) {
         return 1;
+    }
 
-    if (c->crypto_connections == NULL)
+    if (c->crypto_connections == nullptr) {
         return 1;
+    }
 
-    if (c->crypto_connections[crypt_connection_id].status == CRYPTO_CONN_NO_CONNECTION)
+    if (c->crypto_connections[crypt_connection_id].status == CRYPTO_CONN_NO_CONNECTION) {
         return 1;
+    }
 
     return 0;
 }
 
 /* cookie timeout in seconds */
 #define COOKIE_TIMEOUT 15
-#define COOKIE_DATA_LENGTH (crypto_box_PUBLICKEYBYTES * 2)
+#define COOKIE_DATA_LENGTH (CRYPTO_PUBLIC_KEY_SIZE * 2)
 #define COOKIE_CONTENTS_LENGTH (sizeof(uint64_t) + COOKIE_DATA_LENGTH)
-#define COOKIE_LENGTH (crypto_box_NONCEBYTES + COOKIE_CONTENTS_LENGTH + crypto_box_MACBYTES)
+#define COOKIE_LENGTH (CRYPTO_NONCE_SIZE + COOKIE_CONTENTS_LENGTH + CRYPTO_MAC_SIZE)
 
 #define COOKIE_REQUEST_PLAIN_LENGTH (COOKIE_DATA_LENGTH + sizeof(uint64_t))
-#define COOKIE_REQUEST_LENGTH (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + COOKIE_REQUEST_PLAIN_LENGTH + crypto_box_MACBYTES)
-#define COOKIE_RESPONSE_LENGTH (1 + crypto_box_NONCEBYTES + COOKIE_LENGTH + sizeof(uint64_t) + crypto_box_MACBYTES)
+#define COOKIE_REQUEST_LENGTH (1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE)
+#define COOKIE_RESPONSE_LENGTH (1 + CRYPTO_NONCE_SIZE + COOKIE_LENGTH + sizeof(uint64_t) + CRYPTO_MAC_SIZE)
 
 /* Create a cookie request packet and put it in packet.
  * dht_public_key is the dht public key of the other
@@ -68,25 +215,26 @@ static int create_cookie_request(const Net_Crypto *c, uint8_t *packet, uint8_t *
                                  uint8_t *shared_key)
 {
     uint8_t plain[COOKIE_REQUEST_PLAIN_LENGTH];
-    uint8_t padding[crypto_box_PUBLICKEYBYTES] = {0};
+    uint8_t padding[CRYPTO_PUBLIC_KEY_SIZE] = {0};
 
-    memcpy(plain, c->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(plain + crypto_box_PUBLICKEYBYTES, padding, crypto_box_PUBLICKEYBYTES);
-    memcpy(plain + (crypto_box_PUBLICKEYBYTES * 2), &number, sizeof(uint64_t));
+    memcpy(plain, c->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, padding, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(plain + (CRYPTO_PUBLIC_KEY_SIZE * 2), &number, sizeof(uint64_t));
 
     DHT_get_shared_key_sent(c->dht, shared_key, dht_public_key);
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    new_nonce(nonce);
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
+    random_nonce(nonce);
     packet[0] = NET_PACKET_COOKIE_REQUEST;
-    memcpy(packet + 1, c->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
+    memcpy(packet + 1, dht_get_self_public_key(c->dht), CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE);
     int len = encrypt_data_symmetric(shared_key, nonce, plain, sizeof(plain),
-                                     packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
+                                     packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
 
-    if (len != COOKIE_REQUEST_PLAIN_LENGTH + crypto_box_MACBYTES)
+    if (len != COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    return (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + len);
+    return (1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + len);
 }
 
 /* Create cookie of length COOKIE_LENGTH from bytes of length COOKIE_DATA_LENGTH using encryption_key
@@ -100,11 +248,12 @@ static int create_cookie(uint8_t *cookie, const uint8_t *bytes, const uint8_t *e
     uint64_t temp_time = unix_time();
     memcpy(contents, &temp_time, sizeof(temp_time));
     memcpy(contents + sizeof(temp_time), bytes, COOKIE_DATA_LENGTH);
-    new_nonce(cookie);
-    int len = encrypt_data_symmetric(encryption_key, cookie, contents, sizeof(contents), cookie + crypto_box_NONCEBYTES);
+    random_nonce(cookie);
+    int len = encrypt_data_symmetric(encryption_key, cookie, contents, sizeof(contents), cookie + CRYPTO_NONCE_SIZE);
 
-    if (len != COOKIE_LENGTH - crypto_box_NONCEBYTES)
+    if (len != COOKIE_LENGTH - CRYPTO_NONCE_SIZE) {
         return -1;
+    }
 
     return 0;
 }
@@ -117,18 +266,20 @@ static int create_cookie(uint8_t *cookie, const uint8_t *bytes, const uint8_t *e
 static int open_cookie(uint8_t *bytes, const uint8_t *cookie, const uint8_t *encryption_key)
 {
     uint8_t contents[COOKIE_CONTENTS_LENGTH];
-    int len = decrypt_data_symmetric(encryption_key, cookie, cookie + crypto_box_NONCEBYTES,
-                                     COOKIE_LENGTH - crypto_box_NONCEBYTES, contents);
+    int len = decrypt_data_symmetric(encryption_key, cookie, cookie + CRYPTO_NONCE_SIZE,
+                                     COOKIE_LENGTH - CRYPTO_NONCE_SIZE, contents);
 
-    if (len != sizeof(contents))
+    if (len != sizeof(contents)) {
         return -1;
+    }
 
     uint64_t cookie_time;
     memcpy(&cookie_time, contents, sizeof(cookie_time));
     uint64_t temp_time = unix_time();
 
-    if (cookie_time + COOKIE_TIMEOUT < temp_time || temp_time < cookie_time)
+    if (cookie_time + COOKIE_TIMEOUT < temp_time || temp_time < cookie_time) {
         return -1;
+    }
 
     memcpy(bytes, contents + sizeof(cookie_time), COOKIE_DATA_LENGTH);
     return 0;
@@ -146,27 +297,29 @@ static int create_cookie_response(const Net_Crypto *c, uint8_t *packet, const ui
                                   const uint8_t *shared_key, const uint8_t *dht_public_key)
 {
     uint8_t cookie_plain[COOKIE_DATA_LENGTH];
-    memcpy(cookie_plain, request_plain, crypto_box_PUBLICKEYBYTES);
-    memcpy(cookie_plain + crypto_box_PUBLICKEYBYTES, dht_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(cookie_plain, request_plain, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(cookie_plain + CRYPTO_PUBLIC_KEY_SIZE, dht_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     uint8_t plain[COOKIE_LENGTH + sizeof(uint64_t)];
 
-    if (create_cookie(plain, cookie_plain, c->secret_symmetric_key) != 0)
+    if (create_cookie(plain, cookie_plain, c->secret_symmetric_key) != 0) {
         return -1;
+    }
 
     memcpy(plain + COOKIE_LENGTH, request_plain + COOKIE_DATA_LENGTH, sizeof(uint64_t));
     packet[0] = NET_PACKET_COOKIE_RESPONSE;
-    new_nonce(packet + 1);
-    int len = encrypt_data_symmetric(shared_key, packet + 1, plain, sizeof(plain), packet + 1 + crypto_box_NONCEBYTES);
+    random_nonce(packet + 1);
+    int len = encrypt_data_symmetric(shared_key, packet + 1, plain, sizeof(plain), packet + 1 + CRYPTO_NONCE_SIZE);
 
-    if (len != COOKIE_RESPONSE_LENGTH - (1 + crypto_box_NONCEBYTES))
+    if (len != COOKIE_RESPONSE_LENGTH - (1 + CRYPTO_NONCE_SIZE)) {
         return -1;
+    }
 
     return COOKIE_RESPONSE_LENGTH;
 }
 
 /* Handle the cookie request packet of length length.
  * Put what was in the request in request_plain (must be of size COOKIE_REQUEST_PLAIN_LENGTH)
- * Put the key used to decrypt the request into shared_key (of size crypto_box_BEFORENMBYTES) for use in the response.
+ * Put the key used to decrypt the request into shared_key (of size CRYPTO_SHARED_KEY_SIZE) for use in the response.
  *
  * return -1 on failure.
  * return 0 on success.
@@ -174,40 +327,46 @@ static int create_cookie_response(const Net_Crypto *c, uint8_t *packet, const ui
 static int handle_cookie_request(const Net_Crypto *c, uint8_t *request_plain, uint8_t *shared_key,
                                  uint8_t *dht_public_key, const uint8_t *packet, uint16_t length)
 {
-    if (length != COOKIE_REQUEST_LENGTH)
+    if (length != COOKIE_REQUEST_LENGTH) {
         return -1;
+    }
 
-    memcpy(dht_public_key, packet + 1, crypto_box_PUBLICKEYBYTES);
+    memcpy(dht_public_key, packet + 1, CRYPTO_PUBLIC_KEY_SIZE);
     DHT_get_shared_key_sent(c->dht, shared_key, dht_public_key);
-    int len = decrypt_data_symmetric(shared_key, packet + 1 + crypto_box_PUBLICKEYBYTES,
-                                     packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, COOKIE_REQUEST_PLAIN_LENGTH + crypto_box_MACBYTES,
+    int len = decrypt_data_symmetric(shared_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                     packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, COOKIE_REQUEST_PLAIN_LENGTH + CRYPTO_MAC_SIZE,
                                      request_plain);
 
-    if (len != COOKIE_REQUEST_PLAIN_LENGTH)
+    if (len != COOKIE_REQUEST_PLAIN_LENGTH) {
         return -1;
+    }
 
     return 0;
 }
 
 /* Handle the cookie request packet (for raw UDP)
  */
-static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE];
 
-    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key, packet, length) != 0)
+    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key, packet, length) != 0) {
         return 1;
+    }
 
     uint8_t data[COOKIE_RESPONSE_LENGTH];
 
-    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data))
+    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data)) {
         return 1;
+    }
 
-    if ((uint32_t)sendpacket(c->dht->net, source, data, sizeof(data)) != sizeof(data))
+    if ((uint32_t)sendpacket(dht_get_net(c->dht), source, data, sizeof(data)) != sizeof(data)) {
         return 1;
+    }
 
     return 0;
 }
@@ -217,16 +376,18 @@ static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t
 static int tcp_handle_cookie_request(Net_Crypto *c, int connections_number, const uint8_t *packet, uint16_t length)
 {
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE];
 
-    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key, packet, length) != 0)
+    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key, packet, length) != 0) {
         return -1;
+    }
 
     uint8_t data[COOKIE_RESPONSE_LENGTH];
 
-    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data))
+    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data)) {
         return -1;
+    }
 
     int ret = send_packet_tcp_connection(c->tcp_c, connections_number, data, sizeof(data));
     return ret;
@@ -238,19 +399,22 @@ static int tcp_oob_handle_cookie_request(const Net_Crypto *c, unsigned int tcp_c
         const uint8_t *dht_public_key, const uint8_t *packet, uint16_t length)
 {
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    uint8_t dht_public_key_temp[crypto_box_PUBLICKEYBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    uint8_t dht_public_key_temp[CRYPTO_PUBLIC_KEY_SIZE];
 
-    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key_temp, packet, length) != 0)
+    if (handle_cookie_request(c, request_plain, shared_key, dht_public_key_temp, packet, length) != 0) {
         return -1;
+    }
 
-    if (public_key_cmp(dht_public_key, dht_public_key_temp) != 0)
+    if (public_key_cmp(dht_public_key, dht_public_key_temp) != 0) {
         return -1;
+    }
 
     uint8_t data[COOKIE_RESPONSE_LENGTH];
 
-    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data))
+    if (create_cookie_response(c, data, request_plain, shared_key, dht_public_key) != sizeof(data)) {
         return -1;
+    }
 
     int ret = tcp_send_oob_packet(c->tcp_c, tcp_connections_number, dht_public_key, data, sizeof(data));
     return ret;
@@ -267,22 +431,24 @@ static int tcp_oob_handle_cookie_request(const Net_Crypto *c, unsigned int tcp_c
 static int handle_cookie_response(uint8_t *cookie, uint64_t *number, const uint8_t *packet, uint16_t length,
                                   const uint8_t *shared_key)
 {
-    if (length != COOKIE_RESPONSE_LENGTH)
+    if (length != COOKIE_RESPONSE_LENGTH) {
         return -1;
+    }
 
     uint8_t plain[COOKIE_LENGTH + sizeof(uint64_t)];
-    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
-                                     length - (1 + crypto_box_NONCEBYTES), plain);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE,
+                                     length - (1 + CRYPTO_NONCE_SIZE), plain);
 
-    if (len != sizeof(plain))
+    if (len != sizeof(plain)) {
         return -1;
+    }
 
     memcpy(cookie, plain, COOKIE_LENGTH);
     memcpy(number, plain + COOKIE_LENGTH, sizeof(uint64_t));
     return COOKIE_LENGTH;
 }
 
-#define HANDSHAKE_PACKET_LENGTH (1 + COOKIE_LENGTH + crypto_box_NONCEBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES + COOKIE_LENGTH + crypto_box_MACBYTES)
+#define HANDSHAKE_PACKET_LENGTH (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE + COOKIE_LENGTH + CRYPTO_MAC_SIZE)
 
 /* Create a handshake packet and put it in packet.
  * cookie must be COOKIE_LENGTH bytes.
@@ -294,24 +460,26 @@ static int handle_cookie_response(uint8_t *cookie, uint64_t *number, const uint8
 static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const uint8_t *cookie, const uint8_t *nonce,
                                    const uint8_t *session_pk, const uint8_t *peer_real_pk, const uint8_t *peer_dht_pubkey)
 {
-    uint8_t plain[crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES + COOKIE_LENGTH];
-    memcpy(plain, nonce, crypto_box_NONCEBYTES);
-    memcpy(plain + crypto_box_NONCEBYTES, session_pk, crypto_box_PUBLICKEYBYTES);
-    crypto_hash_sha512(plain + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES, cookie, COOKIE_LENGTH);
+    uint8_t plain[CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE + COOKIE_LENGTH];
+    memcpy(plain, nonce, CRYPTO_NONCE_SIZE);
+    memcpy(plain + CRYPTO_NONCE_SIZE, session_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    crypto_sha512(plain + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE, cookie, COOKIE_LENGTH);
     uint8_t cookie_plain[COOKIE_DATA_LENGTH];
-    memcpy(cookie_plain, peer_real_pk, crypto_box_PUBLICKEYBYTES);
-    memcpy(cookie_plain + crypto_box_PUBLICKEYBYTES, peer_dht_pubkey, crypto_box_PUBLICKEYBYTES);
+    memcpy(cookie_plain, peer_real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(cookie_plain + CRYPTO_PUBLIC_KEY_SIZE, peer_dht_pubkey, CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (create_cookie(plain + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES, cookie_plain,
-                      c->secret_symmetric_key) != 0)
+    if (create_cookie(plain + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE, cookie_plain,
+                      c->secret_symmetric_key) != 0) {
         return -1;
+    }
 
-    new_nonce(packet + 1 + COOKIE_LENGTH);
+    random_nonce(packet + 1 + COOKIE_LENGTH);
     int len = encrypt_data(peer_real_pk, c->self_secret_key, packet + 1 + COOKIE_LENGTH, plain, sizeof(plain),
-                           packet + 1 + COOKIE_LENGTH + crypto_box_NONCEBYTES);
+                           packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE);
 
-    if (len != HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + crypto_box_NONCEBYTES))
+    if (len != HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE)) {
         return -1;
+    }
 
     packet[0] = NET_PACKET_CRYPTO_HS;
     memcpy(packet + 1, cookie, COOKIE_LENGTH);
@@ -329,9 +497,9 @@ static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const u
  * if expected_real_pk isn't NULL it denotes the real public key
  * the packet should be from.
  *
- * nonce must be at least crypto_box_NONCEBYTES
- * session_pk must be at least crypto_box_PUBLICKEYBYTES
- * peer_real_pk must be at least crypto_box_PUBLICKEYBYTES
+ * nonce must be at least CRYPTO_NONCE_SIZE
+ * session_pk must be at least CRYPTO_PUBLIC_KEY_SIZE
+ * peer_real_pk must be at least CRYPTO_PUBLIC_KEY_SIZE
  * cookie must be at least COOKIE_LENGTH
  *
  * return -1 on failure.
@@ -340,46 +508,53 @@ static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const u
 static int handle_crypto_handshake(const Net_Crypto *c, uint8_t *nonce, uint8_t *session_pk, uint8_t *peer_real_pk,
                                    uint8_t *dht_public_key, uint8_t *cookie, const uint8_t *packet, uint16_t length, const uint8_t *expected_real_pk)
 {
-    if (length != HANDSHAKE_PACKET_LENGTH)
+    if (length != HANDSHAKE_PACKET_LENGTH) {
         return -1;
+    }
 
     uint8_t cookie_plain[COOKIE_DATA_LENGTH];
 
-    if (open_cookie(cookie_plain, packet + 1, c->secret_symmetric_key) != 0)
+    if (open_cookie(cookie_plain, packet + 1, c->secret_symmetric_key) != 0) {
         return -1;
+    }
 
-    if (expected_real_pk)
-        if (public_key_cmp(cookie_plain, expected_real_pk) != 0)
+    if (expected_real_pk) {
+        if (public_key_cmp(cookie_plain, expected_real_pk) != 0) {
             return -1;
+        }
+    }
 
-    uint8_t cookie_hash[crypto_hash_sha512_BYTES];
-    crypto_hash_sha512(cookie_hash, packet + 1, COOKIE_LENGTH);
+    uint8_t cookie_hash[CRYPTO_SHA512_SIZE];
+    crypto_sha512(cookie_hash, packet + 1, COOKIE_LENGTH);
 
-    uint8_t plain[crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES + COOKIE_LENGTH];
+    uint8_t plain[CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE + COOKIE_LENGTH];
     int len = decrypt_data(cookie_plain, c->self_secret_key, packet + 1 + COOKIE_LENGTH,
-                           packet + 1 + COOKIE_LENGTH + crypto_box_NONCEBYTES,
-                           HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + crypto_box_NONCEBYTES), plain);
+                           packet + 1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE,
+                           HANDSHAKE_PACKET_LENGTH - (1 + COOKIE_LENGTH + CRYPTO_NONCE_SIZE), plain);
 
-    if (len != sizeof(plain))
+    if (len != sizeof(plain)) {
         return -1;
+    }
 
-    if (sodium_memcmp(cookie_hash, plain + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                      crypto_hash_sha512_BYTES) != 0)
+    if (crypto_memcmp(cookie_hash, plain + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                      CRYPTO_SHA512_SIZE) != 0) {
         return -1;
+    }
 
-    memcpy(nonce, plain, crypto_box_NONCEBYTES);
-    memcpy(session_pk, plain + crypto_box_NONCEBYTES, crypto_box_PUBLICKEYBYTES);
-    memcpy(cookie, plain + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES, COOKIE_LENGTH);
-    memcpy(peer_real_pk, cookie_plain, crypto_box_PUBLICKEYBYTES);
-    memcpy(dht_public_key, cookie_plain + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
+    memcpy(nonce, plain, CRYPTO_NONCE_SIZE);
+    memcpy(session_pk, plain + CRYPTO_NONCE_SIZE, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(cookie, plain + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA512_SIZE, COOKIE_LENGTH);
+    memcpy(peer_real_pk, cookie_plain, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(dht_public_key, cookie_plain + CRYPTO_PUBLIC_KEY_SIZE, CRYPTO_PUBLIC_KEY_SIZE);
     return 0;
 }
 
 
 static Crypto_Connection *get_crypto_connection(const Net_Crypto *c, int crypt_connection_id)
 {
-    if (crypt_connection_id_not_valid(c, crypt_connection_id))
-        return 0;
+    if (crypt_connection_id_not_valid(c, crypt_connection_id)) {
+        return nullptr;
+    }
 
     return &c->crypto_connections[crypt_connection_id];
 }
@@ -394,22 +569,25 @@ static int add_ip_port_connection(Net_Crypto *c, int crypt_connection_id, IP_Por
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (ip_port.ip.family == AF_INET) {
-        if (!ipport_equal(&ip_port, &conn->ip_portv4) && LAN_ip(conn->ip_portv4.ip) != 0) {
-            if (!bs_list_add(&c->ip_port_list, (uint8_t *)&ip_port, crypt_connection_id))
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        if (!ipport_equal(&ip_port, &conn->ip_portv4) && ip_is_lan(conn->ip_portv4.ip) != 0) {
+            if (!bs_list_add(&c->ip_port_list, (uint8_t *)&ip_port, crypt_connection_id)) {
                 return -1;
+            }
 
             bs_list_remove(&c->ip_port_list, (uint8_t *)&conn->ip_portv4, crypt_connection_id);
             conn->ip_portv4 = ip_port;
             return 0;
         }
-    } else if (ip_port.ip.family == AF_INET6) {
+    } else if (net_family_is_ipv6(ip_port.ip.family)) {
         if (!ipport_equal(&ip_port, &conn->ip_portv6)) {
-            if (!bs_list_add(&c->ip_port_list, (uint8_t *)&ip_port, crypt_connection_id))
+            if (!bs_list_add(&c->ip_port_list, (uint8_t *)&ip_port, crypt_connection_id)) {
                 return -1;
+            }
 
             bs_list_remove(&c->ip_port_list, (uint8_t *)&conn->ip_portv6, crypt_connection_id);
             conn->ip_portv6 = ip_port;
@@ -425,18 +603,18 @@ static int add_ip_port_connection(Net_Crypto *c, int crypt_connection_id, IP_Por
  * return IP_Port with family 0 on failure.
  * return IP_Port on success.
  */
-IP_Port return_ip_port_connection(Net_Crypto *c, int crypt_connection_id)
+static IP_Port return_ip_port_connection(Net_Crypto *c, int crypt_connection_id)
 {
-    IP_Port empty;
-    empty.ip.family = 0;
+    const IP_Port empty = {{{0}}};
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return empty;
+    }
 
     uint64_t current_time = unix_time();
-    _Bool v6 = 0, v4 = 0;
+    bool v6 = 0, v4 = 0;
 
     if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev4) > current_time) {
         v4 = 1;
@@ -446,15 +624,19 @@ IP_Port return_ip_port_connection(Net_Crypto *c, int crypt_connection_id)
         v6 = 1;
     }
 
-    if (v4 && LAN_ip(conn->ip_portv4.ip) == 0) {
+    if (v4 && ip_is_lan(conn->ip_portv4.ip) == 0) {
         return conn->ip_portv4;
-    } else if (v6 && conn->ip_portv6.ip.family == AF_INET6) {
+    }
+
+    if (v6 && net_family_is_ipv6(conn->ip_portv6.ip.family)) {
         return conn->ip_portv6;
-    } else if (conn->ip_portv4.ip.family == AF_INET) {
+    }
+
+    if (net_family_is_ipv4(conn->ip_portv4.ip.family)) {
         return conn->ip_portv4;
-    } else {
-        return empty;
     }
+
+    return empty;
 }
 
 /* Sends a packet to the peer using the fastest route.
@@ -464,38 +646,39 @@ IP_Port return_ip_port_connection(Net_Crypto *c, int crypt_connection_id)
  */
 static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
-//TODO TCP, etc...
+// TODO(irungentoo): TCP, etc...
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     int direct_send_attempt = 0;
 
     pthread_mutex_lock(&conn->mutex);
     IP_Port ip_port = return_ip_port_connection(c, crypt_connection_id);
 
-    //TODO: on bad networks, direct connections might not last indefinitely.
-    if (ip_port.ip.family != 0) {
-        _Bool direct_connected = 0;
-        crypto_connection_status(c, crypt_connection_id, &direct_connected, NULL);
+    // TODO(irungentoo): on bad networks, direct connections might not last indefinitely.
+    if (!net_family_is_unspec(ip_port.ip.family)) {
+        bool direct_connected = 0;
+        crypto_connection_status(c, crypt_connection_id, &direct_connected, nullptr);
 
         if (direct_connected) {
-            if ((uint32_t)sendpacket(c->dht->net, ip_port, data, length) == length) {
+            if ((uint32_t)sendpacket(dht_get_net(c->dht), ip_port, data, length) == length) {
                 pthread_mutex_unlock(&conn->mutex);
                 return 0;
-            } else {
-                pthread_mutex_unlock(&conn->mutex);
-                return -1;
             }
+
+            pthread_mutex_unlock(&conn->mutex);
+            return -1;
         }
 
-        //TODO: a better way of sending packets directly to confirm the others ip.
+        // TODO(irungentoo): a better way of sending packets directly to confirm the others ip.
         uint64_t current_time = unix_time();
 
         if ((((UDP_DIRECT_TIMEOUT / 2) + conn->direct_send_attempt_time) > current_time && length < 96)
                 || data[0] == NET_PACKET_COOKIE_REQUEST || data[0] == NET_PACKET_CRYPTO_HS) {
-            if ((uint32_t)sendpacket(c->dht->net, ip_port, data, length) == length) {
+            if ((uint32_t)sendpacket(dht_get_net(c->dht), ip_port, data, length) == length) {
                 direct_send_attempt = 1;
                 conn->direct_send_attempt_time = unix_time();
             }
@@ -540,24 +723,28 @@ static uint32_t num_packets_array(const Packets_Array *array)
  */
 static int add_data_to_buffer(Packets_Array *array, uint32_t number, const Packet_Data *data)
 {
-    if (number - array->buffer_start > CRYPTO_PACKET_BUFFER_SIZE)
+    if (number - array->buffer_start > CRYPTO_PACKET_BUFFER_SIZE) {
         return -1;
+    }
 
     uint32_t num = number % CRYPTO_PACKET_BUFFER_SIZE;
 
-    if (array->buffer[num])
+    if (array->buffer[num]) {
         return -1;
+    }
 
-    Packet_Data *new_d = malloc(sizeof(Packet_Data));
+    Packet_Data *new_d = (Packet_Data *)malloc(sizeof(Packet_Data));
 
-    if (new_d == NULL)
+    if (new_d == nullptr) {
         return -1;
+    }
 
     memcpy(new_d, data, sizeof(Packet_Data));
     array->buffer[num] = new_d;
 
-    if ((number - array->buffer_start) >= (array->buffer_end - array->buffer_start))
+    if ((number - array->buffer_start) >= (array->buffer_end - array->buffer_start)) {
         array->buffer_end = number + 1;
+    }
 
     return 0;
 }
@@ -572,13 +759,15 @@ static int get_data_pointer(const Packets_Array *array, Packet_Data **data, uint
 {
     uint32_t num_spots = array->buffer_end - array->buffer_start;
 
-    if (array->buffer_end - number > num_spots || number - array->buffer_start >= num_spots)
+    if (array->buffer_end - number > num_spots || number - array->buffer_start >= num_spots) {
         return -1;
+    }
 
     uint32_t num = number % CRYPTO_PACKET_BUFFER_SIZE;
 
-    if (!array->buffer[num])
+    if (!array->buffer[num]) {
         return 0;
+    }
 
     *data = array->buffer[num];
     return 1;
@@ -591,13 +780,15 @@ static int get_data_pointer(const Packets_Array *array, Packet_Data **data, uint
  */
 static int64_t add_data_end_of_buffer(Packets_Array *array, const Packet_Data *data)
 {
-    if (num_packets_array(array) >= CRYPTO_PACKET_BUFFER_SIZE)
+    if (num_packets_array(array) >= CRYPTO_PACKET_BUFFER_SIZE) {
         return -1;
+    }
 
-    Packet_Data *new_d = malloc(sizeof(Packet_Data));
+    Packet_Data *new_d = (Packet_Data *)malloc(sizeof(Packet_Data));
 
-    if (new_d == NULL)
+    if (new_d == nullptr) {
         return -1;
+    }
 
     memcpy(new_d, data, sizeof(Packet_Data));
     uint32_t id = array->buffer_end;
@@ -613,19 +804,21 @@ static int64_t add_data_end_of_buffer(Packets_Array *array, const Packet_Data *d
  */
 static int64_t read_data_beg_buffer(Packets_Array *array, Packet_Data *data)
 {
-    if (array->buffer_end == array->buffer_start)
+    if (array->buffer_end == array->buffer_start) {
         return -1;
+    }
 
     uint32_t num = array->buffer_start % CRYPTO_PACKET_BUFFER_SIZE;
 
-    if (!array->buffer[num])
+    if (!array->buffer[num]) {
         return -1;
+    }
 
     memcpy(data, array->buffer[num], sizeof(Packet_Data));
     uint32_t id = array->buffer_start;
     ++array->buffer_start;
     free(array->buffer[num]);
-    array->buffer[num] = NULL;
+    array->buffer[num] = nullptr;
     return id;
 }
 
@@ -638,8 +831,9 @@ static int clear_buffer_until(Packets_Array *array, uint32_t number)
 {
     uint32_t num_spots = array->buffer_end - array->buffer_start;
 
-    if (array->buffer_end - number >= num_spots || number - array->buffer_start > num_spots)
+    if (array->buffer_end - number >= num_spots || number - array->buffer_start > num_spots) {
         return -1;
+    }
 
     uint32_t i;
 
@@ -648,7 +842,7 @@ static int clear_buffer_until(Packets_Array *array, uint32_t number)
 
         if (array->buffer[num]) {
             free(array->buffer[num]);
-            array->buffer[num] = NULL;
+            array->buffer[num] = nullptr;
         }
     }
 
@@ -665,7 +859,7 @@ static int clear_buffer(Packets_Array *array)
 
         if (array->buffer[num]) {
             free(array->buffer[num]);
-            array->buffer[num] = NULL;
+            array->buffer[num] = nullptr;
         }
     }
 
@@ -680,11 +874,13 @@ static int clear_buffer(Packets_Array *array)
  */
 static int set_buffer_end(Packets_Array *array, uint32_t number)
 {
-    if ((number - array->buffer_start) > CRYPTO_PACKET_BUFFER_SIZE)
+    if ((number - array->buffer_start) > CRYPTO_PACKET_BUFFER_SIZE) {
         return -1;
+    }
 
-    if ((number - array->buffer_end) > CRYPTO_PACKET_BUFFER_SIZE)
+    if ((number - array->buffer_end) > CRYPTO_PACKET_BUFFER_SIZE) {
         return -1;
+    }
 
     array->buffer_end = number;
     return 0;
@@ -698,18 +894,21 @@ static int set_buffer_end(Packets_Array *array, uint32_t number)
  */
 static int generate_request_packet(uint8_t *data, uint16_t length, const Packets_Array *recv_array)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     data[0] = PACKET_ID_REQUEST;
 
     uint16_t cur_len = 1;
 
-    if (recv_array->buffer_start == recv_array->buffer_end)
+    if (recv_array->buffer_start == recv_array->buffer_end) {
         return cur_len;
+    }
 
-    if (length <= cur_len)
+    if (length <= cur_len) {
         return cur_len;
+    }
 
     uint32_t i, n = 1;
 
@@ -721,16 +920,17 @@ static int generate_request_packet(uint8_t *data, uint16_t length, const Packets
             n = 0;
             ++cur_len;
 
-            if (length <= cur_len)
+            if (length <= cur_len) {
                 return cur_len;
-
+            }
         } else if (n == 255) {
             data[cur_len] = 0;
             n = 0;
             ++cur_len;
 
-            if (length <= cur_len)
+            if (length <= cur_len) {
                 return cur_len;
+            }
         }
 
         ++n;
@@ -748,14 +948,17 @@ static int generate_request_packet(uint8_t *data, uint16_t length, const Packets
 static int handle_request_packet(Packets_Array *send_array, const uint8_t *data, uint16_t length,
                                  uint64_t *latest_send_time, uint64_t rtt_time)
 {
-    if (length < 1)
+    if (length < 1) {
         return -1;
+    }
 
-    if (data[0] != PACKET_ID_REQUEST)
+    if (data[0] != PACKET_ID_REQUEST) {
         return -1;
+    }
 
-    if (length == 1)
+    if (length == 1) {
         return 0;
+    }
 
     ++data;
     --length;
@@ -767,8 +970,9 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
     uint64_t l_sent_time = ~0;
 
     for (i = send_array->buffer_start; i != send_array->buffer_end; ++i) {
-        if (length == 0)
+        if (length == 0) {
             break;
+        }
 
         uint32_t num = i % CRYPTO_PACKET_BUFFER_SIZE;
 
@@ -789,19 +993,21 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
             if (send_array->buffer[num]) {
                 uint64_t sent_time = send_array->buffer[num]->sent_time;
 
-                if (l_sent_time < sent_time)
+                if (l_sent_time < sent_time) {
                     l_sent_time = sent_time;
+                }
 
                 free(send_array->buffer[num]);
-                send_array->buffer[num] = NULL;
+                send_array->buffer[num] = nullptr;
             }
         }
 
         if (n == 255) {
             n = 1;
 
-            if (data[0] != 0)
+            if (data[0] != 0) {
                 return -1;
+            }
 
             ++data;
             --length;
@@ -810,15 +1016,16 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
         }
     }
 
-    if (*latest_send_time < l_sent_time)
+    if (*latest_send_time < l_sent_time) {
         *latest_send_time = l_sent_time;
+    }
 
     return requested;
 }
 
 /** END: Array Related functions **/
 
-#define MAX_DATA_DATA_PACKET_SIZE (MAX_CRYPTO_PACKET_SIZE - (1 + sizeof(uint16_t) + crypto_box_MACBYTES))
+#define MAX_DATA_DATA_PACKET_SIZE (MAX_CRYPTO_PACKET_SIZE - (1 + sizeof(uint16_t) + CRYPTO_MAC_SIZE))
 
 /* Creates and sends a data packet to the peer using the fastest route.
  *
@@ -827,21 +1034,23 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
  */
 static int send_data_packet(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
-    if (length == 0 || length + (1 + sizeof(uint16_t) + crypto_box_MACBYTES) > MAX_CRYPTO_PACKET_SIZE)
+    if (length == 0 || length + (1 + sizeof(uint16_t) + CRYPTO_MAC_SIZE) > MAX_CRYPTO_PACKET_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     pthread_mutex_lock(&conn->mutex);
-    uint8_t packet[1 + sizeof(uint16_t) + length + crypto_box_MACBYTES];
+    VLA(uint8_t, packet, 1 + sizeof(uint16_t) + length + CRYPTO_MAC_SIZE);
     packet[0] = NET_PACKET_CRYPTO_DATA;
-    memcpy(packet + 1, conn->sent_nonce + (crypto_box_NONCEBYTES - sizeof(uint16_t)), sizeof(uint16_t));
+    memcpy(packet + 1, conn->sent_nonce + (CRYPTO_NONCE_SIZE - sizeof(uint16_t)), sizeof(uint16_t));
     int len = encrypt_data_symmetric(conn->shared_key, conn->sent_nonce, data, length, packet + 1 + sizeof(uint16_t));
 
-    if (len + 1 + sizeof(uint16_t) != sizeof(packet)) {
+    if (len + 1 + sizeof(uint16_t) != SIZEOF_VLA(packet)) {
         pthread_mutex_unlock(&conn->mutex);
         return -1;
     }
@@ -849,7 +1058,7 @@ static int send_data_packet(Net_Crypto *c, int crypt_connection_id, const uint8_
     increment_nonce(conn->sent_nonce);
     pthread_mutex_unlock(&conn->mutex);
 
-    return send_packet_to(c, crypt_connection_id, packet, sizeof(packet));
+    return send_packet_to(c, crypt_connection_id, packet, SIZEOF_VLA(packet));
 }
 
 /* Creates and sends a data packet with buffer_start and num to the peer using the fastest route.
@@ -860,32 +1069,34 @@ static int send_data_packet(Net_Crypto *c, int crypt_connection_id, const uint8_
 static int send_data_packet_helper(Net_Crypto *c, int crypt_connection_id, uint32_t buffer_start, uint32_t num,
                                    const uint8_t *data, uint16_t length)
 {
-    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) {
         return -1;
+    }
 
-    num = htonl(num);
-    buffer_start = htonl(buffer_start);
+    num = net_htonl(num);
+    buffer_start = net_htonl(buffer_start);
     uint16_t padding_length = (MAX_CRYPTO_DATA_SIZE - length) % CRYPTO_MAX_PADDING;
-    uint8_t packet[sizeof(uint32_t) + sizeof(uint32_t) + padding_length + length];
+    VLA(uint8_t, packet, sizeof(uint32_t) + sizeof(uint32_t) + padding_length + length);
     memcpy(packet, &buffer_start, sizeof(uint32_t));
     memcpy(packet + sizeof(uint32_t), &num, sizeof(uint32_t));
     memset(packet + (sizeof(uint32_t) * 2), PACKET_ID_PADDING, padding_length);
     memcpy(packet + (sizeof(uint32_t) * 2) + padding_length, data, length);
 
-    return send_data_packet(c, crypt_connection_id, packet, sizeof(packet));
+    return send_data_packet(c, crypt_connection_id, packet, SIZEOF_VLA(packet));
 }
 
 static int reset_max_speed_reached(Net_Crypto *c, int crypt_connection_id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     /* If last packet send failed, try to send packet again.
        If sending it fails we won't be able to send the new packet. */
     if (conn->maximum_speed_reached) {
-        Packet_Data *dt = NULL;
+        Packet_Data *dt = nullptr;
         uint32_t packet_num = conn->send_array.buffer_end - 1;
         int ret = get_data_pointer(&conn->send_array, &dt, packet_num);
 
@@ -918,13 +1129,15 @@ static int reset_max_speed_reached(Net_Crypto *c, int crypt_connection_id)
 static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length,
                                     uint8_t congestion_control)
 {
-    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     /* If last packet send failed, try to send packet again.
        If sending it fails we won't be able to send the new packet. */
@@ -942,21 +1155,23 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
     int64_t packet_num = add_data_end_of_buffer(&conn->send_array, &dt);
     pthread_mutex_unlock(&conn->mutex);
 
-    if (packet_num == -1)
+    if (packet_num == -1) {
         return -1;
+    }
 
     if (!congestion_control && conn->maximum_speed_reached) {
         return packet_num;
     }
 
     if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, data, length) == 0) {
-        Packet_Data *dt1 = NULL;
+        Packet_Data *dt1 = nullptr;
 
-        if (get_data_pointer(&conn->send_array, &dt1, packet_num) == 1)
+        if (get_data_pointer(&conn->send_array, &dt1, packet_num) == 1) {
             dt1->sent_time = current_time_monotonic();
+        }
     } else {
         conn->maximum_speed_reached = 1;
-        LOGGER_ERROR("send_data_packet failed\n");
+        LOGGER_ERROR(c->log, "send_data_packet failed\n");
     }
 
     return packet_num;
@@ -968,8 +1183,8 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
 static uint16_t get_nonce_uint16(const uint8_t *nonce)
 {
     uint16_t num;
-    memcpy(&num, nonce + (crypto_box_NONCEBYTES - sizeof(uint16_t)), sizeof(uint16_t));
-    return ntohs(num);
+    memcpy(&num, nonce + (CRYPTO_NONCE_SIZE - sizeof(uint16_t)), sizeof(uint16_t));
+    return net_ntohs(num);
 }
 
 #define DATA_NUM_THRESHOLD 21845
@@ -984,27 +1199,30 @@ static uint16_t get_nonce_uint16(const uint8_t *nonce)
 static int handle_data_packet(const Net_Crypto *c, int crypt_connection_id, uint8_t *data, const uint8_t *packet,
                               uint16_t length)
 {
-    if (length <= (1 + sizeof(uint16_t) + crypto_box_MACBYTES) || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length <= (1 + sizeof(uint16_t) + CRYPTO_MAC_SIZE) || length > MAX_CRYPTO_PACKET_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    memcpy(nonce, conn->recv_nonce, crypto_box_NONCEBYTES);
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
+    memcpy(nonce, conn->recv_nonce, CRYPTO_NONCE_SIZE);
     uint16_t num_cur_nonce = get_nonce_uint16(nonce);
     uint16_t num;
     memcpy(&num, packet + 1, sizeof(uint16_t));
-    num = ntohs(num);
+    num = net_ntohs(num);
     uint16_t diff = num - num_cur_nonce;
     increment_nonce_number(nonce, diff);
     int len = decrypt_data_symmetric(conn->shared_key, nonce, packet + 1 + sizeof(uint16_t),
                                      length - (1 + sizeof(uint16_t)), data);
 
-    if ((unsigned int)len != length - (1 + sizeof(uint16_t) + crypto_box_MACBYTES))
+    if ((unsigned int)len != length - (1 + sizeof(uint16_t) + CRYPTO_MAC_SIZE)) {
         return -1;
+    }
 
     if (diff > DATA_NUM_THRESHOLD * 2) {
         increment_nonce_number(conn->recv_nonce, DATA_NUM_THRESHOLD);
@@ -1022,14 +1240,16 @@ static int send_request_packet(Net_Crypto *c, int crypt_connection_id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint8_t data[MAX_CRYPTO_DATA_SIZE];
     int len = generate_request_packet(data, sizeof(data), &conn->recv_array);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, conn->send_array.buffer_end, data,
                                    len);
@@ -1042,13 +1262,15 @@ static int send_request_packet(Net_Crypto *c, int crypt_connection_id)
  */
 static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32_t max_num)
 {
-    if (max_num == 0)
+    if (max_num == 0) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint64_t temp_time = current_time_monotonic();
     uint32_t i, num_sent = 0, array_size = num_packets_array(&conn->send_array);
@@ -1060,7 +1282,9 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32
 
         if (ret == -1) {
             return -1;
-        } else if (ret == 0) {
+        }
+
+        if (ret == 0) {
             continue;
         }
 
@@ -1074,8 +1298,9 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32
             ++num_sent;
         }
 
-        if (num_sent >= max_num)
+        if (num_sent >= max_num) {
             break;
+        }
     }
 
     return num_sent;
@@ -1089,21 +1314,25 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32
  */
 static int new_temp_packet(const Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length)
 {
-    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    uint8_t *temp_packet = malloc(length);
+    uint8_t *temp_packet = (uint8_t *)malloc(length);
 
-    if (temp_packet == 0)
+    if (temp_packet == nullptr) {
         return -1;
+    }
 
-    if (conn->temp_packet)
+    if (conn->temp_packet) {
         free(conn->temp_packet);
+    }
 
     memcpy(temp_packet, packet, length);
     conn->temp_packet = temp_packet;
@@ -1122,13 +1351,15 @@ static int clear_temp_packet(const Net_Crypto *c, int crypt_connection_id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (conn->temp_packet)
+    if (conn->temp_packet) {
         free(conn->temp_packet);
+    }
 
-    conn->temp_packet = 0;
+    conn->temp_packet = nullptr;
     conn->temp_packet_length = 0;
     conn->temp_packet_sent_time = 0;
     conn->temp_packet_num_sent = 0;
@@ -1145,14 +1376,17 @@ static int send_temp_packet(Net_Crypto *c, int crypt_connection_id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (!conn->temp_packet)
+    if (!conn->temp_packet) {
         return -1;
+    }
 
-    if (send_packet_to(c, crypt_connection_id, conn->temp_packet, conn->temp_packet_length) != 0)
+    if (send_packet_to(c, crypt_connection_id, conn->temp_packet, conn->temp_packet_length) != 0) {
         return -1;
+    }
 
     conn->temp_packet_sent_time = current_time_monotonic();
     ++conn->temp_packet_num_sent;
@@ -1170,17 +1404,20 @@ static int create_send_handshake(Net_Crypto *c, int crypt_connection_id, const u
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint8_t handshake_packet[HANDSHAKE_PACKET_LENGTH];
 
     if (create_crypto_handshake(c, handshake_packet, cookie, conn->sent_nonce, conn->sessionpublic_key,
-                                conn->public_key, dht_public_key) != sizeof(handshake_packet))
+                                conn->public_key, dht_public_key) != sizeof(handshake_packet)) {
         return -1;
+    }
 
-    if (new_temp_packet(c, crypt_connection_id, handshake_packet, sizeof(handshake_packet)) != 0)
+    if (new_temp_packet(c, crypt_connection_id, handshake_packet, sizeof(handshake_packet)) != 0) {
         return -1;
+    }
 
     send_temp_packet(c, crypt_connection_id);
     return 0;
@@ -1195,23 +1432,26 @@ static int send_kill_packet(Net_Crypto *c, int crypt_connection_id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint8_t kill_packet = PACKET_ID_KILL;
     return send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, conn->send_array.buffer_end,
                                    &kill_packet, sizeof(kill_packet));
 }
 
-static void connection_kill(Net_Crypto *c, int crypt_connection_id)
+static void connection_kill(Net_Crypto *c, int crypt_connection_id, void *userdata)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return;
+    }
 
     if (conn->connection_status_callback) {
-        conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 0);
+        conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 0,
+                                         userdata);
     }
 
     crypto_kill(c, crypt_connection_id);
@@ -1222,28 +1462,31 @@ static void connection_kill(Net_Crypto *c, int crypt_connection_id)
  * return -1 on failure.
  * return 0 on success.
  */
-static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length,
-                                     _Bool udp)
+static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length,
+                                   bool udp, void *userdata)
 {
-    if (length > MAX_CRYPTO_PACKET_SIZE || length <= CRYPTO_DATA_PACKET_MIN_SIZE)
+    if (length > MAX_CRYPTO_PACKET_SIZE || length <= CRYPTO_DATA_PACKET_MIN_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint8_t data[MAX_DATA_DATA_PACKET_SIZE];
     int len = handle_data_packet(c, crypt_connection_id, data, packet, length);
 
-    if (len <= (int)(sizeof(uint32_t) * 2))
+    if (len <= (int)(sizeof(uint32_t) * 2)) {
         return -1;
+    }
 
     uint32_t buffer_start, num;
     memcpy(&buffer_start, data, sizeof(uint32_t));
     memcpy(&num, data + sizeof(uint32_t), sizeof(uint32_t));
-    buffer_start = ntohl(buffer_start);
-    num = ntohl(num);
+    buffer_start = net_ntohl(buffer_start);
+    num = net_ntohl(num);
 
     uint64_t rtt_calc_time = 0;
 
@@ -1266,12 +1509,13 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
         ++real_data;
         --real_length;
 
-        if (real_length == 0)
+        if (real_length == 0) {
             return -1;
+        }
     }
 
     if (real_data[0] == PACKET_ID_KILL) {
-        connection_kill(c, crypt_connection_id);
+        connection_kill(c, crypt_connection_id, userdata);
         return 0;
     }
 
@@ -1279,8 +1523,10 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
         clear_temp_packet(c, crypt_connection_id);
         conn->status = CRYPTO_CONN_ESTABLISHED;
 
-        if (conn->connection_status_callback)
-            conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 1);
+        if (conn->connection_status_callback) {
+            conn->connection_status_callback(conn->connection_status_callback_object, conn->connection_status_callback_id, 1,
+                                             userdata);
+        }
     }
 
     if (real_data[0] == PACKET_ID_REQUEST) {
@@ -1296,8 +1542,6 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
 
         if (requested == -1) {
             return -1;
-        } else {
-            //TODO?
         }
 
         set_buffer_end(&conn->recv_array, num);
@@ -1306,27 +1550,30 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
         dt.length = real_length;
         memcpy(dt.data, real_data, real_length);
 
-        if (add_data_to_buffer(&conn->recv_array, num, &dt) != 0)
+        if (add_data_to_buffer(&conn->recv_array, num, &dt) != 0) {
             return -1;
-
+        }
 
         while (1) {
             pthread_mutex_lock(&conn->mutex);
             int ret = read_data_beg_buffer(&conn->recv_array, &dt);
             pthread_mutex_unlock(&conn->mutex);
 
-            if (ret == -1)
+            if (ret == -1) {
                 break;
+            }
 
-            if (conn->connection_data_callback)
+            if (conn->connection_data_callback) {
                 conn->connection_data_callback(conn->connection_data_callback_object, conn->connection_data_callback_id, dt.data,
-                                               dt.length);
+                                               dt.length, userdata);
+            }
 
             /* conn might get killed in callback. */
             conn = get_crypto_connection(c, crypt_connection_id);
 
-            if (conn == 0)
+            if (conn == nullptr) {
                 return -1;
+            }
         }
 
         /* Packet counter. */
@@ -1336,10 +1583,10 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
 
         set_buffer_end(&conn->recv_array, num);
 
-        if (conn->connection_lossy_data_callback)
+        if (conn->connection_lossy_data_callback) {
             conn->connection_lossy_data_callback(conn->connection_lossy_data_callback_object,
-                                                 conn->connection_lossy_data_callback_id, real_data, real_length);
-
+                                                 conn->connection_lossy_data_callback_id, real_data, real_length, userdata);
+        }
     } else {
         return -1;
     }
@@ -1347,8 +1594,9 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
     if (rtt_calc_time != 0) {
         uint64_t rtt_time = current_time_monotonic() - rtt_calc_time;
 
-        if (rtt_time < conn->rtt_time)
+        if (rtt_time < conn->rtt_time) {
             conn->rtt_time = rtt_time;
+        }
     }
 
     return 0;
@@ -1360,32 +1608,38 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
  * return 0 on success.
  */
 static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length,
-                                    _Bool udp)
+                                    bool udp, void *userdata)
 {
-    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     switch (packet[0]) {
         case NET_PACKET_COOKIE_RESPONSE: {
-            if (conn->status != CRYPTO_CONN_COOKIE_REQUESTING)
+            if (conn->status != CRYPTO_CONN_COOKIE_REQUESTING) {
                 return -1;
+            }
 
             uint8_t cookie[COOKIE_LENGTH];
             uint64_t number;
 
-            if (handle_cookie_response(cookie, &number, packet, length, conn->shared_key) != sizeof(cookie))
+            if (handle_cookie_response(cookie, &number, packet, length, conn->shared_key) != sizeof(cookie)) {
                 return -1;
+            }
 
-            if (number != conn->cookie_request_number)
+            if (number != conn->cookie_request_number) {
                 return -1;
+            }
 
-            if (create_send_handshake(c, crypt_connection_id, cookie, conn->dht_public_key) != 0)
+            if (create_send_handshake(c, crypt_connection_id, cookie, conn->dht_public_key) != 0) {
                 return -1;
+            }
 
             conn->status = CRYPTO_CONN_HANDSHAKE_SENT;
             return 0;
@@ -1394,28 +1648,30 @@ static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, cons
         case NET_PACKET_CRYPTO_HS: {
             if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING || conn->status == CRYPTO_CONN_HANDSHAKE_SENT
                     || conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
-                uint8_t peer_real_pk[crypto_box_PUBLICKEYBYTES];
-                uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
+                uint8_t peer_real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+                uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE];
                 uint8_t cookie[COOKIE_LENGTH];
 
                 if (handle_crypto_handshake(c, conn->recv_nonce, conn->peersessionpublic_key, peer_real_pk, dht_public_key, cookie,
-                                            packet, length, conn->public_key) != 0)
+                                            packet, length, conn->public_key) != 0) {
                     return -1;
+                }
 
                 if (public_key_cmp(dht_public_key, conn->dht_public_key) == 0) {
                     encrypt_precompute(conn->peersessionpublic_key, conn->sessionsecret_key, conn->shared_key);
 
                     if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING) {
-                        if (create_send_handshake(c, crypt_connection_id, cookie, dht_public_key) != 0)
+                        if (create_send_handshake(c, crypt_connection_id, cookie, dht_public_key) != 0) {
                             return -1;
+                        }
                     }
 
                     conn->status = CRYPTO_CONN_NOT_CONFIRMED;
                 } else {
-                    if (conn->dht_pk_callback)
-                        conn->dht_pk_callback(conn->dht_pk_callback_object, conn->dht_pk_callback_number, dht_public_key);
+                    if (conn->dht_pk_callback) {
+                        conn->dht_pk_callback(conn->dht_pk_callback_object, conn->dht_pk_callback_number, dht_public_key, userdata);
+                    }
                 }
-
             } else {
                 return -1;
             }
@@ -1425,20 +1681,16 @@ static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, cons
 
         case NET_PACKET_CRYPTO_DATA: {
             if (conn->status == CRYPTO_CONN_NOT_CONFIRMED || conn->status == CRYPTO_CONN_ESTABLISHED) {
-                return handle_data_packet_helper(c, crypt_connection_id, packet, length, udp);
-            } else {
-                return -1;
+                return handle_data_packet_core(c, crypt_connection_id, packet, length, udp, userdata);
             }
 
-            return 0;
+            return -1;
         }
 
         default: {
             return -1;
         }
     }
-
-    return 0;
 }
 
 /* Set the size of the friend list to numfriends.
@@ -1450,14 +1702,16 @@ static int realloc_cryptoconnection(Net_Crypto *c, uint32_t num)
 {
     if (num == 0) {
         free(c->crypto_connections);
-        c->crypto_connections = NULL;
+        c->crypto_connections = nullptr;
         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)
+    if (newcrypto_connections == nullptr) {
         return -1;
+    }
 
     c->crypto_connections = newcrypto_connections;
     return 0;
@@ -1474,11 +1728,12 @@ static int create_crypto_connection(Net_Crypto *c)
     uint32_t i;
 
     for (i = 0; i < c->crypto_connections_length; ++i) {
-        if (c->crypto_connections[i].status == CRYPTO_CONN_NO_CONNECTION)
+        if (c->crypto_connections[i].status == CRYPTO_CONN_NO_CONNECTION) {
             return i;
+        }
     }
 
-    while (1) { /* TODO: is this really the best way to do this? */
+    while (1) { /* TODO(irungentoo): is this really the best way to do this? */
         pthread_mutex_lock(&c->connections_mutex);
 
         if (!c->connection_use_counter) {
@@ -1493,9 +1748,15 @@ static int create_crypto_connection(Net_Crypto *c)
     if (realloc_cryptoconnection(c, c->crypto_connections_length + 1) == 0) {
         id = c->crypto_connections_length;
         ++c->crypto_connections_length;
-        memset(&(c->crypto_connections[id]), 0, sizeof(Crypto_Connection));
-
-        if (pthread_mutex_init(&c->crypto_connections[id].mutex, NULL) != 0) {
+        memset(&c->crypto_connections[id], 0, sizeof(Crypto_Connection));
+        // Memsetting float/double to 0 is non-portable, so we explicitly set them to 0
+        c->crypto_connections[id].packet_recv_rate = 0;
+        c->crypto_connections[id].packet_send_rate = 0;
+        c->crypto_connections[id].last_packets_left_rem = 0;
+        c->crypto_connections[id].packet_send_rate_requested = 0;
+        c->crypto_connections[id].last_packets_left_requested_rem = 0;
+
+        if (pthread_mutex_init(&c->crypto_connections[id].mutex, nullptr) != 0) {
             pthread_mutex_unlock(&c->connections_mutex);
             return -1;
         }
@@ -1512,14 +1773,15 @@ static int create_crypto_connection(Net_Crypto *c)
  */
 static int wipe_crypto_connection(Net_Crypto *c, int crypt_connection_id)
 {
-    if (crypt_connection_id_not_valid(c, crypt_connection_id))
+    if (crypt_connection_id_not_valid(c, crypt_connection_id)) {
         return -1;
+    }
 
     uint32_t i;
 
     /* Keep mutex, only destroy it when connection is realloced out. */
     pthread_mutex_t mutex = c->crypto_connections[crypt_connection_id].mutex;
-    sodium_memzero(&(c->crypto_connections[crypt_connection_id]), sizeof(Crypto_Connection));
+    crypto_memzero(&c->crypto_connections[crypt_connection_id], sizeof(Crypto_Connection));
     c->crypto_connections[crypt_connection_id].mutex = mutex;
 
     for (i = c->crypto_connections_length; i != 0; --i) {
@@ -1548,9 +1810,11 @@ static int getcryptconnection_id(const Net_Crypto *c, const uint8_t *public_key)
     uint32_t i;
 
     for (i = 0; i < c->crypto_connections_length; ++i) {
-        if (c->crypto_connections[i].status != CRYPTO_CONN_NO_CONNECTION)
-            if (public_key_cmp(public_key, c->crypto_connections[i].public_key) == 0)
+        if (c->crypto_connections[i].status != CRYPTO_CONN_NO_CONNECTION) {
+            if (public_key_cmp(public_key, c->crypto_connections[i].public_key) == 0) {
                 return i;
+            }
+        }
     }
 
     return -1;
@@ -1567,23 +1831,28 @@ static int crypto_connection_add_source(Net_Crypto *c, int crypt_connection_id,
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (source.ip.family == AF_INET || source.ip.family == AF_INET6) {
-        if (add_ip_port_connection(c, crypt_connection_id, source) != 0)
+    if (net_family_is_ipv4(source.ip.family) || net_family_is_ipv6(source.ip.family)) {
+        if (add_ip_port_connection(c, crypt_connection_id, source) != 0) {
             return -1;
+        }
 
-        if (source.ip.family == AF_INET) {
+        if (net_family_is_ipv4(source.ip.family)) {
             conn->direct_lastrecv_timev4 = unix_time();
         } else {
             conn->direct_lastrecv_timev6 = unix_time();
         }
 
         return 0;
-    } else if (source.ip.family == TCP_FAMILY) {
-        if (add_tcp_number_relay_connection(c->tcp_c, conn->connection_number_tcp, source.ip.ip6.uint32[0]) == 0)
+    }
+
+    if (net_family_is_tcp_family(source.ip.family)) {
+        if (add_tcp_number_relay_connection(c->tcp_c, conn->connection_number_tcp, source.ip.ip.v6.uint32[0]) == 0) {
             return 1;
+        }
     }
 
     return -1;
@@ -1609,19 +1878,21 @@ void new_connection_handler(Net_Crypto *c, int (*new_connection_callback)(void *
  * return -1 on failure.
  * return 0 on success.
  */
-static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const uint8_t *data, uint16_t length)
+static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const uint8_t *data, uint16_t length,
+        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)
+    if (n_c.cookie == nullptr) {
         return -1;
+    }
 
     n_c.source = source;
     n_c.cookie_length = COOKIE_LENGTH;
 
     if (handle_crypto_handshake(c, n_c.recv_nonce, n_c.peersessionpublic_key, n_c.public_key, n_c.dht_public_key,
-                                n_c.cookie, data, length, 0) != 0) {
+                                n_c.cookie, data, length, nullptr) != 0) {
         free(n_c.cookie);
         return -1;
     }
@@ -1632,13 +1903,13 @@ static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const
         Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
         if (public_key_cmp(n_c.dht_public_key, conn->dht_public_key) != 0) {
-            connection_kill(c, crypt_connection_id);
+            connection_kill(c, crypt_connection_id, userdata);
         } else {
             int ret = -1;
 
             if (conn && (conn->status == CRYPTO_CONN_COOKIE_REQUESTING || conn->status == CRYPTO_CONN_HANDSHAKE_SENT)) {
-                memcpy(conn->recv_nonce, n_c.recv_nonce, crypto_box_NONCEBYTES);
-                memcpy(conn->peersessionpublic_key, n_c.peersessionpublic_key, crypto_box_PUBLICKEYBYTES);
+                memcpy(conn->recv_nonce, n_c.recv_nonce, CRYPTO_NONCE_SIZE);
+                memcpy(conn->peersessionpublic_key, n_c.peersessionpublic_key, CRYPTO_PUBLIC_KEY_SIZE);
                 encrypt_precompute(conn->peersessionpublic_key, conn->sessionsecret_key, conn->shared_key);
 
                 crypto_connection_add_source(c, crypt_connection_id, source);
@@ -1666,32 +1937,36 @@ static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const
  */
 int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
 {
-    if (getcryptconnection_id(c, n_c->public_key) != -1)
+    if (getcryptconnection_id(c, n_c->public_key) != -1) {
         return -1;
+    }
 
     int crypt_connection_id = create_crypto_connection(c);
 
-    if (crypt_connection_id == -1)
+    if (crypt_connection_id == -1) {
         return -1;
+    }
 
     Crypto_Connection *conn = &c->crypto_connections[crypt_connection_id];
 
-    if (n_c->cookie_length != COOKIE_LENGTH)
+    if (n_c->cookie_length != COOKIE_LENGTH) {
         return -1;
+    }
 
     pthread_mutex_lock(&c->tcp_mutex);
     int connection_number_tcp = new_tcp_connection_to(c->tcp_c, n_c->dht_public_key, crypt_connection_id);
     pthread_mutex_unlock(&c->tcp_mutex);
 
-    if (connection_number_tcp == -1)
+    if (connection_number_tcp == -1) {
         return -1;
+    }
 
     conn->connection_number_tcp = connection_number_tcp;
-    memcpy(conn->public_key, n_c->public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(conn->recv_nonce, n_c->recv_nonce, crypto_box_NONCEBYTES);
-    memcpy(conn->peersessionpublic_key, n_c->peersessionpublic_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(conn->public_key, n_c->public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(conn->recv_nonce, n_c->recv_nonce, CRYPTO_NONCE_SIZE);
+    memcpy(conn->peersessionpublic_key, n_c->peersessionpublic_key, CRYPTO_PUBLIC_KEY_SIZE);
     random_nonce(conn->sent_nonce);
-    crypto_box_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
+    crypto_new_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
     encrypt_precompute(conn->peersessionpublic_key, conn->sessionsecret_key, conn->shared_key);
     conn->status = CRYPTO_CONN_NOT_CONFIRMED;
 
@@ -1703,7 +1978,7 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
         return -1;
     }
 
-    memcpy(conn->dht_public_key, n_c->dht_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(conn->dht_public_key, n_c->dht_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
     conn->packet_send_rate_requested = CRYPTO_PACKET_MIN_RATE;
     conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
@@ -1722,38 +1997,42 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
 {
     int crypt_connection_id = getcryptconnection_id(c, real_public_key);
 
-    if (crypt_connection_id != -1)
+    if (crypt_connection_id != -1) {
         return crypt_connection_id;
+    }
 
     crypt_connection_id = create_crypto_connection(c);
 
-    if (crypt_connection_id == -1)
+    if (crypt_connection_id == -1) {
         return -1;
+    }
 
     Crypto_Connection *conn = &c->crypto_connections[crypt_connection_id];
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     pthread_mutex_lock(&c->tcp_mutex);
     int connection_number_tcp = new_tcp_connection_to(c->tcp_c, dht_public_key, crypt_connection_id);
     pthread_mutex_unlock(&c->tcp_mutex);
 
-    if (connection_number_tcp == -1)
+    if (connection_number_tcp == -1) {
         return -1;
+    }
 
     conn->connection_number_tcp = connection_number_tcp;
-    memcpy(conn->public_key, real_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(conn->public_key, real_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     random_nonce(conn->sent_nonce);
-    crypto_box_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
+    crypto_new_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
     conn->status = CRYPTO_CONN_COOKIE_REQUESTING;
     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
     conn->packet_send_rate_requested = CRYPTO_PACKET_MIN_RATE;
     conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
     conn->rtt_time = DEFAULT_PING_CONNECTION;
-    memcpy(conn->dht_public_key, dht_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(conn->dht_public_key, dht_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
-    conn->cookie_request_number = random_64b();
+    conn->cookie_request_number = random_u64();
     uint8_t cookie_request[COOKIE_REQUEST_LENGTH];
 
     if (create_cookie_request(c, cookie_request, conn->dht_public_key, conn->cookie_request_number,
@@ -1776,85 +2055,89 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
  * return -1 on failure.
  * return 0 on success.
  */
-int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, _Bool connected)
+int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, bool connected)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (add_ip_port_connection(c, crypt_connection_id, ip_port) == 0) {
-        if (connected) {
-            if (ip_port.ip.family == AF_INET) {
-                conn->direct_lastrecv_timev4 = unix_time();
-            } else {
-                conn->direct_lastrecv_timev6 = unix_time();
-            }
-        } else {
-            if (ip_port.ip.family == AF_INET) {
-                conn->direct_lastrecv_timev4 = 0;
-            } else {
-                conn->direct_lastrecv_timev6 = 0;
-            }
-        }
+    if (add_ip_port_connection(c, crypt_connection_id, ip_port) != 0) {
+        return -1;
+    }
 
-        return 0;
+    const uint64_t direct_lastrecv_time = connected ? unix_time() : 0;
+
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        conn->direct_lastrecv_timev4 = direct_lastrecv_time;
+    } else {
+        conn->direct_lastrecv_timev6 = direct_lastrecv_time;
     }
 
-    return -1;
+    return 0;
 }
 
 
-static int tcp_data_callback(void *object, int id, const uint8_t *data, uint16_t length)
+static int tcp_data_callback(void *object, int id, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE) {
         return -1;
+    }
 
-    Net_Crypto *c = object;
+    Net_Crypto *c = (Net_Crypto *)object;
 
     Crypto_Connection *conn = get_crypto_connection(c, id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     if (data[0] == NET_PACKET_COOKIE_REQUEST) {
         return tcp_handle_cookie_request(c, conn->connection_number_tcp, data, length);
     }
 
+    // This unlocks the mutex that at this point is locked by do_tcp before
+    // calling do_tcp_connections.
     pthread_mutex_unlock(&c->tcp_mutex);
-    int ret = handle_packet_connection(c, id, data, length, 0);
+    int ret = handle_packet_connection(c, id, data, length, 0, userdata);
     pthread_mutex_lock(&c->tcp_mutex);
 
-    if (ret != 0)
+    if (ret != 0) {
         return -1;
+    }
 
-    //TODO detect and kill bad TCP connections.
+    // TODO(irungentoo): detect and kill bad TCP connections.
     return 0;
 }
 
 static int tcp_oob_callback(void *object, const uint8_t *public_key, unsigned int tcp_connections_number,
-                            const uint8_t *data, uint16_t length)
+                            const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE) {
         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);
-    } else if (data[0] == NET_PACKET_CRYPTO_HS) {
+    }
+
+    if (data[0] == NET_PACKET_CRYPTO_HS) {
         IP_Port source;
         source.port = 0;
-        source.ip.family = TCP_FAMILY;
-        source.ip.ip6.uint32[0] = tcp_connections_number;
+        source.ip.family = net_family_tcp_family;
+        source.ip.ip.v6.uint32[0] = tcp_connections_number;
 
-        if (handle_new_connection_handshake(c, source, data, length) != 0)
+        if (handle_new_connection_handshake(c, source, data, length, userdata) != 0) {
             return -1;
+        }
 
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 /* Add a tcp relay, associating it to a crypt_connection_id.
@@ -1866,8 +2149,9 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     pthread_mutex_lock(&c->tcp_mutex);
     int ret = add_tcp_relay_connection(c->tcp_c, conn->connection_number_tcp, ip_port, public_key);
@@ -1890,7 +2174,7 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key)
 
 /* Return a random TCP connection number for use in send_tcp_onion_request.
  *
- * TODO: This number is just the index of an array that the elements can
+ * TODO(irungentoo): This number is just the index of an array that the elements can
  * change without warning.
  *
  * return TCP connection number on success.
@@ -1927,8 +2211,9 @@ int send_tcp_onion_request(Net_Crypto *c, unsigned int tcp_connections_number, c
  */
 unsigned int copy_connected_tcp_relays(Net_Crypto *c, Node_format *tcp_relays, uint16_t num)
 {
-    if (num == 0)
+    if (num == 0) {
         return 0;
+    }
 
     pthread_mutex_lock(&c->tcp_mutex);
     unsigned int ret = tcp_copy_connected_relays(c->tcp_c, tcp_relays, num);
@@ -1937,10 +2222,10 @@ unsigned int copy_connected_tcp_relays(Net_Crypto *c, Node_format *tcp_relays, u
     return ret;
 }
 
-static void do_tcp(Net_Crypto *c)
+static void do_tcp(Net_Crypto *c, void *userdata)
 {
     pthread_mutex_lock(&c->tcp_mutex);
-    do_tcp_connections(c->tcp_c);
+    do_tcp_connections(c->tcp_c, userdata);
     pthread_mutex_unlock(&c->tcp_mutex);
 
     uint32_t i;
@@ -1948,12 +2233,13 @@ static void do_tcp(Net_Crypto *c)
     for (i = 0; i < c->crypto_connections_length; ++i) {
         Crypto_Connection *conn = get_crypto_connection(c, i);
 
-        if (conn == 0)
-            return;
+        if (conn == nullptr) {
+            continue;
+        }
 
         if (conn->status == CRYPTO_CONN_ESTABLISHED) {
-            _Bool direct_connected = 0;
-            crypto_connection_status(c, i, &direct_connected, NULL);
+            bool direct_connected = 0;
+            crypto_connection_status(c, i, &direct_connected, nullptr);
 
             if (direct_connected) {
                 pthread_mutex_lock(&c->tcp_mutex);
@@ -1979,12 +2265,13 @@ static void do_tcp(Net_Crypto *c)
  * return 0 on success.
  */
 int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
-                              int (*connection_status_callback)(void *object, int id, uint8_t status), void *object, int id)
+                              int (*connection_status_callback)(void *object, int id, uint8_t status, void *userdata), void *object, int id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     conn->connection_status_callback = connection_status_callback;
     conn->connection_status_callback_object = object;
@@ -2001,12 +2288,13 @@ int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
  * return 0 on success.
  */
 int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
-                            int id, uint8_t *data, uint16_t length), void *object, int id)
+                            int id, const uint8_t *data, uint16_t length, void *userdata), void *object, int id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     conn->connection_data_callback = connection_data_callback;
     conn->connection_data_callback_object = object;
@@ -2023,12 +2311,14 @@ int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*
  * return 0 on success.
  */
 int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
-                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object, int id)
+                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata),
+                                  void *object, int id)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     conn->connection_lossy_data_callback = connection_lossy_data_callback;
     conn->connection_lossy_data_callback_object = object;
@@ -2048,12 +2338,13 @@ int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
  * return 0 on success.
  */
 int nc_dht_pk_callback(Net_Crypto *c, int crypt_connection_id, void (*function)(void *data, int32_t number,
-                       const uint8_t *dht_public_key), void *object, uint32_t number)
+                       const uint8_t *dht_public_key, void *userdata), void *object, uint32_t number)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     conn->dht_pk_callback = function;
     conn->dht_pk_callback_object = object;
@@ -2071,7 +2362,7 @@ static int crypto_id_ip_port(const Net_Crypto *c, IP_Port ip_port)
     return bs_list_find(&c->ip_port_list, (uint8_t *)&ip_port);
 }
 
-#define CRYPTO_MIN_PACKET_SIZE (1 + sizeof(uint16_t) + crypto_box_MACBYTES)
+#define CRYPTO_MIN_PACKET_SIZE (1 + sizeof(uint16_t) + CRYPTO_MAC_SIZE)
 
 /* Handle raw UDP packets coming directly from the socket.
  *
@@ -2081,35 +2372,40 @@ static int crypto_id_ip_port(const Net_Crypto *c, IP_Port ip_port)
  * Crypto data packets.
  *
  */
-static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
 {
-    if (length <= CRYPTO_MIN_PACKET_SIZE || length > MAX_CRYPTO_PACKET_SIZE)
+    if (length <= CRYPTO_MIN_PACKET_SIZE || length > MAX_CRYPTO_PACKET_SIZE) {
         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) {
-        if (packet[0] != NET_PACKET_CRYPTO_HS)
+        if (packet[0] != NET_PACKET_CRYPTO_HS) {
             return 1;
+        }
 
-        if (handle_new_connection_handshake(c, source, packet, length) != 0)
+        if (handle_new_connection_handshake(c, source, packet, length, userdata) != 0) {
             return 1;
+        }
 
         return 0;
     }
 
-    if (handle_packet_connection(c, crypt_connection_id, packet, length, 1) != 0)
+    if (handle_packet_connection(c, crypt_connection_id, packet, length, 1, userdata) != 0) {
         return 1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     pthread_mutex_lock(&conn->mutex);
 
-    if (source.ip.family == AF_INET) {
+    if (net_family_is_ipv4(source.ip.family)) {
         conn->direct_lastrecv_timev4 = unix_time();
     } else {
         conn->direct_lastrecv_timev6 = unix_time();
@@ -2147,37 +2443,40 @@ static void send_crypto_packets(Net_Crypto *c)
     for (i = 0; i < c->crypto_connections_length; ++i) {
         Crypto_Connection *conn = get_crypto_connection(c, i);
 
-        if (conn == 0)
-            return;
+        if (conn == nullptr) {
+            continue;
+        }
 
-        if (CRYPTO_SEND_PACKET_INTERVAL + conn->temp_packet_sent_time < temp_time) {
+        if ((CRYPTO_SEND_PACKET_INTERVAL + conn->temp_packet_sent_time) < temp_time) {
             send_temp_packet(c, i);
         }
 
         if ((conn->status == CRYPTO_CONN_NOT_CONFIRMED || conn->status == CRYPTO_CONN_ESTABLISHED)
-                && ((CRYPTO_SEND_PACKET_INTERVAL) + conn->last_request_packet_sent) < temp_time) {
+                && (CRYPTO_SEND_PACKET_INTERVAL + conn->last_request_packet_sent) < temp_time) {
             if (send_request_packet(c, i) == 0) {
                 conn->last_request_packet_sent = temp_time;
             }
-
         }
 
         if (conn->status == CRYPTO_CONN_ESTABLISHED) {
             if (conn->packet_recv_rate > CRYPTO_PACKET_MIN_RATE) {
-                double request_packet_interval = (REQUEST_PACKETS_COMPARE_CONSTANT / (((double)num_packets_array(
+                double request_packet_interval = (REQUEST_PACKETS_COMPARE_CONSTANT / ((num_packets_array(
                                                       &conn->recv_array) + 1.0) / (conn->packet_recv_rate + 1.0)));
 
                 double request_packet_interval2 = ((CRYPTO_PACKET_MIN_RATE / conn->packet_recv_rate) *
                                                    (double)CRYPTO_SEND_PACKET_INTERVAL) + (double)PACKET_COUNTER_AVERAGE_INTERVAL;
 
-                if (request_packet_interval2 < request_packet_interval)
+                if (request_packet_interval2 < request_packet_interval) {
                     request_packet_interval = request_packet_interval2;
+                }
 
-                if (request_packet_interval < PACKET_COUNTER_AVERAGE_INTERVAL)
+                if (request_packet_interval < PACKET_COUNTER_AVERAGE_INTERVAL) {
                     request_packet_interval = PACKET_COUNTER_AVERAGE_INTERVAL;
+                }
 
-                if (request_packet_interval > CRYPTO_SEND_PACKET_INTERVAL)
+                if (request_packet_interval > CRYPTO_SEND_PACKET_INTERVAL) {
                     request_packet_interval = CRYPTO_SEND_PACKET_INTERVAL;
+                }
 
                 if (temp_time - conn->last_request_packet_sent > (uint64_t)request_packet_interval) {
                     if (send_request_packet(c, i) == 0) {
@@ -2212,7 +2511,6 @@ static void send_crypto_packets(Net_Crypto *c)
                 conn->last_sendqueue_size[pos] = num_packets_array(&conn->send_array);
                 ++conn->last_sendqueue_counter;
 
-                unsigned int j;
                 long signed int sum = 0;
                 sum = (long signed int)conn->last_sendqueue_size[(pos) % CONGESTION_QUEUE_ARRAY_SIZE] -
                       (long signed int)conn->last_sendqueue_size[(pos - (CONGESTION_QUEUE_ARRAY_SIZE - 1)) % CONGESTION_QUEUE_ARRAY_SIZE];
@@ -2221,15 +2519,15 @@ static void send_crypto_packets(Net_Crypto *c)
                 conn->last_num_packets_sent[n_p_pos] = packets_sent;
                 conn->last_num_packets_resent[n_p_pos] = packets_resent;
 
-                _Bool direct_connected = 0;
-                crypto_connection_status(c, i, &direct_connected, NULL);
+                bool direct_connected = 0;
+                crypto_connection_status(c, i, &direct_connected, nullptr);
 
                 if (direct_connected && conn->last_tcp_sent + CONGESTION_EVENT_TIMEOUT > temp_time) {
                     /* When switching from TCP to UDP, don't change the packet send rate for CONGESTION_EVENT_TIMEOUT ms. */
                 } else {
                     long signed int total_sent = 0, total_resent = 0;
 
-                    //TODO use real delay
+                    // TODO(irungentoo): use real delay
                     unsigned int delay = (unsigned int)((conn->rtt_time / PACKET_COUNTER_AVERAGE_INTERVAL) + 0.5);
                     unsigned int packets_set_rem_array = (CONGESTION_LAST_SENT_ARRAY_SIZE - CONGESTION_QUEUE_ARRAY_SIZE);
 
@@ -2237,7 +2535,7 @@ static void send_crypto_packets(Net_Crypto *c)
                         delay = packets_set_rem_array;
                     }
 
-                    for (j = 0; j < CONGESTION_QUEUE_ARRAY_SIZE; ++j) {
+                    for (unsigned j = 0; j < CONGESTION_QUEUE_ARRAY_SIZE; ++j) {
                         unsigned int ind = (j + (packets_set_rem_array  - delay) + n_p_pos) % CONGESTION_LAST_SENT_ARRAY_SIZE;
                         total_sent += conn->last_num_packets_sent[ind];
                         total_resent += conn->last_num_packets_resent[ind];
@@ -2246,8 +2544,9 @@ static void send_crypto_packets(Net_Crypto *c)
                     if (sum > 0) {
                         total_sent -= sum;
                     } else {
-                        if (total_resent > -sum)
+                        if (total_resent > -sum) {
                             total_resent = -sum;
+                        }
                     }
 
                     /* if queue is too big only allow resending packets. */
@@ -2258,12 +2557,13 @@ static void send_crypto_packets(Net_Crypto *c)
                     double min_speed_request = 1000.0 * (((double)(total_sent + total_resent)) / ((double)(
                             CONGESTION_QUEUE_ARRAY_SIZE) * PACKET_COUNTER_AVERAGE_INTERVAL));
 
-                    if (min_speed < CRYPTO_PACKET_MIN_RATE)
+                    if (min_speed < CRYPTO_PACKET_MIN_RATE) {
                         min_speed = CRYPTO_PACKET_MIN_RATE;
+                    }
 
                     double send_array_ratio = (((double)npackets) / min_speed);
 
-                    //TODO: Improve formula?
+                    // TODO(irungentoo): Improve formula?
                     if (send_array_ratio > SEND_QUEUE_RATIO && CRYPTO_MIN_QUEUE_LENGTH < npackets) {
                         conn->packet_send_rate = min_speed * (1.0 / (send_array_ratio / SEND_QUEUE_RATIO));
                     } else if (conn->last_congestion_event + CONGESTION_EVENT_TIMEOUT < temp_time) {
@@ -2282,7 +2582,6 @@ static void send_crypto_packets(Net_Crypto *c)
                         conn->packet_send_rate_requested = conn->packet_send_rate;
                     }
                 }
-
             }
 
             if (conn->last_packets_left_set == 0 || conn->last_packets_left_requested_set == 0) {
@@ -2320,8 +2619,9 @@ static void send_crypto_packets(Net_Crypto *c)
                     conn->last_packets_left_requested_rem = rem;
                 }
 
-                if (conn->packets_left > conn->packets_left_requested)
+                if (conn->packets_left > conn->packets_left_requested) {
                     conn->packets_left_requested = conn->packets_left;
+                }
             }
 
             int ret = send_requested_packets(c, i, conn->packets_left_requested);
@@ -2369,7 +2669,7 @@ static void send_crypto_packets(Net_Crypto *c)
 /* Return 1 if max speed was reached for this connection (no more data can be physically through the pipe).
  * Return 0 if it wasn't reached.
  */
-_Bool max_speed_reached(Net_Crypto *c, int crypt_connection_id)
+bool max_speed_reached(Net_Crypto *c, int crypt_connection_id)
 {
     return reset_max_speed_reached(c, crypt_connection_id) != 0;
 }
@@ -2381,16 +2681,17 @@ uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connecti
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return 0;
+    }
 
     uint32_t max_packets = CRYPTO_PACKET_BUFFER_SIZE - num_packets_array(&conn->send_array);
 
     if (conn->packets_left < max_packets) {
         return conn->packets_left;
-    } else {
-        return max_packets;
     }
+
+    return max_packets;
 }
 
 /* Sends a lossless cryptopacket.
@@ -2403,30 +2704,37 @@ uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connecti
 int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length,
                           uint8_t congestion_control)
 {
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
-    if (data[0] < CRYPTO_RESERVED_PACKETS)
+    if (data[0] < CRYPTO_RESERVED_PACKETS) {
         return -1;
+    }
 
-    if (data[0] >= PACKET_ID_LOSSY_RANGE_START)
+    if (data[0] >= PACKET_ID_LOSSY_RANGE_START) {
         return -1;
+    }
 
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
-    if (conn->status != CRYPTO_CONN_ESTABLISHED)
+    if (conn->status != CRYPTO_CONN_ESTABLISHED) {
         return -1;
+    }
 
-    if (congestion_control && conn->packets_left == 0)
+    if (congestion_control && conn->packets_left == 0) {
         return -1;
+    }
 
     int64_t ret = send_lossless_packet(c, crypt_connection_id, data, length, congestion_control);
 
-    if (ret == -1)
+    if (ret == -1) {
         return -1;
+    }
 
     if (congestion_control) {
         --conn->packets_left;
@@ -2443,22 +2751,30 @@ int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t
  *
  * return -1 on failure.
  * return 0 on success.
+ *
+ * Note: The condition `buffer_end - buffer_start < packet_number - buffer_start` is
+ * a trick which handles situations `buffer_end >= buffer_start` and
+ * `buffer_end < buffer_start`(when buffer_end overflowed) both correctly
+ *
+ * It CANNOT be simplified to `packet_number < buffer_start`, as it will fail
+ * when `buffer_end < buffer_start`.
  */
 int cryptpacket_received(Net_Crypto *c, int crypt_connection_id, uint32_t packet_number)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return -1;
+    }
 
     uint32_t num = conn->send_array.buffer_end - conn->send_array.buffer_start;
     uint32_t num1 = packet_number - conn->send_array.buffer_start;
 
     if (num < num1) {
         return 0;
-    } else {
-        return -1;
     }
+
+    return -1;
 }
 
 /* return -1 on failure.
@@ -2468,14 +2784,17 @@ int cryptpacket_received(Net_Crypto *c, int crypt_connection_id, uint32_t packet
  */
 int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
-    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
+    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE) {
         return -1;
+    }
 
-    if (data[0] < PACKET_ID_LOSSY_RANGE_START)
+    if (data[0] < PACKET_ID_LOSSY_RANGE_START) {
         return -1;
+    }
 
-    if (data[0] >= (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE))
+    if (data[0] >= (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE)) {
         return -1;
+    }
 
     pthread_mutex_lock(&c->connections_mutex);
     ++c->connection_use_counter;
@@ -2507,7 +2826,7 @@ int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t
  */
 int crypto_kill(Net_Crypto *c, int crypt_connection_id)
 {
-    while (1) { /* TODO: is this really the best way to do this? */
+    while (1) { /* TODO(irungentoo): is this really the best way to do this? */
         pthread_mutex_lock(&c->connections_mutex);
 
         if (!c->connection_use_counter) {
@@ -2522,8 +2841,9 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id)
     int ret = -1;
 
     if (conn) {
-        if (conn->status == CRYPTO_CONN_ESTABLISHED)
+        if (conn->status == CRYPTO_CONN_ESTABLISHED) {
             send_kill_packet(c, crypt_connection_id);
+        }
 
         pthread_mutex_lock(&c->tcp_mutex);
         kill_tcp_connection_to(c->tcp_c, conn->connection_number_tcp);
@@ -2547,24 +2867,27 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id)
  * sets direct_connected to 1 if connection connects directly to other, 0 if it isn't.
  * sets online_tcp_relays to the number of connected tcp relays this connection has.
  */
-unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, _Bool *direct_connected,
+unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, bool *direct_connected,
                                       unsigned int *online_tcp_relays)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
-    if (conn == 0)
+    if (conn == nullptr) {
         return CRYPTO_CONN_NO_CONNECTION;
+    }
 
     if (direct_connected) {
         *direct_connected = 0;
 
         uint64_t current_time = unix_time();
 
-        if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev4) > current_time)
+        if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev4) > current_time) {
             *direct_connected = 1;
+        }
 
-        if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev6) > current_time)
+        if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev6) > current_time) {
             *direct_connected = 1;
+        }
     }
 
     if (online_tcp_relays) {
@@ -2576,59 +2899,63 @@ unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_
 
 void new_keys(Net_Crypto *c)
 {
-    crypto_box_keypair(c->self_public_key, c->self_secret_key);
+    crypto_new_keypair(c->self_public_key, c->self_secret_key);
 }
 
 /* Save the public and private keys to the keys array.
- * Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
+ * Length must be CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE.
  *
- * TODO: Save only secret key.
+ * TODO(irungentoo): Save only secret key.
  */
 void save_keys(const Net_Crypto *c, uint8_t *keys)
 {
-    memcpy(keys, c->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(keys + crypto_box_PUBLICKEYBYTES, c->self_secret_key, crypto_box_SECRETKEYBYTES);
+    memcpy(keys, c->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(keys + CRYPTO_PUBLIC_KEY_SIZE, c->self_secret_key, CRYPTO_SECRET_KEY_SIZE);
 }
 
 /* Load the secret key.
- * Length must be crypto_box_SECRETKEYBYTES.
+ * Length must be CRYPTO_SECRET_KEY_SIZE.
  */
 void load_secret_key(Net_Crypto *c, const uint8_t *sk)
 {
-    memcpy(c->self_secret_key, sk, crypto_box_SECRETKEYBYTES);
-    crypto_scalarmult_curve25519_base(c->self_public_key, c->self_secret_key);
+    memcpy(c->self_secret_key, sk, CRYPTO_SECRET_KEY_SIZE);
+    crypto_derive_public_key(c->self_public_key, c->self_secret_key);
 }
 
 /* Run this to (re)initialize net_crypto.
  * Sets all the global connection variables to their default values.
  */
-Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info)
+Net_Crypto *new_net_crypto(Logger *log, DHT *dht, TCP_Proxy_Info *proxy_info)
 {
     unix_time_update();
 
-    if (dht == NULL)
-        return NULL;
+    if (dht == nullptr) {
+        return nullptr;
+    }
+
+    Net_Crypto *temp = (Net_Crypto *)calloc(1, sizeof(Net_Crypto));
 
-    Net_Crypto *temp = calloc(1, sizeof(Net_Crypto));
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
-    if (temp == NULL)
-        return NULL;
+    temp->log = log;
 
-    temp->tcp_c = new_tcp_connections(dht->self_secret_key, proxy_info);
+    temp->tcp_c = new_tcp_connections(dht_get_self_secret_key(dht), proxy_info);
 
-    if (temp->tcp_c == NULL) {
+    if (temp->tcp_c == nullptr) {
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
     set_packet_tcp_connection_callback(temp->tcp_c, &tcp_data_callback, temp);
     set_oob_packet_tcp_connection_callback(temp->tcp_c, &tcp_oob_callback, temp);
 
     if (create_recursive_mutex(&temp->tcp_mutex) != 0 ||
-            pthread_mutex_init(&temp->connections_mutex, NULL) != 0) {
+            pthread_mutex_init(&temp->connections_mutex, nullptr) != 0) {
         kill_tcp_connections(temp->tcp_c);
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
     temp->dht = dht;
@@ -2638,17 +2965,17 @@ Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info)
 
     temp->current_sleep_time = CRYPTO_SEND_PACKET_INTERVAL;
 
-    networking_registerhandler(dht->net, NET_PACKET_COOKIE_REQUEST, &udp_handle_cookie_request, temp);
-    networking_registerhandler(dht->net, NET_PACKET_COOKIE_RESPONSE, &udp_handle_packet, temp);
-    networking_registerhandler(dht->net, NET_PACKET_CRYPTO_HS, &udp_handle_packet, temp);
-    networking_registerhandler(dht->net, NET_PACKET_CRYPTO_DATA, &udp_handle_packet, temp);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_COOKIE_REQUEST, &udp_handle_cookie_request, temp);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_COOKIE_RESPONSE, &udp_handle_packet, temp);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_CRYPTO_HS, &udp_handle_packet, temp);
+    networking_registerhandler(dht_get_net(dht), NET_PACKET_CRYPTO_DATA, &udp_handle_packet, temp);
 
     bs_list_init(&temp->ip_port_list, sizeof(IP_Port), 8);
 
     return temp;
 }
 
-static void kill_timedout(Net_Crypto *c)
+static void kill_timedout(Net_Crypto *c, void *userdata)
 {
     uint32_t i;
     //uint64_t temp_time = current_time_monotonic();
@@ -2656,24 +2983,30 @@ static void kill_timedout(Net_Crypto *c)
     for (i = 0; i < c->crypto_connections_length; ++i) {
         Crypto_Connection *conn = get_crypto_connection(c, i);
 
-        if (conn == 0)
-            return;
+        if (conn == nullptr) {
+            continue;
+        }
 
-        if (conn->status == CRYPTO_CONN_NO_CONNECTION)
+        if (conn->status == CRYPTO_CONN_NO_CONNECTION) {
             continue;
+        }
 
         if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING || conn->status == CRYPTO_CONN_HANDSHAKE_SENT
                 || conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
-            if (conn->temp_packet_num_sent < MAX_NUM_SENDPACKET_TRIES)
+            if (conn->temp_packet_num_sent < MAX_NUM_SENDPACKET_TRIES) {
                 continue;
+            }
 
-            connection_kill(c, i);
-
+            connection_kill(c, i, userdata);
         }
 
+#if 0
+
         if (conn->status == CRYPTO_CONN_ESTABLISHED) {
-            //TODO: add a timeout here?
+            // TODO(irungentoo): add a timeout here?
         }
+
+#endif
     }
 }
 
@@ -2685,11 +3018,11 @@ uint32_t crypto_run_interval(const Net_Crypto *c)
 }
 
 /* Main loop. */
-void do_net_crypto(Net_Crypto *c)
+void do_net_crypto(Net_Crypto *c, void *userdata)
 {
     unix_time_update();
-    kill_timedout(c);
-    do_tcp(c);
+    kill_timedout(c, userdata);
+    do_tcp(c, userdata);
     send_crypto_packets(c);
 }
 
@@ -2706,10 +3039,10 @@ void kill_net_crypto(Net_Crypto *c)
 
     kill_tcp_connections(c->tcp_c);
     bs_list_free(&c->ip_port_list);
-    networking_registerhandler(c->dht->net, NET_PACKET_COOKIE_REQUEST, NULL, NULL);
-    networking_registerhandler(c->dht->net, NET_PACKET_COOKIE_RESPONSE, NULL, NULL);
-    networking_registerhandler(c->dht->net, NET_PACKET_CRYPTO_HS, NULL, NULL);
-    networking_registerhandler(c->dht->net, NET_PACKET_CRYPTO_DATA, NULL, NULL);
-    sodium_memzero(c, sizeof(Net_Crypto));
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_COOKIE_REQUEST, nullptr, nullptr);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_COOKIE_RESPONSE, nullptr, nullptr);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_CRYPTO_HS, nullptr, nullptr);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_CRYPTO_DATA, nullptr, nullptr);
+    crypto_memzero(c, sizeof(Net_Crypto));
     free(c);
 }
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index c9554bfc..ec55bf6f 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -1,32 +1,34 @@
-/* net_crypto.h
- *
+/*
  * Functions for the core network crypto.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef NET_CRYPTO_H
 #define NET_CRYPTO_H
 
 #include "DHT.h"
 #include "LAN_discovery.h"
 #include "TCP_connection.h"
+#include "logger.h"
+
 #include <pthread.h>
 
 #define CRYPTO_CONN_NO_CONNECTION 0
@@ -47,7 +49,7 @@
 /* Maximum total size of packets that net_crypto sends. */
 #define MAX_CRYPTO_PACKET_SIZE 1400
 
-#define CRYPTO_DATA_PACKET_MIN_SIZE (1 + sizeof(uint16_t) + (sizeof(uint32_t) + sizeof(uint32_t)) + crypto_box_MACBYTES)
+#define CRYPTO_DATA_PACKET_MIN_SIZE (1 + sizeof(uint16_t) + (sizeof(uint32_t) + sizeof(uint32_t)) + CRYPTO_MAC_SIZE)
 
 /* Max size of data in packets */
 #define MAX_CRYPTO_DATA_SIZE (MAX_CRYPTO_PACKET_SIZE - CRYPTO_DATA_PACKET_MIN_SIZE)
@@ -60,7 +62,7 @@
 #define MAX_NUM_SENDPACKET_TRIES 8
 
 /* The timeout of no received UDP packets before the direct UDP connection is considered dead. */
-#define UDP_DIRECT_TIMEOUT ((MAX_NUM_SENDPACKET_TRIES * CRYPTO_SEND_PACKET_INTERVAL) / 1000)
+#define UDP_DIRECT_TIMEOUT 8
 
 #define PACKET_ID_PADDING 0 /* Denotes padding */
 #define PACKET_ID_REQUEST 1 /* Used to request unreceived packets */
@@ -87,136 +89,23 @@
 #define DEFAULT_PING_CONNECTION 1000
 #define DEFAULT_TCP_PING_CONNECTION 500
 
-typedef struct {
-    uint64_t sent_time;
-    uint16_t length;
-    uint8_t data[MAX_CRYPTO_DATA_SIZE];
-} Packet_Data;
-
-typedef struct {
-    Packet_Data *buffer[CRYPTO_PACKET_BUFFER_SIZE];
-    uint32_t  buffer_start;
-    uint32_t  buffer_end; /* packet numbers in array: {buffer_start, buffer_end) */
-} Packets_Array;
-
-typedef struct {
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* The real public key of the peer. */
-    uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* Nonce of received packets. */
-    uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* Nonce of sent packets. */
-    uint8_t sessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* Our public key for this session. */
-    uint8_t sessionsecret_key[crypto_box_SECRETKEYBYTES]; /* Our private key for this session. */
-    uint8_t peersessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* The public key of the peer. */
-    uint8_t shared_key[crypto_box_BEFORENMBYTES]; /* The precomputed shared key from encrypt_precompute. */
-    uint8_t status; /* 0 if no connection, 1 we are sending cookie request packets,
-                     * 2 if we are sending handshake packets
-                     * 3 if connection is not confirmed yet (we have received a handshake but no data packets yet),
-                     * 4 if the connection is established.
-                     */
-    uint64_t cookie_request_number; /* number used in the cookie request packets for this connection */
-    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES]; /* The dht public key of the peer */
-
-    uint8_t *temp_packet; /* Where the cookie request/handshake packet is stored while it is being sent. */
-    uint16_t temp_packet_length;
-    uint64_t temp_packet_sent_time; /* The time at which the last temp_packet was sent in ms. */
-    uint32_t temp_packet_num_sent;
-
-    IP_Port ip_portv4; /* The ip and port to contact this guy directly.*/
-    IP_Port ip_portv6;
-    uint64_t direct_lastrecv_timev4; /* The Time at which we last received a direct packet in ms. */
-    uint64_t direct_lastrecv_timev6;
-
-    uint64_t last_tcp_sent; /* Time the last TCP packet was sent. */
-
-    Packets_Array send_array;
-    Packets_Array recv_array;
-
-    int (*connection_status_callback)(void *object, int id, uint8_t status);
-    void *connection_status_callback_object;
-    int connection_status_callback_id;
-
-    int (*connection_data_callback)(void *object, int id, uint8_t *data, uint16_t length);
-    void *connection_data_callback_object;
-    int connection_data_callback_id;
-
-    int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
-    void *connection_lossy_data_callback_object;
-    int connection_lossy_data_callback_id;
-
-    uint64_t last_request_packet_sent;
-    uint64_t direct_send_attempt_time;
-
-    uint32_t packet_counter;
-    double packet_recv_rate;
-    uint64_t packet_counter_set;
-
-    double packet_send_rate;
-    uint32_t packets_left;
-    uint64_t last_packets_left_set;
-    double last_packets_left_rem;
-
-    double packet_send_rate_requested;
-    uint32_t packets_left_requested;
-    uint64_t last_packets_left_requested_set;
-    double last_packets_left_requested_rem;
-
-    uint32_t last_sendqueue_size[CONGESTION_QUEUE_ARRAY_SIZE], last_sendqueue_counter;
-    long signed int last_num_packets_sent[CONGESTION_LAST_SENT_ARRAY_SIZE],
-         last_num_packets_resent[CONGESTION_LAST_SENT_ARRAY_SIZE];
-    uint32_t packets_sent, packets_resent;
-    uint64_t last_congestion_event;
-    uint64_t rtt_time;
-
-    /* TCP_connection connection_number */
-    unsigned int connection_number_tcp;
-
-    uint8_t maximum_speed_reached;
-
-    pthread_mutex_t mutex;
-
-    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key);
-    void *dht_pk_callback_object;
-    uint32_t dht_pk_callback_number;
-} Crypto_Connection;
-
-typedef struct {
+typedef struct Net_Crypto Net_Crypto;
+
+const uint8_t *nc_get_self_public_key(const Net_Crypto *c);
+const uint8_t *nc_get_self_secret_key(const Net_Crypto *c);
+TCP_Connections *nc_get_tcp_c(const Net_Crypto *c);
+DHT *nc_get_dht(const Net_Crypto *c);
+
+typedef struct New_Connection {
     IP_Port source;
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* The real public key of the peer. */
-    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES]; /* The dht public key of the peer. */
-    uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* Nonce of received packets. */
-    uint8_t peersessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* The public key of the peer. */
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The real public key of the peer. */
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The dht public key of the peer. */
+    uint8_t recv_nonce[CRYPTO_NONCE_SIZE]; /* Nonce of received packets. */
+    uint8_t peersessionpublic_key[CRYPTO_PUBLIC_KEY_SIZE]; /* The public key of the peer. */
     uint8_t *cookie;
     uint8_t cookie_length;
 } New_Connection;
 
-typedef struct {
-    DHT *dht;
-    TCP_Connections *tcp_c;
-
-    Crypto_Connection *crypto_connections;
-    pthread_mutex_t tcp_mutex;
-
-    pthread_mutex_t connections_mutex;
-    unsigned int connection_use_counter;
-
-    uint32_t crypto_connections_length; /* Length of connections array. */
-
-    /* Our public and secret keys. */
-    uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
-
-    /* The secret key used for cookies */
-    uint8_t secret_symmetric_key[crypto_box_KEYBYTES];
-
-    int (*new_connection_callback)(void *object, New_Connection *n_c);
-    void *new_connection_callback_object;
-
-    /* The current optimal sleep time */
-    uint32_t current_sleep_time;
-
-    BS_LIST ip_port_list;
-} Net_Crypto;
-
-
 /* Set function to be called when someone requests a new connection to us.
  *
  * The set function should return -1 on failure and 0 on success.
@@ -248,7 +137,7 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
  * return -1 on failure.
  * return 0 on success.
  */
-int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, _Bool connected);
+int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, bool connected);
 
 /* Set function to be called when connection with crypt_connection_id goes connects/disconnects.
  *
@@ -261,7 +150,7 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
  * return 0 on success.
  */
 int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
-                              int (*connection_status_callback)(void *object, int id, uint8_t status), void *object, int id);
+                              int (*connection_status_callback)(void *object, int id, uint8_t status, void *userdata), void *object, int id);
 
 /* Set function to be called when connection with crypt_connection_id receives a lossless data packet of length.
  *
@@ -272,7 +161,7 @@ int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
  * return 0 on success.
  */
 int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
-                            int id, uint8_t *data, uint16_t length), void *object, int id);
+                            int id, const uint8_t *data, uint16_t length, void *userdata), void *object, int id);
 
 
 /* Set function to be called when connection with crypt_connection_id receives a lossy data packet of length.
@@ -284,7 +173,8 @@ int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*
  * return 0 on success.
  */
 int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
-                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
+                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length, void *userdata),
+                                  void *object,
                                   int id);
 
 /* Set the function for this friend that will be callbacked with object and number if
@@ -298,7 +188,7 @@ int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
  * return 0 on success.
  */
 int nc_dht_pk_callback(Net_Crypto *c, int crypt_connection_id, void (*function)(void *data, int32_t number,
-                       const uint8_t *dht_public_key), void *object, uint32_t number);
+                       const uint8_t *dht_public_key, void *userdata), void *object, uint32_t number);
 
 /* returns the number of packet slots left in the sendbuffer.
  * return 0 if failure.
@@ -308,7 +198,7 @@ uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connecti
 /* Return 1 if max speed was reached for this connection (no more data can be physically through the pipe).
  * Return 0 if it wasn't reached.
  */
-_Bool max_speed_reached(Net_Crypto *c, int crypt_connection_id);
+bool max_speed_reached(Net_Crypto *c, int crypt_connection_id);
 
 /* Sends a lossless cryptopacket.
  *
@@ -364,7 +254,7 @@ int get_random_tcp_con_number(Net_Crypto *c);
  * return 0 on success.
  * return -1 on failure.
  */
-int send_tcp_onion_request(Net_Crypto *c, unsigned int TCP_conn_number, const uint8_t *data, uint16_t length);
+int send_tcp_onion_request(Net_Crypto *c, unsigned int tcp_connections_number, const uint8_t *data, uint16_t length);
 
 /* Copy a maximum of num TCP relays we are connected to to tcp_relays.
  * NOTE that the family of the copied ip ports will be set to TCP_INET or TCP_INET6.
@@ -386,7 +276,7 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id);
  * sets direct_connected to 1 if connection connects directly to other, 0 if it isn't.
  * sets online_tcp_relays to the number of connected tcp relays this connection has.
  */
-unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, _Bool *direct_connected,
+unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, bool *direct_connected,
                                       unsigned int *online_tcp_relays);
 
 /* Generate our public and private keys.
@@ -395,26 +285,26 @@ unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_
 void new_keys(Net_Crypto *c);
 
 /* Save the public and private keys to the keys array.
- *  Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
+ *  Length must be CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE.
  */
 void save_keys(const Net_Crypto *c, uint8_t *keys);
 
 /* Load the secret key.
- * Length must be crypto_box_SECRETKEYBYTES.
+ * Length must be CRYPTO_SECRET_KEY_SIZE.
  */
 void load_secret_key(Net_Crypto *c, const uint8_t *sk);
 
 /* Create new instance of Net_Crypto.
  *  Sets all the global connection variables to their default values.
  */
-Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info);
+Net_Crypto *new_net_crypto(Logger *log, DHT *dht, TCP_Proxy_Info *proxy_info);
 
 /* return the optimal interval in ms for running do_net_crypto.
  */
 uint32_t crypto_run_interval(const Net_Crypto *c);
 
 /* Main loop. */
-void do_net_crypto(Net_Crypto *c);
+void do_net_crypto(Net_Crypto *c, void *userdata);
 
 void kill_net_crypto(Net_Crypto *c);
 
diff --git a/toxcore/network.c b/toxcore/network.c
index c6cf6ed4..44ca2dee 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -1,63 +1,113 @@
-/* network.c
- *
+/*
  * Functions for the core networking.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef __APPLE__
+#define _DARWIN_C_SOURCE
+#endif
 
-#if (_WIN32_WINNT >= _WIN32_WINNT_WINXP)
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
+
+#if defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_WINXP
+#undef _WIN32_WINNT
 #define _WIN32_WINNT  0x501
 #endif
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
+#if !defined(OS_WIN32) && (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+#define OS_WIN32
 #endif
 
-#include "logger.h"
+#ifdef OS_WIN32
+#ifndef WINVER
+//Windows XP
+#define WINVER 0x0501
+#endif
+#endif
 
-#if !defined(_WIN32) && !defined(__WIN32__) && !defined (WIN32)
-#include <errno.h>
+#ifdef PLAN9
+#include <u.h> // Plan 9 requires this is imported first
+// Comment line here to avoid reordering by source code formatters.
+#include <libc.h>
+#endif
+
+#ifdef OS_WIN32 /* Put win32 includes here */
+// The mingw32/64 Windows library warns about including winsock2.h after
+// windows.h even though with the above it's a valid thing to do. So, to make
+// mingw32 headers happy, we include winsock2.h first.
+#include <winsock2.h>
+// Comment line here to avoid reordering by source code formatters.
+#include <windows.h>
+#include <ws2tcpip.h>
 #endif
 
+#include "network.h"
+
 #ifdef __APPLE__
 #include <mach/clock.h>
 #include <mach/mach.h>
 #endif
 
-#include "network.h"
-#include "util.h"
+#if !defined(OS_WIN32)
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define TOX_EWOULDBLOCK EWOULDBLOCK
+
+#else
+#ifndef IPV6_V6ONLY
+#define IPV6_V6ONLY 27
+#endif
 
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#define TOX_EWOULDBLOCK WSAEWOULDBLOCK
 
-static const char *inet_ntop(sa_family_t family, void *addr, char *buf, size_t bufsize)
+static const char *inet_ntop(int family, const void *addr, char *buf, size_t bufsize)
 {
     if (family == AF_INET) {
         struct sockaddr_in saddr;
         memset(&saddr, 0, sizeof(saddr));
 
         saddr.sin_family = AF_INET;
-        saddr.sin_addr = *(struct in_addr *)addr;
+        saddr.sin_addr = *(const struct in_addr *)addr;
 
         DWORD len = bufsize;
 
-        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
-            return NULL;
+        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), nullptr, buf, &len)) {
+            return nullptr;
+        }
 
         return buf;
     } else if (family == AF_INET6) {
@@ -65,20 +115,21 @@ static const char *inet_ntop(sa_family_t family, void *addr, char *buf, size_t b
         memset(&saddr, 0, sizeof(saddr));
 
         saddr.sin6_family = AF_INET6;
-        saddr.sin6_addr = *(struct in6_addr *)addr;
+        saddr.sin6_addr = *(const struct in6_addr *)addr;
 
         DWORD len = bufsize;
 
-        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), NULL, buf, &len))
-            return NULL;
+        if (WSAAddressToString((LPSOCKADDR)&saddr, sizeof(saddr), nullptr, buf, &len)) {
+            return nullptr;
+        }
 
         return buf;
     }
 
-    return NULL;
+    return nullptr;
 }
 
-static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
+static int inet_pton(int family, const char *addrString, void *addrbuf)
 {
     if (family == AF_INET) {
         struct sockaddr_in saddr;
@@ -86,8 +137,9 @@ static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
 
         INT len = sizeof(saddr);
 
-        if (WSAStringToAddress((LPTSTR)addrString, AF_INET, NULL, (LPSOCKADDR)&saddr, &len))
+        if (WSAStringToAddress((LPTSTR)addrString, AF_INET, nullptr, (LPSOCKADDR)&saddr, &len)) {
             return 0;
+        }
 
         *(struct in_addr *)addrbuf = saddr.sin_addr;
 
@@ -98,8 +150,9 @@ static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
 
         INT len = sizeof(saddr);
 
-        if (WSAStringToAddress((LPTSTR)addrString, AF_INET6, NULL, (LPSOCKADDR)&saddr, &len))
+        if (WSAStringToAddress((LPTSTR)addrString, AF_INET6, nullptr, (LPSOCKADDR)&saddr, &len)) {
             return 0;
+        }
 
         *(struct in6_addr *)addrbuf = saddr.sin6_addr;
 
@@ -111,34 +164,196 @@ static int inet_pton(sa_family_t family, const char *addrString, void *addrbuf)
 
 #endif
 
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "logger.h"
+#include "util.h"
+
+// Disable MSG_NOSIGNAL on systems not supporting it, e.g. Windows, FreeBSD
+#if !defined(MSG_NOSIGNAL)
+#define MSG_NOSIGNAL 0
+#endif
+
+#ifndef IPV6_ADD_MEMBERSHIP
+#ifdef IPV6_JOIN_GROUP
+#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+#endif
+#endif
+
+#if TOX_INET6_ADDRSTRLEN < INET6_ADDRSTRLEN
+#error TOX_INET6_ADDRSTRLEN should be greater or equal to INET6_ADDRSTRLEN (#INET6_ADDRSTRLEN)
+#endif
+
+#if TOX_INET_ADDRSTRLEN < INET_ADDRSTRLEN
+#error TOX_INET_ADDRSTRLEN should be greater or equal to INET_ADDRSTRLEN (#INET_ADDRSTRLEN)
+#endif
+
+static int make_proto(int proto);
+static int make_socktype(int type);
+
+static int make_family(Family tox_family)
+{
+    switch (tox_family.value) {
+        case TOX_AF_INET:
+            return AF_INET;
+
+        case TOX_AF_INET6:
+            return AF_INET6;
+
+        case TOX_AF_UNSPEC:
+            return AF_UNSPEC;
+
+        default:
+            return tox_family.value;
+    }
+}
+
+static const Family *make_tox_family(int family)
+{
+    switch (family) {
+        case AF_INET:
+            return &net_family_ipv4;
+
+        case AF_INET6:
+            return &net_family_ipv6;
+
+        case AF_UNSPEC:
+            return &net_family_unspec;
+
+        default:
+            return nullptr;
+    }
+}
+
+static void get_ip4(IP4 *result, const struct in_addr *addr)
+{
+    result->uint32 = addr->s_addr;
+}
+
+static void get_ip6(IP6 *result, const struct in6_addr *addr)
+{
+    assert(sizeof(result->uint8) == sizeof(addr->s6_addr));
+    memcpy(result->uint8, addr->s6_addr, sizeof(result->uint8));
+}
+
+static void fill_addr4(IP4 ip, struct in_addr *addr)
+{
+    addr->s_addr = ip.uint32;
+}
+
+static void fill_addr6(IP6 ip, struct in6_addr *addr)
+{
+    assert(sizeof(ip.uint8) == sizeof(addr->s6_addr));
+    memcpy(addr->s6_addr, ip.uint8, sizeof(ip.uint8));
+}
+
+#if !defined(INADDR_LOOPBACK)
+#define INADDR_LOOPBACK 0x7f000001
+#endif
+
+const IP4 IP4_BROADCAST = { INADDR_BROADCAST };
+const IP6 IP6_BROADCAST = {
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+IP4 get_ip4_loopback(void)
+{
+    IP4 loopback;
+    loopback.uint32 = htonl(INADDR_LOOPBACK);
+    return loopback;
+}
+
+IP6 get_ip6_loopback(void)
+{
+    IP6 loopback;
+    get_ip6(&loopback, &in6addr_loopback);
+    return loopback;
+}
+
+const Socket net_invalid_socket = {
+#ifdef OS_WIN32
+    (int)INVALID_SOCKET,
+#else
+    -1,
+#endif
+};
+
+const Family net_family_unspec = {TOX_AF_UNSPEC};
+const Family net_family_ipv4 = {TOX_AF_INET};
+const Family net_family_ipv6 = {TOX_AF_INET6};
+const Family net_family_tcp_family = {TCP_FAMILY};
+const Family net_family_tcp_onion = {TCP_ONION_FAMILY};
+const Family net_family_tcp_ipv4 = {TCP_INET};
+const Family net_family_tcp_ipv6 = {TCP_INET6};
+const Family net_family_tox_tcp_ipv4 = {TOX_TCP_INET};
+const Family net_family_tox_tcp_ipv6 = {TOX_TCP_INET6};
+
+bool net_family_is_unspec(Family family)
+{
+    return family.value == net_family_unspec.value;
+}
+
+bool net_family_is_ipv4(Family family)
+{
+    return family.value == net_family_ipv4.value;
+}
+
+bool net_family_is_ipv6(Family family)
+{
+    return family.value == net_family_ipv6.value;
+}
+
+bool net_family_is_tcp_family(Family family)
+{
+    return family.value == net_family_tcp_family.value;
+}
+
+bool net_family_is_tcp_onion(Family family)
+{
+    return family.value == net_family_tcp_onion.value;
+}
+
+bool net_family_is_tcp_ipv4(Family family)
+{
+    return family.value == net_family_tcp_ipv4.value;
+}
+
+bool net_family_is_tcp_ipv6(Family family)
+{
+    return family.value == net_family_tcp_ipv6.value;
+}
+
+bool net_family_is_tox_tcp_ipv4(Family family)
+{
+    return family.value == net_family_tox_tcp_ipv4.value;
+}
+
+bool net_family_is_tox_tcp_ipv6(Family family)
+{
+    return family.value == net_family_tox_tcp_ipv6.value;
+}
+
 /* Check if socket is valid.
  *
  * return 1 if valid
  * return 0 if not valid
  */
-int sock_valid(sock_t sock)
+int sock_valid(Socket sock)
 {
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-
-    if (sock == INVALID_SOCKET) {
-#else
-
-    if (sock < 0) {
-#endif
-        return 0;
-    }
-
-    return 1;
+    return sock.socket != net_invalid_socket.socket;
 }
 
 /* Close the socket.
  */
-void kill_sock(sock_t sock)
+void kill_sock(Socket sock)
 {
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-    closesocket(sock);
+#ifdef OS_WIN32
+    closesocket(sock.socket);
 #else
-    close(sock);
+    close(sock.socket);
 #endif
 }
 
@@ -147,13 +362,13 @@ void kill_sock(sock_t sock)
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_nonblock(sock_t sock)
+int set_socket_nonblock(Socket sock)
 {
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
     u_long mode = 1;
-    return (ioctlsocket(sock, FIONBIO, &mode) == 0);
+    return (ioctlsocket(sock.socket, FIONBIO, &mode) == 0);
 #else
-    return (fcntl(sock, F_SETFL, O_NONBLOCK, 1) == 0);
+    return (fcntl(sock.socket, F_SETFL, O_NONBLOCK, 1) == 0);
 #endif
 }
 
@@ -162,11 +377,11 @@ int set_socket_nonblock(sock_t sock)
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_nosigpipe(sock_t sock)
+int set_socket_nosigpipe(Socket sock)
 {
-#if defined(__MACH__)
+#if defined(__APPLE__)
     int set = 1;
-    return (setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int)) == 0);
+    return setsockopt(sock.socket, SOL_SOCKET, SO_NOSIGPIPE, (const char *)&set, sizeof(int)) == 0;
 #else
     return 1;
 #endif
@@ -177,10 +392,10 @@ int set_socket_nosigpipe(sock_t sock)
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_reuseaddr(sock_t sock)
+int set_socket_reuseaddr(Socket sock)
 {
     int set = 1;
-    return (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&set, sizeof(set)) == 0);
+    return setsockopt(sock.socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&set, sizeof(set)) == 0;
 }
 
 /* Set socket to dual (IPv4 + IPv6 socket)
@@ -188,17 +403,18 @@ int set_socket_reuseaddr(sock_t sock)
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_dualstack(sock_t sock)
+int set_socket_dualstack(Socket sock)
 {
     int ipv6only = 0;
     socklen_t optsize = sizeof(ipv6only);
-    int res = getsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&ipv6only, &optsize);
+    int res = getsockopt(sock.socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, &optsize);
 
-    if ((res == 0) && (ipv6only == 0))
+    if ((res == 0) && (ipv6only == 0)) {
         return 1;
+    }
 
     ipv6only = 0;
-    return (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&ipv6only, sizeof(ipv6only)) == 0);
+    return setsockopt(sock.socket, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&ipv6only, sizeof(ipv6only)) == 0;
 }
 
 
@@ -206,7 +422,7 @@ int set_socket_dualstack(sock_t sock)
 static uint64_t current_time_actual(void)
 {
     uint64_t time;
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
     /* This probably works fine */
     FILETIME ft;
     GetSystemTimeAsFileTime(&ft);
@@ -217,14 +433,14 @@ static uint64_t current_time_actual(void)
     return time / 10;
 #else
     struct timeval a;
-    gettimeofday(&a, NULL);
+    gettimeofday(&a, nullptr);
     time = 1000000ULL * a.tv_sec + a.tv_usec;
     return time;
 #endif
 }
 
 
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
 static uint64_t last_monotime;
 static uint64_t add_monotime;
 #endif
@@ -233,12 +449,17 @@ static uint64_t add_monotime;
 uint64_t current_time_monotonic(void)
 {
     uint64_t time;
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
+    uint64_t old_add_monotime = add_monotime;
     time = (uint64_t)GetTickCount() + add_monotime;
 
-    if (time < last_monotime) { /* Prevent time from ever decreasing because of 32 bit wrap. */
+    /* Check if time has decreased because of 32 bit wrap from GetTickCount(), while avoiding false positives from race
+     * conditions when multiple threads call this function at once */
+    if (time + 0x10000 < last_monotime) {
         uint32_t add = ~0;
-        add_monotime += add;
+        /* use old_add_monotime rather than simply incrementing add_monotime, to handle the case that many threads
+         * simultaneously detect an overflow */
+        add_monotime = old_add_monotime + add;
         time += add;
     }
 
@@ -265,92 +486,127 @@ uint64_t current_time_monotonic(void)
     return time;
 }
 
-/* In case no logging */
-#ifndef TOX_LOGGER
-#define loglogdata(__message__, __buffer__, __buflen__, __ip_port__, __res__)
-#else
-#define data_0(__buflen__, __buffer__) __buflen__ > 4 ? ntohl(*(uint32_t *)&__buffer__[1]) : 0
-#define data_1(__buflen__, __buffer__) __buflen__ > 7 ? ntohl(*(uint32_t *)&__buffer__[5]) : 0
-
-#define loglogdata(__message__, __buffer__, __buflen__, __ip_port__, __res__) \
-    (__ip_port__) .ip; \
-    if (__res__ < 0) /* Windows doesn't necessarily know %zu */ \
-        LOGGER_TRACE("[%2u] %s %3hu%c %s:%hu (%u: %s) | %04x%04x", \
-                 __buffer__[0], __message__, (__buflen__ < 999 ? (uint16_t)__buflen__ : 999), 'E', \
-                 ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), errno, strerror(errno), data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__)); \
-    else if ((__res__ > 0) && ((size_t)__res__ <= __buflen__)) \
-        LOGGER_TRACE("[%2u] %s %3zu%c %s:%hu (%u: %s) | %04x%04x", \
-                 __buffer__[0], __message__, (__res__ < 999 ? (size_t)__res__ : 999), ((size_t)__res__ < __buflen__ ? '<' : '='), \
-                 ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), 0, "OK", data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__)); \
-    else /* empty or overwrite */ \
-        LOGGER_TRACE("[%2u] %s %zu%c%zu %s:%hu (%u: %s) | %04x%04x", \
-                 __buffer__[0], __message__, (size_t)__res__, (!__res__ ? '!' : '>'), __buflen__, \
-                 ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), 0, "OK", data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__));
-
-#endif /* TOX_LOGGER */
+static uint32_t data_0(uint16_t buflen, const uint8_t *buffer)
+{
+    return buflen > 4 ? net_ntohl(*(const uint32_t *)&buffer[1]) : 0;
+}
+static uint32_t data_1(uint16_t buflen, const uint8_t *buffer)
+{
+    return buflen > 7 ? net_ntohl(*(const uint32_t *)&buffer[5]) : 0;
+}
+
+static void loglogdata(Logger *log, const char *message, const uint8_t *buffer,
+                       uint16_t buflen, IP_Port ip_port, int res)
+{
+    char ip_str[IP_NTOA_LEN];
+
+    if (res < 0) { /* Windows doesn't necessarily know %zu */
+        int error = net_error();
+        const char *strerror = net_new_strerror(error);
+        LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, (buflen < 999 ? buflen : 999), 'E',
+                     ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), error,
+                     strerror, data_0(buflen, buffer), data_1(buflen, buffer));
+        net_kill_strerror(strerror);
+    } else if ((res > 0) && ((size_t)res <= buflen)) {
+        LOGGER_TRACE(log, "[%2u] %s %3u%c %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, (res < 999 ? res : 999), ((size_t)res < buflen ? '<' : '='),
+                     ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), 0, "OK",
+                     data_0(buflen, buffer), data_1(buflen, buffer));
+    } else { /* empty or overwrite */
+        LOGGER_TRACE(log, "[%2u] %s %u%c%u %s:%u (%u: %s) | %04x%04x",
+                     buffer[0], message, res, (!res ? '!' : '>'), buflen,
+                     ip_ntoa(&ip_port.ip, ip_str, sizeof(ip_str)), net_ntohs(ip_port.port), 0, "OK",
+                     data_0(buflen, buffer), data_1(buflen, buffer));
+    }
+}
+
+typedef struct {
+    packet_handler_callback function;
+    void *object;
+} Packet_Handler;
+
+struct Networking_Core {
+    Logger *log;
+    Packet_Handler packethandlers[256];
+
+    Family family;
+    uint16_t port;
+    /* Our UDP socket. */
+    Socket sock;
+};
+
+Family net_family(const Networking_Core *net)
+{
+    return net->family;
+}
+
+uint16_t net_port(const Networking_Core *net)
+{
+    return net->port;
+}
 
 /* Basic network functions:
  * Function to send packet(data) of length length to ip_port.
  */
 int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint16_t length)
 {
-    if (net->family == 0) /* Socket not initialized */
+    if (net_family_is_unspec(net->family)) { /* Socket not initialized */
+        LOGGER_ERROR(net->log, "attempted to send message of length %u on uninitialised socket", (unsigned)length);
         return -1;
+    }
 
-    /* socket AF_INET, but target IP NOT: can't send */
-    if ((net->family == AF_INET) && (ip_port.ip.family != AF_INET))
+    /* socket TOX_AF_INET, but target IP NOT: can't send */
+    if (net_family_is_ipv4(net->family) && !net_family_is_ipv4(ip_port.ip.family)) {
+        LOGGER_ERROR(net->log, "attempted to send message with network family %d (probably IPv6) on IPv4 socket",
+                     ip_port.ip.family.value);
         return -1;
+    }
 
-    struct sockaddr_storage addr;
-    size_t addrsize = 0;
+    if (net_family_is_ipv4(ip_port.ip.family) && net_family_is_ipv6(net->family)) {
+        /* must convert to IPV4-in-IPV6 address */
+        IP6 ip6;
 
-    if (ip_port.ip.family == AF_INET) {
-        if (net->family == AF_INET6) {
-            /* must convert to IPV4-in-IPV6 address */
-            struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+        /* there should be a macro for this in a standards compliant
+         * environment, not found */
+        ip6.uint32[0] = 0;
+        ip6.uint32[1] = 0;
+        ip6.uint32[2] = net_htonl(0xFFFF);
+        ip6.uint32[3] = ip_port.ip.ip.v4.uint32;
 
-            addrsize = sizeof(struct sockaddr_in6);
-            addr6->sin6_family = AF_INET6;
-            addr6->sin6_port = ip_port.port;
+        ip_port.ip.family = net_family_ipv6;
+        ip_port.ip.ip.v6 = ip6;
+    }
 
-            /* there should be a macro for this in a standards compliant
-             * environment, not found */
-            IP6 ip6;
+    struct sockaddr_storage addr;
 
-            ip6.uint32[0] = 0;
-            ip6.uint32[1] = 0;
-            ip6.uint32[2] = htonl(0xFFFF);
-            ip6.uint32[3] = ip_port.ip.ip4.uint32;
-            addr6->sin6_addr = ip6.in6_addr;
+    size_t addrsize;
 
-            addr6->sin6_flowinfo = 0;
-            addr6->sin6_scope_id = 0;
-        } else {
-            struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        struct sockaddr_in *const addr4 = (struct sockaddr_in *)&addr;
 
-            addrsize = sizeof(struct sockaddr_in);
-            addr4->sin_family = AF_INET;
-            addr4->sin_addr = ip_port.ip.ip4.in_addr;
-            addr4->sin_port = ip_port.port;
-        }
-    } else if (ip_port.ip.family == AF_INET6) {
-        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+        addrsize = sizeof(struct sockaddr_in);
+        addr4->sin_family = AF_INET;
+        addr4->sin_port = ip_port.port;
+        fill_addr4(ip_port.ip.ip.v4, &addr4->sin_addr);
+    } else if (net_family_is_ipv6(ip_port.ip.family)) {
+        struct sockaddr_in6 *const addr6 = (struct sockaddr_in6 *)&addr;
 
         addrsize = sizeof(struct sockaddr_in6);
         addr6->sin6_family = AF_INET6;
         addr6->sin6_port = ip_port.port;
-        addr6->sin6_addr = ip_port.ip.ip6.in6_addr;
+        fill_addr6(ip_port.ip.ip.v6, &addr6->sin6_addr);
 
         addr6->sin6_flowinfo = 0;
         addr6->sin6_scope_id = 0;
     } else {
-        /* unknown address type*/
+        LOGGER_WARNING(net->log, "unknown address type: %d", ip_port.ip.family.value);
         return -1;
     }
 
-    int res = sendto(net->sock, (char *) data, length, 0, (struct sockaddr *)&addr, addrsize);
+    const int res = sendto(net->sock.socket, (const char *) data, length, 0, (struct sockaddr *)&addr, addrsize);
 
-    loglogdata("O=>", data, length, ip_port, res);
+    loglogdata(net->log, "O=>", data, length, ip_port, res);
 
     return res;
 }
@@ -360,22 +616,26 @@ int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint1
  *  Packet data is put into data.
  *  Packet length is put into length.
  */
-static int receivepacket(sock_t sock, IP_Port *ip_port, uint8_t *data, uint32_t *length)
+static int receivepacket(Logger *log, Socket sock, IP_Port *ip_port, uint8_t *data, uint32_t *length)
 {
     memset(ip_port, 0, sizeof(IP_Port));
     struct sockaddr_storage addr;
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
     int addrlen = sizeof(addr);
 #else
     socklen_t addrlen = sizeof(addr);
 #endif
     *length = 0;
-    int fail_or_len = recvfrom(sock, (char *) data, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrlen);
+    int fail_or_len = recvfrom(sock.socket, (char *) data, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrlen);
 
     if (fail_or_len < 0) {
+        int error = net_error();
 
-        LOGGER_SCOPE( if ((fail_or_len < 0) && (errno != EWOULDBLOCK))
-                      LOGGER_ERROR("Unexpected error reading from socket: %u, %s\n", errno, strerror(errno)); );
+        if (fail_or_len < 0 && error != TOX_EWOULDBLOCK) {
+            const char *strerror = net_new_strerror(error);
+            LOGGER_ERROR(log, "Unexpected error reading from socket: %u, %s", error, strerror);
+            net_kill_strerror(strerror);
+        }
 
         return -1; /* Nothing received. */
     }
@@ -385,23 +645,38 @@ static int receivepacket(sock_t sock, IP_Port *ip_port, uint8_t *data, uint32_t
     if (addr.ss_family == AF_INET) {
         struct sockaddr_in *addr_in = (struct sockaddr_in *)&addr;
 
-        ip_port->ip.family = addr_in->sin_family;
-        ip_port->ip.ip4.in_addr = addr_in->sin_addr;
+        const Family *const family = make_tox_family(addr_in->sin_family);
+        assert(family != nullptr);
+
+        if (family == nullptr) {
+            return -1;
+        }
+
+        ip_port->ip.family = *family;
+        get_ip4(&ip_port->ip.ip.v4, &addr_in->sin_addr);
         ip_port->port = addr_in->sin_port;
     } else if (addr.ss_family == AF_INET6) {
         struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)&addr;
-        ip_port->ip.family = addr_in6->sin6_family;
-        ip_port->ip.ip6.in6_addr = addr_in6->sin6_addr;
+        const Family *const family = make_tox_family(addr_in6->sin6_family);
+        assert(family != nullptr);
+
+        if (family == nullptr) {
+            return -1;
+        }
+
+        ip_port->ip.family = *family;
+        get_ip6(&ip_port->ip.ip.v6, &addr_in6->sin6_addr);
         ip_port->port = addr_in6->sin6_port;
 
-        if (IPV6_IPV4_IN_V6(ip_port->ip.ip6)) {
-            ip_port->ip.family = AF_INET;
-            ip_port->ip.ip4.uint32 = ip_port->ip.ip6.uint32[3];
+        if (IPV6_IPV4_IN_V6(ip_port->ip.ip.v6)) {
+            ip_port->ip.family = net_family_ipv4;
+            ip_port->ip.ip.v4.uint32 = ip_port->ip.ip.v6.uint32[3];
         }
-    } else
+    } else {
         return -1;
+    }
 
-    loglogdata("=>O", data, MAX_UDP_PACKET_SIZE, *ip_port, *length);
+    loglogdata(log, "=>O", data, MAX_UDP_PACKET_SIZE, *ip_port, *length);
 
     return 0;
 }
@@ -412,10 +687,12 @@ void networking_registerhandler(Networking_Core *net, uint8_t byte, packet_handl
     net->packethandlers[byte].object = object;
 }
 
-void networking_poll(Networking_Core *net)
+void networking_poll(Networking_Core *net, void *userdata)
 {
-    if (net->family == 0) /* Socket not initialized */
+    if (net_family_is_unspec(net->family)) {
+        /* Socket not initialized */
         return;
+    }
 
     unix_time_update();
 
@@ -423,15 +700,17 @@ void networking_poll(Networking_Core *net)
     uint8_t data[MAX_UDP_PACKET_SIZE];
     uint32_t length;
 
-    while (receivepacket(net->sock, &ip_port, data, &length) != -1) {
-        if (length < 1) continue;
+    while (receivepacket(net->log, net->sock, &ip_port, data, &length) != -1) {
+        if (length < 1) {
+            continue;
+        }
 
         if (!(net->packethandlers[data[0]].function)) {
-            LOGGER_WARNING("[%02u] -- Packet has no handler", data[0]);
+            LOGGER_WARNING(net->log, "[%02u] -- Packet has no handler", data[0]);
             continue;
         }
 
-        net->packethandlers[data[0]].function(net->packethandlers[data[0]].object, ip_port, data, length);
+        net->packethandlers[data[0]].function(net->packethandlers[data[0]].object, ip_port, data, length, userdata);
     }
 }
 
@@ -440,27 +719,33 @@ void networking_poll(Networking_Core *net)
 #include <sodium.h>
 #endif
 
-uint8_t at_startup_ran = 0;
+static uint8_t at_startup_ran = 0;
 int networking_at_startup(void)
 {
-    if (at_startup_ran != 0)
+    if (at_startup_ran != 0) {
         return 0;
+    }
 
 #ifndef VANILLA_NACL
 
 #ifdef USE_RANDOMBYTES_STIR
     randombytes_stir();
 #else
-    sodium_init();
+
+    if (sodium_init() == -1) {
+        return -1;
+    }
+
 #endif /*USE_RANDOMBYTES_STIR*/
 
 #endif/*VANILLA_NACL*/
 
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
     WSADATA wsaData;
 
-    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != NO_ERROR)
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != NO_ERROR) {
         return -1;
+    }
 
 #endif
     srand((uint32_t)current_time_actual());
@@ -468,21 +753,22 @@ int networking_at_startup(void)
     return 0;
 }
 
-/* TODO: Put this somewhere
+/* TODO(irungentoo): Put this somewhere */
+#if 0
 static void at_shutdown(void)
 {
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#ifdef OS_WIN32
     WSACleanup();
 #endif
 }
-*/
+#endif
 
 /* Initialize networking.
  * Added for reverse compatibility with old new_networking calls.
  */
-Networking_Core *new_networking(IP ip, uint16_t port)
+Networking_Core *new_networking(Logger *log, IP ip, uint16_t port)
 {
-    return new_networking_ex(ip, port, port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM), 0);
+    return new_networking_ex(log, ip, port, port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM), nullptr);
 }
 
 /* Initialize networking.
@@ -495,7 +781,7 @@ Networking_Core *new_networking(IP ip, uint16_t port)
  *
  * If error is non NULL it is set to 0 if no issues, 1 if socket related error, 2 if other.
  */
-Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to, unsigned int *error)
+Networking_Core *new_networking_ex(Logger *log, IP ip, uint16_t port_from, uint16_t port_to, unsigned int *error)
 {
     /* If both from and to are 0, use default port range
      * If one is 0 and the other is non-0, use the non-0 value as only port
@@ -514,96 +800,104 @@ Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to,
         port_to = temp;
     }
 
-    if (error)
+    if (error) {
         *error = 2;
+    }
 
     /* maybe check for invalid IPs like 224+.x.y.z? if there is any IP set ever */
-    if (ip.family != AF_INET && ip.family != AF_INET6) {
-#ifdef DEBUG
-        fprintf(stderr, "Invalid address family: %u\n", ip.family);
-#endif
-        return NULL;
+    if (!net_family_is_ipv4(ip.family) && !net_family_is_ipv6(ip.family)) {
+        LOGGER_ERROR(log, "invalid address family: %u\n", ip.family.value);
+        return nullptr;
     }
 
-    if (networking_at_startup() != 0)
-        return NULL;
+    if (networking_at_startup() != 0) {
+        return nullptr;
+    }
 
-    Networking_Core *temp = calloc(1, sizeof(Networking_Core));
+    Networking_Core *temp = (Networking_Core *)calloc(1, sizeof(Networking_Core));
 
-    if (temp == NULL)
-        return NULL;
+    if (temp == nullptr) {
+        return nullptr;
+    }
 
+    temp->log = log;
     temp->family = ip.family;
     temp->port = 0;
 
     /* Initialize our socket. */
     /* add log message what we're creating */
-    temp->sock = socket(temp->family, SOCK_DGRAM, IPPROTO_UDP);
+    temp->sock = net_socket(temp->family, TOX_SOCK_DGRAM, TOX_PROTO_UDP);
 
     /* Check for socket error. */
     if (!sock_valid(temp->sock)) {
-#ifdef DEBUG
-        fprintf(stderr, "Failed to get a socket?! %u, %s\n", errno, strerror(errno));
-#endif
+        int neterror = net_error();
+        const char *strerror = net_new_strerror(neterror);
+        LOGGER_ERROR(log, "Failed to get a socket?! %d, %s", neterror, strerror);
+        net_kill_strerror(strerror);
         free(temp);
 
-        if (error)
+        if (error) {
             *error = 1;
+        }
 
-        return NULL;
+        return nullptr;
     }
 
     /* Functions to increase the size of the send and receive UDP buffers.
      */
     int n = 1024 * 1024 * 2;
-    setsockopt(temp->sock, SOL_SOCKET, SO_RCVBUF, (char *)&n, sizeof(n));
-    setsockopt(temp->sock, SOL_SOCKET, SO_SNDBUF, (char *)&n, sizeof(n));
+    setsockopt(temp->sock.socket, SOL_SOCKET, SO_RCVBUF, (const char *)&n, sizeof(n));
+    setsockopt(temp->sock.socket, SOL_SOCKET, SO_SNDBUF, (const char *)&n, sizeof(n));
 
     /* Enable broadcast on socket */
     int broadcast = 1;
-    setsockopt(temp->sock, SOL_SOCKET, SO_BROADCAST, (char *)&broadcast, sizeof(broadcast));
+    setsockopt(temp->sock.socket, SOL_SOCKET, SO_BROADCAST, (const char *)&broadcast, sizeof(broadcast));
 
     /* iOS UDP sockets are weird and apparently can SIGPIPE */
     if (!set_socket_nosigpipe(temp->sock)) {
         kill_networking(temp);
 
-        if (error)
+        if (error) {
             *error = 1;
+        }
 
-        return NULL;
+        return nullptr;
     }
 
     /* Set socket nonblocking. */
     if (!set_socket_nonblock(temp->sock)) {
         kill_networking(temp);
 
-        if (error)
+        if (error) {
             *error = 1;
+        }
 
-        return NULL;
+        return nullptr;
     }
 
     /* Bind our socket to port PORT and the given IP address (usually 0.0.0.0 or ::) */
-    uint16_t *portptr = NULL;
+    uint16_t *portptr = nullptr;
     struct sockaddr_storage addr;
     size_t addrsize;
 
-    if (temp->family == AF_INET) {
+    memset(&addr, 0, sizeof(struct sockaddr_storage));
+
+    if (net_family_is_ipv4(temp->family)) {
         struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
 
         addrsize = sizeof(struct sockaddr_in);
         addr4->sin_family = AF_INET;
         addr4->sin_port = 0;
-        addr4->sin_addr = ip.ip4.in_addr;
+        fill_addr4(ip.ip.v4, &addr4->sin_addr);
 
         portptr = &addr4->sin_port;
-    } else if (temp->family == AF_INET6) {
+    } else if (net_family_is_ipv6(temp->family)) {
         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
 
         addrsize = sizeof(struct sockaddr_in6);
         addr6->sin6_family = AF_INET6;
         addr6->sin6_port = 0;
-        addr6->sin6_addr = ip.ip6.in6_addr;
+        fill_addr6(ip.ip.v6, &addr6->sin6_addr);
 
         addr6->sin6_flowinfo = 0;
         addr6->sin6_scope_id = 0;
@@ -611,16 +905,13 @@ Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to,
         portptr = &addr6->sin6_port;
     } else {
         free(temp);
-        return NULL;
+        return nullptr;
     }
 
-    if (ip.family == AF_INET6) {
-#ifdef TOX_LOGGER
-        int is_dualstack =
-#endif /* TOX_LOGGER */
-            set_socket_dualstack(temp->sock);
-        LOGGER_DEBUG( "Dual-stack socket: %s",
-                      is_dualstack ? "enabled" : "Failed to enable, won't be able to receive from/send to IPv4 addresses" );
+    if (net_family_is_ipv6(ip.family)) {
+        const int is_dualstack = set_socket_dualstack(temp->sock);
+        LOGGER_DEBUG(log, "Dual-stack socket: %s",
+                     is_dualstack ? "enabled" : "Failed to enable, won't be able to receive from/send to IPv4 addresses");
         /* multicast local nodes */
         struct ipv6_mreq mreq;
         memset(&mreq, 0, sizeof(mreq));
@@ -628,13 +919,13 @@ Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to,
         mreq.ipv6mr_multiaddr.s6_addr[ 1] = 0x02;
         mreq.ipv6mr_multiaddr.s6_addr[15] = 0x01;
         mreq.ipv6mr_interface = 0;
-#ifdef TOX_LOGGER
-        int res =
-#endif /* TOX_LOGGER */
-            setsockopt(temp->sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq));
+        const int res = setsockopt(temp->sock.socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (const char *)&mreq, sizeof(mreq));
 
-        LOGGER_DEBUG(res < 0 ? "Failed to activate local multicast membership. (%u, %s)" :
-                     "Local multicast group FF02::1 joined successfully", errno, strerror(errno) );
+        int neterror = net_error();
+        const char *strerror = net_new_strerror(neterror);
+        LOGGER_DEBUG(log, res < 0 ? "Failed to activate local multicast membership. (%d, %s)" :
+                     "Local multicast group FF02::1 joined successfully", neterror, strerror);
+        net_kill_strerror(strerror);
     }
 
     /* a hanging program or a different user might block the standard port;
@@ -654,59 +945,84 @@ Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to,
      *   it worked ok (which it did previously without a successful bind)
      */
     uint16_t port_to_try = port_from;
-    *portptr = htons(port_to_try);
+    *portptr = net_htons(port_to_try);
     int tries;
 
     for (tries = port_from; tries <= port_to; tries++) {
-        int res = bind(temp->sock, (struct sockaddr *)&addr, addrsize);
+        int res = bind(temp->sock.socket, (struct sockaddr *)&addr, addrsize);
 
         if (!res) {
             temp->port = *portptr;
 
-            LOGGER_DEBUG("Bound successfully to %s:%u", ip_ntoa(&ip), ntohs(temp->port));
+            char ip_str[IP_NTOA_LEN];
+            LOGGER_DEBUG(log, "Bound successfully to %s:%u", ip_ntoa(&ip, ip_str, sizeof(ip_str)),
+                         net_ntohs(temp->port));
 
             /* errno isn't reset on success, only set on failure, the failed
              * binds with parallel clients yield a -EPERM to the outside if
              * errno isn't cleared here */
-            if (tries > 0)
+            if (tries > 0) {
                 errno = 0;
+            }
 
-            if (error)
+            if (error) {
                 *error = 0;
+            }
 
             return temp;
         }
 
         port_to_try++;
 
-        if (port_to_try > port_to)
+        if (port_to_try > port_to) {
             port_to_try = port_from;
+        }
 
-        *portptr = htons(port_to_try);
+        *portptr = net_htons(port_to_try);
     }
 
-    LOGGER_ERROR("Failed to bind socket: %u, %s IP: %s port_from: %u port_to: %u", errno, strerror(errno),
-                 ip_ntoa(&ip), port_from, port_to);
-
+    char ip_str[IP_NTOA_LEN];
+    int neterror = net_error();
+    const char *strerror = net_new_strerror(neterror);
+    LOGGER_ERROR(log, "Failed to bind socket: %d, %s IP: %s port_from: %u port_to: %u", neterror, strerror,
+                 ip_ntoa(&ip, ip_str, sizeof(ip_str)), port_from, port_to);
+    net_kill_strerror(strerror);
     kill_networking(temp);
 
-    if (error)
+    if (error) {
         *error = 1;
+    }
+
+    return nullptr;
+}
 
-    return NULL;
+Networking_Core *new_networking_no_udp(Logger *log)
+{
+    /* this is the easiest way to completely disable UDP without changing too much code. */
+    Networking_Core *net = (Networking_Core *)calloc(1, sizeof(Networking_Core));
+
+    if (net == nullptr) {
+        return nullptr;
+    }
+
+    net->log = log;
+
+    return net;
 }
 
 /* Function to cleanup networking stuff. */
 void kill_networking(Networking_Core *net)
 {
-    if (!net)
+    if (!net) {
         return;
+    }
 
-    if (net->family != 0) /* Socket not initialized */
+    if (!net_family_is_unspec(net->family)) {
+        /* Socket is initialized, so we close it. */
         kill_sock(net->sock);
+    }
 
     free(net);
-    return;
 }
 
 
@@ -718,26 +1034,41 @@ void kill_networking(Networking_Core *net)
  */
 int ip_equal(const IP *a, const IP *b)
 {
-    if (!a || !b)
+    if (!a || !b) {
         return 0;
+    }
 
     /* same family */
-    if (a->family == b->family) {
-        if (a->family == AF_INET)
-            return (a->ip4.in_addr.s_addr == b->ip4.in_addr.s_addr);
-        else if (a->family == AF_INET6)
-            return a->ip6.uint64[0] == b->ip6.uint64[0] && a->ip6.uint64[1] == b->ip6.uint64[1];
-        else
-            return 0;
+    if (a->family.value == b->family.value) {
+        if (net_family_is_ipv4(a->family) || net_family_is_tcp_ipv4(a->family)) {
+            struct in_addr addr_a;
+            struct in_addr addr_b;
+            fill_addr4(a->ip.v4, &addr_a);
+            fill_addr4(b->ip.v4, &addr_b);
+            return addr_a.s_addr == addr_b.s_addr;
+        }
+
+        if (net_family_is_ipv6(a->family) || net_family_is_tcp_ipv6(a->family)) {
+            return a->ip.v6.uint64[0] == b->ip.v6.uint64[0] &&
+                   a->ip.v6.uint64[1] == b->ip.v6.uint64[1];
+        }
+
+        return 0;
     }
 
     /* different family: check on the IPv6 one if it is the IPv4 one embedded */
-    if ((a->family == AF_INET) && (b->family == AF_INET6)) {
-        if (IPV6_IPV4_IN_V6(b->ip6))
-            return (a->ip4.in_addr.s_addr == b->ip6.uint32[3]);
-    } else if ((a->family == AF_INET6)  && (b->family == AF_INET)) {
-        if (IPV6_IPV4_IN_V6(a->ip6))
-            return (a->ip6.uint32[3] == b->ip4.in_addr.s_addr);
+    if (net_family_is_ipv4(a->family) && net_family_is_ipv6(b->family)) {
+        if (IPV6_IPV4_IN_V6(b->ip.v6)) {
+            struct in_addr addr_a;
+            fill_addr4(a->ip.v4, &addr_a);
+            return addr_a.s_addr == b->ip.v6.uint32[3];
+        }
+    } else if (net_family_is_ipv6(a->family) && net_family_is_ipv4(b->family)) {
+        if (IPV6_IPV4_IN_V6(a->ip.v6)) {
+            struct in_addr addr_b;
+            fill_addr4(b->ip.v4, &addr_b);
+            return a->ip.v6.uint32[3] == addr_b.s_addr;
+        }
     }
 
     return 0;
@@ -751,11 +1082,13 @@ int ip_equal(const IP *a, const IP *b)
  */
 int ipport_equal(const IP_Port *a, const IP_Port *b)
 {
-    if (!a || !b)
+    if (!a || !b) {
         return 0;
+    }
 
-    if (!a->port || (a->port != b->port))
+    if (!a->port || (a->port != b->port)) {
         return 0;
+    }
 
     return ip_equal(&a->ip, &b->ip);
 }
@@ -763,39 +1096,44 @@ int ipport_equal(const IP_Port *a, const IP_Port *b)
 /* nulls out ip */
 void ip_reset(IP *ip)
 {
-    if (!ip)
+    if (!ip) {
         return;
+    }
 
     memset(ip, 0, sizeof(IP));
 }
 
 /* nulls out ip, sets family according to flag */
-void ip_init(IP *ip, uint8_t ipv6enabled)
+void ip_init(IP *ip, bool ipv6enabled)
 {
-    if (!ip)
+    if (!ip) {
         return;
+    }
 
     memset(ip, 0, sizeof(IP));
-    ip->family = ipv6enabled ? AF_INET6 : AF_INET;
+    ip->family = ipv6enabled ? net_family_ipv6 : net_family_ipv4;
 }
 
 /* checks if ip is valid */
-int ip_isset(const IP *ip)
+bool ip_isset(const IP *ip)
 {
-    if (!ip)
-        return 0;
+    if (!ip) {
+        return false;
+    }
 
-    return (ip->family != 0);
+    return !net_family_is_unspec(ip->family);
 }
 
 /* checks if ip is valid */
-int ipport_isset(const IP_Port *ipport)
+bool ipport_isset(const IP_Port *ipport)
 {
-    if (!ipport)
-        return 0;
+    if (!ipport) {
+        return false;
+    }
 
-    if (!ipport->port)
-        return 0;
+    if (!ipport->port) {
+        return false;
+    }
 
     return ip_isset(&ipport->ip);
 }
@@ -803,8 +1141,9 @@ int ipport_isset(const IP_Port *ipport)
 /* copies an ip structure (careful about direction!) */
 void ip_copy(IP *target, const IP *source)
 {
-    if (!source || !target)
+    if (!source || !target) {
         return;
+    }
 
     memcpy(target, source, sizeof(IP));
 }
@@ -812,47 +1151,59 @@ void ip_copy(IP *target, const IP *source)
 /* copies an ip_port structure (careful about direction!) */
 void ipport_copy(IP_Port *target, const IP_Port *source)
 {
-    if (!source || !target)
+    if (!source || !target) {
         return;
+    }
 
     memcpy(target, source, sizeof(IP_Port));
 }
 
 /* ip_ntoa
  *   converts ip into a string
- *   uses a static buffer, so mustn't used multiple times in the same output
+ *   ip_str must be of length at least IP_NTOA_LEN
  *
  *   IPv6 addresses are enclosed into square brackets, i.e. "[IPv6]"
  *   writes error message into the buffer on error
+ *
+ *   returns ip_str
  */
-/* there would be INET6_ADDRSTRLEN, but it might be too short for the error message */
-static char addresstext[96]; // FIXME magic number. Why not INET6_ADDRSTRLEN ?
-const char *ip_ntoa(const IP *ip)
+const char *ip_ntoa(const IP *ip, char *ip_str, size_t length)
 {
+    if (length < IP_NTOA_LEN) {
+        snprintf(ip_str, length, "Bad buf length");
+        return ip_str;
+    }
+
     if (ip) {
-        if (ip->family == AF_INET) {
+        const int family = make_family(ip->family);
+
+        if (net_family_is_ipv4(ip->family)) {
             /* returns standard quad-dotted notation */
-            struct in_addr *addr = (struct in_addr *)&ip->ip4;
+            struct in_addr addr;
+            fill_addr4(ip->ip.v4, &addr);
 
-            addresstext[0] = 0;
-            inet_ntop(ip->family, addr, addresstext, sizeof(addresstext));
-        } else if (ip->family == AF_INET6) {
+            ip_str[0] = 0;
+            inet_ntop(family, &addr, ip_str, length);
+        } else if (net_family_is_ipv6(ip->family)) {
             /* returns hex-groups enclosed into square brackets */
-            struct in6_addr *addr = (struct in6_addr *)&ip->ip6;
-
-            addresstext[0] = '[';
-            inet_ntop(ip->family, addr, &addresstext[1], sizeof(addresstext) - 3);
-            size_t len = strlen(addresstext);
-            addresstext[len] = ']';
-            addresstext[len + 1] = 0;
-        } else
-            snprintf(addresstext, sizeof(addresstext), "(IP invalid, family %u)", ip->family);
-    } else
-        snprintf(addresstext, sizeof(addresstext), "(IP invalid: NULL)");
+            struct in6_addr addr;
+            fill_addr6(ip->ip.v6, &addr);
+
+            ip_str[0] = '[';
+            inet_ntop(family, &addr, &ip_str[1], length - 3);
+            size_t len = strlen(ip_str);
+            ip_str[len] = ']';
+            ip_str[len + 1] = 0;
+        } else {
+            snprintf(ip_str, length, "(IP invalid, family %u)", ip->family.value);
+        }
+    } else {
+        snprintf(ip_str, length, "(IP invalid: NULL)");
+    }
 
     /* brute force protection against lacking termination */
-    addresstext[sizeof(addresstext) - 1] = 0;
-    return addresstext;
+    ip_str[length - 1] = 0;
+    return ip_str;
 }
 
 /*
@@ -860,10 +1211,10 @@ const char *ip_ntoa(const IP *ip)
  *  parses IP structure into an address string
  *
  * input
- *  ip: ip of AF_INET or AF_INET6 families
+ *  ip: ip of TOX_AF_INET or TOX_AF_INET6 families
  *  length: length of the address buffer
- *          Must be at least INET_ADDRSTRLEN for AF_INET
- *          and INET6_ADDRSTRLEN for AF_INET6
+ *          Must be at least INET_ADDRSTRLEN for TOX_AF_INET
+ *          and INET6_ADDRSTRLEN for TOX_AF_INET6
  *
  * output
  *  address: dotted notation (IPv4: quad, IPv6: 16) or colon notation (IPv6)
@@ -876,12 +1227,14 @@ int ip_parse_addr(const IP *ip, char *address, size_t length)
         return 0;
     }
 
-    if (ip->family == AF_INET) {
-        struct in_addr *addr = (struct in_addr *)&ip->ip4;
-        return inet_ntop(ip->family, addr, address, length) != NULL;
-    } else if (ip->family == AF_INET6) {
-        struct in6_addr *addr = (struct in6_addr *)&ip->ip6;
-        return inet_ntop(ip->family, addr, address, length) != NULL;
+    if (net_family_is_ipv4(ip->family)) {
+        const struct in_addr *addr = (const struct in_addr *)&ip->ip.v4;
+        return inet_ntop(make_family(ip->family), addr, address, length) != nullptr;
+    }
+
+    if (net_family_is_ipv6(ip->family)) {
+        const struct in6_addr *addr = (const struct in6_addr *)&ip->ip.v6;
+        return inet_ntop(make_family(ip->family), addr, address, length) != nullptr;
     }
 
     return 0;
@@ -902,22 +1255,23 @@ int ip_parse_addr(const IP *ip, char *address, size_t length)
  */
 int addr_parse_ip(const char *address, IP *to)
 {
-    if (!address || !to)
+    if (!address || !to) {
         return 0;
+    }
 
     struct in_addr addr4;
 
-    if (1 == inet_pton(AF_INET, address, &addr4)) {
-        to->family = AF_INET;
-        to->ip4.in_addr = addr4;
+    if (inet_pton(AF_INET, address, &addr4) == 1) {
+        to->family = net_family_ipv4;
+        get_ip4(&to->ip.v4, &addr4);
         return 1;
     }
 
     struct in6_addr addr6;
 
-    if (1 == inet_pton(AF_INET6, address, &addr6)) {
-        to->family = AF_INET6;
-        to->ip6.in6_addr = addr6;
+    if (inet_pton(AF_INET6, address, &addr6) == 1) {
+        to->family = net_family_ipv6;
+        get_ip6(&to->ip.v6, &addr6);
         return 1;
     }
 
@@ -932,24 +1286,26 @@ int addr_parse_ip(const char *address, IP *to)
  * input
  *  address: a hostname (or something parseable to an IP address)
  *  to: to.family MUST be initialized, either set to a specific IP version
- *     (AF_INET/AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
+ *     (TOX_AF_INET/TOX_AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
  *     IP versions are acceptable
  *  extra can be NULL and is only set in special circumstances, see returns
  *
  * returns in *to a valid IPAny (v4/v6),
  *     prefers v6 if ip.family was AF_UNSPEC and both available
- * returns in *extra an IPv4 address, if family was AF_UNSPEC and *to is AF_INET6
+ * returns in *extra an IPv4 address, if family was AF_UNSPEC and *to is TOX_AF_INET6
  * returns 0 on failure, TOX_ADDR_RESOLVE_* on success.
  */
 int addr_resolve(const char *address, IP *to, IP *extra)
 {
-    if (!address || !to)
+    if (!address || !to) {
         return 0;
+    }
 
-    sa_family_t family = to->family;
+    Family tox_family = to->family;
+    int family = make_family(tox_family);
 
-    struct addrinfo *server = NULL;
-    struct addrinfo *walker = NULL;
+    struct addrinfo *server = nullptr;
+    struct addrinfo *walker = nullptr;
     struct addrinfo  hints;
     int rc;
     int result = 0;
@@ -959,10 +1315,11 @@ int addr_resolve(const char *address, IP *to, IP *extra)
     hints.ai_family   = family;
     hints.ai_socktype = SOCK_DGRAM; // type of socket Tox uses.
 
-    if (networking_at_startup() != 0)
+    if (networking_at_startup() != 0) {
         return 0;
+    }
 
-    rc = getaddrinfo(address, NULL, &hints, &server);
+    rc = getaddrinfo(address, nullptr, &hints, &server);
 
     // Lookup failed.
     if (rc != 0) {
@@ -974,17 +1331,17 @@ int addr_resolve(const char *address, IP *to, IP *extra)
     IP ip6;
     ip_init(&ip6, 1); // ipv6enabled = 1
 
-    for (walker = server; (walker != NULL) && !done; walker = walker->ai_next) {
+    for (walker = server; (walker != nullptr) && !done; walker = walker->ai_next) {
         switch (walker->ai_family) {
             case AF_INET:
                 if (walker->ai_family == family) { /* AF_INET requested, done */
                     struct sockaddr_in *addr = (struct sockaddr_in *)walker->ai_addr;
-                    to->ip4.in_addr = addr->sin_addr;
+                    get_ip4(&to->ip.v4, &addr->sin_addr);
                     result = TOX_ADDR_RESOLVE_INET;
                     done = 1;
                 } else if (!(result & TOX_ADDR_RESOLVE_INET)) { /* AF_UNSPEC requested, store away */
                     struct sockaddr_in *addr = (struct sockaddr_in *)walker->ai_addr;
-                    ip4.ip4.in_addr = addr->sin_addr;
+                    get_ip4(&ip4.ip.v4, &addr->sin_addr);
                     result |= TOX_ADDR_RESOLVE_INET;
                 }
 
@@ -994,14 +1351,14 @@ int addr_resolve(const char *address, IP *to, IP *extra)
                 if (walker->ai_family == family) { /* AF_INET6 requested, done */
                     if (walker->ai_addrlen == sizeof(struct sockaddr_in6)) {
                         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)walker->ai_addr;
-                        to->ip6.in6_addr = addr->sin6_addr;
+                        get_ip6(&to->ip.v6, &addr->sin6_addr);
                         result = TOX_ADDR_RESOLVE_INET6;
                         done = 1;
                     }
                 } else if (!(result & TOX_ADDR_RESOLVE_INET6)) { /* AF_UNSPEC requested, store away */
                     if (walker->ai_addrlen == sizeof(struct sockaddr_in6)) {
                         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)walker->ai_addr;
-                        ip6.ip6.in6_addr = addr->sin6_addr;
+                        get_ip6(&ip6.ip.v6, &addr->sin6_addr);
                         result |= TOX_ADDR_RESOLVE_INET6;
                     }
                 }
@@ -1014,7 +1371,7 @@ int addr_resolve(const char *address, IP *to, IP *extra)
         if (result & TOX_ADDR_RESOLVE_INET6) {
             ip_copy(to, &ip6);
 
-            if ((result & TOX_ADDR_RESOLVE_INET) && (extra != NULL)) {
+            if ((result & TOX_ADDR_RESOLVE_INET) && (extra != nullptr)) {
                 ip_copy(extra, &ip4);
             }
         } else if (result & TOX_ADDR_RESOLVE_INET) {
@@ -1034,7 +1391,7 @@ int addr_resolve(const char *address, IP *to, IP *extra)
  *
  *  address: a hostname (or something parseable to an IP address)
  *  to: to.family MUST be initialized, either set to a specific IP version
- *     (AF_INET/AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
+ *     (TOX_AF_INET/TOX_AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
  *     IP versions are acceptable
  *  extra can be NULL and is only set in special circumstances, see returns
  *
@@ -1045,9 +1402,323 @@ int addr_resolve(const char *address, IP *to, IP *extra)
  */
 int addr_resolve_or_parse_ip(const char *address, IP *to, IP *extra)
 {
-    if (!addr_resolve(address, to, extra))
-        if (!addr_parse_ip(address, to))
+    if (!addr_resolve(address, to, extra)) {
+        if (!addr_parse_ip(address, to)) {
             return 0;
+        }
+    }
 
     return 1;
 }
+
+int net_connect(Socket sock, IP_Port ip_port)
+{
+    struct sockaddr_storage addr = {0};
+    size_t addrsize;
+
+    if (net_family_is_ipv4(ip_port.ip.family)) {
+        struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
+
+        addrsize = sizeof(struct sockaddr_in);
+        addr4->sin_family = AF_INET;
+        fill_addr4(ip_port.ip.ip.v4, &addr4->sin_addr);
+        addr4->sin_port = ip_port.port;
+    } else if (net_family_is_ipv6(ip_port.ip.family)) {
+        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+
+        addrsize = sizeof(struct sockaddr_in6);
+        addr6->sin6_family = AF_INET6;
+        fill_addr6(ip_port.ip.ip.v6, &addr6->sin6_addr);
+        addr6->sin6_port = ip_port.port;
+    } else {
+        return 0;
+    }
+
+    return connect(sock.socket, (struct sockaddr *)&addr, addrsize);
+}
+
+int32_t net_getipport(const char *node, IP_Port **res, int tox_type)
+{
+    struct addrinfo *infos;
+    int ret = getaddrinfo(node, nullptr, nullptr, &infos);
+    *res = nullptr;
+
+    if (ret != 0) {
+        return -1;
+    }
+
+    // Used to avoid malloc parameter overflow
+    const size_t MAX_COUNT = MIN(SIZE_MAX, INT32_MAX) / sizeof(IP_Port);
+    int type = make_socktype(tox_type);
+    struct addrinfo *cur;
+    size_t count = 0;
+
+    for (cur = infos; count < MAX_COUNT && cur != nullptr; cur = cur->ai_next) {
+        if (cur->ai_socktype && type > 0 && cur->ai_socktype != type) {
+            continue;
+        }
+
+        if (cur->ai_family != AF_INET && cur->ai_family != AF_INET6) {
+            continue;
+        }
+
+        count++;
+    }
+
+    assert(count <= MAX_COUNT);
+
+    if (count == 0) {
+        freeaddrinfo(infos);
+        return 0;
+    }
+
+    *res = (IP_Port *)malloc(sizeof(IP_Port) * count);
+
+    if (*res == nullptr) {
+        freeaddrinfo(infos);
+        return -1;
+    }
+
+    IP_Port *ip_port = *res;
+
+    for (cur = infos; cur != nullptr; cur = cur->ai_next) {
+        if (cur->ai_socktype && type > 0 && cur->ai_socktype != type) {
+            continue;
+        }
+
+        if (cur->ai_family == AF_INET) {
+            struct sockaddr_in *addr = (struct sockaddr_in *)cur->ai_addr;
+            memcpy(&ip_port->ip.ip.v4, &addr->sin_addr, sizeof(IP4));
+        } else if (cur->ai_family == AF_INET6) {
+            struct sockaddr_in6 *addr = (struct sockaddr_in6 *)cur->ai_addr;
+            memcpy(&ip_port->ip.ip.v6, &addr->sin6_addr, sizeof(IP6));
+        } else {
+            continue;
+        }
+
+        const Family *const family = make_tox_family(cur->ai_family);
+        assert(family != nullptr);
+
+        if (family == nullptr) {
+            freeaddrinfo(infos);
+            return -1;
+        }
+
+        ip_port->ip.family = *family;
+
+        ip_port++;
+    }
+
+    freeaddrinfo(infos);
+
+    return count;
+}
+
+void net_freeipport(IP_Port *ip_ports)
+{
+    free(ip_ports);
+}
+
+/* return 1 on success
+ * return 0 on failure
+ */
+int bind_to_port(Socket sock, Family family, uint16_t port)
+{
+    struct sockaddr_storage addr = {0};
+    size_t addrsize;
+
+    if (net_family_is_ipv4(family)) {
+        struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
+
+        addrsize = sizeof(struct sockaddr_in);
+        addr4->sin_family = AF_INET;
+        addr4->sin_port = net_htons(port);
+    } else if (net_family_is_ipv6(family)) {
+        struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+
+        addrsize = sizeof(struct sockaddr_in6);
+        addr6->sin6_family = AF_INET6;
+        addr6->sin6_port = net_htons(port);
+    } else {
+        return 0;
+    }
+
+    return bind(sock.socket, (struct sockaddr *)&addr, addrsize) == 0;
+}
+
+static int make_socktype(int type)
+{
+    switch (type) {
+        case TOX_SOCK_STREAM:
+            return SOCK_STREAM;
+
+        case TOX_SOCK_DGRAM:
+            return SOCK_DGRAM;
+
+        default:
+            return type;
+    }
+}
+
+static int make_proto(int proto)
+{
+    switch (proto) {
+        case TOX_PROTO_TCP:
+            return IPPROTO_TCP;
+
+        case TOX_PROTO_UDP:
+            return IPPROTO_UDP;
+
+        default:
+            return proto;
+    }
+}
+
+Socket net_socket(Family domain, int type, int protocol)
+{
+    const int platform_domain = make_family(domain);
+    const int platform_type = make_socktype(type);
+    const int platform_prot = make_proto(protocol);
+    const Socket sock = {(int)socket(platform_domain, platform_type, platform_prot)};
+    return sock;
+}
+
+int net_send(Socket sock, const void *buf, size_t len)
+{
+    return send(sock.socket, (const char *)buf, len, MSG_NOSIGNAL);
+}
+
+int net_recv(Socket sock, void *buf, size_t len)
+{
+    return recv(sock.socket, (char *)buf, len, MSG_NOSIGNAL);
+}
+
+int net_listen(Socket sock, int backlog)
+{
+    return listen(sock.socket, backlog);
+}
+
+Socket net_accept(Socket sock)
+{
+    const Socket newsock = {accept(sock.socket, nullptr, nullptr)};
+    return newsock;
+}
+
+size_t net_socket_data_recv_buffer(Socket sock)
+{
+#ifdef OS_WIN32
+    unsigned long count = 0;
+    ioctlsocket(sock.socket, FIONREAD, &count);
+#else
+    int count = 0;
+    ioctl(sock.socket, FIONREAD, &count);
+#endif
+
+    return count;
+}
+
+uint32_t net_htonl(uint32_t hostlong)
+{
+    return htonl(hostlong);
+}
+
+uint16_t net_htons(uint16_t hostshort)
+{
+    return htons(hostshort);
+}
+
+uint32_t net_ntohl(uint32_t hostlong)
+{
+    return ntohl(hostlong);
+}
+
+uint16_t net_ntohs(uint16_t hostshort)
+{
+    return ntohs(hostshort);
+}
+
+size_t net_pack_u16(uint8_t *bytes, uint16_t v)
+{
+    bytes[0] = (v >> 8) & 0xff;
+    bytes[1] = v & 0xff;
+    return sizeof(v);
+}
+
+size_t net_pack_u32(uint8_t *bytes, uint32_t v)
+{
+    uint8_t *p = bytes;
+    p += net_pack_u16(p, (v >> 16) & 0xffff);
+    p += net_pack_u16(p, v & 0xffff);
+    return p - bytes;
+}
+
+size_t net_pack_u64(uint8_t *bytes, uint64_t v)
+{
+    uint8_t *p = bytes;
+    p += net_pack_u32(p, (v >> 32) & 0xffffffff);
+    p += net_pack_u32(p, v & 0xffffffff);
+    return p - bytes;
+}
+
+size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v)
+{
+    uint8_t hi = bytes[0];
+    uint8_t lo = bytes[1];
+    *v = ((uint16_t)hi << 8) | lo;
+    return sizeof(*v);
+}
+
+size_t net_unpack_u32(const uint8_t *bytes, uint32_t *v)
+{
+    const uint8_t *p = bytes;
+    uint16_t lo, hi;
+    p += net_unpack_u16(p, &hi);
+    p += net_unpack_u16(p, &lo);
+    *v = ((uint32_t)hi << 16) | lo;
+    return p - bytes;
+}
+
+size_t net_unpack_u64(const uint8_t *bytes, uint64_t *v)
+{
+    const uint8_t *p = bytes;
+    uint32_t lo, hi;
+    p += net_unpack_u32(p, &hi);
+    p += net_unpack_u32(p, &lo);
+    *v = ((uint64_t)hi << 32) | lo;
+    return p - bytes;
+}
+
+int net_error(void)
+{
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+    return WSAGetLastError();
+#else
+    return errno;
+#endif
+}
+
+const char *net_new_strerror(int error)
+{
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+    char *str = nullptr;
+    // Windows API is weird. The 5th function arg is of char* type, but we
+    // have to pass char** so that it could assign new memory block to our
+    // pointer, so we have to cast our char** to char* for the compilation
+    // not to fail (otherwise it would fail to find a variant of this function
+    // accepting char** as the 5th arg) and Windows inside casts it back
+    // to char** to do the assignment. So no, this cast you see here, although
+    // it looks weird, is not a mistake.
+    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
+                   error, 0, (char *)&str, 0, nullptr);
+    return str;
+#else
+    return strerror(error);
+#endif
+}
+
+void net_kill_strerror(const char *strerror)
+{
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+    LocalFree((char *)strerror);
+#endif
+}
diff --git a/toxcore/network.h b/toxcore/network.h
index 8d2ccfce..8071375b 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -1,172 +1,209 @@
-/* network.h
- *
+/*
  * Datatypes, functions and includes for the core networking.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef NETWORK_H
 #define NETWORK_H
 
-#ifdef PLAN9
-#include <u.h> //Plan 9 requires this is imported first
-#include <libc.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <time.h>
+#include "logger.h"
 
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32) /* Put win32 includes here */
-#ifndef WINVER
-//Windows XP
-#define WINVER 0x0501
-#endif
-#include <winsock2.h>
-#include <windows.h>
-#include <ws2tcpip.h>
+#include <stdbool.h>    // bool
+#include <stddef.h>     // size_t
+#include <stdint.h>     // uint*_t
 
-#ifndef IPV6_V6ONLY
-#define IPV6_V6ONLY 27
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-typedef unsigned int sock_t;
-/* sa_family_t is the sockaddr_in / sockaddr_in6 family field */
-typedef short sa_family_t;
-
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK WSAEWOULDBLOCK
-#endif
-
-#else // Linux includes
-
-#include <fcntl.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <netdb.h>
-#include <unistd.h>
+typedef struct Family {
+    uint8_t value;
+} Family;
+
+bool net_family_is_unspec(Family family);
+bool net_family_is_ipv4(Family family);
+bool net_family_is_ipv6(Family family);
+bool net_family_is_tcp_family(Family family);
+bool net_family_is_tcp_onion(Family family);
+bool net_family_is_tcp_ipv4(Family family);
+bool net_family_is_tcp_ipv6(Family family);
+bool net_family_is_tox_tcp_ipv4(Family family);
+bool net_family_is_tox_tcp_ipv6(Family family);
+
+extern const Family net_family_unspec;
+extern const Family net_family_ipv4;
+extern const Family net_family_ipv6;
+extern const Family net_family_tcp_family;
+extern const Family net_family_tcp_onion;
+extern const Family net_family_tcp_ipv4;
+extern const Family net_family_tcp_ipv6;
+extern const Family net_family_tox_tcp_ipv4;
+extern const Family net_family_tox_tcp_ipv6;
+
+typedef struct Socket {
+    int socket;
+} Socket;
+
+Socket net_socket(Family domain, int type, int protocol);
 
-typedef int sock_t;
-
-#endif
+/* Check if socket is valid.
+ *
+ * return 1 if valid
+ * return 0 if not valid
+ */
+int sock_valid(Socket sock);
 
-#if defined(__AIX__)
-#   define _XOPEN_SOURCE 1
-#endif
+extern const Socket net_invalid_socket;
 
-#if defined(__sun__)
-#define __EXTENSIONS__ 1 // SunOS!
-#if defined(__SunOS5_6__) || defined(__SunOS5_7__) || defined(__SunOS5_8__) || defined(__SunOS5_9__) || defined(__SunOS5_10__)
-//Nothing needed
-#else
-#define __MAKECONTEXT_V2_SOURCE 1
-#endif
-#endif
+/**
+ * Calls send(sockfd, buf, len, MSG_NOSIGNAL).
+ */
+int net_send(Socket sockfd, const void *buf, size_t len);
+/**
+ * Calls recv(sockfd, buf, len, MSG_NOSIGNAL).
+ */
+int net_recv(Socket sockfd, void *buf, size_t len);
+/**
+ * Calls listen(sockfd, backlog).
+ */
+int net_listen(Socket sockfd, int backlog);
+/**
+ * Calls accept(sockfd, nullptr, nullptr).
+ */
+Socket net_accept(Socket sockfd);
 
-#ifndef IPV6_ADD_MEMBERSHIP
-#ifdef  IPV6_JOIN_GROUP
-#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
-#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
-#endif
-#endif
+/**
+ * return the amount of data in the tcp recv buffer.
+ * return 0 on failure.
+ */
+size_t net_socket_data_recv_buffer(Socket sock);
 
 #define MAX_UDP_PACKET_SIZE 2048
 
-#define NET_PACKET_PING_REQUEST    0   /* Ping request packet ID. */
-#define NET_PACKET_PING_RESPONSE   1   /* Ping response packet ID. */
-#define NET_PACKET_GET_NODES       2   /* Get nodes request packet ID. */
-#define NET_PACKET_SEND_NODES_IPV6 4   /* Send nodes response packet ID for other addresses. */
-#define NET_PACKET_COOKIE_REQUEST  24  /* Cookie request packet */
-#define NET_PACKET_COOKIE_RESPONSE 25  /* Cookie response packet */
-#define NET_PACKET_CRYPTO_HS       26  /* Crypto handshake packet */
-#define NET_PACKET_CRYPTO_DATA     27  /* Crypto data packet */
-#define NET_PACKET_CRYPTO          32  /* Encrypted data packet ID. */
-#define NET_PACKET_LAN_DISCOVERY   33  /* LAN discovery packet ID. */
+typedef enum NET_PACKET_TYPE {
+    NET_PACKET_PING_REQUEST         = 0x00, /* Ping request packet ID. */
+    NET_PACKET_PING_RESPONSE        = 0x01, /* Ping response packet ID. */
+    NET_PACKET_GET_NODES            = 0x02, /* Get nodes request packet ID. */
+    NET_PACKET_SEND_NODES_IPV6      = 0x04, /* Send nodes response packet ID for other addresses. */
+    NET_PACKET_COOKIE_REQUEST       = 0x18, /* Cookie request packet */
+    NET_PACKET_COOKIE_RESPONSE      = 0x19, /* Cookie response packet */
+    NET_PACKET_CRYPTO_HS            = 0x1a, /* Crypto handshake packet */
+    NET_PACKET_CRYPTO_DATA          = 0x1b, /* Crypto data packet */
+    NET_PACKET_CRYPTO               = 0x20, /* Encrypted data packet ID. */
+    NET_PACKET_LAN_DISCOVERY        = 0x21, /* LAN discovery packet ID. */
+
+    /* See: docs/Prevent_Tracking.txt and onion.{c,h} */
+    NET_PACKET_ONION_SEND_INITIAL   = 0x80,
+    NET_PACKET_ONION_SEND_1         = 0x81,
+    NET_PACKET_ONION_SEND_2         = 0x82,
 
-/* See:  docs/Prevent_Tracking.txt and onion.{c, h} */
-#define NET_PACKET_ONION_SEND_INITIAL 128
-#define NET_PACKET_ONION_SEND_1 129
-#define NET_PACKET_ONION_SEND_2 130
+    NET_PACKET_ANNOUNCE_REQUEST     = 0x83,
+    NET_PACKET_ANNOUNCE_RESPONSE    = 0x84,
+    NET_PACKET_ONION_DATA_REQUEST   = 0x85,
+    NET_PACKET_ONION_DATA_RESPONSE  = 0x86,
 
-#define NET_PACKET_ANNOUNCE_REQUEST 131
-#define NET_PACKET_ANNOUNCE_RESPONSE 132
-#define NET_PACKET_ONION_DATA_REQUEST 133
-#define NET_PACKET_ONION_DATA_RESPONSE 134
+    NET_PACKET_ONION_RECV_3         = 0x8c,
+    NET_PACKET_ONION_RECV_2         = 0x8d,
+    NET_PACKET_ONION_RECV_1         = 0x8e,
 
-#define NET_PACKET_ONION_RECV_3 140
-#define NET_PACKET_ONION_RECV_2 141
-#define NET_PACKET_ONION_RECV_1 142
+    BOOTSTRAP_INFO_PACKET_ID        = 0xf0, /* Only used for bootstrap nodes */
 
-/* Only used for bootstrap nodes */
-#define BOOTSTRAP_INFO_PACKET_ID 240
+    NET_PACKET_MAX                  = 0xff, /* This type must remain within a single uint8. */
+} NET_PACKET_TYPE;
 
 
 #define TOX_PORTRANGE_FROM 33445
 #define TOX_PORTRANGE_TO   33545
 #define TOX_PORT_DEFAULT   TOX_PORTRANGE_FROM
 
+/* Redefinitions of variables for safe transfer over wire. */
+#define TOX_AF_UNSPEC 0
+#define TOX_AF_INET 2
+#define TOX_AF_INET6 10
+#define TOX_TCP_INET 130
+#define TOX_TCP_INET6 138
+
+#define TOX_SOCK_STREAM 1
+#define TOX_SOCK_DGRAM 2
+
+#define TOX_PROTO_TCP 1
+#define TOX_PROTO_UDP 2
+
 /* TCP related */
-#define TCP_ONION_FAMILY (AF_INET6 + 1)
-#define TCP_INET (AF_INET6 + 2)
-#define TCP_INET6 (AF_INET6 + 3)
-#define TCP_FAMILY (AF_INET6 + 4)
+#define TCP_ONION_FAMILY (TOX_AF_INET6 + 1)
+#define TCP_INET (TOX_AF_INET6 + 2)
+#define TCP_INET6 (TOX_AF_INET6 + 3)
+#define TCP_FAMILY (TOX_AF_INET6 + 4)
 
-typedef union {
-    uint8_t uint8[4];
-    uint16_t uint16[2];
+typedef union IP4 {
     uint32_t uint32;
-    struct in_addr in_addr;
-}
-IP4;
+    uint16_t uint16[2];
+    uint8_t uint8[4];
+} IP4;
+
+IP4 get_ip4_loopback(void);
+extern const IP4 IP4_BROADCAST;
 
-typedef union {
+typedef union IP6 {
     uint8_t uint8[16];
     uint16_t uint16[8];
     uint32_t uint32[4];
     uint64_t uint64[2];
-    struct in6_addr in6_addr;
-}
-IP6;
+} IP6;
+
+IP6 get_ip6_loopback(void);
+extern const IP6 IP6_BROADCAST;
 
-typedef struct {
-    uint8_t family;
+#define IP_DEFINED
+typedef struct IP {
+    Family family;
     union {
-        IP4 ip4;
-        IP6 ip6;
-    };
-}
-IP;
+        IP4 v4;
+        IP6 v6;
+    } ip;
+} IP;
 
-typedef struct {
+#define IP_PORT_DEFINED
+typedef struct IP_Port {
     IP ip;
     uint16_t port;
-}
-IP_Port;
+} IP_Port;
+
+/* Convert values between host and network byte order.
+ */
+uint32_t net_htonl(uint32_t hostlong);
+uint16_t net_htons(uint16_t hostshort);
+uint32_t net_ntohl(uint32_t hostlong);
+uint16_t net_ntohs(uint16_t hostshort);
+
+size_t net_pack_u16(uint8_t *bytes, uint16_t v);
+size_t net_pack_u32(uint8_t *bytes, uint32_t v);
+size_t net_pack_u64(uint8_t *bytes, uint64_t v);
+
+size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v);
+size_t net_unpack_u32(const uint8_t *bytes, uint32_t *v);
+size_t net_unpack_u64(const uint8_t *bytes, uint64_t *v);
 
 /* Does the IP6 struct a contain an IPv4 address in an IPv6 one? */
-#define IPV6_IPV4_IN_V6(a) ((a.uint64[0] == 0) && (a.uint32[2] == htonl (0xffff)))
+#define IPV6_IPV4_IN_V6(a) ((a.uint64[0] == 0) && (a.uint32[2] == net_htonl (0xffff)))
 
 #define SIZE_IP4 4
 #define SIZE_IP6 16
@@ -174,30 +211,37 @@ IP_Port;
 #define SIZE_PORT 2
 #define SIZE_IPPORT (SIZE_IP + SIZE_PORT)
 
-#define TOX_ENABLE_IPV6_DEFAULT 1
+#define TOX_ENABLE_IPV6_DEFAULT true
 
 /* addr_resolve return values */
 #define TOX_ADDR_RESOLVE_INET  1
 #define TOX_ADDR_RESOLVE_INET6 2
 
+#define TOX_INET6_ADDRSTRLEN 66
+#define TOX_INET_ADDRSTRLEN 22
+
 /* ip_ntoa
  *   converts ip into a string
- *   uses a static buffer, so mustn't used multiple times in the same output
+ *   ip_str must be of length at least IP_NTOA_LEN
  *
  *   IPv6 addresses are enclosed into square brackets, i.e. "[IPv6]"
  *   writes error message into the buffer on error
+ *
+ *   returns ip_str
  */
-const char *ip_ntoa(const IP *ip);
+/* this would be TOX_INET6_ADDRSTRLEN, but it might be too short for the error message */
+#define IP_NTOA_LEN 96 // TODO(irungentoo): magic number. Why not INET6_ADDRSTRLEN ?
+const char *ip_ntoa(const IP *ip, char *ip_str, size_t length);
 
 /*
  * ip_parse_addr
  *  parses IP structure into an address string
  *
  * input
- *  ip: ip of AF_INET or AF_INET6 families
+ *  ip: ip of TOX_AF_INET or TOX_AF_INET6 families
  *  length: length of the address buffer
- *          Must be at least INET_ADDRSTRLEN for AF_INET
- *          and INET6_ADDRSTRLEN for AF_INET6
+ *          Must be at least TOX_INET_ADDRSTRLEN for TOX_AF_INET
+ *          and TOX_INET6_ADDRSTRLEN for TOX_AF_INET6
  *
  * output
  *  address: dotted notation (IPv4: quad, IPv6: 16) or colon notation (IPv6)
@@ -240,11 +284,11 @@ int ipport_equal(const IP_Port *a, const IP_Port *b);
 /* nulls out ip */
 void ip_reset(IP *ip);
 /* nulls out ip, sets family according to flag */
-void ip_init(IP *ip, uint8_t ipv6enabled);
+void ip_init(IP *ip, bool ipv6enabled);
 /* checks if ip is valid */
-int ip_isset(const IP *ip);
+bool ip_isset(const IP *ip);
 /* checks if ip is valid */
-int ipport_isset(const IP_Port *ipport);
+bool ipport_isset(const IP_Port *ipport);
 /* copies an ip structure */
 void ip_copy(IP *target, const IP *source);
 /* copies an ip_port structure */
@@ -258,13 +302,13 @@ void ipport_copy(IP_Port *target, const IP_Port *source);
  * input
  *  address: a hostname (or something parseable to an IP address)
  *  to: to.family MUST be initialized, either set to a specific IP version
- *     (AF_INET/AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
+ *     (TOX_AF_INET/TOX_AF_INET6) or to the unspecified TOX_AF_UNSPEC (= 0), if both
  *     IP versions are acceptable
  *  extra can be NULL and is only set in special circumstances, see returns
  *
  * returns in *to a valid IPAny (v4/v6),
- *     prefers v6 if ip.family was AF_UNSPEC and both available
- * returns in *extra an IPv4 address, if family was AF_UNSPEC and *to is AF_INET6
+ *     prefers v6 if ip.family was TOX_AF_UNSPEC and both available
+ * returns in *extra an IPv4 address, if family was TOX_AF_UNSPEC and *to is TOX_AF_INET6
  * returns 0 on failure
  */
 int addr_resolve(const char *address, IP *to, IP *extra);
@@ -275,12 +319,12 @@ int addr_resolve(const char *address, IP *to, IP *extra);
  *
  *  address: a hostname (or something parseable to an IP address)
  *  to: to.family MUST be initialized, either set to a specific IP version
- *     (AF_INET/AF_INET6) or to the unspecified AF_UNSPEC (= 0), if both
+ *     (TOX_AF_INET/TOX_AF_INET6) or to the unspecified TOX_AF_UNSPEC (= 0), if both
  *     IP versions are acceptable
  *  extra can be NULL and is only set in special circumstances, see returns
  *
  *  returns in *tro a matching address (IPv6 or IPv4)
- *  returns in *extra, if not NULL, an IPv4 address, if to->family was AF_UNSPEC
+ *  returns in *extra, if not NULL, an IPv4 address, if to->family was TOX_AF_UNSPEC
  *  returns 1 on success
  *  returns 0 on failure
  */
@@ -290,21 +334,13 @@ int addr_resolve_or_parse_ip(const char *address, IP *to, IP *extra);
  * Packet data is put into data.
  * Packet length is put into length.
  */
-typedef int (*packet_handler_callback)(void *object, IP_Port ip_port, const uint8_t *data, uint16_t len);
-
-typedef struct {
-    packet_handler_callback function;
-    void *object;
-} Packet_Handles;
+typedef int (*packet_handler_callback)(void *object, IP_Port ip_port, const uint8_t *data, uint16_t len,
+                                       void *userdata);
 
-typedef struct {
-    Packet_Handles packethandlers[256];
+typedef struct Networking_Core Networking_Core;
 
-    sa_family_t family;
-    uint16_t port;
-    /* Our UDP socket. */
-    sock_t sock;
-} Networking_Core;
+Family net_family(const Networking_Core *net);
+uint16_t net_port(const Networking_Core *net);
 
 /* Run this before creating sockets.
  *
@@ -313,44 +349,37 @@ typedef struct {
  */
 int networking_at_startup(void);
 
-/* Check if socket is valid.
- *
- * return 1 if valid
- * return 0 if not valid
- */
-int sock_valid(sock_t sock);
-
 /* Close the socket.
  */
-void kill_sock(sock_t sock);
+void kill_sock(Socket sock);
 
 /* Set socket as nonblocking
  *
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_nonblock(sock_t sock);
+int set_socket_nonblock(Socket sock);
 
 /* Set socket to not emit SIGPIPE
  *
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_nosigpipe(sock_t sock);
+int set_socket_nosigpipe(Socket sock);
 
 /* Enable SO_REUSEADDR on socket.
  *
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_reuseaddr(sock_t sock);
+int set_socket_reuseaddr(Socket sock);
 
 /* Set socket to dual (IPv4 + IPv6 socket)
  *
  * return 1 on success
  * return 0 on failure
  */
-int set_socket_dualstack(sock_t sock);
+int set_socket_dualstack(Socket sock);
 
 /* return current monotonic time in milliseconds (ms). */
 uint64_t current_time_monotonic(void);
@@ -364,7 +393,60 @@ int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint1
 void networking_registerhandler(Networking_Core *net, uint8_t byte, packet_handler_callback cb, void *object);
 
 /* Call this several times a second. */
-void networking_poll(Networking_Core *net);
+void networking_poll(Networking_Core *net, void *userdata);
+
+/* Connect a socket to the address specified by the ip_port. */
+int net_connect(Socket sock, IP_Port ip_port);
+
+/* High-level getaddrinfo implementation.
+ * Given node, which identifies an Internet host, net_getipport() fills an array
+ * with one or more IP_Port structures, each of which contains an Internet
+ * address that can be specified by calling net_connect(), the port is ignored.
+ *
+ * Skip all addresses with socktype != type (use type = -1 to get all addresses)
+ * To correctly deallocate array memory use net_freeipport()
+ *
+ * return number of elements in res array
+ * and -1 on error.
+ */
+int32_t net_getipport(const char *node, IP_Port **res, int tox_type);
+
+/* Deallocates memory allocated by net_getipport
+ */
+void net_freeipport(IP_Port *ip_ports);
+
+/* return 1 on success
+ * return 0 on failure
+ */
+int bind_to_port(Socket sock, Family family, uint16_t port);
+
+/* Get the last networking error code.
+ *
+ * Similar to Unix's errno, but cross-platform, as not all platforms use errno
+ * to indicate networking errors.
+ *
+ * Note that different platforms may return different codes for the same error,
+ * so you likely shouldn't be checking the value returned by this function
+ * unless you know what you are doing, you likely just want to use it in
+ * combination with net_new_strerror() to print the error.
+ *
+ * return platform-dependent network error code, if any.
+ */
+int net_error(void);
+
+/* Get a text explanation for the error code from net_error().
+ *
+ * return NULL on failure.
+ * return pointer to a NULL-terminated string describing the error code on
+ * success. The returned string must be freed using net_kill_strerror().
+ */
+const char *net_new_strerror(int error);
+
+/* Frees the string returned by net_new_strerror().
+ * It's valid to pass NULL as the argument, the function does nothing in this
+ * case.
+ */
+void net_kill_strerror(const char *strerror);
 
 /* Initialize networking.
  * bind to ip and port.
@@ -376,10 +458,15 @@ void networking_poll(Networking_Core *net);
  *
  * If error is non NULL it is set to 0 if no issues, 1 if socket related error, 2 if other.
  */
-Networking_Core *new_networking(IP ip, uint16_t port);
-Networking_Core *new_networking_ex(IP ip, uint16_t port_from, uint16_t port_to, unsigned int *error);
+Networking_Core *new_networking(Logger *log, IP ip, uint16_t port);
+Networking_Core *new_networking_ex(Logger *log, IP ip, uint16_t port_from, uint16_t port_to, unsigned int *error);
+Networking_Core *new_networking_no_udp(Logger *log);
 
 /* Function to cleanup networking stuff (doesn't do much right now). */
 void kill_networking(Networking_Core *net);
 
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
 #endif
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 2bed5821..5bbc7f75 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -1,29 +1,35 @@
 /*
-* onion.c -- Implementation of the onion part of docs/Prevent_Tracking.txt
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the onion part of docs/Prevent_Tracking.txt
+ */
+
+/*
+ * Copyright © 2016-2018 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "onion.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "util.h"
 
 #define RETURN_1 ONION_RETURN_1
@@ -48,38 +54,37 @@ static void change_symmetric_key(Onion *onion)
 /* packing and unpacking functions */
 static void ip_pack(uint8_t *data, IP source)
 {
-    to_net_family(&source);
-
-    data[0] = source.family;
+    data[0] = source.family.value;
 
-    if (source.family == TOX_AF_INET || source.family == TOX_TCP_INET) {
+    if (net_family_is_ipv4(source.family) || net_family_is_tox_tcp_ipv4(source.family)) {
         memset(data + 1, 0, SIZE_IP6);
-        memcpy(data + 1, source.ip4.uint8, SIZE_IP4);
+        memcpy(data + 1, source.ip.v4.uint8, SIZE_IP4);
     } else {
-        memcpy(data + 1, source.ip6.uint8, SIZE_IP6);
+        memcpy(data + 1, source.ip.v6.uint8, SIZE_IP6);
     }
 }
 
 /* return 0 on success, -1 on failure. */
-static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size, _Bool disable_family_check)
+static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size, bool disable_family_check)
 {
-    if (data_size < (1 + SIZE_IP6))
+    if (data_size < (1 + SIZE_IP6)) {
         return -1;
+    }
 
-    target->family = data[0];
+    // TODO(iphydf): Validate input.
+    target->family.value = data[0];
 
-    if (target->family == TOX_AF_INET || target->family == TOX_TCP_INET) {
-        memcpy(target->ip4.uint8, data + 1, SIZE_IP4);
+    if (net_family_is_ipv4(target->family) || net_family_is_tox_tcp_ipv4(target->family)) {
+        memcpy(target->ip.v4.uint8, data + 1, SIZE_IP4);
     } else {
-        memcpy(target->ip6.uint8, data + 1, SIZE_IP6);
+        memcpy(target->ip.v6.uint8, data + 1, SIZE_IP6);
     }
 
-    if (!disable_family_check) {
-        return to_host_family(target);
-    } else {
-        to_host_family(target);
-        return 0;
-    }
+    bool valid = disable_family_check ||
+                 net_family_is_ipv4(target->family) ||
+                 net_family_is_ipv6(target->family);
+
+    return valid ? 0 : -1;
 }
 
 static void ipport_pack(uint8_t *data, const IP_Port *source)
@@ -89,13 +94,15 @@ static void ipport_pack(uint8_t *data, const IP_Port *source)
 }
 
 /* return 0 on success, -1 on failure. */
-static int ipport_unpack(IP_Port *target, const uint8_t *data, unsigned int data_size, _Bool disable_family_check)
+static int ipport_unpack(IP_Port *target, const uint8_t *data, unsigned int data_size, bool disable_family_check)
 {
-    if (data_size < (SIZE_IP + SIZE_PORT))
+    if (data_size < (SIZE_IP + SIZE_PORT)) {
         return -1;
+    }
 
-    if (ip_unpack(&target->ip, data, data_size, disable_family_check) == -1)
+    if (ip_unpack(&target->ip, data, data_size, disable_family_check) == -1) {
         return -1;
+    }
 
     memcpy(&target->port, data + SIZE_IP, SIZE_PORT);
     return 0;
@@ -113,30 +120,31 @@ static int ipport_unpack(IP_Port *target, const uint8_t *data, unsigned int data
  */
 int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *nodes)
 {
-    if (!new_path || !nodes)
+    if (!new_path || !nodes) {
         return -1;
+    }
 
-    encrypt_precompute(nodes[0].public_key, dht->self_secret_key, new_path->shared_key1);
-    memcpy(new_path->public_key1, dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    encrypt_precompute(nodes[0].public_key, dht_get_self_secret_key(dht), new_path->shared_key1);
+    memcpy(new_path->public_key1, dht_get_self_public_key(dht), CRYPTO_PUBLIC_KEY_SIZE);
 
-    uint8_t random_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t random_secret_key[crypto_box_SECRETKEYBYTES];
+    uint8_t random_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t random_secret_key[CRYPTO_SECRET_KEY_SIZE];
 
-    crypto_box_keypair(random_public_key, random_secret_key);
+    crypto_new_keypair(random_public_key, random_secret_key);
     encrypt_precompute(nodes[1].public_key, random_secret_key, new_path->shared_key2);
-    memcpy(new_path->public_key2, random_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(new_path->public_key2, random_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
-    crypto_box_keypair(random_public_key, random_secret_key);
+    crypto_new_keypair(random_public_key, random_secret_key);
     encrypt_precompute(nodes[2].public_key, random_secret_key, new_path->shared_key3);
-    memcpy(new_path->public_key3, random_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(new_path->public_key3, random_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     new_path->ip_port1 = nodes[0].ip_port;
     new_path->ip_port2 = nodes[1].ip_port;
     new_path->ip_port3 = nodes[2].ip_port;
 
-    memcpy(new_path->node_public_key1, nodes[0].public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(new_path->node_public_key2, nodes[1].public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(new_path->node_public_key3, nodes[2].public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(new_path->node_public_key1, nodes[0].public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(new_path->node_public_key2, nodes[1].public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(new_path->node_public_key3, nodes[2].public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     return 0;
 }
@@ -148,16 +156,17 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
  */
 int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_Path *path)
 {
-    if (num_nodes < ONION_PATH_LENGTH)
+    if (num_nodes < ONION_PATH_LENGTH) {
         return -1;
+    }
 
     nodes[0].ip_port = path->ip_port1;
     nodes[1].ip_port = path->ip_port2;
     nodes[2].ip_port = path->ip_port3;
 
-    memcpy(nodes[0].public_key, path->node_public_key1, crypto_box_PUBLICKEYBYTES);
-    memcpy(nodes[1].public_key, path->node_public_key2, crypto_box_PUBLICKEYBYTES);
-    memcpy(nodes[2].public_key, path->node_public_key3, crypto_box_PUBLICKEYBYTES);
+    memcpy(nodes[0].public_key, path->node_public_key1, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(nodes[1].public_key, path->node_public_key2, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(nodes[2].public_key, path->node_public_key3, CRYPTO_PUBLIC_KEY_SIZE);
     return 0;
 }
 
@@ -173,47 +182,51 @@ int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_
 int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
                         const uint8_t *data, uint16_t length)
 {
-    if (1 + length + SEND_1 > max_packet_length || length == 0)
+    if (1 + length + SEND_1 > max_packet_length || length == 0) {
         return -1;
+    }
 
-    uint8_t step1[SIZE_IPPORT + length];
+    VLA(uint8_t, step1, SIZE_IPPORT + length);
 
     ipport_pack(step1, &dest);
     memcpy(step1 + SIZE_IPPORT, data, length);
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
     random_nonce(nonce);
 
-    uint8_t step2[SIZE_IPPORT + SEND_BASE + length];
+    VLA(uint8_t, step2, SIZE_IPPORT + SEND_BASE + length);
     ipport_pack(step2, &path->ip_port3);
-    memcpy(step2 + SIZE_IPPORT, path->public_key3, crypto_box_PUBLICKEYBYTES);
+    memcpy(step2 + SIZE_IPPORT, path->public_key3, CRYPTO_PUBLIC_KEY_SIZE);
 
-    int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, sizeof(step1),
-                                     step2 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, SIZEOF_VLA(step1),
+                                     step2 + SIZE_IPPORT + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (len != SIZE_IPPORT + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + length + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    uint8_t step3[SIZE_IPPORT + SEND_BASE * 2 + length];
+    VLA(uint8_t, step3, SIZE_IPPORT + SEND_BASE * 2 + length);
     ipport_pack(step3, &path->ip_port2);
-    memcpy(step3 + SIZE_IPPORT, path->public_key2, crypto_box_PUBLICKEYBYTES);
-    len = encrypt_data_symmetric(path->shared_key2, nonce, step2, sizeof(step2),
-                                 step3 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
+    memcpy(step3 + SIZE_IPPORT, path->public_key2, CRYPTO_PUBLIC_KEY_SIZE);
+    len = encrypt_data_symmetric(path->shared_key2, nonce, step2, SIZEOF_VLA(step2),
+                                 step3 + SIZE_IPPORT + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE + length + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
     packet[0] = NET_PACKET_ONION_SEND_INITIAL;
-    memcpy(packet + 1, nonce, crypto_box_NONCEBYTES);
-    memcpy(packet + 1 + crypto_box_NONCEBYTES, path->public_key1, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + 1, nonce, CRYPTO_NONCE_SIZE);
+    memcpy(packet + 1 + CRYPTO_NONCE_SIZE, path->public_key1, CRYPTO_PUBLIC_KEY_SIZE);
 
-    len = encrypt_data_symmetric(path->shared_key1, nonce, step3, sizeof(step3),
-                                 packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+    len = encrypt_data_symmetric(path->shared_key1, nonce, step3, SIZEOF_VLA(step3),
+                                 packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (len != SIZE_IPPORT + SEND_BASE * 2 + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE * 2 + length + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    return 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + len;
+    return 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + len;
 }
 
 /* Create a onion packet to be sent over tcp.
@@ -228,38 +241,41 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
 int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
                             const uint8_t *data, uint16_t length)
 {
-    if (crypto_box_NONCEBYTES + SIZE_IPPORT + SEND_BASE * 2 + length > max_packet_length || length == 0)
+    if (CRYPTO_NONCE_SIZE + SIZE_IPPORT + SEND_BASE * 2 + length > max_packet_length || length == 0) {
         return -1;
+    }
 
-    uint8_t step1[SIZE_IPPORT + length];
+    VLA(uint8_t, step1, SIZE_IPPORT + length);
 
     ipport_pack(step1, &dest);
     memcpy(step1 + SIZE_IPPORT, data, length);
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
     random_nonce(nonce);
 
-    uint8_t step2[SIZE_IPPORT + SEND_BASE + length];
+    VLA(uint8_t, step2, SIZE_IPPORT + SEND_BASE + length);
     ipport_pack(step2, &path->ip_port3);
-    memcpy(step2 + SIZE_IPPORT, path->public_key3, crypto_box_PUBLICKEYBYTES);
+    memcpy(step2 + SIZE_IPPORT, path->public_key3, CRYPTO_PUBLIC_KEY_SIZE);
 
-    int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, sizeof(step1),
-                                     step2 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, SIZEOF_VLA(step1),
+                                     step2 + SIZE_IPPORT + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (len != SIZE_IPPORT + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + length + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    ipport_pack(packet + crypto_box_NONCEBYTES, &path->ip_port2);
-    memcpy(packet + crypto_box_NONCEBYTES + SIZE_IPPORT, path->public_key2, crypto_box_PUBLICKEYBYTES);
-    len = encrypt_data_symmetric(path->shared_key2, nonce, step2, sizeof(step2),
-                                 packet + crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
+    ipport_pack(packet + CRYPTO_NONCE_SIZE, &path->ip_port2);
+    memcpy(packet + CRYPTO_NONCE_SIZE + SIZE_IPPORT, path->public_key2, CRYPTO_PUBLIC_KEY_SIZE);
+    len = encrypt_data_symmetric(path->shared_key2, nonce, step2, SIZEOF_VLA(step2),
+                                 packet + CRYPTO_NONCE_SIZE + SIZE_IPPORT + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE + length + CRYPTO_MAC_SIZE) {
         return -1;
+    }
 
-    memcpy(packet, nonce, crypto_box_NONCEBYTES);
+    memcpy(packet, nonce, CRYPTO_NONCE_SIZE);
 
-    return crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES + len;
+    return CRYPTO_NONCE_SIZE + SIZE_IPPORT + CRYPTO_PUBLIC_KEY_SIZE + len;
 }
 
 /* Create and send a onion packet.
@@ -275,11 +291,13 @@ int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     int len = create_onion_packet(packet, sizeof(packet), path, dest, data, length);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
-    if (sendpacket(net, path->ip_port1, packet, len) != len)
+    if (sendpacket(net, path->ip_port1, packet, len) != len) {
         return -1;
+    }
 
     return 0;
 }
@@ -292,151 +310,170 @@ int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest
  */
 int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data, uint16_t length, const uint8_t *ret)
 {
-    if (length > ONION_RESPONSE_MAX_DATA_SIZE || length == 0)
+    if (length > ONION_RESPONSE_MAX_DATA_SIZE || length == 0) {
         return -1;
+    }
 
-    uint8_t packet[1 + RETURN_3 + length];
+    VLA(uint8_t, packet, 1 + RETURN_3 + length);
     packet[0] = NET_PACKET_ONION_RECV_3;
     memcpy(packet + 1, ret, RETURN_3);
     memcpy(packet + 1 + RETURN_3, data, length);
 
-    if ((uint32_t)sendpacket(net, dest, packet, sizeof(packet)) != sizeof(packet))
+    if ((uint32_t)sendpacket(net, dest, packet, SIZEOF_VLA(packet)) != SIZEOF_VLA(packet)) {
         return -1;
+    }
 
     return 0;
 }
 
-static int handle_send_initial(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + SEND_1)
+    if (length <= 1 + SEND_1) {
         return 1;
+    }
 
     change_symmetric_key(onion);
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    get_shared_key(&onion->shared_keys_1, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES), plain);
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    get_shared_key(&onion->shared_keys_1, shared_key, dht_get_self_secret_key(onion->dht), packet + 1 + CRYPTO_NONCE_SIZE);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                                     length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE), plain);
 
-    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES))
+    if (len != length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE)) {
         return 1;
+    }
 
     return onion_send_1(onion, plain, len, source, packet + 1);
 }
 
 int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port source, const uint8_t *nonce)
 {
-    if (len > ONION_MAX_PACKET_SIZE + SIZE_IPPORT - (1 + crypto_box_NONCEBYTES + ONION_RETURN_1))
+    if (len > ONION_MAX_PACKET_SIZE + SIZE_IPPORT - (1 + CRYPTO_NONCE_SIZE + ONION_RETURN_1)) {
         return 1;
+    }
 
-    if (len <= SIZE_IPPORT + SEND_BASE * 2)
+    if (len <= SIZE_IPPORT + SEND_BASE * 2) {
         return 1;
+    }
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1) {
         return 1;
+    }
 
     uint8_t ip_port[SIZE_IPPORT];
     ipport_pack(ip_port, &source);
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_SEND_1;
-    memcpy(data + 1, nonce, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
-    uint16_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
+    memcpy(data + 1, nonce, CRYPTO_NONCE_SIZE);
+    memcpy(data + 1 + CRYPTO_NONCE_SIZE, plain + SIZE_IPPORT, len - SIZE_IPPORT);
+    uint16_t data_len = 1 + CRYPTO_NONCE_SIZE + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
-    new_nonce(ret_part);
+    random_nonce(ret_part);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ip_port, SIZE_IPPORT,
-                                 ret_part + crypto_box_NONCEBYTES);
+                                 ret_part + CRYPTO_NONCE_SIZE);
 
-    if (len != SIZE_IPPORT + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + CRYPTO_MAC_SIZE) {
         return 1;
+    }
 
-    data_len += crypto_box_NONCEBYTES + len;
+    data_len += CRYPTO_NONCE_SIZE + len;
 
-    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
 
-static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + SEND_2)
+    if (length <= 1 + SEND_2) {
         return 1;
+    }
 
     change_symmetric_key(onion);
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    get_shared_key(&onion->shared_keys_2, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1), plain);
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    get_shared_key(&onion->shared_keys_2, shared_key, dht_get_self_secret_key(onion->dht), packet + 1 + CRYPTO_NONCE_SIZE);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                                     length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_1), plain);
 
-    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1 + crypto_box_MACBYTES))
+    if (len != length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_1 + CRYPTO_MAC_SIZE)) {
         return 1;
+    }
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1) {
         return 1;
+    }
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_SEND_2;
-    memcpy(data + 1, packet + 1, crypto_box_NONCEBYTES);
-    memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
-    uint16_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
+    memcpy(data + 1, packet + 1, CRYPTO_NONCE_SIZE);
+    memcpy(data + 1 + CRYPTO_NONCE_SIZE, plain + SIZE_IPPORT, len - SIZE_IPPORT);
+    uint16_t data_len = 1 + CRYPTO_NONCE_SIZE + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
-    new_nonce(ret_part);
+    random_nonce(ret_part);
     uint8_t ret_data[RETURN_1 + SIZE_IPPORT];
     ipport_pack(ret_data, &source);
     memcpy(ret_data + SIZE_IPPORT, packet + (length - RETURN_1), RETURN_1);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ret_data, sizeof(ret_data),
-                                 ret_part + crypto_box_NONCEBYTES);
+                                 ret_part + CRYPTO_NONCE_SIZE);
 
-    if (len != RETURN_2 - crypto_box_NONCEBYTES)
+    if (len != RETURN_2 - CRYPTO_NONCE_SIZE) {
         return 1;
+    }
 
-    data_len += crypto_box_NONCEBYTES + len;
+    data_len += CRYPTO_NONCE_SIZE + len;
 
-    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
 
-static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + SEND_3)
+    if (length <= 1 + SEND_3) {
         return 1;
+    }
 
     change_symmetric_key(onion);
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    get_shared_key(&onion->shared_keys_3, shared_key, onion->dht->self_secret_key, packet + 1 + crypto_box_NONCEBYTES);
-    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                     length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2), plain);
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    get_shared_key(&onion->shared_keys_3, shared_key, dht_get_self_secret_key(onion->dht), packet + 1 + CRYPTO_NONCE_SIZE);
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                                     length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_2), plain);
 
-    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2 + crypto_box_MACBYTES))
+    if (len != length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + RETURN_2 + CRYPTO_MAC_SIZE)) {
         return 1;
+    }
 
     if (len <= SIZE_IPPORT) {
         return 1;
@@ -449,41 +486,46 @@ static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, ui
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1) {
         return 1;
+    }
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     memcpy(data, plain + SIZE_IPPORT, len - SIZE_IPPORT);
     uint16_t data_len = (len - SIZE_IPPORT);
     uint8_t *ret_part = data + (len - SIZE_IPPORT);
-    new_nonce(ret_part);
+    random_nonce(ret_part);
     uint8_t ret_data[RETURN_2 + SIZE_IPPORT];
     ipport_pack(ret_data, &source);
     memcpy(ret_data + SIZE_IPPORT, packet + (length - RETURN_2), RETURN_2);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ret_data, sizeof(ret_data),
-                                 ret_part + crypto_box_NONCEBYTES);
+                                 ret_part + CRYPTO_NONCE_SIZE);
 
-    if (len != RETURN_3 - crypto_box_NONCEBYTES)
+    if (len != RETURN_3 - CRYPTO_NONCE_SIZE) {
         return 1;
+    }
 
     data_len += RETURN_3;
 
-    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
 
 
-static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + RETURN_3)
+    if (length <= 1 + RETURN_3) {
         return 1;
+    }
 
     if (packet[1 + RETURN_3] != NET_PACKET_ANNOUNCE_RESPONSE &&
             packet[1 + RETURN_3] != NET_PACKET_ONION_DATA_RESPONSE) {
@@ -493,16 +535,18 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
     change_symmetric_key(onion);
 
     uint8_t plain[SIZE_IPPORT + RETURN_2];
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
-                                     SIZE_IPPORT + RETURN_2 + crypto_box_MACBYTES, plain);
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE,
+                                     SIZE_IPPORT + RETURN_2 + CRYPTO_MAC_SIZE, plain);
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != sizeof(plain)) {
         return 1;
+    }
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1) {
         return 1;
+    }
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_2;
@@ -510,21 +554,24 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
     memcpy(data + 1 + RETURN_2, packet + 1 + RETURN_3, length - (1 + RETURN_3));
     uint16_t data_len = 1 + RETURN_2 + (length - (1 + RETURN_3));
 
-    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
 
-static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + RETURN_2)
+    if (length <= 1 + RETURN_2) {
         return 1;
+    }
 
     if (packet[1 + RETURN_2] != NET_PACKET_ANNOUNCE_RESPONSE &&
             packet[1 + RETURN_2] != NET_PACKET_ONION_DATA_RESPONSE) {
@@ -534,16 +581,18 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
     change_symmetric_key(onion);
 
     uint8_t plain[SIZE_IPPORT + RETURN_1];
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
-                                     SIZE_IPPORT + RETURN_1 + crypto_box_MACBYTES, plain);
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE,
+                                     SIZE_IPPORT + RETURN_1 + CRYPTO_MAC_SIZE, plain);
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != sizeof(plain)) {
         return 1;
+    }
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1) {
         return 1;
+    }
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_1;
@@ -551,21 +600,24 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
     memcpy(data + 1 + RETURN_1, packet + 1 + RETURN_2, length - (1 + RETURN_2));
     uint16_t data_len = 1 + RETURN_1 + (length - (1 + RETURN_2));
 
-    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
 
-static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
-    if (length <= 1 + RETURN_1)
+    if (length <= 1 + RETURN_1) {
         return 1;
+    }
 
     if (packet[1 + RETURN_1] != NET_PACKET_ANNOUNCE_RESPONSE &&
             packet[1 + RETURN_1] != NET_PACKET_ONION_DATA_RESPONSE) {
@@ -575,24 +627,30 @@ static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, ui
     change_symmetric_key(onion);
 
     uint8_t plain[SIZE_IPPORT];
-    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES,
-                                     SIZE_IPPORT + crypto_box_MACBYTES, plain);
+    int len = decrypt_data_symmetric(onion->secret_symmetric_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE,
+                                     SIZE_IPPORT + CRYPTO_MAC_SIZE, plain);
 
-    if ((uint32_t)len != SIZE_IPPORT)
+    if ((uint32_t)len != SIZE_IPPORT) {
         return 1;
+    }
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len, 1) == -1)
+    if (ipport_unpack(&send_to, plain, len, 1) == -1) {
         return 1;
+    }
 
     uint16_t data_len = length - (1 + RETURN_1);
 
-    if (onion->recv_1_function && send_to.ip.family != AF_INET && send_to.ip.family != AF_INET6)
+    if (onion->recv_1_function &&
+            !net_family_is_ipv4(send_to.ip.family) &&
+            !net_family_is_ipv6(send_to.ip.family)) {
         return onion->recv_1_function(onion->callback_object, send_to, packet + (1 + RETURN_1), data_len);
+    }
 
-    if ((uint32_t)sendpacket(onion->net, send_to, packet + (1 + RETURN_1), data_len) != data_len)
+    if ((uint32_t)sendpacket(onion->net, send_to, packet + (1 + RETURN_1), data_len) != data_len) {
         return 1;
+    }
 
     return 0;
 }
@@ -605,16 +663,18 @@ void set_callback_handle_recv_1(Onion *onion, int (*function)(void *, IP_Port, c
 
 Onion *new_onion(DHT *dht)
 {
-    if (dht == NULL)
-        return NULL;
+    if (dht == nullptr) {
+        return nullptr;
+    }
 
-    Onion *onion = calloc(1, sizeof(Onion));
+    Onion *onion = (Onion *)calloc(1, sizeof(Onion));
 
-    if (onion == NULL)
-        return NULL;
+    if (onion == nullptr) {
+        return nullptr;
+    }
 
     onion->dht = dht;
-    onion->net = dht->net;
+    onion->net = dht_get_net(dht);
     new_symmetric_key(onion->secret_symmetric_key);
     onion->timestamp = unix_time();
 
@@ -631,16 +691,17 @@ Onion *new_onion(DHT *dht)
 
 void kill_onion(Onion *onion)
 {
-    if (onion == NULL)
+    if (onion == nullptr) {
         return;
+    }
 
-    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_INITIAL, NULL, NULL);
-    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_1, NULL, NULL);
-    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_2, NULL, NULL);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_INITIAL, nullptr, nullptr);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_1, nullptr, nullptr);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_SEND_2, nullptr, nullptr);
 
-    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_3, NULL, NULL);
-    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_2, NULL, NULL);
-    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_1, NULL, NULL);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_3, nullptr, nullptr);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_2, nullptr, nullptr);
+    networking_registerhandler(onion->net, NET_PACKET_ONION_RECV_1, nullptr, nullptr);
 
     free(onion);
 }
diff --git a/toxcore/onion.h b/toxcore/onion.h
index 2b270ea9..e81b3a52 100644
--- a/toxcore/onion.h
+++ b/toxcore/onion.h
@@ -1,25 +1,26 @@
 /*
-* onion.h -- Implementation of the onion part of docs/Prevent_Tracking.txt
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the onion part of docs/Prevent_Tracking.txt
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifndef ONION_H
 #define ONION_H
 
@@ -28,7 +29,7 @@
 typedef struct {
     DHT     *dht;
     Networking_Core *net;
-    uint8_t secret_symmetric_key[crypto_box_KEYBYTES];
+    uint8_t secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE];
     uint64_t timestamp;
 
     Shared_Keys shared_keys_1;
@@ -41,14 +42,14 @@ typedef struct {
 
 #define ONION_MAX_PACKET_SIZE 1400
 
-#define ONION_RETURN_1 (crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_MACBYTES)
-#define ONION_RETURN_2 (crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_MACBYTES + ONION_RETURN_1)
-#define ONION_RETURN_3 (crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_MACBYTES + ONION_RETURN_2)
+#define ONION_RETURN_1 (CRYPTO_NONCE_SIZE + SIZE_IPPORT + CRYPTO_MAC_SIZE)
+#define ONION_RETURN_2 (CRYPTO_NONCE_SIZE + SIZE_IPPORT + CRYPTO_MAC_SIZE + ONION_RETURN_1)
+#define ONION_RETURN_3 (CRYPTO_NONCE_SIZE + SIZE_IPPORT + CRYPTO_MAC_SIZE + ONION_RETURN_2)
 
-#define ONION_SEND_BASE (crypto_box_PUBLICKEYBYTES + SIZE_IPPORT + crypto_box_MACBYTES)
-#define ONION_SEND_3 (crypto_box_NONCEBYTES + ONION_SEND_BASE + ONION_RETURN_2)
-#define ONION_SEND_2 (crypto_box_NONCEBYTES + ONION_SEND_BASE*2 + ONION_RETURN_1)
-#define ONION_SEND_1 (crypto_box_NONCEBYTES + ONION_SEND_BASE*3)
+#define ONION_SEND_BASE (CRYPTO_PUBLIC_KEY_SIZE + SIZE_IPPORT + CRYPTO_MAC_SIZE)
+#define ONION_SEND_3 (CRYPTO_NONCE_SIZE + ONION_SEND_BASE + ONION_RETURN_2)
+#define ONION_SEND_2 (CRYPTO_NONCE_SIZE + ONION_SEND_BASE*2 + ONION_RETURN_1)
+#define ONION_SEND_1 (CRYPTO_NONCE_SIZE + ONION_SEND_BASE*3)
 
 #define ONION_MAX_DATA_SIZE (ONION_MAX_PACKET_SIZE - (ONION_SEND_1 + 1))
 #define ONION_RESPONSE_MAX_DATA_SIZE (ONION_MAX_PACKET_SIZE - (1 + ONION_RETURN_3))
@@ -56,22 +57,22 @@ typedef struct {
 #define ONION_PATH_LENGTH 3
 
 typedef struct {
-    uint8_t shared_key1[crypto_box_BEFORENMBYTES];
-    uint8_t shared_key2[crypto_box_BEFORENMBYTES];
-    uint8_t shared_key3[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key1[CRYPTO_SHARED_KEY_SIZE];
+    uint8_t shared_key2[CRYPTO_SHARED_KEY_SIZE];
+    uint8_t shared_key3[CRYPTO_SHARED_KEY_SIZE];
 
-    uint8_t public_key1[crypto_box_PUBLICKEYBYTES];
-    uint8_t public_key2[crypto_box_PUBLICKEYBYTES];
-    uint8_t public_key3[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key1[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t public_key2[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t public_key3[CRYPTO_PUBLIC_KEY_SIZE];
 
     IP_Port     ip_port1;
-    uint8_t     node_public_key1[crypto_box_PUBLICKEYBYTES];
+    uint8_t     node_public_key1[CRYPTO_PUBLIC_KEY_SIZE];
 
     IP_Port     ip_port2;
-    uint8_t     node_public_key2[crypto_box_PUBLICKEYBYTES];
+    uint8_t     node_public_key2[CRYPTO_PUBLIC_KEY_SIZE];
 
     IP_Port     ip_port3;
-    uint8_t     node_public_key3[crypto_box_PUBLICKEYBYTES];
+    uint8_t     node_public_key3[CRYPTO_PUBLIC_KEY_SIZE];
 
     uint32_t path_num;
 } Onion_Path;
@@ -144,12 +145,12 @@ int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data,
  *
  * Used to handle these packets that are received in a non traditional way (by TCP for example).
  *
- * Source family must be set to something else than AF_INET6 or AF_INET so that the callback gets called
+ * Source family must be set to something else than TOX_AF_INET6 or TOX_AF_INET so that the callback gets called
  * when the response is received.
  */
 int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port source, const uint8_t *nonce);
 
-/* Set the callback to be called when the dest ip_port doesn't have AF_INET6 or AF_INET as the family.
+/* Set the callback to be called when the dest ip_port doesn't have TOX_AF_INET6 or TOX_AF_INET as the family.
  *
  * Format: function(void *object, IP_Port dest, uint8_t *data, uint16_t length)
  */
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index 676b38da..6c9e8659 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -1,39 +1,73 @@
 /*
-* onion_announce.c -- Implementation of the announce part of docs/Prevent_Tracking.txt
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the announce part of docs/Prevent_Tracking.txt
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "onion_announce.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "LAN_discovery.h"
 #include "util.h"
 
-#define PING_ID_TIMEOUT 20
+#define PING_ID_TIMEOUT ONION_ANNOUNCE_TIMEOUT
 
 #define ANNOUNCE_REQUEST_SIZE_RECV (ONION_ANNOUNCE_REQUEST_SIZE + ONION_RETURN_3)
 
 #define DATA_REQUEST_MIN_SIZE ONION_DATA_REQUEST_MIN_SIZE
 #define DATA_REQUEST_MIN_SIZE_RECV (DATA_REQUEST_MIN_SIZE + ONION_RETURN_3)
 
+typedef struct {
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    IP_Port ret_ip_port;
+    uint8_t ret[ONION_RETURN_3];
+    uint8_t data_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint64_t time;
+} Onion_Announce_Entry;
+
+struct Onion_Announce {
+    DHT     *dht;
+    Networking_Core *net;
+    Onion_Announce_Entry entries[ONION_ANNOUNCE_MAX_ENTRIES];
+    /* This is CRYPTO_SYMMETRIC_KEY_SIZE long just so we can use new_symmetric_key() to fill it */
+    uint8_t secret_bytes[CRYPTO_SYMMETRIC_KEY_SIZE];
+
+    Shared_Keys shared_keys_recv;
+};
+
+uint8_t *onion_announce_entry_public_key(Onion_Announce *onion_a, uint32_t entry)
+{
+    return onion_a->entries[entry].public_key;
+}
+
+void onion_announce_entry_set_time(Onion_Announce *onion_a, uint32_t entry, uint64_t time)
+{
+    onion_a->entries[entry].time = time;
+}
+
 /* Create an onion announce request packet in packet of max_packet_length (recommended size ONION_ANNOUNCE_REQUEST_SIZE).
  *
  * dest_client_id is the public key of the node the packet will be sent to.
@@ -51,27 +85,29 @@ int create_announce_request(uint8_t *packet, uint16_t max_packet_length, const u
                             const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id, const uint8_t *client_id,
                             const uint8_t *data_public_key, uint64_t sendback_data)
 {
-    if (max_packet_length < ONION_ANNOUNCE_REQUEST_SIZE)
+    if (max_packet_length < ONION_ANNOUNCE_REQUEST_SIZE) {
         return -1;
+    }
 
-    uint8_t plain[ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES +
-                  ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
+    uint8_t plain[ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE +
+                                     ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
     memcpy(plain, ping_id, ONION_PING_ID_SIZE);
-    memcpy(plain + ONION_PING_ID_SIZE, client_id, crypto_box_PUBLICKEYBYTES);
-    memcpy(plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES, data_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES, &sendback_data,
+    memcpy(plain + ONION_PING_ID_SIZE, client_id, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(plain + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE, data_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(plain + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE, &sendback_data,
            sizeof(sendback_data));
 
     packet[0] = NET_PACKET_ANNOUNCE_REQUEST;
     random_nonce(packet + 1);
 
     int len = encrypt_data(dest_client_id, secret_key, packet + 1, plain, sizeof(plain),
-                           packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+                           packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if ((uint32_t)len + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES != ONION_ANNOUNCE_REQUEST_SIZE)
+    if ((uint32_t)len + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE != ONION_ANNOUNCE_REQUEST_SIZE) {
         return -1;
+    }
 
-    memcpy(packet + 1 + crypto_box_NONCEBYTES, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + 1 + CRYPTO_NONCE_SIZE, public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     return ONION_ANNOUNCE_REQUEST_SIZE;
 }
@@ -89,28 +125,31 @@ int create_announce_request(uint8_t *packet, uint16_t max_packet_length, const u
 int create_data_request(uint8_t *packet, uint16_t max_packet_length, const uint8_t *public_key,
                         const uint8_t *encrypt_public_key, const uint8_t *nonce, const uint8_t *data, uint16_t length)
 {
-    if (DATA_REQUEST_MIN_SIZE + length > max_packet_length)
+    if (DATA_REQUEST_MIN_SIZE + length > max_packet_length) {
         return -1;
+    }
 
-    if ((unsigned int)DATA_REQUEST_MIN_SIZE + length > ONION_MAX_DATA_SIZE)
+    if (DATA_REQUEST_MIN_SIZE + length > ONION_MAX_DATA_SIZE) {
         return -1;
+    }
 
     packet[0] = NET_PACKET_ONION_DATA_REQUEST;
-    memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
+    memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE);
 
-    uint8_t random_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t random_secret_key[crypto_box_SECRETKEYBYTES];
-    crypto_box_keypair(random_public_key, random_secret_key);
+    uint8_t random_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t random_secret_key[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(random_public_key, random_secret_key);
 
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, random_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE, random_public_key, CRYPTO_PUBLIC_KEY_SIZE);
 
-    int len = encrypt_data(encrypt_public_key, random_secret_key, packet + 1 + crypto_box_PUBLICKEYBYTES, data, length,
-                           packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data(encrypt_public_key, random_secret_key, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, data, length,
+                           packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + len != DATA_REQUEST_MIN_SIZE +
-            length)
+    if (1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + len != DATA_REQUEST_MIN_SIZE +
+            length) {
         return -1;
+    }
 
     return DATA_REQUEST_MIN_SIZE + length;
 }
@@ -137,17 +176,20 @@ int send_announce_request(Networking_Core *net, const Onion_Path *path, Node_for
     int len = create_announce_request(request, sizeof(request), dest.public_key, public_key, secret_key, ping_id, client_id,
                                       data_public_key, sendback_data);
 
-    if (len != sizeof(request))
+    if (len != sizeof(request)) {
         return -1;
+    }
 
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     len = create_onion_packet(packet, sizeof(packet), path, dest.ip_port, request, sizeof(request));
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
-    if (sendpacket(net, path->ip_port1, packet, len) != len)
+    if (sendpacket(net, path->ip_port1, packet, len) != len) {
         return -1;
+    }
 
     return 0;
 }
@@ -172,17 +214,20 @@ int send_data_request(Networking_Core *net, const Onion_Path *path, IP_Port dest
     uint8_t request[ONION_MAX_DATA_SIZE];
     int len = create_data_request(request, sizeof(request), public_key, encrypt_public_key, nonce, data, length);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     len = create_onion_packet(packet, sizeof(packet), path, dest, request, len);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
-    if (sendpacket(net, path->ip_port1, packet, len) != len)
+    if (sendpacket(net, path->ip_port1, packet, len) != len) {
         return -1;
+    }
 
     return 0;
 }
@@ -192,12 +237,12 @@ static void generate_ping_id(const Onion_Announce *onion_a, uint64_t time, const
                              IP_Port ret_ip_port, uint8_t *ping_id)
 {
     time /= PING_ID_TIMEOUT;
-    uint8_t data[crypto_box_KEYBYTES + sizeof(time) + crypto_box_PUBLICKEYBYTES + sizeof(ret_ip_port)];
-    memcpy(data, onion_a->secret_bytes, crypto_box_KEYBYTES);
-    memcpy(data + crypto_box_KEYBYTES, &time, sizeof(time));
-    memcpy(data + crypto_box_KEYBYTES + sizeof(time), public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(data + crypto_box_KEYBYTES + sizeof(time) + crypto_box_PUBLICKEYBYTES, &ret_ip_port, sizeof(ret_ip_port));
-    crypto_hash_sha256(ping_id, data, sizeof(data));
+    uint8_t data[CRYPTO_SYMMETRIC_KEY_SIZE + sizeof(time) + CRYPTO_PUBLIC_KEY_SIZE + sizeof(ret_ip_port)];
+    memcpy(data, onion_a->secret_bytes, CRYPTO_SYMMETRIC_KEY_SIZE);
+    memcpy(data + CRYPTO_SYMMETRIC_KEY_SIZE, &time, sizeof(time));
+    memcpy(data + CRYPTO_SYMMETRIC_KEY_SIZE + sizeof(time), public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(data + CRYPTO_SYMMETRIC_KEY_SIZE + sizeof(time) + CRYPTO_PUBLIC_KEY_SIZE, &ret_ip_port, sizeof(ret_ip_port));
+    crypto_sha256(ping_id, data, sizeof(data));
 }
 
 /* check if public key is in entries list
@@ -211,42 +256,74 @@ static int in_entries(const Onion_Announce *onion_a, const uint8_t *public_key)
 
     for (i = 0; i < ONION_ANNOUNCE_MAX_ENTRIES; ++i) {
         if (!is_timeout(onion_a->entries[i].time, ONION_ANNOUNCE_TIMEOUT)
-                && public_key_cmp(onion_a->entries[i].public_key, public_key) == 0)
+                && public_key_cmp(onion_a->entries[i].public_key, public_key) == 0) {
             return i;
+        }
     }
 
     return -1;
 }
 
-static uint8_t cmp_public_key[crypto_box_PUBLICKEYBYTES];
+typedef struct {
+    const uint8_t *base_public_key;
+    Onion_Announce_Entry entry;
+} Cmp_data;
+
 static int cmp_entry(const void *a, const void *b)
 {
-    Onion_Announce_Entry entry1, entry2;
-    memcpy(&entry1, a, sizeof(Onion_Announce_Entry));
-    memcpy(&entry2, b, sizeof(Onion_Announce_Entry));
+    Cmp_data cmp1, cmp2;
+    memcpy(&cmp1, a, sizeof(Cmp_data));
+    memcpy(&cmp2, b, sizeof(Cmp_data));
+    Onion_Announce_Entry entry1 = cmp1.entry;
+    Onion_Announce_Entry entry2 = cmp2.entry;
+    const uint8_t *cmp_public_key = cmp1.base_public_key;
+
     int t1 = is_timeout(entry1.time, ONION_ANNOUNCE_TIMEOUT);
     int t2 = is_timeout(entry2.time, ONION_ANNOUNCE_TIMEOUT);
 
-    if (t1 && t2)
+    if (t1 && t2) {
         return 0;
+    }
 
-    if (t1)
+    if (t1) {
         return -1;
+    }
 
-    if (t2)
+    if (t2) {
         return 1;
+    }
 
     int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
 
-    if (close == 1)
+    if (close == 1) {
         return 1;
+    }
 
-    if (close == 2)
+    if (close == 2) {
         return -1;
+    }
 
     return 0;
 }
 
+static void sort_onion_announce_list(Onion_Announce_Entry *list, unsigned int length, const uint8_t *comp_public_key)
+{
+    // Pass comp_public_key to qsort with each Client_data entry, so the
+    // comparison function can use it as the base of comparison.
+    VLA(Cmp_data, cmp_list, length);
+
+    for (uint32_t i = 0; i < length; i++) {
+        cmp_list[i].base_public_key = comp_public_key;
+        cmp_list[i].entry = list[i];
+    }
+
+    qsort(cmp_list, length, sizeof(Cmp_data), cmp_entry);
+
+    for (uint32_t i = 0; i < length; i++) {
+        list[i] = cmp_list[i].entry;
+    }
+}
+
 /* add entry to entries list
  *
  * return -1 if failure
@@ -258,53 +335,55 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
 
     int pos = in_entries(onion_a, public_key);
 
-    unsigned int i;
-
     if (pos == -1) {
-        for (i = 0; i < ONION_ANNOUNCE_MAX_ENTRIES; ++i) {
-            if (is_timeout(onion_a->entries[i].time, ONION_ANNOUNCE_TIMEOUT))
+        for (unsigned i = 0; i < ONION_ANNOUNCE_MAX_ENTRIES; ++i) {
+            if (is_timeout(onion_a->entries[i].time, ONION_ANNOUNCE_TIMEOUT)) {
                 pos = i;
+            }
         }
     }
 
     if (pos == -1) {
-        if (id_closest(onion_a->dht->self_public_key, public_key, onion_a->entries[0].public_key) == 1)
+        if (id_closest(dht_get_self_public_key(onion_a->dht), public_key, onion_a->entries[0].public_key) == 1) {
             pos = 0;
+        }
     }
 
-    if (pos == -1)
+    if (pos == -1) {
         return -1;
+    }
 
-    memcpy(onion_a->entries[pos].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(onion_a->entries[pos].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     onion_a->entries[pos].ret_ip_port = ret_ip_port;
     memcpy(onion_a->entries[pos].ret, ret, ONION_RETURN_3);
-    memcpy(onion_a->entries[pos].data_public_key, data_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(onion_a->entries[pos].data_public_key, data_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     onion_a->entries[pos].time = unix_time();
 
-    memcpy(cmp_public_key, onion_a->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
-    qsort(onion_a->entries, ONION_ANNOUNCE_MAX_ENTRIES, sizeof(Onion_Announce_Entry), cmp_entry);
+    sort_onion_announce_list(onion_a->entries, ONION_ANNOUNCE_MAX_ENTRIES, dht_get_self_public_key(onion_a->dht));
     return in_entries(onion_a, public_key);
 }
 
-static int handle_announce_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length != ANNOUNCE_REQUEST_SIZE_RECV) {
         return 1;
+    }
 
-    const uint8_t *packet_public_key = packet + 1 + crypto_box_NONCEBYTES;
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
-    get_shared_key(&onion_a->shared_keys_recv, shared_key, onion_a->dht->self_secret_key, packet_public_key);
+    const uint8_t *packet_public_key = packet + 1 + CRYPTO_NONCE_SIZE;
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
+    get_shared_key(&onion_a->shared_keys_recv, shared_key, dht_get_self_secret_key(onion_a->dht), packet_public_key);
 
-    uint8_t plain[ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES +
-                  ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
-    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                                     ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH +
-                                     crypto_box_MACBYTES, plain);
+    uint8_t plain[ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE +
+                                     ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
+    int len = decrypt_data_symmetric(shared_key, packet + 1, packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                                     ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH +
+                                     CRYPTO_MAC_SIZE, plain);
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != sizeof(plain)) {
         return 1;
+    }
 
     uint8_t ping_id1[ONION_PING_ID_SIZE];
     generate_ping_id(onion_a, unix_time(), packet_public_key, source, ping_id1);
@@ -312,12 +391,12 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
     uint8_t ping_id2[ONION_PING_ID_SIZE];
     generate_ping_id(onion_a, unix_time() + PING_ID_TIMEOUT, packet_public_key, source, ping_id2);
 
-    int index = -1;
+    int index;
 
-    uint8_t *data_public_key = plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES;
+    uint8_t *data_public_key = plain + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE;
 
-    if (sodium_memcmp(ping_id1, plain, ONION_PING_ID_SIZE) == 0
-            || sodium_memcmp(ping_id2, plain, ONION_PING_ID_SIZE) == 0) {
+    if (crypto_memcmp(ping_id1, plain, ONION_PING_ID_SIZE) == 0
+            || crypto_memcmp(ping_id2, plain, ONION_PING_ID_SIZE) == 0) {
         index = add_to_entries(onion_a, source, packet_public_key, data_public_key,
                                packet + (ANNOUNCE_REQUEST_SIZE_RECV - ONION_RETURN_3));
     } else {
@@ -326,9 +405,9 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
 
     /*Respond with a announce response packet*/
     Node_format nodes_list[MAX_SENT_NODES];
-    unsigned int num_nodes = get_close_nodes(onion_a->dht, plain + ONION_PING_ID_SIZE, nodes_list, 0,
-                             LAN_ip(source.ip) == 0, 1);
-    uint8_t nonce[crypto_box_NONCEBYTES];
+    unsigned int num_nodes = get_close_nodes(onion_a->dht, plain + ONION_PING_ID_SIZE, nodes_list, net_family_unspec,
+                             ip_is_lan(source.ip) == 0, 1);
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
     random_nonce(nonce);
 
     uint8_t pl[1 + ONION_PING_ID_SIZE + sizeof(nodes_list)];
@@ -347,7 +426,7 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
             }
         } else {
             pl[0] = 1;
-            memcpy(pl + 1, onion_a->entries[index].data_public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(pl + 1, onion_a->entries[index].data_public_key, CRYPTO_PUBLIC_KEY_SIZE);
         }
     }
 
@@ -356,68 +435,77 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
     if (num_nodes != 0) {
         nodes_length = pack_nodes(pl + 1 + ONION_PING_ID_SIZE, sizeof(nodes_list), nodes_list, num_nodes);
 
-        if (nodes_length <= 0)
+        if (nodes_length <= 0) {
             return 1;
+        }
     }
 
     uint8_t data[ONION_ANNOUNCE_RESPONSE_MAX_SIZE];
     len = encrypt_data_symmetric(shared_key, nonce, pl, 1 + ONION_PING_ID_SIZE + nodes_length,
-                                 data + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES);
+                                 data + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE);
 
-    if (len != 1 + ONION_PING_ID_SIZE + nodes_length + crypto_box_MACBYTES)
+    if (len != 1 + ONION_PING_ID_SIZE + nodes_length + CRYPTO_MAC_SIZE) {
         return 1;
+    }
 
     data[0] = NET_PACKET_ANNOUNCE_RESPONSE;
-    memcpy(data + 1, plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES,
+    memcpy(data + 1, plain + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
            ONION_ANNOUNCE_SENDBACK_DATA_LENGTH);
-    memcpy(data + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH, nonce, crypto_box_NONCEBYTES);
+    memcpy(data + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH, nonce, CRYPTO_NONCE_SIZE);
 
     if (send_onion_response(onion_a->net, source, data,
-                            1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES + len,
-                            packet + (ANNOUNCE_REQUEST_SIZE_RECV - ONION_RETURN_3)) == -1)
+                            1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE + len,
+                            packet + (ANNOUNCE_REQUEST_SIZE_RECV - ONION_RETURN_3)) == -1) {
         return 1;
+    }
 
     return 0;
 }
 
-static int handle_data_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length <= DATA_REQUEST_MIN_SIZE_RECV) {
         return 1;
+    }
 
-    if (length > ONION_MAX_PACKET_SIZE)
+    if (length > ONION_MAX_PACKET_SIZE) {
         return 1;
+    }
 
     int index = in_entries(onion_a, packet + 1);
 
-    if (index == -1)
+    if (index == -1) {
         return 1;
+    }
 
-    uint8_t data[length - (crypto_box_PUBLICKEYBYTES + ONION_RETURN_3)];
+    VLA(uint8_t, data, length - (CRYPTO_PUBLIC_KEY_SIZE + ONION_RETURN_3));
     data[0] = NET_PACKET_ONION_DATA_RESPONSE;
-    memcpy(data + 1, packet + 1 + crypto_box_PUBLICKEYBYTES, length - (1 + crypto_box_PUBLICKEYBYTES + ONION_RETURN_3));
+    memcpy(data + 1, packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, length - (1 + CRYPTO_PUBLIC_KEY_SIZE + ONION_RETURN_3));
 
-    if (send_onion_response(onion_a->net, onion_a->entries[index].ret_ip_port, data, sizeof(data),
-                            onion_a->entries[index].ret) == -1)
+    if (send_onion_response(onion_a->net, onion_a->entries[index].ret_ip_port, data, SIZEOF_VLA(data),
+                            onion_a->entries[index].ret) == -1) {
         return 1;
+    }
 
     return 0;
 }
 
 Onion_Announce *new_onion_announce(DHT *dht)
 {
-    if (dht == NULL)
-        return NULL;
+    if (dht == nullptr) {
+        return nullptr;
+    }
 
-    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;
+    if (onion_a == nullptr) {
+        return nullptr;
+    }
 
     onion_a->dht = dht;
-    onion_a->net = dht->net;
+    onion_a->net = dht_get_net(dht);
     new_symmetric_key(onion_a->secret_bytes);
 
     networking_registerhandler(onion_a->net, NET_PACKET_ANNOUNCE_REQUEST, &handle_announce_request, onion_a);
@@ -428,10 +516,11 @@ Onion_Announce *new_onion_announce(DHT *dht)
 
 void kill_onion_announce(Onion_Announce *onion_a)
 {
-    if (onion_a == NULL)
+    if (onion_a == nullptr) {
         return;
+    }
 
-    networking_registerhandler(onion_a->net, NET_PACKET_ANNOUNCE_REQUEST, NULL, NULL);
-    networking_registerhandler(onion_a->net, NET_PACKET_ONION_DATA_REQUEST, NULL, NULL);
+    networking_registerhandler(onion_a->net, NET_PACKET_ANNOUNCE_REQUEST, nullptr, nullptr);
+    networking_registerhandler(onion_a->net, NET_PACKET_ONION_DATA_REQUEST, nullptr, nullptr);
     free(onion_a);
 }
diff --git a/toxcore/onion_announce.h b/toxcore/onion_announce.h
index a9128be8..36484ff2 100644
--- a/toxcore/onion_announce.h
+++ b/toxcore/onion_announce.h
@@ -1,25 +1,26 @@
 /*
-* onion_announce.h -- Implementation of the announce part of docs/Prevent_Tracking.txt
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the announce part of docs/Prevent_Tracking.txt
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifndef ONION_ANNOUNCE_H
 #define ONION_ANNOUNCE_H
 
@@ -27,41 +28,29 @@
 
 #define ONION_ANNOUNCE_MAX_ENTRIES 160
 #define ONION_ANNOUNCE_TIMEOUT 300
-#define ONION_PING_ID_SIZE crypto_hash_sha256_BYTES
+#define ONION_PING_ID_SIZE CRYPTO_SHA256_SIZE
 
 #define ONION_ANNOUNCE_SENDBACK_DATA_LENGTH (sizeof(uint64_t))
 
-#define ONION_ANNOUNCE_REQUEST_SIZE (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_MACBYTES)
+#define ONION_ANNOUNCE_REQUEST_SIZE (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + ONION_PING_ID_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_MAC_SIZE)
 
-#define ONION_ANNOUNCE_RESPONSE_MIN_SIZE (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES + 1 + ONION_PING_ID_SIZE + crypto_box_MACBYTES)
+#define ONION_ANNOUNCE_RESPONSE_MIN_SIZE (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE + 1 + ONION_PING_ID_SIZE + CRYPTO_MAC_SIZE)
 #define ONION_ANNOUNCE_RESPONSE_MAX_SIZE (ONION_ANNOUNCE_RESPONSE_MIN_SIZE + sizeof(Node_format)*MAX_SENT_NODES)
 
-#define ONION_DATA_RESPONSE_MIN_SIZE (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES)
+#define ONION_DATA_RESPONSE_MIN_SIZE (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE)
 
-#if ONION_PING_ID_SIZE != crypto_box_PUBLICKEYBYTES
-#error announce response packets assume that ONION_PING_ID_SIZE is equal to crypto_box_PUBLICKEYBYTES
+#if ONION_PING_ID_SIZE != CRYPTO_PUBLIC_KEY_SIZE
+#error announce response packets assume that ONION_PING_ID_SIZE is equal to CRYPTO_PUBLIC_KEY_SIZE
 #endif
 
-#define ONION_DATA_REQUEST_MIN_SIZE (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES)
+#define ONION_DATA_REQUEST_MIN_SIZE (1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE)
 #define MAX_DATA_REQUEST_SIZE (ONION_MAX_DATA_SIZE - ONION_DATA_REQUEST_MIN_SIZE)
 
-typedef struct {
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    IP_Port ret_ip_port;
-    uint8_t ret[ONION_RETURN_3];
-    uint8_t data_public_key[crypto_box_PUBLICKEYBYTES];
-    uint64_t time;
-} Onion_Announce_Entry;
-
-typedef struct {
-    DHT     *dht;
-    Networking_Core *net;
-    Onion_Announce_Entry entries[ONION_ANNOUNCE_MAX_ENTRIES];
-    /* This is crypto_box_KEYBYTES long just so we can use new_symmetric_key() to fill it */
-    uint8_t secret_bytes[crypto_box_KEYBYTES];
-
-    Shared_Keys shared_keys_recv;
-} Onion_Announce;
+typedef struct Onion_Announce Onion_Announce;
+
+/* These two are not public; they are for tests only! */
+uint8_t *onion_announce_entry_public_key(Onion_Announce *onion_a, uint32_t entry);
+void onion_announce_entry_set_time(Onion_Announce *onion_a, uint32_t entry, uint64_t time);
 
 /* Create an onion announce request packet in packet of max_packet_length (recommended size ONION_ANNOUNCE_REQUEST_SIZE).
  *
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index b879f393..fa6c08c9 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -1,38 +1,161 @@
 /*
-* onion_client.c -- Implementation of the client part of docs/Prevent_Tracking.txt
-*                   (The part that uses the onion stuff to connect to the friend)
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the client part of docs/Prevent_Tracking.txt (The part that
+ * uses the onion stuff to connect to the friend)
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "onion_client.h"
-#include "util.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "LAN_discovery.h"
+#include "util.h"
 
 /* defines for the array size and
    timeout for onion announce packets. */
 #define ANNOUNCE_ARRAY_SIZE 256
 #define ANNOUNCE_TIMEOUT 10
 
+typedef struct {
+    uint8_t     public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    IP_Port     ip_port;
+    uint8_t     ping_id[ONION_PING_ID_SIZE];
+    uint8_t     data_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t     is_stored;
+
+    uint64_t    added_time;
+
+    uint64_t    timestamp;
+
+    uint64_t    last_pinged;
+
+    uint8_t     unsuccessful_pings;
+
+    uint32_t    path_used;
+} Onion_Node;
+
+typedef struct {
+    Onion_Path paths[NUMBER_ONION_PATHS];
+    uint64_t last_path_success[NUMBER_ONION_PATHS];
+    uint64_t last_path_used[NUMBER_ONION_PATHS];
+    uint64_t path_creation_time[NUMBER_ONION_PATHS];
+    /* number of times used without success. */
+    unsigned int last_path_used_times[NUMBER_ONION_PATHS];
+} Onion_Client_Paths;
+
+typedef struct {
+    uint8_t     public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint64_t    timestamp;
+} Last_Pinged;
+
+typedef struct {
+    uint8_t status; /* 0 if friend is not valid, 1 if friend is valid.*/
+    uint8_t is_online; /* Set by the onion_set_friend_status function. */
+
+    uint8_t know_dht_public_key; /* 0 if we don't know the dht public key of the other, 1 if we do. */
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t real_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+
+    Onion_Node clients_list[MAX_ONION_CLIENTS];
+    uint8_t temp_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t temp_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    uint64_t last_reported_announced;
+
+    uint64_t last_dht_pk_onion_sent;
+    uint64_t last_dht_pk_dht_sent;
+
+    uint64_t last_noreplay;
+
+    uint64_t last_seen;
+
+    Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
+    uint8_t last_pinged_index;
+
+    int (*tcp_relay_node_callback)(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key);
+    void *tcp_relay_node_callback_object;
+    uint32_t tcp_relay_node_callback_number;
+
+    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key, void *userdata);
+    void *dht_pk_callback_object;
+    uint32_t dht_pk_callback_number;
+
+    uint32_t run_count;
+} Onion_Friend;
+
+struct Onion_Client {
+    DHT     *dht;
+    Net_Crypto *c;
+    Networking_Core *net;
+    Onion_Friend    *friends_list;
+    uint16_t       num_friends;
+
+    Onion_Node clients_announce_list[MAX_ONION_CLIENTS_ANNOUNCE];
+    uint64_t last_announce;
+
+    Onion_Client_Paths onion_paths_self;
+    Onion_Client_Paths onion_paths_friends;
+
+    uint8_t secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE];
+    uint64_t last_run, first_run;
+
+    uint8_t temp_public_key[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t temp_secret_key[CRYPTO_SECRET_KEY_SIZE];
+
+    Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
+
+    Node_format path_nodes[MAX_PATH_NODES];
+    uint16_t path_nodes_index;
+
+    Node_format path_nodes_bs[MAX_PATH_NODES];
+    uint16_t path_nodes_index_bs;
+
+    Ping_Array *announce_ping_array;
+    uint8_t last_pinged_index;
+    struct {
+        oniondata_handler_callback function;
+        void *object;
+    } Onion_Data_Handlers[256];
+
+    uint64_t last_packet_recv;
+
+    unsigned int onion_connected;
+    bool UDP_connected;
+};
+
+DHT *onion_get_dht(const Onion_Client *onion_c)
+{
+    return onion_c->dht;
+}
+
+Net_Crypto *onion_get_net_crypto(const Onion_Client *onion_c)
+{
+    return onion_c->c;
+}
+
 /* Add a node to the path_nodes bootstrap array.
  *
  * return -1 on failure
@@ -40,25 +163,28 @@
  */
 int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *public_key)
 {
-    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+    if (!net_family_is_ipv4(ip_port.ip.family) && !net_family_is_ipv6(ip_port.ip.family)) {
         return -1;
+    }
 
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (public_key_cmp(public_key, onion_c->path_nodes_bs[i].public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->path_nodes_bs[i].public_key) == 0) {
             return -1;
+        }
     }
 
     onion_c->path_nodes_bs[onion_c->path_nodes_index_bs % MAX_PATH_NODES].ip_port = ip_port;
     memcpy(onion_c->path_nodes_bs[onion_c->path_nodes_index_bs % MAX_PATH_NODES].public_key, public_key,
-           crypto_box_PUBLICKEYBYTES);
+           CRYPTO_PUBLIC_KEY_SIZE);
 
     uint16_t last = onion_c->path_nodes_index_bs;
     ++onion_c->path_nodes_index_bs;
 
-    if (onion_c->path_nodes_index_bs < last)
+    if (onion_c->path_nodes_index_bs < last) {
         onion_c->path_nodes_index_bs = MAX_PATH_NODES + 1;
+    }
 
     return 0;
 }
@@ -70,25 +196,28 @@ int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t
  */
 static int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *public_key)
 {
-    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+    if (!net_family_is_ipv4(ip_port.ip.family) && !net_family_is_ipv6(ip_port.ip.family)) {
         return -1;
+    }
 
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (public_key_cmp(public_key, onion_c->path_nodes[i].public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->path_nodes[i].public_key) == 0) {
             return -1;
+        }
     }
 
     onion_c->path_nodes[onion_c->path_nodes_index % MAX_PATH_NODES].ip_port = ip_port;
     memcpy(onion_c->path_nodes[onion_c->path_nodes_index % MAX_PATH_NODES].public_key, public_key,
-           crypto_box_PUBLICKEYBYTES);
+           CRYPTO_PUBLIC_KEY_SIZE);
 
     uint16_t last = onion_c->path_nodes_index;
     ++onion_c->path_nodes_index;
 
-    if (onion_c->path_nodes_index < last)
+    if (onion_c->path_nodes_index < last) {
         onion_c->path_nodes_index = MAX_PATH_NODES + 1;
+    }
 
     return 0;
 }
@@ -101,16 +230,19 @@ uint16_t onion_backup_nodes(const Onion_Client *onion_c, Node_format *nodes, uin
 {
     unsigned int i;
 
-    if (!max_num)
+    if (!max_num) {
         return 0;
+    }
 
     unsigned int num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
-    if (num_nodes < max_num)
+    if (num_nodes < max_num) {
         max_num = num_nodes;
+    }
 
     for (i = 0; i < max_num; ++i) {
         nodes[i] = onion_c->path_nodes[(onion_c->path_nodes_index - (1 + i)) % num_nodes];
@@ -127,15 +259,17 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
 {
     unsigned int i;
 
-    if (!max_num)
+    if (!max_num) {
         return 0;
+    }
 
     unsigned int num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
 
     //if (DHT_non_lan_connected(onion_c->dht)) {
     if (DHT_isconnected(onion_c->dht)) {
-        if (num_nodes == 0)
+        if (num_nodes == 0) {
             return 0;
+        }
 
         for (i = 0; i < max_num; ++i) {
             nodes[i] = onion_c->path_nodes[rand() % num_nodes];
@@ -148,8 +282,8 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
         }
 
         if (num_nodes >= 2) {
-            nodes[0].ip_port.ip.family = TCP_FAMILY;
-            nodes[0].ip_port.ip.ip4.uint32 = random_tcp;
+            nodes[0].ip_port.ip.family = net_family_tcp_family;
+            nodes[0].ip_port.ip.ip.v4.uint32 = random_tcp;
 
             for (i = 1; i < max_num; ++i) {
                 nodes[i] = onion_c->path_nodes[rand() % num_nodes];
@@ -158,11 +292,12 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
             unsigned int num_nodes_bs = (onion_c->path_nodes_index_bs < MAX_PATH_NODES) ? onion_c->path_nodes_index_bs :
                                         MAX_PATH_NODES;
 
-            if (num_nodes_bs == 0)
+            if (num_nodes_bs == 0) {
                 return 0;
+            }
 
-            nodes[0].ip_port.ip.family = TCP_FAMILY;
-            nodes[0].ip_port.ip.ip4.uint32 = random_tcp;
+            nodes[0].ip_port.ip.family = net_family_tcp_family;
+            nodes[0].ip_port.ip.ip.v4.uint32 = random_tcp;
 
             for (i = 1; i < max_num; ++i) {
                 nodes[i] = onion_c->path_nodes_bs[rand() % num_nodes_bs];
@@ -190,7 +325,7 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
             continue;
         }
 
-        // TODO: do we really have to check it with the last node?
+        // TODO(irungentoo): do we really have to check it with the last node?
         if (ipport_equal(&onion_paths->paths[i].ip_port1, &nodes[ONION_PATH_LENGTH - 1].ip_port)) {
             return i;
         }
@@ -200,23 +335,34 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
 }
 
 /* is path timed out */
-static _Bool path_timed_out(Onion_Client_Paths *onion_paths, uint32_t pathnum)
+static bool path_timed_out(Onion_Client_Paths *onion_paths, uint32_t pathnum)
 {
     pathnum = pathnum % NUMBER_ONION_PATHS;
 
-    return ((onion_paths->last_path_success[pathnum] + ONION_PATH_TIMEOUT < onion_paths->last_path_used[pathnum]
-             && onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES)
+    bool is_new = onion_paths->last_path_success[pathnum] == onion_paths->path_creation_time[pathnum];
+    uint64_t timeout = is_new ? ONION_PATH_FIRST_TIMEOUT : ONION_PATH_TIMEOUT;
+
+    return ((onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES
+             && is_timeout(onion_paths->last_path_used[pathnum], timeout))
             || is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME));
 }
 
+/* should node be considered to have timed out */
+static bool onion_node_timed_out(const Onion_Node *node)
+{
+    return (node->timestamp == 0
+            || (node->unsuccessful_pings >= ONION_NODE_MAX_PINGS
+                && is_timeout(node->last_pinged, ONION_NODE_TIMEOUT)));
+}
+
 /* Create a new path or use an old suitable one (if pathnum is valid)
  * or a random one from onion_paths.
  *
  * return -1 on failure
  * return 0 on success
  *
- * TODO: Make this function better, it currently probably is vulnerable to some attacks that
- * could de anonimize us.
+ * TODO(irungentoo): Make this function better, it currently probably is
+ * vulnerable to some attacks that could deanonimize us.
  */
 static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_paths, uint32_t pathnum, Onion_Path *path)
 {
@@ -229,17 +375,19 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
     if (path_timed_out(onion_paths, pathnum)) {
         Node_format nodes[ONION_PATH_LENGTH];
 
-        if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH)
+        if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH) {
             return -1;
+        }
 
         int n = is_path_used(onion_paths, nodes);
 
         if (n == -1) {
-            if (create_onion_path(onion_c->dht, &onion_paths->paths[pathnum], nodes) == -1)
+            if (create_onion_path(onion_c->dht, &onion_paths->paths[pathnum], nodes) == -1) {
                 return -1;
+            }
 
-            onion_paths->last_path_success[pathnum] = unix_time() + ONION_PATH_FIRST_TIMEOUT - ONION_PATH_TIMEOUT;
             onion_paths->path_creation_time[pathnum] = unix_time();
+            onion_paths->last_path_success[pathnum] = onion_paths->path_creation_time[pathnum];
             onion_paths->last_path_used_times[pathnum] = ONION_PATH_MAX_NO_RESPONSE_USES / 2;
 
             uint32_t path_num = rand();
@@ -253,17 +401,21 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
         }
     }
 
+    if (onion_paths->last_path_used_times[pathnum] < ONION_PATH_MAX_NO_RESPONSE_USES) {
+        onion_paths->last_path_used[pathnum] = unix_time();
+    }
+
     ++onion_paths->last_path_used_times[pathnum];
-    onion_paths->last_path_used[pathnum] = unix_time();
     memcpy(path, &onion_paths->paths[pathnum], sizeof(Onion_Path));
     return 0;
 }
 
 /* Does path with path_num exist. */
-static _Bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
+static bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
 {
-    if (path_timed_out(onion_paths, path_num))
+    if (path_timed_out(onion_paths, path_num)) {
         return 0;
+    }
 
     return onion_paths->paths[path_num % NUMBER_ONION_PATHS].path_num == path_num;
 }
@@ -273,8 +425,9 @@ static _Bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
  */
 static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t path_num)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
     Onion_Client_Paths *onion_paths;
 
@@ -312,28 +465,33 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
 static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Path *path, IP_Port dest,
                                      const uint8_t *data, uint16_t length)
 {
-    if (path->ip_port1.ip.family == AF_INET || path->ip_port1.ip.family == AF_INET6) {
+    if (net_family_is_ipv4(path->ip_port1.ip.family) || net_family_is_ipv6(path->ip_port1.ip.family)) {
         uint8_t packet[ONION_MAX_PACKET_SIZE];
         int len = create_onion_packet(packet, sizeof(packet), path, dest, data, length);
 
-        if (len == -1)
+        if (len == -1) {
             return -1;
+        }
 
-        if (sendpacket(onion_c->net, path->ip_port1, packet, len) != len)
+        if (sendpacket(onion_c->net, path->ip_port1, packet, len) != len) {
             return -1;
+        }
 
         return 0;
-    } else if (path->ip_port1.ip.family == TCP_FAMILY) {
+    }
+
+    if (net_family_is_tcp_family(path->ip_port1.ip.family)) {
         uint8_t packet[ONION_MAX_PACKET_SIZE];
         int len = create_onion_packet_tcp(packet, sizeof(packet), path, dest, data, length);
 
-        if (len == -1)
+        if (len == -1) {
             return -1;
+        }
 
-        return send_tcp_onion_request(onion_c->c, path->ip_port1.ip.ip4.uint32, packet, len);
-    } else {
-        return -1;
+        return send_tcp_onion_request(onion_c->c, path->ip_port1.ip.ip.v4.uint32, packet, len);
     }
+
+    return -1;
 }
 
 /* Creates a sendback for use in an announce request.
@@ -354,15 +512,16 @@ static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Pa
 static int new_sendback(Onion_Client *onion_c, uint32_t num, const uint8_t *public_key, IP_Port ip_port,
                         uint32_t path_num, uint64_t *sendback)
 {
-    uint8_t data[sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port) + sizeof(uint32_t)];
+    uint8_t data[sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + sizeof(IP_Port) + sizeof(uint32_t)];
     memcpy(data, &num, sizeof(uint32_t));
-    memcpy(data + sizeof(uint32_t), public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES, &ip_port, sizeof(IP_Port));
-    memcpy(data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port), &path_num, sizeof(uint32_t));
-    *sendback = ping_array_add(&onion_c->announce_ping_array, data, sizeof(data));
+    memcpy(data + sizeof(uint32_t), public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(data + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE, &ip_port, sizeof(IP_Port));
+    memcpy(data + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + sizeof(IP_Port), &path_num, sizeof(uint32_t));
+    *sendback = ping_array_add(onion_c->announce_ping_array, data, sizeof(data));
 
-    if (*sendback == 0)
+    if (*sendback == 0) {
         return -1;
+    }
 
     return 0;
 }
@@ -371,7 +530,7 @@ static int new_sendback(Onion_Client *onion_c, uint32_t num, const uint8_t *publ
  * ip contained in it in ret_ip_port
  *
  * sendback is the sendback ONION_ANNOUNCE_SENDBACK_DATA_LENGTH big
- * ret_pubkey must be at least crypto_box_PUBLICKEYBYTES big
+ * ret_pubkey must be at least CRYPTO_PUBLIC_KEY_SIZE big
  * ret_ip_port must be at least 1 big
  *
  * return ~0 on failure
@@ -382,14 +541,15 @@ static uint32_t check_sendback(Onion_Client *onion_c, const uint8_t *sendback, u
 {
     uint64_t sback;
     memcpy(&sback, sendback, sizeof(uint64_t));
-    uint8_t data[sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port) + sizeof(uint32_t)];
+    uint8_t data[sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + sizeof(IP_Port) + sizeof(uint32_t)];
 
-    if (ping_array_check(data, sizeof(data), &onion_c->announce_ping_array, sback) != sizeof(data))
+    if (ping_array_check(onion_c->announce_ping_array, data, sizeof(data), sback) != sizeof(data)) {
         return ~0;
+    }
 
-    memcpy(ret_pubkey, data + sizeof(uint32_t), crypto_box_PUBLICKEYBYTES);
-    memcpy(ret_ip_port, data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES, sizeof(IP_Port));
-    memcpy(path_num, data + sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port), sizeof(uint32_t));
+    memcpy(ret_pubkey, data + sizeof(uint32_t), CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(ret_ip_port, data + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE, sizeof(IP_Port));
+    memcpy(path_num, data + sizeof(uint32_t) + CRYPTO_PUBLIC_KEY_SIZE + sizeof(IP_Port), sizeof(uint32_t));
 
     uint32_t num;
     memcpy(&num, data, sizeof(uint32_t));
@@ -399,39 +559,44 @@ static uint32_t check_sendback(Onion_Client *onion_c, const uint8_t *sendback, u
 static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_Port dest, const uint8_t *dest_pubkey,
                                         const uint8_t *ping_id, uint32_t pathnum)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
     uint64_t sendback;
     Onion_Path path;
 
     if (num == 0) {
-        if (random_path(onion_c, &onion_c->onion_paths_self, pathnum, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_self, pathnum, &path) == -1) {
             return -1;
+        }
     } else {
-        if (random_path(onion_c, &onion_c->onion_paths_friends, pathnum, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_friends, pathnum, &path) == -1) {
             return -1;
+        }
     }
 
-    if (new_sendback(onion_c, num, dest_pubkey, dest, path.path_num, &sendback) == -1)
+    if (new_sendback(onion_c, num, dest_pubkey, dest, path.path_num, &sendback) == -1) {
         return -1;
+    }
 
     uint8_t zero_ping_id[ONION_PING_ID_SIZE] = {0};
 
-    if (ping_id == NULL)
+    if (ping_id == nullptr) {
         ping_id = zero_ping_id;
+    }
 
     uint8_t request[ONION_ANNOUNCE_REQUEST_SIZE];
     int len;
 
     if (num == 0) {
-        len = create_announce_request(request, sizeof(request), dest_pubkey, onion_c->c->self_public_key,
-                                      onion_c->c->self_secret_key, ping_id, onion_c->c->self_public_key, onion_c->temp_public_key, sendback);
-
+        len = create_announce_request(request, sizeof(request), dest_pubkey, nc_get_self_public_key(onion_c->c),
+                                      nc_get_self_secret_key(onion_c->c), ping_id, nc_get_self_public_key(onion_c->c),
+                                      onion_c->temp_public_key, sendback);
     } else {
         len = create_announce_request(request, sizeof(request), dest_pubkey, onion_c->friends_list[num - 1].temp_public_key,
-                                      onion_c->friends_list[num - 1].temp_secret_key, ping_id, onion_c->friends_list[num - 1].real_public_key, zero_ping_id,
-                                      sendback);
+                                      onion_c->friends_list[num - 1].temp_secret_key, ping_id,
+                                      onion_c->friends_list[num - 1].real_public_key, zero_ping_id, sendback);
     }
 
     if (len == -1) {
@@ -441,70 +606,105 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
     return send_onion_packet_tcp_udp(onion_c, &path, dest, request, len);
 }
 
-static uint8_t cmp_public_key[crypto_box_PUBLICKEYBYTES];
-static int cmp_entry(const void *a, const void *b)
+typedef struct {
+    const uint8_t *base_public_key;
+    Onion_Node entry;
+} Onion_Client_Cmp_data;
+
+static int onion_client_cmp_entry(const void *a, const void *b)
 {
-    Onion_Node entry1, entry2;
-    memcpy(&entry1, a, sizeof(Onion_Node));
-    memcpy(&entry2, b, sizeof(Onion_Node));
-    int t1 = is_timeout(entry1.timestamp, ONION_NODE_TIMEOUT);
-    int t2 = is_timeout(entry2.timestamp, ONION_NODE_TIMEOUT);
+    Onion_Client_Cmp_data cmp1, cmp2;
+    memcpy(&cmp1, a, sizeof(Onion_Client_Cmp_data));
+    memcpy(&cmp2, b, sizeof(Onion_Client_Cmp_data));
+    Onion_Node entry1 = cmp1.entry;
+    Onion_Node entry2 = cmp2.entry;
+    const uint8_t *cmp_public_key = cmp1.base_public_key;
+
+    int t1 = onion_node_timed_out(&entry1);
+    int t2 = onion_node_timed_out(&entry2);
 
-    if (t1 && t2)
+    if (t1 && t2) {
         return 0;
+    }
 
-    if (t1)
+    if (t1) {
         return -1;
+    }
 
-    if (t2)
+    if (t2) {
         return 1;
+    }
 
     int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
 
-    if (close == 1)
+    if (close == 1) {
         return 1;
+    }
 
-    if (close == 2)
+    if (close == 2) {
         return -1;
+    }
 
     return 0;
 }
 
+static void sort_onion_node_list(Onion_Node *list, unsigned int length, const uint8_t *comp_public_key)
+{
+    // Pass comp_public_key to qsort with each Client_data entry, so the
+    // comparison function can use it as the base of comparison.
+    VLA(Onion_Client_Cmp_data, cmp_list, length);
+
+    for (uint32_t i = 0; i < length; i++) {
+        cmp_list[i].base_public_key = comp_public_key;
+        cmp_list[i].entry = list[i];
+    }
+
+    qsort(cmp_list, length, sizeof(Onion_Client_Cmp_data), onion_client_cmp_entry);
+
+    for (uint32_t i = 0; i < length; i++) {
+        list[i] = cmp_list[i].entry;
+    }
+}
+
 static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t *public_key, IP_Port ip_port,
-                              uint8_t is_stored, const uint8_t *pingid_or_key, uint32_t path_num)
+                              uint8_t is_stored, const uint8_t *pingid_or_key, uint32_t path_used)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
-    Onion_Node *list_nodes = NULL;
-    uint8_t *reference_id = NULL;
+    Onion_Node *list_nodes = nullptr;
+    const uint8_t *reference_id = nullptr;
     unsigned int list_length;
 
     if (num == 0) {
         list_nodes = onion_c->clients_announce_list;
-        reference_id = onion_c->c->self_public_key;
+        reference_id = nc_get_self_public_key(onion_c->c);
         list_length = MAX_ONION_CLIENTS_ANNOUNCE;
 
         if (is_stored == 1 && public_key_cmp(pingid_or_key, onion_c->temp_public_key) != 0) {
             is_stored = 0;
         }
-
     } else {
-        if (is_stored >= 2)
+        if (is_stored >= 2) {
             return -1;
+        }
+
+        if (is_stored == 1) {
+            onion_c->friends_list[num - 1].last_reported_announced = unix_time();
+        }
 
         list_nodes = onion_c->friends_list[num - 1].clients_list;
         reference_id = onion_c->friends_list[num - 1].real_public_key;
         list_length = MAX_ONION_CLIENTS;
     }
 
-    memcpy(cmp_public_key, reference_id, crypto_box_PUBLICKEYBYTES);
-    qsort(list_nodes, list_length, sizeof(Onion_Node), cmp_entry);
+    sort_onion_node_list(list_nodes, list_length, reference_id);
 
     int index = -1, stored = 0;
     unsigned int i;
 
-    if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)
+    if (onion_node_timed_out(&list_nodes[0])
             || id_closest(reference_id, list_nodes[0].public_key, public_key) == 2) {
         index = 0;
     }
@@ -517,28 +717,32 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
         }
     }
 
-    if (index == -1)
+    if (index == -1) {
         return 0;
+    }
 
-    memcpy(list_nodes[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(list_nodes[index].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     list_nodes[index].ip_port = ip_port;
 
-    //TODO: remove this and find a better source of nodes to use for paths.
+    // TODO(irungentoo): remove this and find a better source of nodes to use for paths.
     onion_add_path_node(onion_c, ip_port, public_key);
 
     if (is_stored == 1) {
-        memcpy(list_nodes[index].data_public_key, pingid_or_key, crypto_box_PUBLICKEYBYTES);
+        memcpy(list_nodes[index].data_public_key, pingid_or_key, CRYPTO_PUBLIC_KEY_SIZE);
     } else {
         memcpy(list_nodes[index].ping_id, pingid_or_key, ONION_PING_ID_SIZE);
     }
 
     list_nodes[index].is_stored = is_stored;
     list_nodes[index].timestamp = unix_time();
+    list_nodes[index].unsuccessful_pings = 0;
 
-    if (!stored)
+    if (!stored) {
         list_nodes[index].last_pinged = 0;
+        list_nodes[index].added_time = unix_time();
+    }
 
-    list_nodes[index].path_used = set_path_timeouts(onion_c, num, path_num);
+    list_nodes[index].path_used = path_used;
     return 0;
 }
 
@@ -547,12 +751,14 @@ static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, co
     unsigned int i;
 
     for (i = 0; i < MAX_STORED_PINGED_NODES; ++i) {
-        if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME))
-            if (public_key_cmp(last_pinged[i].public_key, public_key) == 0)
+        if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME)) {
+            if (public_key_cmp(last_pinged[i].public_key, public_key) == 0) {
                 return 0;
+            }
+        }
     }
 
-    memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].timestamp = unix_time();
     ++*last_pinged_index;
     return 1;
@@ -561,22 +767,24 @@ static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, co
 static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_format *nodes, uint16_t num_nodes,
                              IP_Port source)
 {
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return -1;
+    }
 
-    if (num_nodes == 0)
+    if (num_nodes == 0) {
         return 0;
+    }
 
-    Onion_Node *list_nodes = NULL;
-    uint8_t *reference_id = NULL;
+    Onion_Node *list_nodes = nullptr;
+    const uint8_t *reference_id = nullptr;
     unsigned int list_length;
 
-    Last_Pinged *last_pinged = NULL;
-    uint8_t *last_pinged_index = NULL;
+    Last_Pinged *last_pinged = nullptr;
+    uint8_t *last_pinged_index = nullptr;
 
     if (num == 0) {
         list_nodes = onion_c->clients_announce_list;
-        reference_id = onion_c->c->self_public_key;
+        reference_id = nc_get_self_public_key(onion_c->c);
         list_length = MAX_ONION_CLIENTS_ANNOUNCE;
         last_pinged = onion_c->last_pinged;
         last_pinged_index = &onion_c->last_pinged_index;
@@ -589,18 +797,20 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
     }
 
     unsigned int i, j;
-    int lan_ips_accepted = (LAN_ip(source.ip) == 0);
+    int lan_ips_accepted = (ip_is_lan(source.ip) == 0);
 
     for (i = 0; i < num_nodes; ++i) {
 
-        if (!lan_ips_accepted)
-            if (LAN_ip(nodes[i].ip_port.ip) == 0)
+        if (!lan_ips_accepted) {
+            if (ip_is_lan(nodes[i].ip_port.ip) == 0) {
                 continue;
+            }
+        }
 
-        if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)
+        if (onion_node_timed_out(&list_nodes[0])
                 || id_closest(reference_id, list_nodes[0].public_key, nodes[i].public_key) == 2
-                || is_timeout(list_nodes[1].timestamp, ONION_NODE_TIMEOUT)
-                || id_closest(reference_id, list_nodes[1].public_key, nodes[i].public_key) == 2 ) {
+                || onion_node_timed_out(&list_nodes[1])
+                || id_closest(reference_id, list_nodes[1].public_key, nodes[i].public_key) == 2) {
             /* check if node is already in list. */
             for (j = 0; j < list_length; ++j) {
                 if (public_key_cmp(list_nodes[j].public_key, nodes[i].public_key) == 0) {
@@ -609,7 +819,7 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
             }
 
             if (j == list_length && good_to_ping(last_pinged, last_pinged_index, nodes[i].public_key)) {
-                client_send_announce_request(onion_c, num, nodes[i].ip_port, nodes[i].public_key, NULL, ~0);
+                client_send_announce_request(onion_c, num, nodes[i].ip_port, nodes[i].public_key, nullptr, ~0);
             }
         }
     }
@@ -617,125 +827,148 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
     return 0;
 }
 
-static int handle_announce_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE) {
         return 1;
+    }
 
     uint16_t len_nodes = length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE;
 
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     IP_Port ip_port;
     uint32_t path_num;
     uint32_t num = check_sendback(onion_c, packet + 1, public_key, &ip_port, &path_num);
 
-    if (num > onion_c->num_friends)
+    if (num > onion_c->num_friends) {
         return 1;
+    }
 
-    uint8_t plain[1 + ONION_PING_ID_SIZE + len_nodes];
-    int len = -1;
+    VLA(uint8_t, plain, 1 + ONION_PING_ID_SIZE + len_nodes);
+    int len;
 
     if (num == 0) {
-        len = decrypt_data(public_key, onion_c->c->self_secret_key, packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
-                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,
-                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);
+        len = decrypt_data(public_key, nc_get_self_secret_key(onion_c->c),
+                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
+                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE,
+                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE), plain);
     } else {
-        if (onion_c->friends_list[num - 1].status == 0)
+        if (onion_c->friends_list[num - 1].status == 0) {
             return 1;
+        }
 
         len = decrypt_data(public_key, onion_c->friends_list[num - 1].temp_secret_key,
                            packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
-                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,
-                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);
+                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE,
+                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + CRYPTO_NONCE_SIZE), plain);
     }
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != SIZEOF_VLA(plain)) {
         return 1;
+    }
 
-    if (client_add_to_list(onion_c, num, public_key, ip_port, plain[0], plain + 1, path_num) == -1)
+    uint32_t path_used = set_path_timeouts(onion_c, num, path_num);
+
+    if (client_add_to_list(onion_c, num, public_key, ip_port, plain[0], plain + 1, path_used) == -1) {
         return 1;
+    }
 
     if (len_nodes != 0) {
         Node_format nodes[MAX_SENT_NODES];
-        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, plain + 1 + ONION_PING_ID_SIZE, len_nodes, 0);
+        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, nullptr, plain + 1 + ONION_PING_ID_SIZE, len_nodes, 0);
 
-        if (num_nodes <= 0)
+        if (num_nodes <= 0) {
             return 1;
+        }
 
-        if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1)
+        if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1) {
             return 1;
+        }
     }
 
-    //TODO: LAN vs non LAN ips?, if we are connected only to LAN, are we offline?
+    // TODO(irungentoo): LAN vs non LAN ips?, if we are connected only to LAN, are we offline?
     onion_c->last_packet_recv = unix_time();
     return 0;
 }
 
 #define DATA_IN_RESPONSE_MIN_SIZE ONION_DATA_IN_RESPONSE_MIN_SIZE
 
-static int handle_data_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
+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))
+    if (length <= (ONION_DATA_RESPONSE_MIN_SIZE + DATA_IN_RESPONSE_MIN_SIZE)) {
         return 1;
+    }
 
-    if (length > MAX_DATA_REQUEST_SIZE)
+    if (length > MAX_DATA_REQUEST_SIZE) {
         return 1;
+    }
 
-    uint8_t temp_plain[length - ONION_DATA_RESPONSE_MIN_SIZE];
-    int len = decrypt_data(packet + 1 + crypto_box_NONCEBYTES, onion_c->temp_secret_key, packet + 1,
-                           packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES,
-                           length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES), temp_plain);
+    VLA(uint8_t, temp_plain, length - ONION_DATA_RESPONSE_MIN_SIZE);
+    int len = decrypt_data(packet + 1 + CRYPTO_NONCE_SIZE, onion_c->temp_secret_key, packet + 1,
+                           packet + 1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE,
+                           length - (1 + CRYPTO_NONCE_SIZE + CRYPTO_PUBLIC_KEY_SIZE), temp_plain);
 
-    if ((uint32_t)len != sizeof(temp_plain))
+    if ((uint32_t)len != SIZEOF_VLA(temp_plain)) {
         return 1;
+    }
 
-    uint8_t plain[sizeof(temp_plain) - DATA_IN_RESPONSE_MIN_SIZE];
-    len = decrypt_data(temp_plain, onion_c->c->self_secret_key, packet + 1, temp_plain + crypto_box_PUBLICKEYBYTES,
-                       sizeof(temp_plain) - crypto_box_PUBLICKEYBYTES, plain);
+    VLA(uint8_t, plain, SIZEOF_VLA(temp_plain) - DATA_IN_RESPONSE_MIN_SIZE);
+    len = decrypt_data(temp_plain, nc_get_self_secret_key(onion_c->c),
+                       packet + 1, temp_plain + CRYPTO_PUBLIC_KEY_SIZE,
+                       SIZEOF_VLA(temp_plain) - CRYPTO_PUBLIC_KEY_SIZE, plain);
 
-    if ((uint32_t)len != sizeof(plain))
+    if ((uint32_t)len != SIZEOF_VLA(plain)) {
         return 1;
+    }
 
-    if (!onion_c->Onion_Data_Handlers[plain[0]].function)
+    if (!onion_c->Onion_Data_Handlers[plain[0]].function) {
         return 1;
+    }
 
     return onion_c->Onion_Data_Handlers[plain[0]].function(onion_c->Onion_Data_Handlers[plain[0]].object, temp_plain, plain,
-            sizeof(plain));
+            SIZEOF_VLA(plain), userdata);
 }
 
-#define DHTPK_DATA_MIN_LENGTH (1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES)
+#define DHTPK_DATA_MIN_LENGTH (1 + sizeof(uint64_t) + CRYPTO_PUBLIC_KEY_SIZE)
 #define DHTPK_DATA_MAX_LENGTH (DHTPK_DATA_MIN_LENGTH + sizeof(Node_format)*MAX_SENT_NODES)
-static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t length)
+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)
+    if (length < DHTPK_DATA_MIN_LENGTH) {
         return 1;
+    }
 
-    if (length > DHTPK_DATA_MAX_LENGTH)
+    if (length > DHTPK_DATA_MAX_LENGTH) {
         return 1;
+    }
 
     int friend_num = onion_friend_num(onion_c, source_pubkey);
 
-    if (friend_num == -1)
+    if (friend_num == -1) {
         return 1;
+    }
 
     uint64_t no_replay;
     memcpy(&no_replay, data + 1, sizeof(uint64_t));
     net_to_host((uint8_t *) &no_replay, sizeof(no_replay));
 
-    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay)
+    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay) {
         return 1;
+    }
 
     onion_c->friends_list[friend_num].last_noreplay = no_replay;
 
-    if (onion_c->friends_list[friend_num].dht_pk_callback)
+    if (onion_c->friends_list[friend_num].dht_pk_callback) {
         onion_c->friends_list[friend_num].dht_pk_callback(onion_c->friends_list[friend_num].dht_pk_callback_object,
-                onion_c->friends_list[friend_num].dht_pk_callback_number, data + 1 + sizeof(uint64_t));
+                onion_c->friends_list[friend_num].dht_pk_callback_number, data + 1 + sizeof(uint64_t), userdata);
+    }
 
     onion_set_friend_DHT_pubkey(onion_c, friend_num, data + 1 + sizeof(uint64_t));
     onion_c->friends_list[friend_num].last_seen = unix_time();
@@ -744,20 +977,21 @@ static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, con
 
     if (len_nodes != 0) {
         Node_format nodes[MAX_SENT_NODES];
-        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, data + 1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES,
+        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, nullptr, data + 1 + sizeof(uint64_t) + CRYPTO_PUBLIC_KEY_SIZE,
                                      len_nodes, 1);
 
-        if (num_nodes <= 0)
+        if (num_nodes <= 0) {
             return 1;
+        }
 
         int i;
 
         for (i = 0; i < num_nodes; ++i) {
-            uint8_t family = nodes[i].ip_port.ip.family;
+            const Family family = nodes[i].ip_port.ip.family;
 
-            if (family == AF_INET || family == AF_INET6) {
+            if (net_family_is_ipv4(family) || net_family_is_ipv6(family)) {
                 DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].public_key, onion_c->friends_list[friend_num].dht_public_key);
-            } else if (family == TCP_INET || family == TCP_INET6) {
+            } else if (net_family_is_tcp_ipv4(family) || net_family_is_tcp_ipv6(family)) {
                 if (onion_c->friends_list[friend_num].tcp_relay_node_callback) {
                     void *obj = onion_c->friends_list[friend_num].tcp_relay_node_callback_object;
                     uint32_t number = onion_c->friends_list[friend_num].tcp_relay_node_callback_number;
@@ -770,18 +1004,21 @@ static int handle_dhtpk_announce(void *object, const uint8_t *source_pubkey, con
     return 0;
 }
 
-static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length)
+static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length, void *userdata)
 {
-    if (length == 0)
+    if (length == 0) {
         return 1;
+    }
 
-    IP_Port ip_port = {0};
-    ip_port.ip.family = TCP_FAMILY;
+    IP_Port ip_port = {{{0}}};
+    ip_port.ip.family = net_family_tcp_family;
 
     if (data[0] == NET_PACKET_ANNOUNCE_RESPONSE) {
-        return handle_announce_response(object, ip_port, data, length);
-    } else if (data[0] == NET_PACKET_ONION_DATA_RESPONSE) {
-        return handle_data_response(object, ip_port, data, length);
+        return handle_announce_response(object, ip_port, data, length, userdata);
+    }
+
+    if (data[0] == NET_PACKET_ONION_DATA_RESPONSE) {
+        return handle_data_response(object, ip_port, data, length, userdata);
     }
 
     return 1;
@@ -797,21 +1034,25 @@ static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length)
  */
 int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (length + DATA_IN_RESPONSE_MIN_SIZE > MAX_DATA_REQUEST_SIZE)
+    if (length + DATA_IN_RESPONSE_MIN_SIZE > MAX_DATA_REQUEST_SIZE) {
         return -1;
+    }
 
-    if (length == 0)
+    if (length == 0) {
         return -1;
+    }
 
     unsigned int i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0;
     Onion_Node *list_nodes = onion_c->friends_list[friend_num].clients_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT))
+        if (onion_node_timed_out(&list_nodes[i])) {
             continue;
+        }
 
         ++num_nodes;
 
@@ -821,37 +1062,43 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data,
         }
     }
 
-    if (num_good < (num_nodes / 4) + 1)
+    if (num_good < (num_nodes - 1) / 4 + 1) {
         return -1;
+    }
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
     random_nonce(nonce);
 
-    uint8_t packet[DATA_IN_RESPONSE_MIN_SIZE + length];
-    memcpy(packet, onion_c->c->self_public_key, crypto_box_PUBLICKEYBYTES);
-    int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key, onion_c->c->self_secret_key, nonce, data,
-                           length, packet + crypto_box_PUBLICKEYBYTES);
+    VLA(uint8_t, packet, DATA_IN_RESPONSE_MIN_SIZE + length);
+    memcpy(packet, nc_get_self_public_key(onion_c->c), CRYPTO_PUBLIC_KEY_SIZE);
+    int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key,
+                           nc_get_self_secret_key(onion_c->c), nonce, data,
+                           length, packet + CRYPTO_PUBLIC_KEY_SIZE);
 
-    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES != sizeof(packet))
+    if ((uint32_t)len + CRYPTO_PUBLIC_KEY_SIZE != SIZEOF_VLA(packet)) {
         return -1;
+    }
 
     unsigned int good = 0;
 
     for (i = 0; i < num_good; ++i) {
         Onion_Path path;
 
-        if (random_path(onion_c, &onion_c->onion_paths_friends, ~0, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_friends, ~0, &path) == -1) {
             continue;
+        }
 
         uint8_t o_packet[ONION_MAX_PACKET_SIZE];
         len = create_data_request(o_packet, sizeof(o_packet), onion_c->friends_list[friend_num].real_public_key,
-                                  list_nodes[good_nodes[i]].data_public_key, nonce, packet, sizeof(packet));
+                                  list_nodes[good_nodes[i]].data_public_key, nonce, packet, SIZEOF_VLA(packet));
 
-        if (len == -1)
+        if (len == -1) {
             continue;
+        }
 
-        if (send_onion_packet_tcp_udp(onion_c, &path, list_nodes[good_nodes[i]].ip_port, o_packet, len) == 0)
+        if (send_onion_packet_tcp_udp(onion_c, &path, list_nodes[good_nodes[i]].ip_port, o_packet, len) == 0) {
             ++good;
+        }
     }
 
     return good;
@@ -866,57 +1113,67 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data,
  */
 static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (!onion_c->friends_list[friend_num].know_dht_public_key)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key) {
         return -1;
+    }
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    new_nonce(nonce);
+    uint8_t nonce[CRYPTO_NONCE_SIZE];
+    random_nonce(nonce);
 
-    uint8_t temp[DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES + length];
-    memcpy(temp, onion_c->c->self_public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(temp + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
-    int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key, onion_c->c->self_secret_key, nonce, data,
-                           length, temp + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
+    VLA(uint8_t, temp, DATA_IN_RESPONSE_MIN_SIZE + CRYPTO_NONCE_SIZE + length);
+    memcpy(temp, nc_get_self_public_key(onion_c->c), CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(temp + CRYPTO_PUBLIC_KEY_SIZE, nonce, CRYPTO_NONCE_SIZE);
+    int len = encrypt_data(onion_c->friends_list[friend_num].real_public_key,
+                           nc_get_self_secret_key(onion_c->c), nonce, data,
+                           length, temp + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
 
-    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES != sizeof(temp))
+    if ((uint32_t)len + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE != SIZEOF_VLA(temp)) {
         return -1;
+    }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
-    len = create_request(onion_c->dht->self_public_key, onion_c->dht->self_secret_key, packet,
-                         onion_c->friends_list[friend_num].dht_public_key, temp, sizeof(temp), CRYPTO_PACKET_DHTPK);
+    len = create_request(dht_get_self_public_key(onion_c->dht), dht_get_self_secret_key(onion_c->dht), packet,
+                         onion_c->friends_list[friend_num].dht_public_key, temp, SIZEOF_VLA(temp), CRYPTO_PACKET_DHTPK);
 
-    if (len == -1)
+    if (len == -1) {
         return -1;
+    }
 
     return route_tofriend(onion_c->dht, onion_c->friends_list[friend_num].dht_public_key, packet, len);
 }
 
 static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                            uint16_t length)
+                            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)
+    if (length < DHTPK_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + CRYPTO_NONCE_SIZE) {
         return 1;
+    }
 
-    if (length > DHTPK_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
+    if (length > DHTPK_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + CRYPTO_NONCE_SIZE) {
         return 1;
+    }
 
     uint8_t plain[DHTPK_DATA_MAX_LENGTH];
-    int len = decrypt_data(packet, onion_c->c->self_secret_key, packet + crypto_box_PUBLICKEYBYTES,
-                           packet + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
-                           length - (crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES), plain);
+    int len = decrypt_data(packet, nc_get_self_secret_key(onion_c->c),
+                           packet + CRYPTO_PUBLIC_KEY_SIZE,
+                           packet + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE,
+                           length - (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE), plain);
 
-    if (len != length - (DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES))
+    if (len != length - (DATA_IN_RESPONSE_MIN_SIZE + CRYPTO_NONCE_SIZE)) {
         return 1;
+    }
 
-    if (public_key_cmp(source_pubkey, plain + 1 + sizeof(uint64_t)) != 0)
+    if (public_key_cmp(source_pubkey, plain + 1 + sizeof(uint64_t)) != 0) {
         return 1;
+    }
 
-    return handle_dhtpk_announce(onion_c, packet, plain, len);
+    return handle_dhtpk_announce(onion_c, packet, plain, len, userdata);
 }
 /* Send the packets to tell our friends what our DHT public key is.
  *
@@ -929,15 +1186,16 @@ static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_
  */
 static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8_t onion_dht_both)
 {
-    if (friend_num >= onion_c->num_friends)
+    if (friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     uint8_t data[DHTPK_DATA_MAX_LENGTH];
     data[0] = ONION_DATA_DHTPK;
     uint64_t no_replay = unix_time();
     host_to_net((uint8_t *)&no_replay, sizeof(no_replay));
     memcpy(data + 1, &no_replay, sizeof(no_replay));
-    memcpy(data + 1 + sizeof(uint64_t), onion_c->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(data + 1 + sizeof(uint64_t), dht_get_self_public_key(onion_c->dht), CRYPTO_PUBLIC_KEY_SIZE);
     Node_format nodes[MAX_SENT_NODES];
     uint16_t num_relays = copy_connected_tcp_relays(onion_c->c, nodes, (MAX_SENT_NODES / 2));
     uint16_t num_nodes = closelist_nodes(onion_c->dht, &nodes[num_relays], MAX_SENT_NODES - num_relays);
@@ -948,23 +1206,28 @@ static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8
         nodes_len = pack_nodes(data + DHTPK_DATA_MIN_LENGTH, DHTPK_DATA_MAX_LENGTH - DHTPK_DATA_MIN_LENGTH, nodes,
                                num_nodes);
 
-        if (nodes_len <= 0)
+        if (nodes_len <= 0) {
             return -1;
+        }
     }
 
     int num1 = -1, num2 = -1;
 
-    if (onion_dht_both != 1)
+    if (onion_dht_both != 1) {
         num1 = send_onion_data(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
+    }
 
-    if (onion_dht_both != 0)
+    if (onion_dht_both != 0) {
         num2 = send_dht_dhtpk(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
+    }
 
-    if (num1 == -1)
+    if (num1 == -1) {
         return num2;
+    }
 
-    if (num2 == -1)
+    if (num2 == -1) {
         return num1;
+    }
 
     return num1 + num2;
 }
@@ -979,11 +1242,13 @@ int onion_friend_num(const Onion_Client *onion_c, const uint8_t *public_key)
     unsigned int i;
 
     for (i = 0; i < onion_c->num_friends; ++i) {
-        if (onion_c->friends_list[i].status == 0)
+        if (onion_c->friends_list[i].status == 0) {
             continue;
+        }
 
-        if (public_key_cmp(public_key, onion_c->friends_list[i].real_public_key) == 0)
+        if (public_key_cmp(public_key, onion_c->friends_list[i].real_public_key) == 0) {
             return i;
+        }
     }
 
     return -1;
@@ -998,14 +1263,15 @@ static int realloc_onion_friends(Onion_Client *onion_c, uint32_t num)
 {
     if (num == 0) {
         free(onion_c->friends_list);
-        onion_c->friends_list = NULL;
+        onion_c->friends_list = nullptr;
         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)
+    if (newonion_friends == nullptr) {
         return -1;
+    }
 
     onion_c->friends_list = newonion_friends;
     return 0;
@@ -1020,8 +1286,9 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
 {
     int num = onion_friend_num(onion_c, public_key);
 
-    if (num != -1)
+    if (num != -1) {
         return num;
+    }
 
     unsigned int i, index = ~0;
 
@@ -1033,17 +1300,18 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
     }
 
     if (index == (uint32_t)~0) {
-        if (realloc_onion_friends(onion_c, onion_c->num_friends + 1) == -1)
+        if (realloc_onion_friends(onion_c, onion_c->num_friends + 1) == -1) {
             return -1;
+        }
 
         index = onion_c->num_friends;
-        memset(&(onion_c->friends_list[onion_c->num_friends]), 0, sizeof(Onion_Friend));
+        memset(&onion_c->friends_list[onion_c->num_friends], 0, sizeof(Onion_Friend));
         ++onion_c->num_friends;
     }
 
     onion_c->friends_list[index].status = 1;
-    memcpy(onion_c->friends_list[index].real_public_key, public_key, crypto_box_PUBLICKEYBYTES);
-    crypto_box_keypair(onion_c->friends_list[index].temp_public_key, onion_c->friends_list[index].temp_secret_key);
+    memcpy(onion_c->friends_list[index].real_public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    crypto_new_keypair(onion_c->friends_list[index].temp_public_key, onion_c->friends_list[index].temp_secret_key);
     return index;
 }
 
@@ -1054,18 +1322,20 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
  */
 int onion_delfriend(Onion_Client *onion_c, int friend_num)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     //if (onion_c->friends_list[friend_num].know_dht_public_key)
     //    DHT_delfriend(onion_c->dht, onion_c->friends_list[friend_num].dht_public_key, 0);
 
-    sodium_memzero(&(onion_c->friends_list[friend_num]), sizeof(Onion_Friend));
+    crypto_memzero(&onion_c->friends_list[friend_num], sizeof(Onion_Friend));
     unsigned int i;
 
     for (i = onion_c->num_friends; i != 0; --i) {
-        if (onion_c->friends_list[i - 1].status != 0)
+        if (onion_c->friends_list[i - 1].status != 0) {
             break;
+        }
     }
 
     if (onion_c->num_friends != i) {
@@ -1084,13 +1354,14 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
  * return -1 on failure.
  * return 0 on success.
  */
-int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_relay_node_callback)(void *object,
+int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*callback)(void *object,
                            uint32_t number, IP_Port ip_port, const uint8_t *public_key), void *object, uint32_t number)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    onion_c->friends_list[friend_num].tcp_relay_node_callback = tcp_relay_node_callback;
+    onion_c->friends_list[friend_num].tcp_relay_node_callback = callback;
     onion_c->friends_list[friend_num].tcp_relay_node_callback_object = object;
     onion_c->friends_list[friend_num].tcp_relay_node_callback_number = number;
     return 0;
@@ -1105,10 +1376,11 @@ int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_rela
  * return 0 on success.
  */
 int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function)(void *data, int32_t number,
-                          const uint8_t *dht_public_key), void *object, uint32_t number)
+                          const uint8_t *dht_public_key, void *userdata), void *object, uint32_t number)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
     onion_c->friends_list[friend_num].dht_pk_callback = function;
     onion_c->friends_list[friend_num].dht_pk_callback_object = object;
@@ -1123,11 +1395,13 @@ int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function
  */
 int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (onion_c->friends_list[friend_num].status == 0)
+    if (onion_c->friends_list[friend_num].status == 0) {
         return -1;
+    }
 
     if (onion_c->friends_list[friend_num].know_dht_public_key) {
         if (public_key_cmp(dht_key, onion_c->friends_list[friend_num].dht_public_key) == 0) {
@@ -1139,7 +1413,7 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
 
     onion_c->friends_list[friend_num].last_seen = unix_time();
     onion_c->friends_list[friend_num].know_dht_public_key = 1;
-    memcpy(onion_c->friends_list[friend_num].dht_public_key, dht_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(onion_c->friends_list[friend_num].dht_public_key, dht_key, CRYPTO_PUBLIC_KEY_SIZE);
 
     return 0;
 }
@@ -1151,16 +1425,19 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
  */
 unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return 0;
+    }
 
-    if (onion_c->friends_list[friend_num].status == 0)
+    if (onion_c->friends_list[friend_num].status == 0) {
         return 0;
+    }
 
-    if (!onion_c->friends_list[friend_num].know_dht_public_key)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key) {
         return 0;
+    }
 
-    memcpy(dht_key, onion_c->friends_list[friend_num].dht_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(dht_key, onion_c->friends_list[friend_num].dht_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     return 1;
 }
 
@@ -1173,10 +1450,11 @@ unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_
  */
 int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_port)
 {
-    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t dht_public_key[CRYPTO_PUBLIC_KEY_SIZE];
 
-    if (onion_getfriend_DHT_pubkey(onion_c, friend_num, dht_public_key) == 0)
+    if (onion_getfriend_DHT_pubkey(onion_c, friend_num, dht_public_key) == 0) {
         return -1;
+    }
 
     return DHT_getfriendip(onion_c->dht, dht_public_key, ip_port);
 }
@@ -1193,11 +1471,13 @@ int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_p
  */
 int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_online)
 {
-    if ((uint32_t)friend_num >= onion_c->num_friends)
+    if ((uint32_t)friend_num >= onion_c->num_friends) {
         return -1;
+    }
 
-    if (is_online == 0 && onion_c->friends_list[friend_num].is_online == 1)
+    if (is_online == 0 && onion_c->friends_list[friend_num].is_online == 1) {
         onion_c->friends_list[friend_num].last_seen = unix_time();
+    }
 
     onion_c->friends_list[friend_num].is_online = is_online;
 
@@ -1237,30 +1517,63 @@ static void populate_path_nodes_tcp(Onion_Client *onion_c)
 
 #define ANNOUNCE_FRIEND (ONION_NODE_PING_INTERVAL * 6)
 #define ANNOUNCE_FRIEND_BEGINNING 3
-#define FRIEND_ONION_NODE_TIMEOUT (ONION_NODE_TIMEOUT * 6)
 
 #define RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING 17
 
+#define ONION_FRIEND_BACKOFF_FACTOR 4
+#define ONION_FRIEND_MAX_PING_INTERVAL (5*60*MAX_ONION_CLIENTS)
+
 static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
 {
-    if (friendnum >= onion_c->num_friends)
+    if (friendnum >= onion_c->num_friends) {
         return;
+    }
 
-    if (onion_c->friends_list[friendnum].status == 0)
+    if (onion_c->friends_list[friendnum].status == 0) {
         return;
+    }
 
     unsigned int interval = ANNOUNCE_FRIEND;
 
-    if (onion_c->friends_list[friendnum].run_count < RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING)
+    if (onion_c->friends_list[friendnum].run_count < RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING) {
         interval = ANNOUNCE_FRIEND_BEGINNING;
+    } else {
+        if (onion_c->friends_list[friendnum].last_reported_announced == 0) {
+            onion_c->friends_list[friendnum].last_reported_announced = unix_time();
+        }
 
-    unsigned int i, count = 0;
-    Onion_Node *list_nodes = onion_c->friends_list[friendnum].clients_list;
+        uint64_t backoff_interval = (unix_time() - onion_c->friends_list[friendnum].last_reported_announced)
+                                    / ONION_FRIEND_BACKOFF_FACTOR;
+
+        if (backoff_interval > ONION_FRIEND_MAX_PING_INTERVAL) {
+            backoff_interval = ONION_FRIEND_MAX_PING_INTERVAL;
+        }
+
+        if (interval < backoff_interval) {
+            interval = backoff_interval;
+        }
+    }
 
     if (!onion_c->friends_list[friendnum].is_online) {
-        for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-            if (is_timeout(list_nodes[i].timestamp, FRIEND_ONION_NODE_TIMEOUT))
+        unsigned int count = 0;
+        Onion_Node *list_nodes = onion_c->friends_list[friendnum].clients_list;
+
+        // ensure we get a response from some node roughly once per
+        // (interval / MAX_ONION_CLIENTS)
+        bool ping_random = true;
+
+        for (unsigned i = 0; i < MAX_ONION_CLIENTS; ++i) {
+            if (!(is_timeout(list_nodes[i].timestamp, interval / MAX_ONION_CLIENTS)
+                    && is_timeout(list_nodes[i].last_pinged, ONION_NODE_PING_INTERVAL))) {
+                ping_random = false;
+                break;
+            }
+        }
+
+        for (unsigned i = 0; i < MAX_ONION_CLIENTS; ++i) {
+            if (onion_node_timed_out(&list_nodes[i])) {
                 continue;
+            }
 
             ++count;
 
@@ -1270,9 +1583,17 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
                 continue;
             }
 
-            if (is_timeout(list_nodes[i].last_pinged, interval)) {
-                if (client_send_announce_request(onion_c, friendnum + 1, list_nodes[i].ip_port, list_nodes[i].public_key, 0, ~0) == 0) {
+            if (list_nodes[i].unsuccessful_pings >= ONION_NODE_MAX_PINGS) {
+                continue;
+            }
+
+            if (is_timeout(list_nodes[i].last_pinged, interval)
+                    || (ping_random && rand() % (MAX_ONION_CLIENTS - i) == 0)) {
+                if (client_send_announce_request(onion_c, friendnum + 1, list_nodes[i].ip_port,
+                                                 list_nodes[i].public_key, nullptr, ~0) == 0) {
                     list_nodes[i].last_pinged = unix_time();
+                    ++list_nodes[i].unsuccessful_pings;
+                    ping_random = false;
                 }
             }
         }
@@ -1282,33 +1603,39 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
 
             unsigned int n = num_nodes;
 
-            if (num_nodes > (MAX_ONION_CLIENTS / 2))
+            if (num_nodes > (MAX_ONION_CLIENTS / 2)) {
                 n = (MAX_ONION_CLIENTS / 2);
+            }
 
-            if (num_nodes != 0) {
-                unsigned int j;
+            if (count <= (uint32_t)rand() % MAX_ONION_CLIENTS) {
+                if (num_nodes != 0) {
+                    unsigned int j;
 
-                for (j = 0; j < n; ++j) {
-                    unsigned int num = rand() % num_nodes;
-                    client_send_announce_request(onion_c, friendnum + 1, onion_c->path_nodes[num].ip_port,
-                                                 onion_c->path_nodes[num].public_key, 0, ~0);
-                }
+                    for (j = 0; j < n; ++j) {
+                        unsigned int num = rand() % num_nodes;
+                        client_send_announce_request(onion_c, friendnum + 1, onion_c->path_nodes[num].ip_port,
+                                                     onion_c->path_nodes[num].public_key, nullptr, ~0);
+                    }
 
-                ++onion_c->friends_list[friendnum].run_count;
+                    ++onion_c->friends_list[friendnum].run_count;
+                }
             }
         } else {
             ++onion_c->friends_list[friendnum].run_count;
         }
 
         /* send packets to friend telling them our DHT public key. */
-        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_onion_sent, ONION_DHTPK_SEND_INTERVAL))
-            if (send_dhtpk_announce(onion_c, friendnum, 0) >= 1)
+        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_onion_sent, ONION_DHTPK_SEND_INTERVAL)) {
+            if (send_dhtpk_announce(onion_c, friendnum, 0) >= 1) {
                 onion_c->friends_list[friendnum].last_dht_pk_onion_sent = unix_time();
+            }
+        }
 
-        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_dht_sent, DHT_DHTPK_SEND_INTERVAL))
-            if (send_dhtpk_announce(onion_c, friendnum, 1) >= 1)
+        if (is_timeout(onion_c->friends_list[friendnum].last_dht_pk_dht_sent, DHT_DHTPK_SEND_INTERVAL)) {
+            if (send_dhtpk_announce(onion_c, friendnum, 1) >= 1) {
                 onion_c->friends_list[friendnum].last_dht_pk_dht_sent = unix_time();
-
+            }
+        }
     }
 }
 
@@ -1323,14 +1650,18 @@ void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_ha
 #define ANNOUNCE_INTERVAL_NOT_ANNOUNCED 3
 #define ANNOUNCE_INTERVAL_ANNOUNCED ONION_NODE_PING_INTERVAL
 
+#define TIME_TO_STABLE (ONION_NODE_PING_INTERVAL * 6)
+#define ANNOUNCE_INTERVAL_STABLE (ONION_NODE_PING_INTERVAL * 8)
+
 static void do_announce(Onion_Client *onion_c)
 {
     unsigned int i, count = 0;
     Onion_Node *list_nodes = onion_c->clients_announce_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) {
-        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT))
+        if (onion_node_timed_out(&list_nodes[i])) {
             continue;
+        }
 
         ++count;
 
@@ -1340,16 +1671,48 @@ static void do_announce(Onion_Client *onion_c)
             continue;
         }
 
+        if (list_nodes[i].unsuccessful_pings >= ONION_NODE_MAX_PINGS) {
+            continue;
+        }
+
+
         unsigned int interval = ANNOUNCE_INTERVAL_NOT_ANNOUNCED;
 
         if (list_nodes[i].is_stored && path_exists(&onion_c->onion_paths_self, list_nodes[i].path_used)) {
             interval = ANNOUNCE_INTERVAL_ANNOUNCED;
+
+            uint32_t pathnum = list_nodes[i].path_used % NUMBER_ONION_PATHS;
+
+            /* A node/path is considered 'stable', and can be pinged less
+             * aggressively, if it has survived for at least TIME_TO_STABLE
+             * and the latest packets sent to it are not timing out.
+             */
+            if (is_timeout(list_nodes[i].added_time, TIME_TO_STABLE)
+                    && !(list_nodes[i].unsuccessful_pings > 0
+                         && is_timeout(list_nodes[i].last_pinged, ONION_NODE_TIMEOUT))
+                    && is_timeout(onion_c->onion_paths_self.path_creation_time[pathnum], TIME_TO_STABLE)
+                    && !(onion_c->onion_paths_self.last_path_used_times[pathnum] > 0
+                         && is_timeout(onion_c->onion_paths_self.last_path_used[pathnum], ONION_PATH_TIMEOUT))) {
+                interval = ANNOUNCE_INTERVAL_STABLE;
+            }
         }
 
-        if (is_timeout(list_nodes[i].last_pinged, interval)) {
+        if (is_timeout(list_nodes[i].last_pinged, interval)
+                || (is_timeout(onion_c->last_announce, ONION_NODE_PING_INTERVAL)
+                    && rand() % (MAX_ONION_CLIENTS_ANNOUNCE - i) == 0)) {
+            uint32_t path_to_use = list_nodes[i].path_used;
+
+            if (list_nodes[i].unsuccessful_pings == ONION_NODE_MAX_PINGS - 1
+                    && is_timeout(list_nodes[i].added_time, TIME_TO_STABLE)) {
+                /* Last chance for a long-lived node - try a random path */
+                path_to_use = ~0;
+            }
+
             if (client_send_announce_request(onion_c, 0, list_nodes[i].ip_port, list_nodes[i].public_key,
-                                             list_nodes[i].ping_id, list_nodes[i].path_used) == 0) {
+                                             list_nodes[i].ping_id, path_to_use) == 0) {
                 list_nodes[i].last_pinged = unix_time();
+                ++list_nodes[i].unsuccessful_pings;
+                onion_c->last_announce = unix_time();
             }
         }
     }
@@ -1366,11 +1729,11 @@ static void do_announce(Onion_Client *onion_c)
             path_nodes = onion_c->path_nodes;
         }
 
-        if (count < (uint32_t)rand() % MAX_ONION_CLIENTS_ANNOUNCE) {
+        if (count <= (uint32_t)rand() % MAX_ONION_CLIENTS_ANNOUNCE) {
             if (num_nodes != 0) {
                 for (i = 0; i < (MAX_ONION_CLIENTS_ANNOUNCE / 2); ++i) {
                     unsigned int num = rand() % num_nodes;
-                    client_send_announce_request(onion_c, 0, path_nodes[num].ip_port, path_nodes[num].public_key, 0, ~0);
+                    client_send_announce_request(onion_c, 0, path_nodes[num].ip_port, path_nodes[num].public_key, nullptr, ~0);
                 }
             }
         }
@@ -1384,14 +1747,16 @@ static int onion_isconnected(const Onion_Client *onion_c)
 {
     unsigned int i, num = 0, announced = 0;
 
-    if (is_timeout(onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT))
+    if (is_timeout(onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT)) {
         return 0;
+    }
 
-    if (onion_c->path_nodes_index == 0)
+    if (onion_c->path_nodes_index == 0) {
         return 0;
+    }
 
     for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) {
-        if (!is_timeout(onion_c->clients_announce_list[i].timestamp, ONION_NODE_TIMEOUT)) {
+        if (!onion_node_timed_out(&onion_c->clients_announce_list[i])) {
             ++num;
 
             if (onion_c->clients_announce_list[i].is_stored) {
@@ -1407,10 +1772,11 @@ static int onion_isconnected(const Onion_Client *onion_c)
     }
 
     /* Consider ourselves online if we are announced to half or more nodes
-      we are connected to */
+       we are connected to */
     if (num && announced) {
-        if ((num / 2) <= announced && (pnodes / 2) <= num)
+        if ((num / 2) <= announced && (pnodes / 2) <= num) {
             return 1;
+        }
     }
 
     return 0;
@@ -1427,9 +1793,9 @@ unsigned int onion_connection_status(const Onion_Client *onion_c)
     if (onion_c->onion_connected >= ONION_CONNECTION_SECONDS) {
         if (onion_c->UDP_connected) {
             return 2;
-        } else {
-            return 1;
         }
+
+        return 1;
     }
 
     return 0;
@@ -1437,10 +1803,9 @@ unsigned int onion_connection_status(const Onion_Client *onion_c)
 
 void do_onion_client(Onion_Client *onion_c)
 {
-    unsigned int i;
-
-    if (onion_c->last_run == unix_time())
+    if (onion_c->last_run == unix_time()) {
         return;
+    }
 
     if (is_timeout(onion_c->first_run, ONION_CONNECTION_SECONDS)) {
         populate_path_nodes(onion_c);
@@ -1451,7 +1816,6 @@ void do_onion_client(Onion_Client *onion_c)
         if (onion_c->onion_connected < ONION_CONNECTION_SECONDS * 2) {
             ++onion_c->onion_connected;
         }
-
     } else {
         populate_path_nodes_tcp(onion_c);
 
@@ -1460,17 +1824,17 @@ void do_onion_client(Onion_Client *onion_c)
         }
     }
 
-    _Bool UDP_connected = DHT_non_lan_connected(onion_c->dht);
+    bool UDP_connected = DHT_non_lan_connected(onion_c->dht);
 
     if (is_timeout(onion_c->first_run, ONION_CONNECTION_SECONDS * 2)) {
-        set_tcp_onion_status(onion_c->c->tcp_c, !UDP_connected);
+        set_tcp_onion_status(nc_get_tcp_c(onion_c->c), !UDP_connected);
     }
 
     onion_c->UDP_connected = UDP_connected
-                             || get_random_tcp_onion_conn_number(onion_c->c->tcp_c) == -1; /* Check if connected to any TCP relays. */
+                             || get_random_tcp_onion_conn_number(nc_get_tcp_c(onion_c->c)) == -1; /* Check if connected to any TCP relays. */
 
     if (onion_connection_status(onion_c)) {
-        for (i = 0; i < onion_c->num_friends; ++i) {
+        for (unsigned i = 0; i < onion_c->num_friends; ++i) {
             do_friend(onion_c, i);
         }
     }
@@ -1484,46 +1848,50 @@ void do_onion_client(Onion_Client *onion_c)
 
 Onion_Client *new_onion_client(Net_Crypto *c)
 {
-    if (c == NULL)
-        return NULL;
+    if (c == nullptr) {
+        return nullptr;
+    }
 
-    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;
+    if (onion_c == nullptr) {
+        return nullptr;
+    }
 
-    if (ping_array_init(&onion_c->announce_ping_array, ANNOUNCE_ARRAY_SIZE, ANNOUNCE_TIMEOUT) != 0) {
+    onion_c->announce_ping_array = ping_array_new(ANNOUNCE_ARRAY_SIZE, ANNOUNCE_TIMEOUT);
+
+    if (onion_c->announce_ping_array == nullptr) {
         free(onion_c);
-        return NULL;
+        return nullptr;
     }
 
-    onion_c->dht = c->dht;
-    onion_c->net = c->dht->net;
+    onion_c->dht = nc_get_dht(c);
+    onion_c->net = dht_get_net(onion_c->dht);
     onion_c->c = c;
     new_symmetric_key(onion_c->secret_symmetric_key);
-    crypto_box_keypair(onion_c->temp_public_key, onion_c->temp_secret_key);
+    crypto_new_keypair(onion_c->temp_public_key, onion_c->temp_secret_key);
     networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE, &handle_announce_response, onion_c);
     networking_registerhandler(onion_c->net, NET_PACKET_ONION_DATA_RESPONSE, &handle_data_response, onion_c);
     oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, &handle_dhtpk_announce, onion_c);
     cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_DHTPK, &handle_dht_dhtpk, onion_c);
-    set_onion_packet_tcp_connection_callback(onion_c->c->tcp_c, &handle_tcp_onion, onion_c);
+    set_onion_packet_tcp_connection_callback(nc_get_tcp_c(onion_c->c), &handle_tcp_onion, onion_c);
 
     return onion_c;
 }
 
 void kill_onion_client(Onion_Client *onion_c)
 {
-    if (onion_c == NULL)
+    if (onion_c == nullptr) {
         return;
+    }
 
-    ping_array_free_all(&onion_c->announce_ping_array);
+    ping_array_kill(onion_c->announce_ping_array);
     realloc_onion_friends(onion_c, 0);
-    networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE, NULL, NULL);
-    networking_registerhandler(onion_c->net, NET_PACKET_ONION_DATA_RESPONSE, NULL, NULL);
-    oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, NULL, NULL);
-    cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_DHTPK, NULL, NULL);
-    set_onion_packet_tcp_connection_callback(onion_c->c->tcp_c, NULL, NULL);
-    sodium_memzero(onion_c, sizeof(Onion_Client));
+    networking_registerhandler(onion_c->net, NET_PACKET_ANNOUNCE_RESPONSE, nullptr, nullptr);
+    networking_registerhandler(onion_c->net, NET_PACKET_ONION_DATA_RESPONSE, nullptr, nullptr);
+    oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, nullptr, nullptr);
+    cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_DHTPK, nullptr, nullptr);
+    set_onion_packet_tcp_connection_callback(nc_get_tcp_c(onion_c->c), nullptr, nullptr);
+    crypto_memzero(onion_c, sizeof(Onion_Client));
     free(onion_c);
 }
-
diff --git a/toxcore/onion_client.h b/toxcore/onion_client.h
index 91056a09..327d4923 100644
--- a/toxcore/onion_client.h
+++ b/toxcore/onion_client.h
@@ -1,37 +1,38 @@
 /*
-* onion_client.h -- Implementation of the client part of docs/Prevent_Tracking.txt
-*                   (The part that uses the onion stuff to connect to the friend)
-*
-*  Copyright (C) 2013 Tox project All Rights Reserved.
-*
-*  This file is part of Tox.
-*
-*  Tox is free software: you can redistribute it and/or modify
-*  it under the terms of the GNU General Public License as published by
-*  the Free Software Foundation, either version 3 of the License, or
-*  (at your option) any later version.
-*
-*  Tox is distributed in the hope that it will be useful,
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*  GNU General Public License for more details.
-*
-*  You should have received a copy of the GNU General Public License
-*  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
-*
-*/
+ * Implementation of the client part of docs/Prevent_Tracking.txt (The part that
+ * uses the onion stuff to connect to the friend)
+ */
 
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #ifndef ONION_CLIENT_H
 #define ONION_CLIENT_H
 
-#include "onion_announce.h"
 #include "net_crypto.h"
+#include "onion_announce.h"
 #include "ping_array.h"
 
 #define MAX_ONION_CLIENTS 8
 #define MAX_ONION_CLIENTS_ANNOUNCE 12 /* Number of nodes to announce ourselves to. */
 #define ONION_NODE_PING_INTERVAL 15
-#define ONION_NODE_TIMEOUT (ONION_NODE_PING_INTERVAL * 3)
+#define ONION_NODE_TIMEOUT ONION_NODE_PING_INTERVAL
 
 /* The interval in seconds at which to tell our friends where we are */
 #define ONION_DHTPK_SEND_INTERVAL 30
@@ -49,120 +50,25 @@
 #define MAX_STORED_PINGED_NODES 9
 #define MIN_NODE_PING_TIME 10
 
+#define ONION_NODE_MAX_PINGS 3
+
 #define MAX_PATH_NODES 32
 
-/* If no packets are received within that interval tox will
- * be considered offline.
+/* If no announce response packets are received within this interval tox will
+ * be considered offline. We give time for a node to be pinged often enough
+ * that it times out, which leads to the network being thoroughly tested as it
+ * is replaced.
  */
-#define ONION_OFFLINE_TIMEOUT (ONION_NODE_PING_INTERVAL * 1.25)
+#define ONION_OFFLINE_TIMEOUT (ONION_NODE_PING_INTERVAL * (ONION_NODE_MAX_PINGS+2))
 
 /* Onion data packet ids. */
 #define ONION_DATA_FRIEND_REQ CRYPTO_PACKET_FRIEND_REQ
 #define ONION_DATA_DHTPK CRYPTO_PACKET_DHTPK
 
-typedef struct {
-    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
-    IP_Port     ip_port;
-    uint8_t     ping_id[ONION_PING_ID_SIZE];
-    uint8_t     data_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t     is_stored;
-
-    uint64_t    timestamp;
-
-    uint64_t    last_pinged;
-
-    uint32_t    path_used;
-} Onion_Node;
-
-typedef struct {
-    Onion_Path paths[NUMBER_ONION_PATHS];
-    uint64_t last_path_success[NUMBER_ONION_PATHS];
-    uint64_t last_path_used[NUMBER_ONION_PATHS];
-    uint64_t path_creation_time[NUMBER_ONION_PATHS];
-    /* number of times used without success. */
-    unsigned int last_path_used_times[NUMBER_ONION_PATHS];
-} Onion_Client_Paths;
-
-typedef struct {
-    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
-    uint64_t    timestamp;
-} Last_Pinged;
-
-typedef struct {
-    uint8_t status; /* 0 if friend is not valid, 1 if friend is valid.*/
-    uint8_t is_online; /* Set by the onion_set_friend_status function. */
-
-    uint8_t know_dht_public_key; /* 0 if we don't know the dht public key of the other, 1 if we do. */
-    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t real_public_key[crypto_box_PUBLICKEYBYTES];
-
-    Onion_Node clients_list[MAX_ONION_CLIENTS];
-    uint8_t temp_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t temp_secret_key[crypto_box_SECRETKEYBYTES];
-
-    uint64_t last_dht_pk_onion_sent;
-    uint64_t last_dht_pk_dht_sent;
-
-    uint64_t last_noreplay;
-
-    uint64_t last_seen;
-
-    Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
-    uint8_t last_pinged_index;
-
-    int (*tcp_relay_node_callback)(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key);
-    void *tcp_relay_node_callback_object;
-    uint32_t tcp_relay_node_callback_number;
-
-    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key);
-    void *dht_pk_callback_object;
-    uint32_t dht_pk_callback_number;
-
-    uint32_t run_count;
-} Onion_Friend;
-
-typedef int (*oniondata_handler_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data,
-        uint16_t len);
-
-typedef struct {
-    DHT     *dht;
-    Net_Crypto *c;
-    Networking_Core *net;
-    Onion_Friend    *friends_list;
-    uint16_t       num_friends;
-
-    Onion_Node clients_announce_list[MAX_ONION_CLIENTS_ANNOUNCE];
-
-    Onion_Client_Paths onion_paths_self;
-    Onion_Client_Paths onion_paths_friends;
-
-    uint8_t secret_symmetric_key[crypto_box_KEYBYTES];
-    uint64_t last_run, first_run;
-
-    uint8_t temp_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t temp_secret_key[crypto_box_SECRETKEYBYTES];
-
-    Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
-
-    Node_format path_nodes[MAX_PATH_NODES];
-    uint16_t path_nodes_index;
-
-    Node_format path_nodes_bs[MAX_PATH_NODES];
-    uint16_t path_nodes_index_bs;
-
-    Ping_Array announce_ping_array;
-    uint8_t last_pinged_index;
-    struct {
-        oniondata_handler_callback function;
-        void *object;
-    } Onion_Data_Handlers[256];
-
-    uint64_t last_packet_recv;
-
-    unsigned int onion_connected;
-    _Bool UDP_connected;
-} Onion_Client;
+typedef struct Onion_Client Onion_Client;
 
+DHT *onion_get_dht(const Onion_Client *onion_c);
+Net_Crypto *onion_get_net_crypto(const Onion_Client *onion_c);
 
 /* Add a node to the path_nodes bootstrap array.
  *
@@ -239,7 +145,7 @@ int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_rela
  * return 0 on success.
  */
 int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function)(void *data, int32_t number,
-                          const uint8_t *dht_public_key), void *object, uint32_t number);
+                          const uint8_t *dht_public_key, void *userdata), void *object, uint32_t number);
 
 /* Set a friends DHT public key.
  * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
@@ -257,7 +163,7 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
  */
 unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key);
 
-#define ONION_DATA_IN_RESPONSE_MIN_SIZE (crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES)
+#define ONION_DATA_IN_RESPONSE_MIN_SIZE (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE)
 #define ONION_CLIENT_MAX_DATA_SIZE (MAX_DATA_REQUEST_SIZE - ONION_DATA_IN_RESPONSE_MIN_SIZE)
 
 /* Send data of length length to friendnum.
@@ -271,6 +177,9 @@ unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_
  */
 int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length);
 
+typedef int (*oniondata_handler_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data,
+        uint16_t len, void *userdata);
+
 /* Function to call when onion data packet with contents beginning with byte is received. */
 void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_handler_callback cb, void *object);
 
diff --git a/toxcore/ping.api.h b/toxcore/ping.api.h
new file mode 100644
index 00000000..edc04723
--- /dev/null
+++ b/toxcore/ping.api.h
@@ -0,0 +1,65 @@
+%{
+/*
+ * Buffered pinging using cyclic arrays.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ * Copyright © 2013 plutooo
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ * This file is donated to the Tox Project.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef PING_H
+#define PING_H
+
+#include "DHT.h"
+#include "network.h"
+
+#include <stdint.h>
+%}
+
+class iP_Port { struct this; }
+class dHT { struct this; }
+
+class ping {
+
+struct this;
+
+static this new(dHT::this *dht);
+void kill();
+
+/** Add nodes to the to_ping list.
+ * All nodes in this list are pinged every TIME_TOPING seconds
+ * and are then removed from the list.
+ * If the list is full the nodes farthest from our public_key are replaced.
+ * The purpose of this list is to enable quick integration of new nodes into the
+ * network while preventing amplification attacks.
+ *
+ *  return 0 if node was added.
+ *  return -1 if node was not added.
+ */
+int32_t add(const uint8_t *public_key, iP_Port::this ip_port);
+void iterate();
+
+int32_t send_request(iP_Port::this ipp, const uint8_t *public_key);
+
+}
+
+%{
+#endif /* PING_H */
+%}
diff --git a/toxcore/ping.c b/toxcore/ping.c
index f81766cb..3daeff86 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -1,40 +1,41 @@
 /*
- * ping.c -- Buffered pinging using cyclic arrays.
+ * Buffered pinging using cyclic arrays.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ * Copyright © 2013 plutooo
  *
+ * This file is part of Tox, the free peer to peer instant messenger.
  * This file is donated to the Tox Project.
- * Copyright 2013  plutooo
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <stdint.h>
-
-#include "DHT.h"
 #include "ping.h"
 
+#include <stdlib.h>
+#include <string.h>
+
+#include "DHT.h"
 #include "network.h"
-#include "util.h"
 #include "ping_array.h"
+#include "util.h"
 
 #define PING_NUM_MAX 512
 
@@ -45,143 +46,154 @@
 #define TIME_TO_PING 2
 
 
-struct PING {
+struct Ping {
     DHT *dht;
 
-    Ping_Array  ping_array;
+    Ping_Array  *ping_array;
     Node_format to_ping[MAX_TO_PING];
     uint64_t    last_to_ping;
 };
 
 
 #define PING_PLAIN_SIZE (1 + sizeof(uint64_t))
-#define DHT_PING_SIZE (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + PING_PLAIN_SIZE + crypto_box_MACBYTES)
-#define PING_DATA_SIZE (crypto_box_PUBLICKEYBYTES + sizeof(IP_Port))
+#define DHT_PING_SIZE (1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + PING_PLAIN_SIZE + CRYPTO_MAC_SIZE)
+#define PING_DATA_SIZE (CRYPTO_PUBLIC_KEY_SIZE + sizeof(IP_Port))
 
-int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key)
+int32_t ping_send_request(Ping *ping, IP_Port ipp, const uint8_t *public_key)
 {
     uint8_t   pk[DHT_PING_SIZE];
     int       rc;
     uint64_t  ping_id;
 
-    if (id_equal(public_key, ping->dht->self_public_key))
+    if (id_equal(public_key, dht_get_self_public_key(ping->dht))) {
         return 1;
+    }
 
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 
     // generate key to encrypt ping_id with recipient privkey
     DHT_get_shared_key_sent(ping->dht, shared_key, public_key);
     // Generate random ping_id.
     uint8_t data[PING_DATA_SIZE];
     id_copy(data, public_key);
-    memcpy(data + crypto_box_PUBLICKEYBYTES, &ipp, sizeof(IP_Port));
-    ping_id = ping_array_add(&ping->ping_array, data, sizeof(data));
+    memcpy(data + CRYPTO_PUBLIC_KEY_SIZE, &ipp, sizeof(IP_Port));
+    ping_id = ping_array_add(ping->ping_array, data, sizeof(data));
 
-    if (ping_id == 0)
+    if (ping_id == 0) {
         return 1;
+    }
 
     uint8_t ping_plain[PING_PLAIN_SIZE];
     ping_plain[0] = NET_PACKET_PING_REQUEST;
     memcpy(ping_plain + 1, &ping_id, sizeof(ping_id));
 
     pk[0] = NET_PACKET_PING_REQUEST;
-    id_copy(pk + 1, ping->dht->self_public_key);     // Our pubkey
-    new_nonce(pk + 1 + crypto_box_PUBLICKEYBYTES); // Generate new nonce
+    id_copy(pk + 1, dht_get_self_public_key(ping->dht));     // Our pubkey
+    random_nonce(pk + 1 + CRYPTO_PUBLIC_KEY_SIZE); // Generate new nonce
 
 
     rc = encrypt_data_symmetric(shared_key,
-                                pk + 1 + crypto_box_PUBLICKEYBYTES,
+                                pk + 1 + CRYPTO_PUBLIC_KEY_SIZE,
                                 ping_plain, sizeof(ping_plain),
-                                pk + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES);
+                                pk + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
 
-    if (rc != PING_PLAIN_SIZE + crypto_box_MACBYTES)
+    if (rc != PING_PLAIN_SIZE + CRYPTO_MAC_SIZE) {
         return 1;
+    }
 
-    return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
+    return sendpacket(dht_get_net(ping->dht), ipp, pk, sizeof(pk));
 }
 
-static int send_ping_response(PING *ping, IP_Port ipp, const uint8_t *public_key, uint64_t ping_id,
+static int ping_send_response(Ping *ping, IP_Port ipp, const uint8_t *public_key, uint64_t ping_id,
                               uint8_t *shared_encryption_key)
 {
     uint8_t   pk[DHT_PING_SIZE];
     int       rc;
 
-    if (id_equal(public_key, ping->dht->self_public_key))
+    if (id_equal(public_key, dht_get_self_public_key(ping->dht))) {
         return 1;
+    }
 
     uint8_t ping_plain[PING_PLAIN_SIZE];
     ping_plain[0] = NET_PACKET_PING_RESPONSE;
     memcpy(ping_plain + 1, &ping_id, sizeof(ping_id));
 
     pk[0] = NET_PACKET_PING_RESPONSE;
-    id_copy(pk + 1, ping->dht->self_public_key);     // Our pubkey
-    new_nonce(pk + 1 + crypto_box_PUBLICKEYBYTES); // Generate new nonce
+    id_copy(pk + 1, dht_get_self_public_key(ping->dht));     // Our pubkey
+    random_nonce(pk + 1 + CRYPTO_PUBLIC_KEY_SIZE); // Generate new nonce
 
     // Encrypt ping_id using recipient privkey
     rc = encrypt_data_symmetric(shared_encryption_key,
-                                pk + 1 + crypto_box_PUBLICKEYBYTES,
+                                pk + 1 + CRYPTO_PUBLIC_KEY_SIZE,
                                 ping_plain, sizeof(ping_plain),
-                                pk + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES );
+                                pk + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
 
-    if (rc != PING_PLAIN_SIZE + crypto_box_MACBYTES)
+    if (rc != PING_PLAIN_SIZE + CRYPTO_MAC_SIZE) {
         return 1;
+    }
 
-    return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
+    return sendpacket(dht_get_net(ping->dht), ipp, pk, sizeof(pk));
 }
 
-static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length != DHT_PING_SIZE) {
         return 1;
+    }
 
-    PING *ping = dht->ping;
+    Ping *ping = dht_get_ping(dht);
 
-    if (id_equal(packet + 1, ping->dht->self_public_key))
+    if (id_equal(packet + 1, dht_get_self_public_key(ping->dht))) {
         return 1;
+    }
 
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 
     uint8_t ping_plain[PING_PLAIN_SIZE];
     // Decrypt ping_id
     DHT_get_shared_key_recv(dht, shared_key, packet + 1);
     rc = decrypt_data_symmetric(shared_key,
-                                packet + 1 + crypto_box_PUBLICKEYBYTES,
-                                packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
-                                PING_PLAIN_SIZE + crypto_box_MACBYTES,
-                                ping_plain );
+                                packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE,
+                                PING_PLAIN_SIZE + CRYPTO_MAC_SIZE,
+                                ping_plain);
 
-    if (rc != sizeof(ping_plain))
+    if (rc != sizeof(ping_plain)) {
         return 1;
+    }
 
-    if (ping_plain[0] != NET_PACKET_PING_REQUEST)
+    if (ping_plain[0] != NET_PACKET_PING_REQUEST) {
         return 1;
+    }
 
     uint64_t   ping_id;
     memcpy(&ping_id, ping_plain + 1, sizeof(ping_id));
     // Send response
-    send_ping_response(ping, source, packet + 1, ping_id, shared_key);
-    add_to_ping(ping, packet + 1, source);
+    ping_send_response(ping, source, packet + 1, ping_id, shared_key);
+    ping_add(ping, packet + 1, source);
 
     return 0;
 }
 
-static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length)
+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)
+    if (length != DHT_PING_SIZE) {
         return 1;
+    }
 
-    PING *ping = dht->ping;
+    Ping *ping = dht_get_ping(dht);
 
-    if (id_equal(packet + 1, ping->dht->self_public_key))
+    if (id_equal(packet + 1, dht_get_self_public_key(ping->dht))) {
         return 1;
+    }
 
-    uint8_t shared_key[crypto_box_BEFORENMBYTES];
+    uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 
     // generate key to encrypt ping_id with recipient privkey
     DHT_get_shared_key_sent(ping->dht, shared_key, packet + 1);
@@ -189,32 +201,37 @@ static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packe
     uint8_t ping_plain[PING_PLAIN_SIZE];
     // Decrypt ping_id
     rc = decrypt_data_symmetric(shared_key,
-                                packet + 1 + crypto_box_PUBLICKEYBYTES,
-                                packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES,
-                                PING_PLAIN_SIZE + crypto_box_MACBYTES,
+                                packet + 1 + CRYPTO_PUBLIC_KEY_SIZE,
+                                packet + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE,
+                                PING_PLAIN_SIZE + CRYPTO_MAC_SIZE,
                                 ping_plain);
 
-    if (rc != sizeof(ping_plain))
+    if (rc != sizeof(ping_plain)) {
         return 1;
+    }
 
-    if (ping_plain[0] != NET_PACKET_PING_RESPONSE)
+    if (ping_plain[0] != NET_PACKET_PING_RESPONSE) {
         return 1;
+    }
 
     uint64_t   ping_id;
     memcpy(&ping_id, ping_plain + 1, sizeof(ping_id));
     uint8_t data[PING_DATA_SIZE];
 
-    if (ping_array_check(data, sizeof(data), &ping->ping_array, ping_id) != sizeof(data))
+    if (ping_array_check(ping->ping_array, data, sizeof(data), ping_id) != sizeof(data)) {
         return 1;
+    }
 
-    if (!id_equal(packet + 1, data))
+    if (!id_equal(packet + 1, data)) {
         return 1;
+    }
 
     IP_Port ipp;
-    memcpy(&ipp, data + crypto_box_PUBLICKEYBYTES, sizeof(IP_Port));
+    memcpy(&ipp, data + CRYPTO_PUBLIC_KEY_SIZE, sizeof(IP_Port));
 
-    if (!ipport_equal(&ipp, &source))
+    if (!ipport_equal(&ipp, &source)) {
         return 1;
+    }
 
     addto_lists(dht, source, packet + 1);
     return 0;
@@ -233,14 +250,15 @@ static int in_list(const Client_data *list, uint16_t length, const uint8_t *publ
         if (id_equal(list[i].public_key, public_key)) {
             const IPPTsPng *ipptp;
 
-            if (ip_port.ip.family == AF_INET) {
+            if (net_family_is_ipv4(ip_port.ip.family)) {
                 ipptp = &list[i].assoc4;
             } else {
                 ipptp = &list[i].assoc6;
             }
 
-            if (!is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT) && ipport_equal(&ipptp->ip_port, &ip_port))
+            if (!is_timeout(ipptp->timestamp, BAD_NODE_TIMEOUT) && ipport_equal(&ipptp->ip_port, &ip_port)) {
                 return 1;
+            }
         }
     }
 
@@ -257,21 +275,24 @@ static int in_list(const Client_data *list, uint16_t length, const uint8_t *publ
  *  return 0 if node was added.
  *  return -1 if node was not added.
  */
-int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port)
+int32_t ping_add(Ping *ping, const uint8_t *public_key, IP_Port ip_port)
 {
-    if (!ip_isset(&ip_port.ip))
+    if (!ip_isset(&ip_port.ip)) {
         return -1;
+    }
 
-    if (!node_addable_to_close_list(ping->dht, public_key, ip_port))
+    if (!node_addable_to_close_list(ping->dht, public_key, ip_port)) {
         return -1;
+    }
 
-    if (in_list(ping->dht->close_clientlist, LCLIENT_LIST, public_key, ip_port))
+    if (in_list(dht_get_close_clientlist(ping->dht), LCLIENT_LIST, public_key, ip_port)) {
         return -1;
+    }
 
     IP_Port temp;
 
     if (DHT_getfriendip(ping->dht, public_key, &temp) == 0) {
-        send_ping_request(ping, ip_port, public_key);
+        ping_send_request(ping, ip_port, public_key);
         return -1;
     }
 
@@ -279,7 +300,7 @@ int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port)
 
     for (i = 0; i < MAX_TO_PING; ++i) {
         if (!ip_isset(&ping->to_ping[i].ip_port.ip)) {
-            memcpy(ping->to_ping[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(ping->to_ping[i].public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
             ipport_copy(&ping->to_ping[i].ip_port, &ip_port);
             return 0;
         }
@@ -289,8 +310,9 @@ int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port)
         }
     }
 
-    if (add_to_list(ping->to_ping, MAX_TO_PING, public_key, ip_port, ping->dht->self_public_key))
+    if (add_to_list(ping->to_ping, MAX_TO_PING, public_key, ip_port, dht_get_self_public_key(ping->dht))) {
         return 0;
+    }
 
     return -1;
 }
@@ -299,56 +321,64 @@ int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port)
 /* Ping all the valid nodes in the to_ping list every TIME_TO_PING seconds.
  * This function must be run at least once every TIME_TO_PING seconds.
  */
-void do_to_ping(PING *ping)
+void ping_iterate(Ping *ping)
 {
-    if (!is_timeout(ping->last_to_ping, TIME_TO_PING))
+    if (!is_timeout(ping->last_to_ping, TIME_TO_PING)) {
         return;
+    }
 
-    if (!ip_isset(&ping->to_ping[0].ip_port.ip))
+    if (!ip_isset(&ping->to_ping[0].ip_port.ip)) {
         return;
+    }
 
     unsigned int i;
 
     for (i = 0; i < MAX_TO_PING; ++i) {
-        if (!ip_isset(&ping->to_ping[i].ip_port.ip))
+        if (!ip_isset(&ping->to_ping[i].ip_port.ip)) {
             break;
+        }
 
-        if (!node_addable_to_close_list(ping->dht, ping->to_ping[i].public_key, ping->to_ping[i].ip_port))
+        if (!node_addable_to_close_list(ping->dht, ping->to_ping[i].public_key, ping->to_ping[i].ip_port)) {
             continue;
+        }
 
-        send_ping_request(ping, ping->to_ping[i].ip_port, ping->to_ping[i].public_key);
+        ping_send_request(ping, ping->to_ping[i].ip_port, ping->to_ping[i].public_key);
         ip_reset(&ping->to_ping[i].ip_port.ip);
     }
 
-    if (i != 0)
+    if (i != 0) {
         ping->last_to_ping = unix_time();
+    }
 }
 
 
-PING *new_ping(DHT *dht)
+Ping *ping_new(DHT *dht)
 {
-    PING *ping = calloc(1, sizeof(PING));
+    Ping *ping = (Ping *)calloc(1, sizeof(Ping));
+
+    if (ping == nullptr) {
+        return nullptr;
+    }
 
-    if (ping == NULL)
-        return NULL;
+    ping->ping_array = ping_array_new(PING_NUM_MAX, PING_TIMEOUT);
 
-    if (ping_array_init(&ping->ping_array, PING_NUM_MAX, PING_TIMEOUT) != 0) {
+    if (ping->ping_array == nullptr) {
         free(ping);
-        return NULL;
+        return nullptr;
     }
 
     ping->dht = dht;
-    networking_registerhandler(ping->dht->net, NET_PACKET_PING_REQUEST, &handle_ping_request, dht);
-    networking_registerhandler(ping->dht->net, NET_PACKET_PING_RESPONSE, &handle_ping_response, dht);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_REQUEST, &handle_ping_request, dht);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_RESPONSE, &handle_ping_response, dht);
 
     return ping;
 }
 
-void kill_ping(PING *ping)
+void ping_kill(Ping *ping)
 {
-    networking_registerhandler(ping->dht->net, NET_PACKET_PING_REQUEST, NULL, NULL);
-    networking_registerhandler(ping->dht->net, NET_PACKET_PING_RESPONSE, NULL, NULL);
-    ping_array_free_all(&ping->ping_array);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_REQUEST, nullptr, nullptr);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_RESPONSE, nullptr, nullptr);
+    ping_array_kill(ping->ping_array);
 
     free(ping);
 }
diff --git a/toxcore/ping.h b/toxcore/ping.h
index 904ad844..61875a0b 100644
--- a/toxcore/ping.h
+++ b/toxcore/ping.h
@@ -1,32 +1,56 @@
 /*
- * ping.h -- Buffered pinging using cyclic arrays.
+ * Buffered pinging using cyclic arrays.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ * Copyright © 2013 plutooo
  *
+ * This file is part of Tox, the free peer to peer instant messenger.
  * This file is donated to the Tox Project.
- * Copyright 2013  plutooo
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  This file is part of Tox.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef __PING_H__
-#define __PING_H__
+#ifndef PING_H
+#define PING_H
+
+#include "DHT.h"
+#include "network.h"
+
+#include <stdint.h>
+
+#ifndef IP_PORT_DEFINED
+#define IP_PORT_DEFINED
+typedef struct IP_Port IP_Port;
+#endif /* IP_PORT_DEFINED */
+
+#ifndef DHT_DEFINED
+#define DHT_DEFINED
+typedef struct DHT DHT;
+#endif /* DHT_DEFINED */
+
+#ifndef PING_DEFINED
+#define PING_DEFINED
+typedef struct Ping Ping;
+#endif /* PING_DEFINED */
+
+Ping *ping_new(DHT *dht);
 
-typedef struct PING PING;
+void ping_kill(Ping *ping);
 
-/* Add nodes to the to_ping list.
+/** Add nodes to the to_ping list.
  * All nodes in this list are pinged every TIME_TOPING seconds
  * and are then removed from the list.
  * If the list is full the nodes farthest from our public_key are replaced.
@@ -36,12 +60,10 @@ typedef struct PING PING;
  *  return 0 if node was added.
  *  return -1 if node was not added.
  */
-int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port);
-void do_to_ping(PING *ping);
+int32_t ping_add(Ping *ping, const uint8_t *public_key, struct IP_Port ip_port);
 
-PING *new_ping(DHT *dht);
-void kill_ping(PING *ping);
+void ping_iterate(Ping *ping);
 
-int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key);
+int32_t ping_send_request(Ping *ping, struct IP_Port ipp, const uint8_t *public_key);
 
-#endif /* __PING_H__ */
+#endif /* PING_H */
diff --git a/toxcore/ping_array.api.h b/toxcore/ping_array.api.h
new file mode 100644
index 00000000..55b80570
--- /dev/null
+++ b/toxcore/ping_array.api.h
@@ -0,0 +1,72 @@
+%{
+/*
+ * Implementation of an efficient array to store that we pinged something.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef PING_ARRAY_H
+#define PING_ARRAY_H
+
+#include "network.h"
+%}
+
+class ping_Array {
+
+struct this;
+
+/**
+ * Initialize a Ping_Array.
+ * size represents the total size of the array and should be a power of 2.
+ * timeout represents the maximum timeout in seconds for the entry.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static this new(uint32_t size, uint32_t timeout);
+
+/**
+ * Free all the allocated memory in a Ping_Array.
+ */
+void kill();
+
+/**
+ * Add a data with length to the Ping_Array list and return a ping_id.
+ *
+ * return ping_id on success.
+ * return 0 on failure.
+ */
+uint64_t add(const uint8_t *data, uint32_t length);
+
+/**
+ * Check if ping_id is valid and not timed out.
+ *
+ * On success, copies the data into data of length,
+ *
+ * return length of data copied on success.
+ * return -1 on failure.
+ */
+int32_t check(uint8_t[length] data, uint64_t ping_id);
+
+}
+
+%{
+#endif
+%}
diff --git a/toxcore/ping_array.c b/toxcore/ping_array.c
index 93dade05..bcab9fe2 100644
--- a/toxcore/ping_array.c
+++ b/toxcore/ping_array.c
@@ -1,44 +1,110 @@
-/* ping_array.c
- *
+/*
  * Implementation of an efficient array to store that we pinged something.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2014 Tox project.
  *
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Copyright (C) 2014 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "ping_array.h"
+
+#include <stdlib.h>
+#include <string.h>
+
 #include "crypto_core.h"
 #include "util.h"
 
+
+typedef struct {
+    void *data;
+    uint32_t length;
+    uint64_t time;
+    uint64_t ping_id;
+} Ping_Array_Entry;
+
+struct Ping_Array {
+    Ping_Array_Entry *entries;
+
+    uint32_t last_deleted; /* number representing the next entry to be deleted. */
+    uint32_t last_added; /* number representing the last entry to be added. */
+    uint32_t total_size; /* The length of entries */
+    uint32_t timeout; /* The timeout after which entries are cleared. */
+};
+
+/* Initialize a Ping_Array.
+ * size represents the total size of the array and should be a power of 2.
+ * timeout represents the maximum timeout in seconds for the entry.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+Ping_Array *ping_array_new(uint32_t size, uint32_t timeout)
+{
+    if (size == 0 || timeout == 0) {
+        return nullptr;
+    }
+
+    Ping_Array *empty_array = (Ping_Array *)calloc(1, sizeof(Ping_Array));
+
+    if (empty_array == nullptr) {
+        return nullptr;
+    }
+
+    empty_array->entries = (Ping_Array_Entry *)calloc(size, sizeof(Ping_Array_Entry));
+
+    if (empty_array->entries == nullptr) {
+        free(empty_array);
+        return nullptr;
+    }
+
+    empty_array->last_deleted = empty_array->last_added = 0;
+    empty_array->total_size = size;
+    empty_array->timeout = timeout;
+    return empty_array;
+}
+
 static void clear_entry(Ping_Array *array, uint32_t index)
 {
     free(array->entries[index].data);
-    array->entries[index].data = NULL;
+    array->entries[index].data = nullptr;
     array->entries[index].length =
         array->entries[index].time =
             array->entries[index].ping_id = 0;
 }
 
+/* Free all the allocated memory in a Ping_Array.
+ */
+void ping_array_kill(Ping_Array *array)
+{
+    while (array->last_deleted != array->last_added) {
+        uint32_t index = array->last_deleted % array->total_size;
+        clear_entry(array, index);
+        ++array->last_deleted;
+    }
+
+    free(array->entries);
+    free(array);
+}
+
 /* Clear timed out entries.
  */
 static void ping_array_clear_timedout(Ping_Array *array)
@@ -46,8 +112,9 @@ static void ping_array_clear_timedout(Ping_Array *array)
     while (array->last_deleted != array->last_added) {
         uint32_t index = array->last_deleted % array->total_size;
 
-        if (!is_timeout(array->entries[index].time, array->timeout))
+        if (!is_timeout(array->entries[index].time, array->timeout)) {
             break;
+        }
 
         clear_entry(array, index);
         ++array->last_deleted;
@@ -64,27 +131,29 @@ uint64_t ping_array_add(Ping_Array *array, const uint8_t *data, uint32_t length)
     ping_array_clear_timedout(array);
     uint32_t index = array->last_added % array->total_size;
 
-    if (array->entries[index].data != NULL) {
+    if (array->entries[index].data != nullptr) {
         array->last_deleted = array->last_added - array->total_size;
         clear_entry(array, index);
     }
 
     array->entries[index].data = malloc(length);
 
-    if (array->entries[index].data == NULL)
+    if (array->entries[index].data == nullptr) {
         return 0;
+    }
 
     memcpy(array->entries[index].data, data, length);
     array->entries[index].length = length;
     array->entries[index].time = unix_time();
     ++array->last_added;
-    uint64_t ping_id = random_64b();
+    uint64_t ping_id = random_u64();
     ping_id /= array->total_size;
     ping_id *= array->total_size;
     ping_id += index;
 
-    if (ping_id == 0)
+    if (ping_id == 0) {
         ping_id += array->total_size;
+    }
 
     array->entries[index].ping_id = ping_id;
     return ping_id;
@@ -98,65 +167,32 @@ uint64_t ping_array_add(Ping_Array *array, const uint8_t *data, uint32_t length)
  * return length of data copied on success.
  * return -1 on failure.
  */
-int ping_array_check(uint8_t *data, uint32_t length, Ping_Array *array, uint64_t ping_id)
+int32_t ping_array_check(Ping_Array *array, uint8_t *data, size_t length, uint64_t ping_id)
 {
-    if (ping_id == 0)
+    if (ping_id == 0) {
         return -1;
+    }
 
     uint32_t index = ping_id % array->total_size;
 
-    if (array->entries[index].ping_id != ping_id)
+    if (array->entries[index].ping_id != ping_id) {
         return -1;
+    }
 
-    if (is_timeout(array->entries[index].time, array->timeout))
+    if (is_timeout(array->entries[index].time, array->timeout)) {
         return -1;
+    }
 
-    if (array->entries[index].length > length)
+    if (array->entries[index].length > length) {
         return -1;
+    }
 
-    if (array->entries[index].data == NULL)
+    if (array->entries[index].data == nullptr) {
         return -1;
+    }
 
     memcpy(data, array->entries[index].data, array->entries[index].length);
     uint32_t len = array->entries[index].length;
     clear_entry(array, index);
     return len;
 }
-
-/* Initialize a Ping_Array.
- * size represents the total size of the array and should be a power of 2.
- * timeout represents the maximum timeout in seconds for the entry.
- *
- * return 0 on success.
- * return -1 on failure.
- */
-int ping_array_init(Ping_Array *empty_array, uint32_t size, uint32_t timeout)
-{
-    if (size == 0 || timeout == 0 || empty_array == NULL)
-        return -1;
-
-    empty_array->entries = calloc(size, sizeof(Ping_Array_Entry));
-
-    if (empty_array->entries == NULL)
-        return -1;
-
-    empty_array->last_deleted = empty_array->last_added = 0;
-    empty_array->total_size = size;
-    empty_array->timeout = timeout;
-    return 0;
-}
-
-/* Free all the allocated memory in a Ping_Array.
- */
-void ping_array_free_all(Ping_Array *array)
-{
-    while (array->last_deleted != array->last_added) {
-        uint32_t index = array->last_deleted % array->total_size;
-        clear_entry(array, index);
-        ++array->last_deleted;
-    }
-
-    free(array->entries);
-    array->entries = NULL;
-}
-
diff --git a/toxcore/ping_array.h b/toxcore/ping_array.h
index 364ad833..b927bbd4 100644
--- a/toxcore/ping_array.h
+++ b/toxcore/ping_array.h
@@ -1,75 +1,67 @@
-/* ping_array.h
- *
+/*
  * Implementation of an efficient array to store that we pinged something.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
 #ifndef PING_ARRAY_H
 #define PING_ARRAY_H
 
 #include "network.h"
 
-typedef struct {
-    void *data;
-    uint32_t length;
-    uint64_t time;
-    uint64_t ping_id;
-} Ping_Array_Entry;
-
+#ifndef PING_ARRAY_DEFINED
+#define PING_ARRAY_DEFINED
+typedef struct Ping_Array Ping_Array;
+#endif /* PING_ARRAY_DEFINED */
 
-typedef struct {
-    Ping_Array_Entry *entries;
-
-    uint32_t last_deleted; /* number representing the next entry to be deleted. */
-    uint32_t last_added; /* number representing the last entry to be added. */
-    uint32_t total_size; /* The length of entries */
-    uint32_t timeout; /* The timeout after which entries are cleared. */
-} Ping_Array;
+/**
+ * Initialize a Ping_Array.
+ * size represents the total size of the array and should be a power of 2.
+ * timeout represents the maximum timeout in seconds for the entry.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+struct Ping_Array *ping_array_new(uint32_t size, uint32_t timeout);
 
+/**
+ * Free all the allocated memory in a Ping_Array.
+ */
+void ping_array_kill(struct Ping_Array *_array);
 
-/* Add a data with length to the Ping_Array list and return a ping_id.
+/**
+ * Add a data with length to the Ping_Array list and return a ping_id.
  *
  * return ping_id on success.
  * return 0 on failure.
  */
-uint64_t ping_array_add(Ping_Array *array, const uint8_t *data, uint32_t length);
+uint64_t ping_array_add(struct Ping_Array *_array, const uint8_t *data, uint32_t length);
 
-/* Check if ping_id is valid and not timed out.
+/**
+ * Check if ping_id is valid and not timed out.
  *
  * On success, copies the data into data of length,
  *
  * return length of data copied on success.
  * return -1 on failure.
  */
-int ping_array_check(uint8_t *data, uint32_t length, Ping_Array *array, uint64_t ping_id);
-
-/* Initialize a Ping_Array.
- * size represents the total size of the array and should be a power of 2.
- * timeout represents the maximum timeout in seconds for the entry.
- *
- * return 0 on success.
- * return -1 on failure.
- */
-int ping_array_init(Ping_Array *empty_array, uint32_t size, uint32_t timeout);
-
-/* Free all the allocated memory in a Ping_Array.
- */
-void ping_array_free_all(Ping_Array *array);
+int32_t ping_array_check(struct Ping_Array *_array, uint8_t *data, size_t length, uint64_t ping_id);
 
 #endif
diff --git a/toxcore/tox.api.h b/toxcore/tox.api.h
new file mode 100644
index 00000000..1c3b1121
--- /dev/null
+++ b/toxcore/tox.api.h
@@ -0,0 +1,2606 @@
+%{
+/*
+ * The Tox public API.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ *
+ * This file is part of Tox, the free peer to peer instant messenger.
+ *
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TOX_H
+#define TOX_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+%}
+
+
+/*****************************************************************************
+ * `tox.h` SHOULD *NOT* BE EDITED MANUALLY – any changes should be made to   *
+ * `tox.api.h`, located in `toxcore/`. For instructions on how to            *
+ * generate `tox.h` from `tox.api.h` please refer to `docs/apidsl.md`        *
+ *****************************************************************************/
+
+
+/** \page core Public core API for Tox clients.
+ *
+ * Every function that can fail takes a function-specific error code pointer
+ * that can be used to diagnose problems with the Tox state or the function
+ * arguments. The error code pointer can be NULL, which does not influence the
+ * function's behaviour, but can be done if the reason for failure is irrelevant
+ * to the client.
+ *
+ * The exception to this rule are simple allocation functions whose only failure
+ * mode is allocation failure. They return NULL in that case, and do not set an
+ * error code.
+ *
+ * Every error code type has an OK value to which functions will set their error
+ * code value on success. Clients can keep their error code uninitialised before
+ * passing it to a function. The library guarantees that after returning, the
+ * value pointed to by the error code pointer has been initialised.
+ *
+ * Functions with pointer parameters often have a NULL error code, meaning they
+ * could not perform any operation, because one of the required parameters was
+ * NULL. Some functions operate correctly or are defined as effectless on NULL.
+ *
+ * Some functions additionally return a value outside their
+ * return type domain, or a bool containing true on success and false on
+ * failure.
+ *
+ * All functions that take a Tox instance pointer will cause undefined behaviour
+ * when passed a NULL Tox pointer.
+ *
+ * All integer values are expected in host byte order.
+ *
+ * Functions with parameters with enum types cause unspecified behaviour if the
+ * enumeration value is outside the valid range of the type. If possible, the
+ * function will try to use a sane default, but there will be no error code,
+ * and one possible action for the function to take is to have no effect.
+ *
+ * Integer constants and the memory layout of publicly exposed structs are not
+ * part of the ABI.
+ */
+
+/** \subsection events Events and callbacks
+ *
+ * Events are handled by callbacks. One callback can be registered per event.
+ * All events have a callback function type named `tox_{event}_cb` and a
+ * function to register it named `tox_callback_{event}`. Passing a NULL
+ * callback will result in no callback being registered for that event. Only
+ * one callback per event can be registered, so if a client needs multiple
+ * event listeners, it needs to implement the dispatch functionality itself.
+ *
+ * The last argument to a callback is the user data pointer. It is passed from
+ * ${tox.iterate} to each callback in sequence.
+ *
+ * The user data pointer is never stored or dereferenced by any library code, so
+ * can be any pointer, including NULL. Callbacks must all operate on the same
+ * object type. In the apidsl code (tox.in.h), this is denoted with `any`. The
+ * `any` in ${tox.iterate} must be the same `any` as in all callbacks. In C,
+ * lacking parametric polymorphism, this is a pointer to void.
+ *
+ * Old style callbacks that are registered together with a user data pointer
+ * receive that pointer as argument when they are called. They can each have
+ * their own user data pointer of their own type.
+ */
+
+/** \subsection threading Threading implications
+ *
+ * It is possible to run multiple concurrent threads with a Tox instance for
+ * each thread. It is also possible to run all Tox instances in the same thread.
+ * A common way to run Tox (multiple or single instance) is to have one thread
+ * running a simple ${tox.iterate} loop, sleeping for ${tox.iteration_interval}
+ * milliseconds on each iteration.
+ *
+ * If you want to access a single Tox instance from multiple threads, access
+ * to the instance must be synchronised. While multiple threads can concurrently
+ * access multiple different Tox instances, no more than one API function can
+ * operate on a single instance at any given time.
+ *
+ * Functions that write to variable length byte arrays will always have a size
+ * function associated with them. The result of this size function is only valid
+ * until another mutating function (one that takes a pointer to non-const Tox)
+ * is called. Thus, clients must ensure that no other thread calls a mutating
+ * function between the call to the size function and the call to the retrieval
+ * function.
+ *
+ * E.g. to get the current nickname, one would write
+ *
+ * \code
+ * size_t length = ${tox.self.name.size}(tox);
+ * uint8_t *name = malloc(length);
+ * if (!name) abort();
+ * ${tox.self.name.get}(tox, name);
+ * \endcode
+ *
+ * If any other thread calls ${tox.self.name.set} while this thread is allocating
+ * memory, the length may have become invalid, and the call to
+ * ${tox.self.name.get} may cause undefined behaviour.
+ */
+
+// The rest of this file is in class tox.
+class tox {
+
+/**
+ * The Tox instance type. All the state associated with a connection is held
+ * within the instance. Multiple instances can exist and operate concurrently.
+ * The maximum number of Tox instances that can exist on a single network
+ * device is limited. Note that this is not just a per-process limit, since the
+ * limiting factor is the number of usable ports on a device.
+ */
+struct this;
+
+
+/*******************************************************************************
+ *
+ * :: API version
+ *
+ ******************************************************************************/
+
+
+/**
+ * The major version number. Incremented when the API or ABI changes in an
+ * incompatible way.
+ *
+ * The function variants of these constants return the version number of the
+ * library. They can be used to display the Tox library version or to check
+ * whether the client is compatible with the dynamically linked version of Tox.
+ */
+const VERSION_MAJOR                = 0;
+
+/**
+ * The minor version number. Incremented when functionality is added without
+ * breaking the API or ABI. Set to 0 when the major version number is
+ * incremented.
+ */
+const VERSION_MINOR                = 2;
+
+/**
+ * The patch or revision number. Incremented when bugfixes are applied without
+ * changing any functionality or API or ABI.
+ */
+const VERSION_PATCH                = 2;
+
+/**
+ * A macro to check at preprocessing time whether the client code is compatible
+ * with the installed version of Tox. Leading zeros in the version number are
+ * ignored. E.g. 0.1.5 is to 0.1.4 what 1.5 is to 1.4, that is: it can add new
+ * features, but can't break the API.
+ */
+#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)              \
+  ((TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (           \
+    /* 1.x.x, 2.x.x, etc. with matching major version. */               \
+    TOX_VERSION_MINOR > MINOR ||                                        \
+    (TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH)          \
+  )) || ((TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                    \
+    /* 0.x.x makes minor behave like major above. */                    \
+    ((TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (         \
+      TOX_VERSION_PATCH >= PATCH                                        \
+    )) || ((TOX_VERSION_MINOR == 0 && MINOR == 0) && (                  \
+      /* 0.0.x and 0.0.y are only compatible if x == y. */              \
+      TOX_VERSION_PATCH == PATCH                                        \
+    ))                                                                  \
+  ))
+
+static namespace version {
+
+  /**
+   * Return whether the compiled library version is compatible with the passed
+   * version numbers.
+   */
+  bool is_compatible(uint32_t major, uint32_t minor, uint32_t patch);
+
+}
+
+/**
+ * A convenience macro to call tox_version_is_compatible with the currently
+ * compiling API version.
+ */
+#define TOX_VERSION_IS_ABI_COMPATIBLE()                         \
+  tox_version_is_compatible(TOX_VERSION_MAJOR, TOX_VERSION_MINOR, TOX_VERSION_PATCH)
+
+/*******************************************************************************
+ *
+ * :: Numeric constants
+ *
+ * The values of these are not part of the ABI. Prefer to use the function
+ * versions of them for code that should remain compatible with future versions
+ * of toxcore.
+ *
+ ******************************************************************************/
+
+
+/**
+ * The size of a Tox Public Key in bytes.
+ */
+const PUBLIC_KEY_SIZE              = 32;
+
+/**
+ * The size of a Tox Secret Key in bytes.
+ */
+const SECRET_KEY_SIZE              = 32;
+
+/**
+ * The size of the nospam in bytes when written in a Tox address.
+ */
+const NOSPAM_SIZE                  = sizeof(uint32_t);
+
+/**
+ * The size of a Tox address in bytes. Tox addresses are in the format
+ * [Public Key ($PUBLIC_KEY_SIZE bytes)][nospam (4 bytes)][checksum (2 bytes)].
+ *
+ * The checksum is computed over the Public Key and the nospam value. The first
+ * byte is an XOR of all the even bytes (0, 2, 4, ...), the second byte is an
+ * XOR of all the odd bytes (1, 3, 5, ...) of the Public Key and nospam.
+ */
+const ADDRESS_SIZE                = PUBLIC_KEY_SIZE + NOSPAM_SIZE + sizeof(uint16_t);
+
+/**
+ * Maximum length of a nickname in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_NAME_LENGTH             = 128;
+
+/**
+ * Maximum length of a status message in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_STATUS_MESSAGE_LENGTH   = 1007;
+
+/**
+ * Maximum length of a friend request message in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_FRIEND_REQUEST_LENGTH   = 1016;
+
+/**
+ * Maximum length of a single message after which it should be split.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_MESSAGE_LENGTH          = 1372;
+
+/**
+ * Maximum size of custom packets. TODO(iphydf): should be LENGTH?
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_CUSTOM_PACKET_SIZE      = 1373;
+
+/**
+ * The number of bytes in a hash generated by $hash.
+ */
+const HASH_LENGTH                 = 32;
+
+/**
+ * The number of bytes in a file id.
+ */
+const FILE_ID_LENGTH              = 32;
+
+/**
+ * Maximum file name length for file transfers.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
+ */
+const MAX_FILENAME_LENGTH         = 255;
+
+
+/*******************************************************************************
+ *
+ * :: Global enumerations
+ *
+ ******************************************************************************/
+
+
+/**
+ * Represents the possible statuses a client can have.
+ */
+enum class USER_STATUS {
+  /**
+   * User is online and available.
+   */
+  NONE,
+  /**
+   * User is away. Clients can set this e.g. after a user defined
+   * inactivity time.
+   */
+  AWAY,
+  /**
+   * User is busy. Signals to other clients that this client does not
+   * currently wish to communicate.
+   */
+  BUSY,
+}
+
+
+/**
+ * Represents message types for ${tox.friend.send.message} and conference
+ * messages.
+ */
+enum class MESSAGE_TYPE {
+  /**
+   * Normal text message. Similar to PRIVMSG on IRC.
+   */
+  NORMAL,
+  /**
+   * A message describing an user action. This is similar to /me (CTCP ACTION)
+   * on IRC.
+   */
+  ACTION,
+}
+
+
+/*******************************************************************************
+ *
+ * :: Startup options
+ *
+ ******************************************************************************/
+
+
+/**
+ * Type of proxy used to connect to TCP relays.
+ */
+enum class PROXY_TYPE {
+  /**
+   * Don't use a proxy.
+   */
+  NONE,
+  /**
+   * HTTP proxy using CONNECT.
+   */
+  HTTP,
+  /**
+   * SOCKS proxy for simple socket pipes.
+   */
+  SOCKS5,
+}
+
+/**
+ * Type of savedata to create the Tox instance from.
+ */
+enum class SAVEDATA_TYPE {
+  /**
+   * No savedata.
+   */
+  NONE,
+  /**
+   * Savedata is one that was obtained from ${savedata.get}.
+   */
+  TOX_SAVE,
+  /**
+   * Savedata is a secret key of length $SECRET_KEY_SIZE.
+   */
+  SECRET_KEY,
+}
+
+
+/**
+ * Severity level of log messages.
+ */
+enum class LOG_LEVEL {
+  /**
+   * Very detailed traces including all network activity.
+   */
+  TRACE,
+  /**
+   * Debug messages such as which port we bind to.
+   */
+  DEBUG,
+  /**
+   * Informational log messages such as video call status changes.
+   */
+  INFO,
+  /**
+   * Warnings about internal inconsistency or logic errors.
+   */
+  WARNING,
+  /**
+   * Severe unexpected errors caused by external or internal inconsistency.
+   */
+  ERROR,
+}
+
+/**
+ * This event is triggered when the toxcore library logs an internal message.
+ * This is mostly useful for debugging. This callback can be called from any
+ * function, not just $iterate. This means the user data lifetime must at
+ * least extend between registering and unregistering it or $kill.
+ *
+ * Other toxcore modules such as toxav may concurrently call this callback at
+ * any time. Thus, user code must make sure it is equipped to handle concurrent
+ * execution, e.g. by employing appropriate mutex locking.
+ *
+ * @param level The severity of the log message.
+ * @param file The source file from which the message originated.
+ * @param line The source line from which the message originated.
+ * @param func The function from which the message originated.
+ * @param message The log message.
+ * @param user_data The user data pointer passed to $new in options.
+ */
+typedef void log_cb(LOG_LEVEL level, string file, uint32_t line, string func, string message, any user_data);
+
+
+static class options {
+  /**
+   * This struct contains all the startup options for Tox. You must $new to
+   * allocate an object of this type.
+   *
+   * WARNING: Although this struct happens to be visible in the API, it is
+   * effectively private. Do not allocate this yourself or access members
+   * directly, as it *will* break binary compatibility frequently.
+   *
+   * @deprecated The memory layout of this struct (size, alignment, and field
+   * order) is not part of the ABI. To remain compatible, prefer to use $new to
+   * allocate the object and accessor functions to set the members. The struct
+   * will become opaque (i.e. the definition will become private) in v0.3.0.
+   */
+  struct this [get, set] {
+    /**
+     * The type of socket to create.
+     *
+     * If this is set to false, an IPv4 socket is created, which subsequently
+     * only allows IPv4 communication.
+     * If it is set to true, an IPv6 socket is created, allowing both IPv4 and
+     * IPv6 communication.
+     */
+    bool ipv6_enabled;
+
+    /**
+     * Enable the use of UDP communication when available.
+     *
+     * Setting this to false will force Tox to use TCP only. Communications will
+     * need to be relayed through a TCP relay node, potentially slowing them down.
+     * Disabling UDP support is necessary when using anonymous proxies or Tor.
+     */
+    bool udp_enabled;
+
+    /**
+     * Enable local network peer discovery.
+     *
+     * Disabling this will cause Tox to not look for peers on the local network.
+     */
+    bool local_discovery_enabled;
+
+    namespace proxy {
+      /**
+       * Pass communications through a proxy.
+       */
+      PROXY_TYPE type;
+
+      /**
+       * The IP address or DNS name of the proxy to be used.
+       *
+       * If used, this must be non-NULL and be a valid DNS name. The name must not
+       * exceed 255 characters, and be in a NUL-terminated C string format
+       * (255 chars + 1 NUL byte).
+       *
+       * This member is ignored (it can be NULL) if proxy_type is ${PROXY_TYPE.NONE}.
+       *
+       * The data pointed at by this member is owned by the user, so must
+       * outlive the options object.
+       */
+      string host;
+
+      /**
+       * The port to use to connect to the proxy server.
+       *
+       * Ports must be in the range (1, 65535). The value is ignored if
+       * proxy_type is ${PROXY_TYPE.NONE}.
+       */
+      uint16_t port;
+    }
+
+    /**
+     * The start port of the inclusive port range to attempt to use.
+     *
+     * If both start_port and end_port are 0, the default port range will be
+     * used: [33445, 33545].
+     *
+     * If either start_port or end_port is 0 while the other is non-zero, the
+     * non-zero port will be the only port in the range.
+     *
+     * Having start_port > end_port will yield the same behavior as if start_port
+     * and end_port were swapped.
+     */
+    uint16_t start_port;
+
+    /**
+     * The end port of the inclusive port range to attempt to use.
+     */
+    uint16_t end_port;
+
+    /**
+     * The port to use for the TCP server (relay). If 0, the TCP server is
+     * disabled.
+     *
+     * Enabling it is not required for Tox to function properly.
+     *
+     * When enabled, your Tox instance can act as a TCP relay for other Tox
+     * instance. This leads to increased traffic, thus when writing a client
+     * it is recommended to enable TCP server only if the user has an option
+     * to disable it.
+     */
+    uint16_t tcp_port;
+
+    /**
+     * Enables or disables UDP hole-punching in toxcore. (Default: enabled).
+     */
+    bool hole_punching_enabled;
+
+    namespace savedata {
+      /**
+       * The type of savedata to load from.
+       */
+      SAVEDATA_TYPE type;
+
+      /**
+       * The savedata.
+       *
+       * The data pointed at by this member is owned by the user, so must
+       * outlive the options object.
+       */
+      const uint8_t[length] data;
+
+      /**
+       * The length of the savedata.
+       */
+      size_t length;
+    }
+
+    namespace log {
+      /**
+       * Logging callback for the new tox instance.
+       */
+      log_cb *callback;
+
+      /**
+       * User data pointer passed to the logging callback.
+       */
+      any user_data;
+    }
+  }
+
+
+  /**
+   * Initialises a $this object with the default options.
+   *
+   * The result of this function is independent of the original options. All
+   * values will be overwritten, no values will be read (so it is permissible
+   * to pass an uninitialised object).
+   *
+   * If options is NULL, this function has no effect.
+   *
+   * @param options An options object to be filled with default options.
+   */
+  void default();
+
+
+  /**
+   * Allocates a new $this object and initialises it with the default
+   * options. This function can be used to preserve long term ABI compatibility by
+   * giving the responsibility of allocation and deallocation to the Tox library.
+   *
+   * Objects returned from this function must be freed using the $free
+   * function.
+   *
+   * @return A new $this object with default options or NULL on failure.
+   */
+  static this new() {
+    /**
+     * The function failed to allocate enough memory for the options struct.
+     */
+    MALLOC,
+  }
+
+
+  /**
+   * Releases all resources associated with an options objects.
+   *
+   * Passing a pointer that was not returned by $new results in
+   * undefined behaviour.
+   */
+  void free();
+}
+
+
+/*******************************************************************************
+ *
+ * :: Creation and destruction
+ *
+ ******************************************************************************/
+
+
+/**
+ * @brief Creates and initialises a new Tox instance with the options passed.
+ *
+ * This function will bring the instance into a valid state. Running the event
+ * loop with a new instance will operate correctly.
+ *
+ * If loading failed or succeeded only partially, the new or partially loaded
+ * instance is returned and an error code is set.
+ *
+ * @param options An options object as described above. If this parameter is
+ *   NULL, the default options are used.
+ *
+ * @see $iterate for the event loop.
+ *
+ * @return A new Tox instance pointer on success or NULL on failure.
+ */
+static this new(const options_t *options) {
+  NULL,
+  /**
+   * The function was unable to allocate enough memory to store the internal
+   * structures for the Tox object.
+   */
+  MALLOC,
+  /**
+   * The function was unable to bind to a port. This may mean that all ports
+   * have already been bound, e.g. by other Tox instances, or it may mean
+   * a permission error. You may be able to gather more information from errno.
+   */
+  PORT_ALLOC,
+
+  namespace PROXY {
+    /**
+     * proxy_type was invalid.
+     */
+    BAD_TYPE,
+    /**
+     * proxy_type was valid but the proxy_host passed had an invalid format
+     * or was NULL.
+     */
+    BAD_HOST,
+    /**
+     * proxy_type was valid, but the proxy_port was invalid.
+     */
+    BAD_PORT,
+    /**
+     * The proxy address passed could not be resolved.
+     */
+    NOT_FOUND,
+  }
+
+  namespace LOAD {
+    /**
+     * The byte array to be loaded contained an encrypted save.
+     */
+    ENCRYPTED,
+    /**
+     * The data format was invalid. This can happen when loading data that was
+     * saved by an older version of Tox, or when the data has been corrupted.
+     * When loading from badly formatted data, some data may have been loaded,
+     * and the rest is discarded. Passing an invalid length parameter also
+     * causes this error.
+     */
+    BAD_FORMAT,
+  }
+}
+
+
+/**
+ * Releases all resources associated with the Tox instance and disconnects from
+ * the network.
+ *
+ * After calling this function, the Tox pointer becomes invalid. No other
+ * functions can be called, and the pointer value can no longer be read.
+ */
+void kill();
+
+
+uint8_t[size] savedata {
+  /**
+   * Calculates the number of bytes required to store the tox instance with
+   * $get. This function cannot fail. The result is always greater than 0.
+   *
+   * @see threading for concurrency implications.
+   */
+  size();
+
+  /**
+   * Store all information associated with the tox instance to a byte array.
+   *
+   * @param savedata A memory region large enough to store the tox instance
+   *   data. Call $size to find the number of bytes required. If this parameter
+   *   is NULL, this function has no effect.
+   */
+  get();
+}
+
+
+/*******************************************************************************
+ *
+ * :: Connection lifecycle and event loop
+ *
+ ******************************************************************************/
+
+
+/**
+ * Sends a "get nodes" request to the given bootstrap node with IP, port, and
+ * public key to setup connections.
+ *
+ * This function will attempt to connect to the node using UDP. You must use
+ * this function even if ${options.this.udp_enabled} was set to false.
+ *
+ * @param address The hostname or IP address (IPv4 or IPv6) of the node.
+ * @param port The port on the host on which the bootstrap Tox instance is
+ *   listening.
+ * @param public_key The long term public key of the bootstrap node
+ *   ($PUBLIC_KEY_SIZE bytes).
+ * @return true on success.
+ */
+bool bootstrap(string address, uint16_t port, const uint8_t[PUBLIC_KEY_SIZE] public_key) {
+  NULL,
+  /**
+   * The address could not be resolved to an IP address, or the IP address
+   * passed was invalid.
+   */
+  BAD_HOST,
+  /**
+   * The port passed was invalid. The valid port range is (1, 65535).
+   */
+  BAD_PORT,
+}
+
+
+/**
+ * Adds additional host:port pair as TCP relay.
+ *
+ * This function can be used to initiate TCP connections to different ports on
+ * the same bootstrap node, or to add TCP relays without using them as
+ * bootstrap nodes.
+ *
+ * @param address The hostname or IP address (IPv4 or IPv6) of the TCP relay.
+ * @param port The port on the host on which the TCP relay is listening.
+ * @param public_key The long term public key of the TCP relay
+ *   ($PUBLIC_KEY_SIZE bytes).
+ * @return true on success.
+ */
+bool add_tcp_relay(string address, uint16_t port, const uint8_t[PUBLIC_KEY_SIZE] public_key)
+    with error for bootstrap;
+
+
+/**
+ * Protocols that can be used to connect to the network or friends.
+ */
+enum class CONNECTION {
+  /**
+   * There is no connection. This instance, or the friend the state change is
+   * about, is now offline.
+   */
+  NONE,
+  /**
+   * A TCP connection has been established. For the own instance, this means it
+   * is connected through a TCP relay, only. For a friend, this means that the
+   * connection to that particular friend goes through a TCP relay.
+   */
+  TCP,
+  /**
+   * A UDP connection has been established. For the own instance, this means it
+   * is able to send UDP packets to DHT nodes, but may still be connected to
+   * a TCP relay. For a friend, this means that the connection to that
+   * particular friend was built using direct UDP packets.
+   */
+  UDP,
+}
+
+
+inline namespace self {
+
+  CONNECTION connection_status {
+    /**
+     * Return whether we are connected to the DHT. The return value is equal to the
+     * last value received through the `${event connection_status}` callback.
+     *
+     * @deprecated This getter is deprecated. Use the event and store the status
+     * in the client state.
+     */
+    get();
+  }
+
+
+  /**
+   * This event is triggered whenever there is a change in the DHT connection
+   * state. When disconnected, a client may choose to call $bootstrap again, to
+   * reconnect to the DHT. Note that this state may frequently change for short
+   * amounts of time. Clients should therefore not immediately bootstrap on
+   * receiving a disconnect.
+   *
+   * TODO(iphydf): how long should a client wait before bootstrapping again?
+   */
+  event connection_status const {
+    /**
+     * @param connection_status Whether we are connected to the DHT.
+     */
+    typedef void(CONNECTION connection_status);
+  }
+
+}
+
+
+/**
+ * Return the time in milliseconds before $iterate() should be called again
+ * for optimal performance.
+ */
+const uint32_t iteration_interval();
+
+
+/**
+ * The main loop that needs to be run in intervals of $iteration_interval()
+ * milliseconds.
+ */
+void iterate(any user_data);
+
+
+/*******************************************************************************
+ *
+ * :: Internal client information (Tox address/id)
+ *
+ ******************************************************************************/
+
+
+inline namespace self {
+
+  uint8_t[ADDRESS_SIZE] address {
+    /**
+     * Writes the Tox friend address of the client to a byte array. The address is
+     * not in human-readable format. If a client wants to display the address,
+     * formatting is required.
+     *
+     * @param address A memory region of at least $ADDRESS_SIZE bytes. If this
+     *   parameter is NULL, this function has no effect.
+     * @see $ADDRESS_SIZE for the address format.
+     */
+    get();
+  }
+
+
+  uint32_t nospam {
+    /**
+     * Set the 4-byte nospam part of the address. This value is expected in host
+     * byte order. I.e. 0x12345678 will form the bytes [12, 34, 56, 78] in the
+     * nospam part of the Tox friend address.
+     *
+     * @param nospam Any 32 bit unsigned integer.
+     */
+    set();
+
+    /**
+     * Get the 4-byte nospam part of the address. This value is returned in host
+     * byte order.
+     */
+    get();
+  }
+
+
+  uint8_t[PUBLIC_KEY_SIZE] public_key {
+    /**
+     * Copy the Tox Public Key (long term) from the Tox object.
+     *
+     * @param public_key A memory region of at least $PUBLIC_KEY_SIZE bytes. If
+     *   this parameter is NULL, this function has no effect.
+     */
+    get();
+  }
+
+
+  uint8_t[SECRET_KEY_SIZE] secret_key {
+    /**
+     * Copy the Tox Secret Key from the Tox object.
+     *
+     * @param secret_key A memory region of at least $SECRET_KEY_SIZE bytes. If
+     *   this parameter is NULL, this function has no effect.
+     */
+    get();
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: User-visible client information (nickname/status)
+ *
+ ******************************************************************************/
+
+
+/**
+ * Common error codes for all functions that set a piece of user-visible
+ * client information.
+ */
+error for set_info {
+  NULL,
+  /**
+   * Information length exceeded maximum permissible size.
+   */
+  TOO_LONG,
+}
+
+
+inline namespace self {
+
+  uint8_t[length <= MAX_NAME_LENGTH] name {
+    /**
+     * Set the nickname for the Tox client.
+     *
+     * Nickname length cannot exceed $MAX_NAME_LENGTH. If length is 0, the name
+     * parameter is ignored (it can be NULL), and the nickname is set back to empty.
+     *
+     * @param name A byte array containing the new nickname.
+     * @param length The size of the name byte array.
+     *
+     * @return true on success.
+     */
+    set() with error for set_info;
+
+    /**
+     * Return the length of the current nickname as passed to $set.
+     *
+     * If no nickname was set before calling this function, the name is empty,
+     * and this function returns 0.
+     *
+     * @see threading for concurrency implications.
+     */
+    size();
+
+    /**
+     * Write the nickname set by $set to a byte array.
+     *
+     * If no nickname was set before calling this function, the name is empty,
+     * and this function has no effect.
+     *
+     * Call $size to find out how much memory to allocate for
+     * the result.
+     *
+     * @param name A valid memory location large enough to hold the nickname.
+     *   If this parameter is NULL, the function has no effect.
+     */
+    get();
+  }
+
+
+  uint8_t[length <= MAX_STATUS_MESSAGE_LENGTH] status_message {
+    /**
+     * Set the client's status message.
+     *
+     * Status message length cannot exceed $MAX_STATUS_MESSAGE_LENGTH. If
+     * length is 0, the status parameter is ignored (it can be NULL), and the
+     * user status is set back to empty.
+     */
+    set() with error for set_info;
+
+    /**
+     * Return the length of the current status message as passed to $set.
+     *
+     * If no status message was set before calling this function, the status
+     * is empty, and this function returns 0.
+     *
+     * @see threading for concurrency implications.
+     */
+    size();
+
+    /**
+     * Write the status message set by $set to a byte array.
+     *
+     * If no status message was set before calling this function, the status is
+     * empty, and this function has no effect.
+     *
+     * Call $size to find out how much memory to allocate for
+     * the result.
+     *
+     * @param status_message A valid memory location large enough to hold the
+     *   status message. If this parameter is NULL, the function has no effect.
+     */
+    get();
+  }
+
+
+  USER_STATUS status {
+    /**
+     * Set the client's user status.
+     *
+     * @param status One of the user statuses listed in the enumeration above.
+     */
+    set();
+
+    /**
+     * Returns the client's user status.
+     */
+    get();
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Friend list management
+ *
+ ******************************************************************************/
+
+
+namespace friend {
+
+  /**
+   * Add a friend to the friend list and send a friend request.
+   *
+   * A friend request message must be at least 1 byte long and at most
+   * $MAX_FRIEND_REQUEST_LENGTH.
+   *
+   * Friend numbers are unique identifiers used in all functions that operate on
+   * friends. Once added, a friend number is stable for the lifetime of the Tox
+   * object. After saving the state and reloading it, the friend numbers may not
+   * be the same as before. Deleting a friend creates a gap in the friend number
+   * set, which is filled by the next adding of a friend. Any pattern in friend
+   * numbers should not be relied on.
+   *
+   * If more than INT32_MAX friends are added, this function causes undefined
+   * behaviour.
+   *
+   * @param address The address of the friend (returned by ${self.address.get} of
+   *   the friend you wish to add) it must be $ADDRESS_SIZE bytes.
+   * @param message The message that will be sent along with the friend request.
+   * @param length The length of the data byte array.
+   *
+   * @return the friend number on success, UINT32_MAX on failure.
+   */
+  uint32_t add(
+      const uint8_t[ADDRESS_SIZE] address,
+      const uint8_t[length <= MAX_FRIEND_REQUEST_LENGTH] message
+  ) {
+    NULL,
+    /**
+     * The length of the friend request message exceeded
+     * $MAX_FRIEND_REQUEST_LENGTH.
+     */
+    TOO_LONG,
+    /**
+     * The friend request message was empty. This, and the TOO_LONG code will
+     * never be returned from $add_norequest.
+     */
+    NO_MESSAGE,
+    /**
+     * The friend address belongs to the sending client.
+     */
+    OWN_KEY,
+    /**
+     * A friend request has already been sent, or the address belongs to a friend
+     * that is already on the friend list.
+     */
+    ALREADY_SENT,
+    /**
+     * The friend address checksum failed.
+     */
+    BAD_CHECKSUM,
+    /**
+     * The friend was already there, but the nospam value was different.
+     */
+    SET_NEW_NOSPAM,
+    /**
+     * A memory allocation failed when trying to increase the friend list size.
+     */
+    MALLOC,
+  }
+
+
+  /**
+   * Add a friend without sending a friend request.
+   *
+   * This function is used to add a friend in response to a friend request. If the
+   * client receives a friend request, it can be reasonably sure that the other
+   * client added this client as a friend, eliminating the need for a friend
+   * request.
+   *
+   * This function is also useful in a situation where both instances are
+   * controlled by the same entity, so that this entity can perform the mutual
+   * friend adding. In this case, there is no need for a friend request, either.
+   *
+   * @param public_key A byte array of length $PUBLIC_KEY_SIZE containing the
+   *   Public Key (not the Address) of the friend to add.
+   *
+   * @return the friend number on success, UINT32_MAX on failure.
+   * @see $add for a more detailed description of friend numbers.
+   */
+  uint32_t add_norequest(const uint8_t[PUBLIC_KEY_SIZE] public_key)
+      with error for add;
+
+
+  /**
+   * Remove a friend from the friend list.
+   *
+   * This does not notify the friend of their deletion. After calling this
+   * function, this client will appear offline to the friend and no communication
+   * can occur between the two.
+   *
+   * @param friend_number Friend number for the friend to be deleted.
+   *
+   * @return true on success.
+   */
+  bool delete(uint32_t friend_number) {
+    /**
+     * There was no friend with the given friend number. No friends were deleted.
+     */
+    FRIEND_NOT_FOUND,
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Friend list queries
+ *
+ ******************************************************************************/
+
+namespace friend {
+
+  /**
+   * Return the friend number associated with that Public Key.
+   *
+   * @return the friend number on success, UINT32_MAX on failure.
+   * @param public_key A byte array containing the Public Key.
+   */
+  const uint32_t by_public_key(const uint8_t[PUBLIC_KEY_SIZE] public_key) {
+    NULL,
+    /**
+     * No friend with the given Public Key exists on the friend list.
+     */
+    NOT_FOUND,
+  }
+
+
+  /**
+   * Checks if a friend with the given friend number exists and returns true if
+   * it does.
+   */
+  const bool exists(uint32_t friend_number);
+
+}
+
+inline namespace self {
+
+  uint32_t[size] friend_list {
+    /**
+     * Return the number of friends on the friend list.
+     *
+     * This function can be used to determine how much memory to allocate for
+     * $get.
+     */
+    size();
+
+
+    /**
+     * Copy a list of valid friend numbers into an array.
+     *
+     * Call $size to determine the number of elements to allocate.
+     *
+     * @param friend_list A memory region with enough space to hold the friend
+     *   list. If this parameter is NULL, this function has no effect.
+     */
+    get();
+  }
+
+}
+
+
+
+namespace friend {
+
+  uint8_t[PUBLIC_KEY_SIZE] public_key {
+    /**
+     * Copies the Public Key associated with a given friend number to a byte array.
+     *
+     * @param friend_number The friend number you want the Public Key of.
+     * @param public_key A memory region of at least $PUBLIC_KEY_SIZE bytes. If
+     *   this parameter is NULL, this function has no effect.
+     *
+     * @return true on success.
+     */
+    get(uint32_t friend_number) {
+      /**
+       * No friend with the given number exists on the friend list.
+       */
+      FRIEND_NOT_FOUND,
+    }
+  }
+
+}
+
+namespace friend {
+
+  uint64_t last_online {
+    /**
+     * Return a unix-time timestamp of the last time the friend associated with a given
+     * friend number was seen online. This function will return UINT64_MAX on error.
+     *
+     * @param friend_number The friend number you want to query.
+     */
+    get(uint32_t friend_number) {
+      /**
+       * No friend with the given number exists on the friend list.
+       */
+      FRIEND_NOT_FOUND,
+    }
+  }
+
+}
+
+/*******************************************************************************
+ *
+ * :: Friend-specific state queries (can also be received through callbacks)
+ *
+ ******************************************************************************/
+
+
+namespace friend {
+
+  /**
+   * Common error codes for friend state query functions.
+   */
+  error for query {
+    /**
+     * The pointer parameter for storing the query result (name, message) was
+     * NULL. Unlike the `_self_` variants of these functions, which have no effect
+     * when a parameter is NULL, these functions return an error in that case.
+     */
+    NULL,
+    /**
+     * The friend_number did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+  }
+
+
+  uint8_t[length <= MAX_NAME_LENGTH] name {
+    /**
+     * Return the length of the friend's name. If the friend number is invalid, the
+     * return value is unspecified.
+     *
+     * The return value is equal to the `length` argument received by the last
+     * `${event name}` callback.
+     */
+    size(uint32_t friend_number)
+        with error for query;
+
+    /**
+     * Write the name of the friend designated by the given friend number to a byte
+     * array.
+     *
+     * Call $size to determine the allocation size for the `name`
+     * parameter.
+     *
+     * The data written to `name` is equal to the data received by the last
+     * `${event name}` callback.
+     *
+     * @param name A valid memory region large enough to store the friend's name.
+     *
+     * @return true on success.
+     */
+    get(uint32_t friend_number)
+        with error for query;
+  }
+
+
+  /**
+   * This event is triggered when a friend changes their name.
+   */
+  event name const {
+    /**
+     * @param friend_number The friend number of the friend whose name changed.
+     * @param name A byte array containing the same data as
+     *   ${name.get} would write to its `name` parameter.
+     * @param length A value equal to the return value of
+     *   ${name.size}.
+     */
+    typedef void(uint32_t friend_number, const uint8_t[length <= MAX_NAME_LENGTH] name);
+  }
+
+
+  uint8_t[length <= MAX_STATUS_MESSAGE_LENGTH] status_message {
+    /**
+     * Return the length of the friend's status message. If the friend number is
+     * invalid, the return value is SIZE_MAX.
+     */
+    size(uint32_t friend_number)
+        with error for query;
+
+    /**
+     * Write the status message of the friend designated by the given friend number to a byte
+     * array.
+     *
+     * Call $size to determine the allocation size for the `status_name`
+     * parameter.
+     *
+     * The data written to `status_message` is equal to the data received by the last
+     * `${event status_message}` callback.
+     *
+     * @param status_message A valid memory region large enough to store the friend's status message.
+     */
+    get(uint32_t friend_number)
+        with error for query;
+  }
+
+
+  /**
+   * This event is triggered when a friend changes their status message.
+   */
+  event status_message const {
+    /**
+     * @param friend_number The friend number of the friend whose status message
+     *   changed.
+     * @param message A byte array containing the same data as
+     *   ${status_message.get} would write to its `status_message` parameter.
+     * @param length A value equal to the return value of
+     *   ${status_message.size}.
+     */
+    typedef void(uint32_t friend_number, const uint8_t[length <= MAX_STATUS_MESSAGE_LENGTH] message);
+  }
+
+
+  USER_STATUS status {
+    /**
+     * Return the friend's user status (away/busy/...). If the friend number is
+     * invalid, the return value is unspecified.
+     *
+     * The status returned is equal to the last status received through the
+     * `${event status}` callback.
+     *
+     * @deprecated This getter is deprecated. Use the event and store the status
+     *   in the client state.
+     */
+    get(uint32_t friend_number)
+        with error for query;
+  }
+
+
+  /**
+   * This event is triggered when a friend changes their user status.
+   */
+  event status const {
+    /**
+     * @param friend_number The friend number of the friend whose user status
+     *   changed.
+     * @param status The new user status.
+     */
+    typedef void(uint32_t friend_number, USER_STATUS status);
+  }
+
+
+  CONNECTION connection_status {
+    /**
+     * Check whether a friend is currently connected to this client.
+     *
+     * The result of this function is equal to the last value received by the
+     * `${event connection_status}` callback.
+     *
+     * @param friend_number The friend number for which to query the connection
+     *   status.
+     *
+     * @return the friend's connection status as it was received through the
+     *   `${event connection_status}` event.
+     *
+     * @deprecated This getter is deprecated. Use the event and store the status
+     *   in the client state.
+     */
+    get(uint32_t friend_number)
+        with error for query;
+  }
+
+
+  /**
+   * This event is triggered when a friend goes offline after having been online,
+   * or when a friend goes online.
+   *
+   * This callback is not called when adding friends. It is assumed that when
+   * adding friends, their connection status is initially offline.
+   */
+  event connection_status const {
+    /**
+     * @param friend_number The friend number of the friend whose connection status
+     *   changed.
+     * @param connection_status The result of calling
+     *   ${connection_status.get} on the passed friend_number.
+     */
+    typedef void(uint32_t friend_number, CONNECTION connection_status);
+  }
+
+
+  bool typing {
+    /**
+     * Check whether a friend is currently typing a message.
+     *
+     * @param friend_number The friend number for which to query the typing status.
+     *
+     * @return true if the friend is typing.
+     * @return false if the friend is not typing, or the friend number was
+     *   invalid. Inspect the error code to determine which case it is.
+     *
+     * @deprecated This getter is deprecated. Use the event and store the status
+     *   in the client state.
+     */
+    get(uint32_t friend_number)
+        with error for query;
+  }
+
+
+  /**
+   * This event is triggered when a friend starts or stops typing.
+   */
+  event typing const {
+    /**
+     * @param friend_number The friend number of the friend who started or stopped
+     *   typing.
+     * @param is_typing The result of calling ${typing.get} on the passed
+     *   friend_number.
+     */
+    typedef void(uint32_t friend_number, bool is_typing);
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Sending private messages
+ *
+ ******************************************************************************/
+
+
+inline namespace self {
+
+  bool typing {
+    /**
+     * Set the client's typing status for a friend.
+     *
+     * The client is responsible for turning it on or off.
+     *
+     * @param friend_number The friend to which the client is typing a message.
+     * @param typing The typing status. True means the client is typing.
+     *
+     * @return true on success.
+     */
+    set(uint32_t friend_number) {
+      /**
+       * The friend number did not designate a valid friend.
+       */
+      FRIEND_NOT_FOUND,
+    }
+  }
+
+}
+
+
+namespace friend {
+
+  namespace send {
+
+    /**
+     * Send a text chat message to an online friend.
+     *
+     * This function creates a chat message packet and pushes it into the send
+     * queue.
+     *
+     * The message length may not exceed $MAX_MESSAGE_LENGTH. Larger messages
+     * must be split by the client and sent as separate messages. Other clients can
+     * then reassemble the fragments. Messages may not be empty.
+     *
+     * The return value of this function is the message ID. If a read receipt is
+     * received, the triggered `${event read_receipt}` event will be passed this message ID.
+     *
+     * Message IDs are unique per friend. The first message ID is 0. Message IDs are
+     * incremented by 1 each time a message is sent. If UINT32_MAX messages were
+     * sent, the next message ID is 0.
+     *
+     * @param type Message type (normal, action, ...).
+     * @param friend_number The friend number of the friend to send the message to.
+     * @param message A non-NULL pointer to the first element of a byte array
+     *   containing the message text.
+     * @param length Length of the message to be sent.
+     */
+    uint32_t message(uint32_t friend_number, MESSAGE_TYPE type,
+                     const uint8_t[length <= MAX_MESSAGE_LENGTH] message) {
+      NULL,
+      /**
+       * The friend number did not designate a valid friend.
+       */
+      FRIEND_NOT_FOUND,
+      /**
+       * This client is currently not connected to the friend.
+       */
+      FRIEND_NOT_CONNECTED,
+      /**
+       * An allocation error occurred while increasing the send queue size.
+       */
+      SENDQ,
+      /**
+       * Message length exceeded $MAX_MESSAGE_LENGTH.
+       */
+      TOO_LONG,
+      /**
+       * Attempted to send a zero-length message.
+       */
+      EMPTY,
+    }
+
+  }
+
+
+  /**
+   * This event is triggered when the friend receives the message sent with
+   * ${send.message} with the corresponding message ID.
+   */
+  event read_receipt const {
+    /**
+     * @param friend_number The friend number of the friend who received the message.
+     * @param message_id The message ID as returned from ${send.message}
+     *   corresponding to the message sent.
+     */
+    typedef void(uint32_t friend_number, uint32_t message_id);
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Receiving private messages and friend requests
+ *
+ ******************************************************************************/
+
+
+namespace friend {
+
+  /**
+   * This event is triggered when a friend request is received.
+   */
+  event request const {
+    /**
+     * @param public_key The Public Key of the user who sent the friend request.
+     * @param message The message they sent along with the request.
+     * @param length The size of the message byte array.
+     */
+    typedef void(const uint8_t[PUBLIC_KEY_SIZE] public_key,
+                 const uint8_t[length <= MAX_MESSAGE_LENGTH] message);
+  }
+
+
+  /**
+   * This event is triggered when a message from a friend is received.
+   */
+  event message const {
+    /**
+     * @param friend_number The friend number of the friend who sent the message.
+     * @param message The message data they sent.
+     * @param length The size of the message byte array.
+     */
+    typedef void(uint32_t friend_number, MESSAGE_TYPE type,
+                 const uint8_t[length <= MAX_MESSAGE_LENGTH] message);
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: File transmission: common between sending and receiving
+ *
+ ******************************************************************************/
+
+
+/**
+ * Generates a cryptographic hash of the given data.
+ *
+ * This function may be used by clients for any purpose, but is provided
+ * primarily for validating cached avatars. This use is highly recommended to
+ * avoid unnecessary avatar updates.
+ *
+ * If hash is NULL or data is NULL while length is not 0 the function returns false,
+ * otherwise it returns true.
+ *
+ * This function is a wrapper to internal message-digest functions.
+ *
+ * @param hash A valid memory location the hash data. It must be at least
+ *   $HASH_LENGTH bytes in size.
+ * @param data Data to be hashed or NULL.
+ * @param length Size of the data array or 0.
+ *
+ * @return true if hash was not NULL.
+ */
+static bool hash(uint8_t[HASH_LENGTH] hash, const uint8_t[length] data);
+
+
+namespace file {
+
+  enum KIND {
+    /**
+     * Arbitrary file data. Clients can choose to handle it based on the file name
+     * or magic or any other way they choose.
+     */
+    DATA,
+    /**
+     * Avatar file_id. This consists of $hash(image).
+     * Avatar data. This consists of the image data.
+     *
+     * Avatars can be sent at any time the client wishes. Generally, a client will
+     * send the avatar to a friend when that friend comes online, and to all
+     * friends when the avatar changed. A client can save some traffic by
+     * remembering which friend received the updated avatar already and only send
+     * it if the friend has an out of date avatar.
+     *
+     * Clients who receive avatar send requests can reject it (by sending
+     * ${CONTROL.CANCEL} before any other controls), or accept it (by
+     * sending ${CONTROL.RESUME}). The file_id of length $HASH_LENGTH bytes
+     * (same length as $FILE_ID_LENGTH) will contain the hash. A client can compare
+     * this hash with a saved hash and send ${CONTROL.CANCEL} to terminate the avatar
+     * transfer if it matches.
+     *
+     * When file_size is set to 0 in the transfer request it means that the client
+     * has no avatar.
+     */
+    AVATAR,
+  }
+
+
+  enum class CONTROL {
+    /**
+     * Sent by the receiving side to accept a file send request. Also sent after a
+     * $PAUSE command to continue sending or receiving.
+     */
+    RESUME,
+    /**
+     * Sent by clients to pause the file transfer. The initial state of a file
+     * transfer is always paused on the receiving side and running on the sending
+     * side. If both the sending and receiving side pause the transfer, then both
+     * need to send $RESUME for the transfer to resume.
+     */
+    PAUSE,
+    /**
+     * Sent by the receiving side to reject a file send request before any other
+     * commands are sent. Also sent by either side to terminate a file transfer.
+     */
+    CANCEL,
+  }
+
+
+  /**
+   * Sends a file control command to a friend for a given file transfer.
+   *
+   * @param friend_number The friend number of the friend the file is being
+   *   transferred to or received from.
+   * @param file_number The friend-specific identifier for the file transfer.
+   * @param control The control command to send.
+   *
+   * @return true on success.
+   */
+  bool control(uint32_t friend_number, uint32_t file_number, CONTROL control) {
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    FRIEND_NOT_CONNECTED,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    NOT_FOUND,
+    /**
+     * A RESUME control was sent, but the file transfer is running normally.
+     */
+    NOT_PAUSED,
+    /**
+     * A RESUME control was sent, but the file transfer was paused by the other
+     * party. Only the party that paused the transfer can resume it.
+     */
+    DENIED,
+    /**
+     * A PAUSE control was sent, but the file transfer was already paused.
+     */
+    ALREADY_PAUSED,
+    /**
+     * Packet queue is full.
+     */
+    SENDQ,
+  }
+
+
+  /**
+   * This event is triggered when a file control command is received from a
+   * friend.
+   */
+  event recv_control const {
+    /**
+     * When receiving ${CONTROL.CANCEL}, the client should release the
+     * resources associated with the file number and consider the transfer failed.
+     *
+     * @param friend_number The friend number of the friend who is sending the file.
+     * @param file_number The friend-specific file number the data received is
+     *   associated with.
+     * @param control The file control command received.
+     */
+    typedef void(uint32_t friend_number, uint32_t file_number, CONTROL control);
+  }
+
+  /**
+   * Sends a file seek control command to a friend for a given file transfer.
+   *
+   * This function can only be called to resume a file transfer right before
+   * ${CONTROL.RESUME} is sent.
+   *
+   * @param friend_number The friend number of the friend the file is being
+   *   received from.
+   * @param file_number The friend-specific identifier for the file transfer.
+   * @param position The position that the file should be seeked to.
+   */
+  bool seek(uint32_t friend_number, uint32_t file_number, uint64_t position) {
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    FRIEND_NOT_CONNECTED,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    NOT_FOUND,
+    /**
+     * File was not in a state where it could be seeked.
+     */
+    DENIED,
+    /**
+     * Seek position was invalid
+     */
+    INVALID_POSITION,
+    /**
+     * Packet queue is full.
+     */
+    SENDQ,
+  }
+
+
+  error for get {
+    NULL,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    NOT_FOUND,
+  }
+
+  uint8_t[FILE_ID_LENGTH] file_id {
+    /**
+     * Copy the file id associated to the file transfer to a byte array.
+     *
+     * @param friend_number The friend number of the friend the file is being
+     *   transferred to or received from.
+     * @param file_number The friend-specific identifier for the file transfer.
+     * @param file_id A memory region of at least $FILE_ID_LENGTH bytes. If
+     *   this parameter is NULL, this function has no effect.
+     *
+     * @return true on success.
+     */
+    get(uint32_t friend_number, uint32_t file_number)
+        with error for get;
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: File transmission: sending
+ *
+ ******************************************************************************/
+
+
+namespace file {
+
+  /**
+   * Send a file transmission request.
+   *
+   * Maximum filename length is $MAX_FILENAME_LENGTH bytes. The filename
+   * should generally just be a file name, not a path with directory names.
+   *
+   * If a non-UINT64_MAX file size is provided, it can be used by both sides to
+   * determine the sending progress. File size can be set to UINT64_MAX for streaming
+   * data of unknown size.
+   *
+   * File transmission occurs in chunks, which are requested through the
+   * `${event chunk_request}` event.
+   *
+   * When a friend goes offline, all file transfers associated with the friend are
+   * purged from core.
+   *
+   * If the file contents change during a transfer, the behaviour is unspecified
+   * in general. What will actually happen depends on the mode in which the file
+   * was modified and how the client determines the file size.
+   *
+   * - If the file size was increased
+   *   - and sending mode was streaming (file_size = UINT64_MAX), the behaviour
+   *     will be as expected.
+   *   - and sending mode was file (file_size != UINT64_MAX), the
+   *     ${event chunk_request} callback will receive length = 0 when Core thinks
+   *     the file transfer has finished. If the client remembers the file size as
+   *     it was when sending the request, it will terminate the transfer normally.
+   *     If the client re-reads the size, it will think the friend cancelled the
+   *     transfer.
+   * - If the file size was decreased
+   *   - and sending mode was streaming, the behaviour is as expected.
+   *   - and sending mode was file, the callback will return 0 at the new
+   *     (earlier) end-of-file, signalling to the friend that the transfer was
+   *     cancelled.
+   * - If the file contents were modified
+   *   - at a position before the current read, the two files (local and remote)
+   *     will differ after the transfer terminates.
+   *   - at a position after the current read, the file transfer will succeed as
+   *     expected.
+   *   - In either case, both sides will regard the transfer as complete and
+   *     successful.
+   *
+   * @param friend_number The friend number of the friend the file send request
+   *   should be sent to.
+   * @param kind The meaning of the file to be sent.
+   * @param file_size Size in bytes of the file the client wants to send, UINT64_MAX if
+   *   unknown or streaming.
+   * @param file_id A file identifier of length $FILE_ID_LENGTH that can be used to
+   *   uniquely identify file transfers across core restarts. If NULL, a random one will
+   *   be generated by core. It can then be obtained by using ${file_id.get}().
+   * @param filename Name of the file. Does not need to be the actual name. This
+   *   name will be sent along with the file send request.
+   * @param filename_length Size in bytes of the filename.
+   *
+   * @return A file number used as an identifier in subsequent callbacks. This
+   *   number is per friend. File numbers are reused after a transfer terminates.
+   *   On failure, this function returns UINT32_MAX. Any pattern in file numbers
+   *   should not be relied on.
+   */
+  uint32_t send(uint32_t friend_number, uint32_t kind, uint64_t file_size,
+                const uint8_t[FILE_ID_LENGTH] file_id,
+                const uint8_t[filename_length <= MAX_FILENAME_LENGTH] filename) {
+    NULL,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    FRIEND_NOT_CONNECTED,
+    /**
+     * Filename length exceeded $MAX_FILENAME_LENGTH bytes.
+     */
+    NAME_TOO_LONG,
+    /**
+     * Too many ongoing transfers. The maximum number of concurrent file transfers
+     * is 256 per friend per direction (sending and receiving).
+     */
+    TOO_MANY,
+  }
+
+
+  /**
+   * Send a chunk of file data to a friend.
+   *
+   * This function is called in response to the `${event chunk_request}` callback. The
+   * length parameter should be equal to the one received though the callback.
+   * If it is zero, the transfer is assumed complete. For files with known size,
+   * Core will know that the transfer is complete after the last byte has been
+   * received, so it is not necessary (though not harmful) to send a zero-length
+   * chunk to terminate. For streams, core will know that the transfer is finished
+   * if a chunk with length less than the length requested in the callback is sent.
+   *
+   * @param friend_number The friend number of the receiving friend for this file.
+   * @param file_number The file transfer identifier returned by tox_file_send.
+   * @param position The file or stream position from which to continue reading.
+   * @return true on success.
+   */
+  bool send_chunk(uint32_t friend_number, uint32_t file_number, uint64_t position, const uint8_t[length] data) {
+    /**
+     * The length parameter was non-zero, but data was NULL.
+     */
+    NULL,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    FRIEND_NOT_CONNECTED,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    NOT_FOUND,
+    /**
+     * File transfer was found but isn't in a transferring state: (paused, done,
+     * broken, etc...) (happens only when not called from the request chunk callback).
+     */
+    NOT_TRANSFERRING,
+    /**
+     * Attempted to send more or less data than requested. The requested data size is
+     * adjusted according to maximum transmission unit and the expected end of
+     * the file. Trying to send less or more than requested will return this error.
+     */
+    INVALID_LENGTH,
+    /**
+     * Packet queue is full.
+     */
+    SENDQ,
+    /**
+     * Position parameter was wrong.
+     */
+    WRONG_POSITION,
+  }
+
+
+  /**
+   * This event is triggered when Core is ready to send more file data.
+   */
+  event chunk_request const {
+    /**
+     * If the length parameter is 0, the file transfer is finished, and the client's
+     * resources associated with the file number should be released. After a call
+     * with zero length, the file number can be reused for future file transfers.
+     *
+     * If the requested position is not equal to the client's idea of the current
+     * file or stream position, it will need to seek. In case of read-once streams,
+     * the client should keep the last read chunk so that a seek back can be
+     * supported. A seek-back only ever needs to read from the last requested chunk.
+     * This happens when a chunk was requested, but the send failed. A seek-back
+     * request can occur an arbitrary number of times for any given chunk.
+     *
+     * In response to receiving this callback, the client should call the function
+     * `$send_chunk` with the requested chunk. If the number of bytes sent
+     * through that function is zero, the file transfer is assumed complete. A
+     * client must send the full length of data requested with this callback.
+     *
+     * @param friend_number The friend number of the receiving friend for this file.
+     * @param file_number The file transfer identifier returned by $send.
+     * @param position The file or stream position from which to continue reading.
+     * @param length The number of bytes requested for the current chunk.
+     */
+    typedef void(uint32_t friend_number, uint32_t file_number, uint64_t position, size_t length);
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: File transmission: receiving
+ *
+ ******************************************************************************/
+
+
+namespace file {
+
+  /**
+   * This event is triggered when a file transfer request is received.
+   */
+  event recv const {
+    /**
+     * The client should acquire resources to be associated with the file transfer.
+     * Incoming file transfers start in the PAUSED state. After this callback
+     * returns, a transfer can be rejected by sending a ${CONTROL.CANCEL}
+     * control command before any other control commands. It can be accepted by
+     * sending ${CONTROL.RESUME}.
+     *
+     * @param friend_number The friend number of the friend who is sending the file
+     *   transfer request.
+     * @param file_number The friend-specific file number the data received is
+     *   associated with.
+     * @param kind The meaning of the file to be sent.
+     * @param file_size Size in bytes of the file the client wants to send,
+     *   UINT64_MAX if unknown or streaming.
+     * @param filename Name of the file. Does not need to be the actual name. This
+     *   name will be sent along with the file send request.
+     * @param filename_length Size in bytes of the filename.
+     */
+    typedef void(uint32_t friend_number, uint32_t file_number, uint32_t kind,
+                 uint64_t file_size, const uint8_t[filename_length <= MAX_FILENAME_LENGTH] filename);
+  }
+
+
+  /**
+   * This event is first triggered when a file transfer request is received, and
+   * subsequently when a chunk of file data for an accepted request was received.
+   */
+  event recv_chunk const {
+    /**
+     * When length is 0, the transfer is finished and the client should release the
+     * resources it acquired for the transfer. After a call with length = 0, the
+     * file number can be reused for new file transfers.
+     *
+     * If position is equal to file_size (received in the file_receive callback)
+     * when the transfer finishes, the file was received completely. Otherwise, if
+     * file_size was UINT64_MAX, streaming ended successfully when length is 0.
+     *
+     * @param friend_number The friend number of the friend who is sending the file.
+     * @param file_number The friend-specific file number the data received is
+     *   associated with.
+     * @param position The file position of the first byte in data.
+     * @param data A byte array containing the received chunk.
+     * @param length The length of the received chunk.
+     */
+    typedef void(uint32_t friend_number, uint32_t file_number, uint64_t position,
+                 const uint8_t[length] data);
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Conference management
+ *
+ ******************************************************************************/
+
+namespace conference {
+
+  /**
+   * Conference types for the ${event invite} event.
+   */
+  enum class TYPE {
+    /**
+     * Text-only conferences that must be accepted with the $join function.
+     */
+    TEXT,
+    /**
+     * Video conference. The function to accept these is in toxav.
+     */
+    AV,
+  }
+
+
+  /**
+   * This event is triggered when the client is invited to join a conference.
+   */
+  event invite const {
+    /**
+     * The invitation will remain valid until the inviting friend goes offline
+     * or exits the conference.
+     *
+     * @param friend_number The friend who invited us.
+     * @param type The conference type (text only or audio/video).
+     * @param cookie A piece of data of variable length required to join the
+     *   conference.
+     * @param length The length of the cookie.
+     */
+    typedef void(uint32_t friend_number, TYPE type, const uint8_t[length] cookie);
+  }
+
+
+  /**
+   * This event is triggered when the client receives a conference message.
+   */
+  event message const {
+    /**
+     * @param conference_number The conference number of the conference the message is intended for.
+     * @param peer_number The ID of the peer who sent the message.
+     * @param type The type of message (normal, action, ...).
+     * @param message The message data.
+     * @param length The length of the message.
+     */
+    typedef void(uint32_t conference_number, uint32_t peer_number, MESSAGE_TYPE type,
+                 const uint8_t[length] message);
+  }
+
+
+  /**
+   * This event is triggered when a peer changes the conference title.
+   *
+   * If peer_number == UINT32_MAX, then author is unknown (e.g. initial joining the conference).
+   */
+  event title const {
+    /**
+     * @param conference_number The conference number of the conference the title change is intended for.
+     * @param peer_number The ID of the peer who changed the title.
+     * @param title The title data.
+     * @param length The title length.
+     */
+    typedef void(uint32_t conference_number, uint32_t peer_number, const uint8_t[length] title);
+  }
+
+  namespace peer {
+
+    /**
+     * This event is triggered when a peer changes their name.
+     */
+    event name const {
+      /**
+       * @param conference_number The conference number of the conference the
+       *   peer is in.
+       * @param peer_number The ID of the peer who changed their nickname.
+       * @param name A byte array containing the new nickname.
+       * @param length The size of the name byte array.
+       */
+      typedef void(uint32_t conference_number, uint32_t peer_number, const uint8_t[length] name);
+    }
+
+    /**
+     * This event is triggered when a peer joins or leaves the conference.
+     */
+    event list_changed const {
+      /**
+       * @param conference_number The conference number of the conference the
+       *   peer is in.
+       */
+      typedef void(uint32_t conference_number);
+    }
+
+  }
+
+
+  /**
+   * Creates a new conference.
+   *
+   * This function creates a new text conference.
+   *
+   * @return conference number on success, or UINT32_MAX on failure.
+   */
+  uint32_t new() {
+    /**
+     * The conference instance failed to initialize.
+     */
+    INIT,
+  }
+
+  /**
+   * This function deletes a conference.
+   *
+   * @param conference_number The conference number of the conference to be deleted.
+   *
+   * @return true on success.
+   */
+  bool delete(uint32_t conference_number) {
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    CONFERENCE_NOT_FOUND,
+  }
+
+
+  namespace peer {
+
+    /**
+     * Error codes for peer info queries.
+     */
+    error for query {
+      /**
+       * The conference number passed did not designate a valid conference.
+       */
+      CONFERENCE_NOT_FOUND,
+      /**
+       * The peer number passed did not designate a valid peer.
+       */
+      PEER_NOT_FOUND,
+      /**
+       * The client is not connected to the conference.
+       */
+      NO_CONNECTION,
+    }
+
+    /**
+     * Return the number of peers in the conference. Return value is unspecified on failure.
+     */
+    const uint32_t count(uint32_t conference_number)
+        with error for query;
+
+    uint8_t[size] name {
+
+      /**
+       * Return the length of the peer's name. Return value is unspecified on failure.
+       */
+      size(uint32_t conference_number, uint32_t peer_number)
+          with error for query;
+
+      /**
+       * Copy the name of peer_number who is in conference_number to name.
+       * name must be at least $MAX_NAME_LENGTH long.
+       *
+       * @return true on success.
+       */
+      get(uint32_t conference_number, uint32_t peer_number)
+          with error for query;
+    }
+
+    /**
+     * Copy the public key of peer_number who is in conference_number to public_key.
+     * public_key must be $PUBLIC_KEY_SIZE long.
+     *
+     * @return true on success.
+     */
+    uint8_t[PUBLIC_KEY_SIZE] public_key {
+      get(uint32_t conference_number, uint32_t peer_number)
+          with error for query;
+    }
+
+    /**
+     * Return true if passed peer_number corresponds to our own.
+     */
+    const bool number_is_ours(uint32_t conference_number, uint32_t peer_number)
+        with error for query;
+
+  }
+
+
+  /**
+   * Invites a friend to a conference.
+   *
+   * @param friend_number The friend number of the friend we want to invite.
+   * @param conference_number The conference number of the conference we want to invite the friend to.
+   *
+   * @return true on success.
+   */
+  bool invite(uint32_t friend_number, uint32_t conference_number) {
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    CONFERENCE_NOT_FOUND,
+    /**
+     * The invite packet failed to send.
+     */
+    FAIL_SEND,
+  }
+
+
+  /**
+   * Joins a conference that the client has been invited to.
+   *
+   * @param friend_number The friend number of the friend who sent the invite.
+   * @param cookie Received via the `${event invite}` event.
+   * @param length The size of cookie.
+   *
+   * @return conference number on success, UINT32_MAX on failure.
+   */
+  uint32_t join(uint32_t friend_number, const uint8_t[length] cookie) {
+    /**
+     * The cookie passed has an invalid length.
+     */
+    INVALID_LENGTH,
+    /**
+     * The conference is not the expected type. This indicates an invalid cookie.
+     */
+    WRONG_TYPE,
+    /**
+     * The friend number passed does not designate a valid friend.
+     */
+    FRIEND_NOT_FOUND,
+    /**
+     * Client is already in this conference.
+     */
+    DUPLICATE,
+    /**
+     * Conference instance failed to initialize.
+     */
+    INIT_FAIL,
+    /**
+     * The join packet failed to send.
+     */
+    FAIL_SEND,
+  }
+
+
+  namespace send {
+
+    /**
+     * Send a text chat message to the conference.
+     *
+     * This function creates a conference message packet and pushes it into the send
+     * queue.
+     *
+     * The message length may not exceed $MAX_MESSAGE_LENGTH. Larger messages
+     * must be split by the client and sent as separate messages. Other clients can
+     * then reassemble the fragments.
+     *
+     * @param conference_number The conference number of the conference the message is intended for.
+     * @param type Message type (normal, action, ...).
+     * @param message A non-NULL pointer to the first element of a byte array
+     *   containing the message text.
+     * @param length Length of the message to be sent.
+     *
+     * @return true on success.
+     */
+    bool message(uint32_t conference_number, MESSAGE_TYPE type, const uint8_t[length] message) {
+      /**
+       * The conference number passed did not designate a valid conference.
+       */
+      CONFERENCE_NOT_FOUND,
+      /**
+       * The message is too long.
+       */
+      TOO_LONG,
+      /**
+       * The client is not connected to the conference.
+       */
+      NO_CONNECTION,
+      /**
+       * The message packet failed to send.
+       */
+      FAIL_SEND,
+    }
+  }
+
+  error for title {
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    CONFERENCE_NOT_FOUND,
+    /**
+     * The title is too long or empty.
+     */
+    INVALID_LENGTH,
+    /**
+     * The title packet failed to send.
+     */
+    FAIL_SEND,
+  }
+
+  uint8_t[length <= MAX_NAME_LENGTH] title {
+
+    /**
+     * Return the length of the conference title. Return value is unspecified on failure.
+     *
+     * The return value is equal to the `length` argument received by the last
+     * `${event title}` callback.
+     */
+    size(uint32_t conference_number)
+        with error for title;
+
+    /**
+     * Write the title designated by the given conference number to a byte array.
+     *
+     * Call $size to determine the allocation size for the `title` parameter.
+     *
+     * The data written to `title` is equal to the data received by the last
+     * `${event title}` callback.
+     *
+     * @param title A valid memory region large enough to store the title.
+     *   If this parameter is NULL, this function has no effect.
+     *
+     * @return true on success.
+     */
+    get(uint32_t conference_number)
+        with error for title;
+
+    /**
+     * Set the conference title and broadcast it to the rest of the conference.
+     *
+     * Title length cannot be longer than $MAX_NAME_LENGTH.
+     *
+     * @return true on success.
+     */
+    set(uint32_t conference_number)
+        with error for title;
+  }
+
+
+  uint32_t[size] chatlist {
+    /**
+     * Return the number of conferences in the Tox instance.
+     * This should be used to determine how much memory to allocate for `$get`.
+     */
+    size();
+
+    /**
+     * Copy a list of valid conference IDs into the array chatlist. Determine how much space
+     * to allocate for the array with the `$size` function.
+     */
+    get();
+  }
+
+
+  /**
+   * Returns the type of conference ($TYPE) that conference_number is. Return value is
+   * unspecified on failure.
+   */
+  TYPE type {
+    get(uint32_t conference_number) {
+      /**
+       * The conference number passed did not designate a valid conference.
+       */
+      CONFERENCE_NOT_FOUND,
+    }
+  }
+
+}
+
+
+/*******************************************************************************
+ *
+ * :: Low-level custom packet sending and receiving
+ *
+ ******************************************************************************/
+
+
+namespace friend {
+
+  inline namespace send {
+
+    error for custom_packet {
+      NULL,
+      /**
+       * The friend number did not designate a valid friend.
+       */
+      FRIEND_NOT_FOUND,
+      /**
+       * This client is currently not connected to the friend.
+       */
+      FRIEND_NOT_CONNECTED,
+      /**
+       * The first byte of data was not in the specified range for the packet type.
+       * This range is 200-254 for lossy, and 160-191 for lossless packets.
+       */
+      INVALID,
+      /**
+       * Attempted to send an empty packet.
+       */
+      EMPTY,
+      /**
+       * Packet data length exceeded $MAX_CUSTOM_PACKET_SIZE.
+       */
+      TOO_LONG,
+      /**
+       * Packet queue is full.
+       */
+      SENDQ,
+    }
+
+    /**
+     * Send a custom lossy packet to a friend.
+     *
+     * The first byte of data must be in the range 200-254. Maximum length of a
+     * custom packet is $MAX_CUSTOM_PACKET_SIZE.
+     *
+     * Lossy packets behave like UDP packets, meaning they might never reach the
+     * other side or might arrive more than once (if someone is messing with the
+     * connection) or might arrive in the wrong order.
+     *
+     * Unless latency is an issue, it is recommended that you use lossless custom
+     * packets instead.
+     *
+     * @param friend_number The friend number of the friend this lossy packet
+     *   should be sent to.
+     * @param data A byte array containing the packet data.
+     * @param length The length of the packet data byte array.
+     *
+     * @return true on success.
+     */
+    bool lossy_packet(uint32_t friend_number, const uint8_t[length <= MAX_CUSTOM_PACKET_SIZE] data)
+        with error for custom_packet;
+
+
+    /**
+     * Send a custom lossless packet to a friend.
+     *
+     * The first byte of data must be in the range 160-191. Maximum length of a
+     * custom packet is $MAX_CUSTOM_PACKET_SIZE.
+     *
+     * Lossless packet behaviour is comparable to TCP (reliability, arrive in order)
+     * but with packets instead of a stream.
+     *
+     * @param friend_number The friend number of the friend this lossless packet
+     *   should be sent to.
+     * @param data A byte array containing the packet data.
+     * @param length The length of the packet data byte array.
+     *
+     * @return true on success.
+     */
+    bool lossless_packet(uint32_t friend_number, const uint8_t[length <= MAX_CUSTOM_PACKET_SIZE] data)
+        with error for custom_packet;
+
+  }
+
+
+  event lossy_packet const {
+    /**
+     * @param friend_number The friend number of the friend who sent a lossy packet.
+     * @param data A byte array containing the received packet data.
+     * @param length The length of the packet data byte array.
+     */
+    typedef void(uint32_t friend_number, const uint8_t[length <= MAX_CUSTOM_PACKET_SIZE] data);
+  }
+
+
+  event lossless_packet const {
+    /**
+     * @param friend_number The friend number of the friend who sent the packet.
+     * @param data A byte array containing the received packet data.
+     * @param length The length of the packet data byte array.
+     */
+    typedef void(uint32_t friend_number, const uint8_t[length <= MAX_CUSTOM_PACKET_SIZE] data);
+  }
+
+}
+
+
+
+/*******************************************************************************
+ *
+ * :: Low-level network information
+ *
+ ******************************************************************************/
+
+
+inline namespace self {
+
+  uint8_t[PUBLIC_KEY_SIZE] dht_id {
+    /**
+     * Writes the temporary DHT public key of this instance to a byte array.
+     *
+     * This can be used in combination with an externally accessible IP address and
+     * the bound port (from ${udp_port.get}) to run a temporary bootstrap node.
+     *
+     * Be aware that every time a new instance is created, the DHT public key
+     * changes, meaning this cannot be used to run a permanent bootstrap node.
+     *
+     * @param dht_id A memory region of at least $PUBLIC_KEY_SIZE bytes. If this
+     *   parameter is NULL, this function has no effect.
+     */
+    get();
+  }
+
+
+  error for get_port {
+    /**
+     * The instance was not bound to any port.
+     */
+    NOT_BOUND,
+  }
+
+
+  uint16_t udp_port {
+    /**
+     * Return the UDP port this Tox instance is bound to.
+     */
+    get() with error for get_port;
+  }
+
+
+  uint16_t tcp_port {
+    /**
+     * Return the TCP port this Tox instance is bound to. This is only relevant if
+     * the instance is acting as a TCP relay.
+     */
+    get() with error for get_port;
+  }
+
+}
+
+} // class tox
+
+%{
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+%}
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 23d0d3e4..2f210209 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -1,65 +1,68 @@
-/* tox.c
- *
+/*
  * The Tox public API.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
+#define _XOPEN_SOURCE 600
+
+#define TOX_DEFINED
+typedef struct Messenger Tox;
+#include "tox.h"
+
+#include <string.h>
+
 #include "Messenger.h"
 #include "group.h"
 #include "logger.h"
 
 #include "../toxencryptsave/defines.h"
 
-#define TOX_DEFINED
-typedef struct Messenger Tox;
-
-#include "tox.h"
-
 #define SET_ERROR_PARAMETER(param, x) {if(param) {*param = x;}}
 
-#if TOX_HASH_LENGTH != crypto_hash_sha256_BYTES
-#error TOX_HASH_LENGTH is assumed to be equal to crypto_hash_sha256_BYTES
+#if TOX_HASH_LENGTH != CRYPTO_SHA256_SIZE
+#error TOX_HASH_LENGTH is assumed to be equal to CRYPTO_SHA256_SIZE
 #endif
 
-#if FILE_ID_LENGTH != crypto_box_KEYBYTES
-#error FILE_ID_LENGTH is assumed to be equal to crypto_box_KEYBYTES
+#if FILE_ID_LENGTH != CRYPTO_SYMMETRIC_KEY_SIZE
+#error FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE
 #endif
 
-#if TOX_FILE_ID_LENGTH != crypto_box_KEYBYTES
-#error TOX_FILE_ID_LENGTH is assumed to be equal to crypto_box_KEYBYTES
+#if TOX_FILE_ID_LENGTH != CRYPTO_SYMMETRIC_KEY_SIZE
+#error TOX_FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE
 #endif
 
 #if TOX_FILE_ID_LENGTH != TOX_HASH_LENGTH
 #error TOX_FILE_ID_LENGTH is assumed to be equal to TOX_HASH_LENGTH
 #endif
 
-#if TOX_PUBLIC_KEY_SIZE != crypto_box_PUBLICKEYBYTES
-#error TOX_PUBLIC_KEY_SIZE is assumed to be equal to crypto_box_PUBLICKEYBYTES
+#if TOX_PUBLIC_KEY_SIZE != CRYPTO_PUBLIC_KEY_SIZE
+#error TOX_PUBLIC_KEY_SIZE is assumed to be equal to CRYPTO_PUBLIC_KEY_SIZE
 #endif
 
-#if TOX_SECRET_KEY_SIZE != crypto_box_SECRETKEYBYTES
-#error TOX_SECRET_KEY_SIZE is assumed to be equal to crypto_box_SECRETKEYBYTES
+#if TOX_SECRET_KEY_SIZE != CRYPTO_SECRET_KEY_SIZE
+#error TOX_SECRET_KEY_SIZE is assumed to be equal to CRYPTO_SECRET_KEY_SIZE
 #endif
 
 #if TOX_MAX_NAME_LENGTH != MAX_NAME_LENGTH
@@ -70,107 +73,62 @@ typedef struct Messenger Tox;
 #error TOX_MAX_STATUS_MESSAGE_LENGTH is assumed to be equal to MAX_STATUSMESSAGE_LENGTH
 #endif
 
-uint32_t tox_version_major(void)
-{
-    return TOX_VERSION_MAJOR;
-}
-
-uint32_t tox_version_minor(void)
-{
-    return TOX_VERSION_MINOR;
-}
-
-uint32_t tox_version_patch(void)
-{
-    return TOX_VERSION_PATCH;
-}
 
 bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)
 {
-  return (TOX_VERSION_MAJOR == major && /* Force the major version */
-            (TOX_VERSION_MINOR > minor || /* Current minor version must be newer than requested -- or -- */
-                (TOX_VERSION_MINOR == minor && TOX_VERSION_PATCH >= patch) /* the patch must be the same or newer */
-            )
-         );
+    return TOX_VERSION_IS_API_COMPATIBLE(major, minor, patch);
 }
 
 
-void tox_options_default(struct Tox_Options *options)
-{
-    if (options) {
-        memset(options, 0, sizeof(struct Tox_Options));
-        options->ipv6_enabled = 1;
-        options->udp_enabled = 1;
-        options->proxy_type = TOX_PROXY_TYPE_NONE;
-    }
-}
-
-struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error)
-{
-    struct Tox_Options *options = calloc(sizeof(struct Tox_Options), 1);
-
-    if (options) {
-        tox_options_default(options);
-        SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_OK);
-        return options;
-    }
-
-    SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_MALLOC);
-    return NULL;
-}
-
-void tox_options_free(struct Tox_Options *options)
-{
-    free(options);
-}
-
 Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
 {
-    if (!logger_get_global())
-        logger_set_global(logger_new(LOGGER_OUTPUT_FILE, LOGGER_LEVEL, "toxcore"));
-
     Messenger_Options m_options = {0};
 
-    _Bool load_savedata_sk = 0, load_savedata_tox = 0;
+    bool load_savedata_sk = false, load_savedata_tox = false;
 
-    if (options == NULL) {
+    if (options == nullptr) {
         m_options.ipv6enabled = TOX_ENABLE_IPV6_DEFAULT;
     } else {
-        if (options->savedata_type != TOX_SAVEDATA_TYPE_NONE) {
-            if (options->savedata_data == NULL || options->savedata_length == 0) {
+        if (tox_options_get_savedata_type(options) != TOX_SAVEDATA_TYPE_NONE) {
+            if (tox_options_get_savedata_data(options) == nullptr || tox_options_get_savedata_length(options) == 0) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
-                return NULL;
+                return nullptr;
             }
         }
 
-        if (options->savedata_type == TOX_SAVEDATA_TYPE_SECRET_KEY) {
-            if (options->savedata_length != TOX_SECRET_KEY_SIZE) {
+        if (tox_options_get_savedata_type(options) == TOX_SAVEDATA_TYPE_SECRET_KEY) {
+            if (tox_options_get_savedata_length(options) != TOX_SECRET_KEY_SIZE) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
-                return NULL;
+                return nullptr;
             }
 
-            load_savedata_sk = 1;
-        } else if (options->savedata_type == TOX_SAVEDATA_TYPE_TOX_SAVE) {
-            if (options->savedata_length < TOX_ENC_SAVE_MAGIC_LENGTH) {
+            load_savedata_sk = true;
+        } else if (tox_options_get_savedata_type(options) == TOX_SAVEDATA_TYPE_TOX_SAVE) {
+            if (tox_options_get_savedata_length(options) < TOX_ENC_SAVE_MAGIC_LENGTH) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
-                return NULL;
+                return nullptr;
             }
 
-            if (sodium_memcmp(options->savedata_data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {
+            if (crypto_memcmp(tox_options_get_savedata_data(options), TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_ENCRYPTED);
-                return NULL;
+                return nullptr;
             }
 
-            load_savedata_tox = 1;
+            load_savedata_tox = true;
         }
 
-        m_options.ipv6enabled = options->ipv6_enabled;
-        m_options.udp_disabled = !options->udp_enabled;
-        m_options.port_range[0] = options->start_port;
-        m_options.port_range[1] = options->end_port;
-        m_options.tcp_server_port = options->tcp_port;
+        m_options.ipv6enabled = tox_options_get_ipv6_enabled(options);
+        m_options.udp_disabled = !tox_options_get_udp_enabled(options);
+        m_options.port_range[0] = tox_options_get_start_port(options);
+        m_options.port_range[1] = tox_options_get_end_port(options);
+        m_options.tcp_server_port = tox_options_get_tcp_port(options);
+        m_options.hole_punching_enabled = tox_options_get_hole_punching_enabled(options);
+        m_options.local_discovery_enabled = tox_options_get_local_discovery_enabled(options);
 
-        switch (options->proxy_type) {
+        m_options.log_callback = (logger_cb *)tox_options_get_log_callback(options);
+        m_options.log_user_data = tox_options_get_log_user_data(options);
+
+        switch (tox_options_get_proxy_type(options)) {
             case TOX_PROXY_TYPE_HTTP:
                 m_options.proxy_info.proxy_type = TCP_PROXY_HTTP;
                 break;
@@ -185,27 +143,28 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
 
             default:
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_TYPE);
-                return NULL;
+                return nullptr;
         }
 
         if (m_options.proxy_info.proxy_type != TCP_PROXY_NONE) {
-            if (options->proxy_port == 0) {
+            if (tox_options_get_proxy_port(options) == 0) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_PORT);
-                return NULL;
+                return nullptr;
             }
 
             ip_init(&m_options.proxy_info.ip_port.ip, m_options.ipv6enabled);
 
-            if (m_options.ipv6enabled)
-                m_options.proxy_info.ip_port.ip.family = AF_UNSPEC;
+            if (m_options.ipv6enabled) {
+                m_options.proxy_info.ip_port.ip.family = net_family_unspec;
+            }
 
-            if (!addr_resolve_or_parse_ip(options->proxy_host, &m_options.proxy_info.ip_port.ip, NULL)) {
+            if (addr_resolve_or_parse_ip(tox_options_get_proxy_host(options), &m_options.proxy_info.ip_port.ip, nullptr) == 0) {
                 SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST);
-                //TODO: TOX_ERR_NEW_PROXY_NOT_FOUND if domain.
-                return NULL;
+                // TODO(irungentoo): TOX_ERR_NEW_PROXY_NOT_FOUND if domain.
+                return nullptr;
             }
 
-            m_options.proxy_info.ip_port.port = htons(options->proxy_port);
+            m_options.proxy_info.ip_port.port = net_htons(tox_options_get_proxy_port(options));
         }
     }
 
@@ -223,13 +182,14 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
             SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
         }
 
-        return NULL;
+        return nullptr;
     }
 
-    if (load_savedata_tox && messenger_load(m, options->savedata_data, options->savedata_length) == -1) {
+    if (load_savedata_tox
+            && messenger_load(m, tox_options_get_savedata_data(options), tox_options_get_savedata_length(options)) == -1) {
         SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
     } else if (load_savedata_sk) {
-        load_secret_key(m->net_crypto, options->savedata_data);
+        load_secret_key(m->net_crypto, tox_options_get_savedata_data(options));
         SET_ERROR_PARAMETER(error, TOX_ERR_NEW_OK);
     } else {
         SET_ERROR_PARAMETER(error, TOX_ERR_NEW_OK);
@@ -240,10 +200,13 @@ Tox *tox_new(const struct Tox_Options *options, TOX_ERR_NEW *error)
 
 void tox_kill(Tox *tox)
 {
+    if (tox == nullptr) {
+        return;
+    }
+
     Messenger *m = tox;
-    kill_groupchats(m->group_chat_object);
+    kill_groupchats((Group_Chats *)m->conferences_object);
     kill_messenger(m);
-    logger_kill_global();
 }
 
 size_t tox_get_savedata_size(const Tox *tox)
@@ -252,11 +215,11 @@ size_t tox_get_savedata_size(const Tox *tox)
     return messenger_size(m);
 }
 
-void tox_get_savedata(const Tox *tox, uint8_t *data)
+void tox_get_savedata(const Tox *tox, uint8_t *savedata)
 {
-    if (data) {
+    if (savedata) {
         const Messenger *m = tox;
-        messenger_save(m, data);
+        messenger_save(m, savedata);
     }
 }
 
@@ -272,49 +235,35 @@ bool tox_bootstrap(Tox *tox, const char *address, uint16_t port, const uint8_t *
         return 0;
     }
 
-    struct addrinfo *root, *info;
+    IP_Port *root;
+
+    int32_t count = net_getipport(address, &root, TOX_SOCK_DGRAM);
 
-    if (getaddrinfo(address, NULL, NULL, &root) != 0) {
+    if (count == -1) {
+        net_freeipport(root);
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
         return 0;
     }
 
-    info = root;
+    unsigned int i;
 
-    unsigned int count = 0;
-
-    do {
-        IP_Port ip_port;
-        ip_port.port = htons(port);
-        ip_port.ip.family = info->ai_family;
-
-        if (info->ai_socktype && info->ai_socktype != SOCK_DGRAM) {
-            continue;
-        }
-
-        if (info->ai_family == AF_INET) {
-            ip_port.ip.ip4.in_addr = ((struct sockaddr_in *)info->ai_addr)->sin_addr;
-        } else if (info->ai_family == AF_INET6) {
-            ip_port.ip.ip6.in6_addr = ((struct sockaddr_in6 *)info->ai_addr)->sin6_addr;
-        } else {
-            continue;
-        }
+    for (i = 0; i < count; i++) {
+        root[i].port = net_htons(port);
 
         Messenger *m = tox;
-        onion_add_bs_path_node(m->onion_c, ip_port, public_key);
-        DHT_bootstrap(m->dht, ip_port, public_key);
-        ++count;
-    } while ((info = info->ai_next));
+        onion_add_bs_path_node(m->onion_c, root[i], public_key);
+        DHT_bootstrap(m->dht, root[i], public_key);
+    }
 
-    freeaddrinfo(root);
+    net_freeipport(root);
 
     if (count) {
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
         return 1;
-    } else {
-        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
-        return 0;
     }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
+    return 0;
 }
 
 bool tox_add_tcp_relay(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key,
@@ -330,48 +279,34 @@ bool tox_add_tcp_relay(Tox *tox, const char *address, uint16_t port, const uint8
         return 0;
     }
 
-    struct addrinfo *root, *info;
+    IP_Port *root;
+
+    int32_t count = net_getipport(address, &root, TOX_SOCK_STREAM);
 
-    if (getaddrinfo(address, NULL, NULL, &root) != 0) {
+    if (count == -1) {
+        net_freeipport(root);
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
         return 0;
     }
 
-    info = root;
+    unsigned int i;
 
-    unsigned int count = 0;
-
-    do {
-        IP_Port ip_port;
-        ip_port.port = htons(port);
-        ip_port.ip.family = info->ai_family;
-
-        if (info->ai_socktype && info->ai_socktype != SOCK_STREAM) {
-            continue;
-        }
-
-        if (info->ai_family == AF_INET) {
-            ip_port.ip.ip4.in_addr = ((struct sockaddr_in *)info->ai_addr)->sin_addr;
-        } else if (info->ai_family == AF_INET6) {
-            ip_port.ip.ip6.in6_addr = ((struct sockaddr_in6 *)info->ai_addr)->sin6_addr;
-        } else {
-            continue;
-        }
+    for (i = 0; i < count; i++) {
+        root[i].port = net_htons(port);
 
         Messenger *m = tox;
-        add_tcp_relay(m->net_crypto, ip_port, public_key);
-        ++count;
-    } while ((info = info->ai_next));
+        add_tcp_relay(m->net_crypto, root[i], public_key);
+    }
 
-    freeaddrinfo(root);
+    net_freeipport(root);
 
     if (count) {
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
         return 1;
-    } else {
-        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
-        return 0;
     }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
+    return 0;
 }
 
 TOX_CONNECTION tox_self_get_connection_status(const Tox *tox)
@@ -382,18 +317,20 @@ TOX_CONNECTION tox_self_get_connection_status(const Tox *tox)
 
     if (ret == 2) {
         return TOX_CONNECTION_UDP;
-    } else if (ret == 1) {
+    }
+
+    if (ret == 1) {
         return TOX_CONNECTION_TCP;
-    } else {
-        return TOX_CONNECTION_NONE;
     }
+
+    return TOX_CONNECTION_NONE;
 }
 
 
-void tox_callback_self_connection_status(Tox *tox, tox_self_connection_status_cb *function, void *user_data)
+void tox_callback_self_connection_status(Tox *tox, tox_self_connection_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_core_connection(m, function, user_data);
+    m_callback_core_connection(m, (void (*)(Messenger *, unsigned int, void *))callback);
 }
 
 uint32_t tox_iteration_interval(const Tox *tox)
@@ -402,11 +339,11 @@ uint32_t tox_iteration_interval(const Tox *tox)
     return messenger_run_interval(m);
 }
 
-void tox_iterate(Tox *tox)
+void tox_iterate(Tox *tox, void *user_data)
 {
     Messenger *m = tox;
-    do_messenger(m);
-    do_groupchats(m->group_chat_object);
+    do_messenger(m, user_data);
+    do_groupchats((Group_Chats *)m->conferences_object, user_data);
 }
 
 void tox_self_get_address(const Tox *tox, uint8_t *address)
@@ -420,29 +357,31 @@ void tox_self_get_address(const Tox *tox, uint8_t *address)
 void tox_self_set_nospam(Tox *tox, uint32_t nospam)
 {
     Messenger *m = tox;
-    set_nospam(&(m->fr), nospam);
+    set_nospam(m->fr, net_htonl(nospam));
 }
 
 uint32_t tox_self_get_nospam(const Tox *tox)
 {
     const Messenger *m = tox;
-    return get_nospam(&(m->fr));
+    return net_ntohl(get_nospam(m->fr));
 }
 
 void tox_self_get_public_key(const Tox *tox, uint8_t *public_key)
 {
     const Messenger *m = tox;
 
-    if (public_key)
-        memcpy(public_key, m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
+    if (public_key) {
+        memcpy(public_key, nc_get_self_public_key(m->net_crypto), CRYPTO_PUBLIC_KEY_SIZE);
+    }
 }
 
 void tox_self_get_secret_key(const Tox *tox, uint8_t *secret_key)
 {
     const Messenger *m = tox;
 
-    if (secret_key)
-        memcpy(secret_key, m->net_crypto->self_secret_key, crypto_box_SECRETKEYBYTES);
+    if (secret_key) {
+        memcpy(secret_key, nc_get_self_secret_key(m->net_crypto), CRYPTO_SECRET_KEY_SIZE);
+    }
 }
 
 bool tox_self_set_name(Tox *tox, const uint8_t *name, size_t length, TOX_ERR_SET_INFO *error)
@@ -455,14 +394,14 @@ bool tox_self_set_name(Tox *tox, const uint8_t *name, size_t length, TOX_ERR_SET
     Messenger *m = tox;
 
     if (setname(m, name, length) == 0) {
-        //TODO: function to set different per group names?
-        send_name_all_groups(m->group_chat_object);
+        // TODO(irungentoo): function to set different per group names?
+        send_name_all_groups((Group_Chats *)m->conferences_object);
         SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_OK);
         return 1;
-    } else {
-        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
-        return 0;
     }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
+    return 0;
 }
 
 size_t tox_self_get_name_size(const Tox *tox)
@@ -479,22 +418,22 @@ void tox_self_get_name(const Tox *tox, uint8_t *name)
     }
 }
 
-bool tox_self_set_status_message(Tox *tox, const uint8_t *status, size_t length, TOX_ERR_SET_INFO *error)
+bool tox_self_set_status_message(Tox *tox, const uint8_t *status_message, size_t length, TOX_ERR_SET_INFO *error)
 {
-    if (!status && length != 0) {
+    if (!status_message && length != 0) {
         SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_NULL);
         return 0;
     }
 
     Messenger *m = tox;
 
-    if (m_set_statusmessage(m, status, length) == 0) {
+    if (m_set_statusmessage(m, status_message, length) == 0) {
         SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_OK);
         return 1;
-    } else {
-        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
-        return 0;
     }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
+    return 0;
 }
 
 size_t tox_self_get_status_message_size(const Tox *tox)
@@ -503,24 +442,25 @@ size_t tox_self_get_status_message_size(const Tox *tox)
     return m_get_self_statusmessage_size(m);
 }
 
-void tox_self_get_status_message(const Tox *tox, uint8_t *status)
+void tox_self_get_status_message(const Tox *tox, uint8_t *status_message)
 {
-    if (status) {
+    if (status_message) {
         const Messenger *m = tox;
-        m_copy_self_statusmessage(m, status);
+        m_copy_self_statusmessage(m, status_message);
     }
 }
 
-void tox_self_set_status(Tox *tox, TOX_USER_STATUS user_status)
+void tox_self_set_status(Tox *tox, TOX_USER_STATUS status)
 {
     Messenger *m = tox;
-    m_set_userstatus(m, user_status);
+    m_set_userstatus(m, status);
 }
 
 TOX_USER_STATUS tox_self_get_status(const Tox *tox)
 {
     const Messenger *m = tox;
-    return m_get_self_userstatus(m);
+    const uint8_t status = m_get_self_userstatus(m);
+    return (TOX_USER_STATUS)status;
 }
 
 static void set_friend_error(int32_t ret, TOX_ERR_FRIEND_ADD *error)
@@ -553,7 +493,6 @@ static void set_friend_error(int32_t ret, TOX_ERR_FRIEND_ADD *error)
         case FAERR_NOMEM:
             SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_MALLOC);
             break;
-
     }
 }
 
@@ -601,7 +540,7 @@ bool tox_friend_delete(Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_DELETE *
     Messenger *m = tox;
     int ret = m_delfriend(m, friend_number);
 
-    //TODO handle if realloc fails?
+    // TODO(irungentoo): handle if realloc fails?
     if (ret == -1) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND);
         return 0;
@@ -674,12 +613,12 @@ size_t tox_self_get_friend_list_size(const Tox *tox)
     return count_friendlist(m);
 }
 
-void tox_self_get_friend_list(const Tox *tox, uint32_t *list)
+void tox_self_get_friend_list(const Tox *tox, uint32_t *friend_list)
 {
-    if (list) {
+    if (friend_list) {
         const Messenger *m = tox;
-        //TODO: size parameter?
-        copy_friendlist(m, list, tox_self_get_friend_list_size(tox));
+        // TODO(irungentoo): size parameter?
+        copy_friendlist(m, friend_list, tox_self_get_friend_list_size(tox));
     }
 }
 
@@ -716,10 +655,10 @@ bool tox_friend_get_name(const Tox *tox, uint32_t friend_number, uint8_t *name,
     return 1;
 }
 
-void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *function, void *user_data)
+void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_namechange(m, function, user_data);
+    m_callback_namechange(m, callback);
 }
 
 size_t tox_friend_get_status_message_size(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
@@ -736,17 +675,17 @@ size_t tox_friend_get_status_message_size(const Tox *tox, uint32_t friend_number
     return ret;
 }
 
-bool tox_friend_get_status_message(const Tox *tox, uint32_t friend_number, uint8_t *message,
+bool tox_friend_get_status_message(const Tox *tox, uint32_t friend_number, uint8_t *status_message,
                                    TOX_ERR_FRIEND_QUERY *error)
 {
-    if (!message) {
+    if (!status_message) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_NULL);
         return 0;
     }
 
     const Messenger *m = tox;
-    //TODO: size parameter?
-    int ret = m_copy_statusmessage(m, friend_number, message, m_get_statusmessage_size(m, friend_number));
+    // TODO(irungentoo): size parameter?
+    int ret = m_copy_statusmessage(m, friend_number, status_message, m_get_statusmessage_size(m, friend_number));
 
     if (ret == -1) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
@@ -757,10 +696,10 @@ bool tox_friend_get_status_message(const Tox *tox, uint32_t friend_number, uint8
     return 1;
 }
 
-void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *function, void *user_data)
+void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_statusmessage(m, function, user_data);
+    m_callback_statusmessage(m, callback);
 }
 
 TOX_USER_STATUS tox_friend_get_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
@@ -771,17 +710,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 *function, void *user_data)
+void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_userstatus(m, function, user_data);
+    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)
@@ -796,13 +735,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 *function, void *user_data)
+void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_connectionstatus(m, function, user_data);
+    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)
@@ -819,17 +758,17 @@ bool tox_friend_get_typing(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEN
     return !!ret;
 }
 
-void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *function, void *user_data)
+void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_typingchange(m, function, user_data);
+    m_callback_typingchange(m, callback);
 }
 
-bool tox_self_set_typing(Tox *tox, uint32_t friend_number, bool is_typing, TOX_ERR_SET_TYPING *error)
+bool tox_self_set_typing(Tox *tox, uint32_t friend_number, bool typing, TOX_ERR_SET_TYPING *error)
 {
     Messenger *m = tox;
 
-    if (m_set_usertyping(m, friend_number, is_typing) == -1) {
+    if (m_set_usertyping(m, friend_number, typing) == -1) {
         SET_ERROR_PARAMETER(error, TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND);
         return 0;
     }
@@ -886,22 +825,22 @@ uint32_t tox_friend_send_message(Tox *tox, uint32_t friend_number, TOX_MESSAGE_T
     return message_id;
 }
 
-void tox_callback_friend_read_receipt(Tox *tox, tox_friend_read_receipt_cb *function, void *user_data)
+void tox_callback_friend_read_receipt(Tox *tox, tox_friend_read_receipt_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_read_receipt(m, function, user_data);
+    m_callback_read_receipt(m, callback);
 }
 
-void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *function, void *user_data)
+void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_friendrequest(m, function, user_data);
+    m_callback_friendrequest(m, callback);
 }
 
-void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *function, void *user_data)
+void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *callback)
 {
     Messenger *m = tox;
-    m_callback_friendmessage(m, function, user_data);
+    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)
@@ -910,7 +849,7 @@ bool tox_hash(uint8_t *hash, const uint8_t *data, size_t length)
         return 0;
     }
 
-    crypto_hash_sha256(hash, data, length);
+    crypto_sha256(hash, data, length);
     return 1;
 }
 
@@ -987,7 +926,7 @@ bool tox_file_seek(Tox *tox, uint32_t friend_number, uint32_t file_number, uint6
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_NOT_FOUND);
             return 0;
 
-        case -4:
+        case -4: // fall-through
         case -5:
             SET_ERROR_PARAMETER(error, TOX_ERR_FILE_SEEK_DENIED);
             return 0;
@@ -1005,10 +944,10 @@ bool tox_file_seek(Tox *tox, uint32_t friend_number, uint32_t file_number, uint6
     return 0;
 }
 
-void tox_callback_file_recv_control(Tox *tox, tox_file_recv_control_cb *function, void *user_data)
+void tox_callback_file_recv_control(Tox *tox, tox_file_recv_control_cb *callback)
 {
     Messenger *m = tox;
-    callback_file_control(m, function, user_data);
+    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,
@@ -1025,7 +964,9 @@ bool tox_file_get_file_id(const Tox *tox, uint32_t friend_number, uint32_t file_
     if (ret == 0) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FILE_GET_OK);
         return 1;
-    } else if (ret == -1) {
+    }
+
+    if (ret == -1) {
         SET_ERROR_PARAMETER(error, TOX_ERR_FILE_GET_FRIEND_NOT_FOUND);
     } else {
         SET_ERROR_PARAMETER(error, TOX_ERR_FILE_GET_NOT_FOUND);
@@ -1125,22 +1066,363 @@ bool tox_file_send_chunk(Tox *tox, uint32_t friend_number, uint32_t file_number,
     return 0;
 }
 
-void tox_callback_file_chunk_request(Tox *tox, tox_file_chunk_request_cb *function, void *user_data)
+void tox_callback_file_chunk_request(Tox *tox, tox_file_chunk_request_cb *callback)
+{
+    Messenger *m = tox;
+    callback_file_reqchunk(m, callback);
+}
+
+void tox_callback_file_recv(Tox *tox, tox_file_recv_cb *callback)
 {
     Messenger *m = tox;
-    callback_file_reqchunk(m, function, user_data);
+    callback_file_sendrequest(m, callback);
 }
 
-void tox_callback_file_recv(Tox *tox, tox_file_recv_cb *function, void *user_data)
+void tox_callback_file_recv_chunk(Tox *tox, tox_file_recv_chunk_cb *callback)
 {
     Messenger *m = tox;
-    callback_file_sendrequest(m, function, user_data);
+    callback_file_data(m, callback);
 }
 
-void tox_callback_file_recv_chunk(Tox *tox, tox_file_recv_chunk_cb *function, void *user_data)
+void tox_callback_conference_invite(Tox *tox, tox_conference_invite_cb *callback)
 {
     Messenger *m = tox;
-    callback_file_data(m, function, user_data);
+    g_callback_group_invite((Group_Chats *)m->conferences_object, (void (*)(Messenger * m, uint32_t, int, const uint8_t *,
+                            size_t,
+                            void *))callback);
+}
+
+void tox_callback_conference_message(Tox *tox, tox_conference_message_cb *callback)
+{
+    Messenger *m = tox;
+    g_callback_group_message((Group_Chats *)m->conferences_object, (void (*)(Messenger * m, uint32_t, uint32_t, int,
+                             const uint8_t *,
+                             size_t, void *))callback);
+}
+
+void tox_callback_conference_title(Tox *tox, tox_conference_title_cb *callback)
+{
+    Messenger *m = tox;
+    g_callback_group_title((Group_Chats *)m->conferences_object, callback);
+}
+
+void tox_callback_conference_peer_name(Tox *tox, tox_conference_peer_name_cb *callback)
+{
+    Messenger *m = tox;
+    g_callback_peer_name((Group_Chats *)m->conferences_object, callback);
+}
+
+void tox_callback_conference_peer_list_changed(Tox *tox, tox_conference_peer_list_changed_cb *callback)
+{
+    Messenger *m = tox;
+    g_callback_peer_list_changed((Group_Chats *)m->conferences_object, callback);
+}
+
+uint32_t tox_conference_new(Tox *tox, TOX_ERR_CONFERENCE_NEW *error)
+{
+    Messenger *m = tox;
+    int ret = add_groupchat((Group_Chats *)m->conferences_object, GROUPCHAT_TYPE_TEXT);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_NEW_INIT);
+        return UINT32_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_NEW_OK);
+    return ret;
+}
+
+bool tox_conference_delete(Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_DELETE *error)
+{
+    Messenger *m = tox;
+    int ret = del_groupchat((Group_Chats *)m->conferences_object, conference_number);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_DELETE_CONFERENCE_NOT_FOUND);
+        return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_DELETE_OK);
+    return true;
+}
+
+uint32_t tox_conference_peer_count(const Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_PEER_QUERY *error)
+{
+    const Messenger *m = tox;
+    int ret = group_number_peers((Group_Chats *)m->conferences_object, conference_number);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
+        return UINT32_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
+    return ret;
+}
+
+size_t tox_conference_peer_get_name_size(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+        TOX_ERR_CONFERENCE_PEER_QUERY *error)
+{
+    const Messenger *m = tox;
+    int ret = group_peername_size((Group_Chats *)m->conferences_object, conference_number, peer_number);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
+            return -1;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
+            return -1;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
+    return ret;
+}
+
+bool tox_conference_peer_get_name(const Tox *tox, uint32_t conference_number, uint32_t peer_number, uint8_t *name,
+                                  TOX_ERR_CONFERENCE_PEER_QUERY *error)
+{
+    const Messenger *m = tox;
+    int ret = group_peername((Group_Chats *)m->conferences_object, conference_number, peer_number, name);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
+    return true;
+}
+
+bool tox_conference_peer_get_public_key(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+                                        uint8_t *public_key, TOX_ERR_CONFERENCE_PEER_QUERY *error)
+{
+    const Messenger *m = tox;
+    int ret = group_peer_pubkey((Group_Chats *)m->conferences_object, conference_number, peer_number, public_key);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
+    return true;
+}
+
+bool tox_conference_peer_number_is_ours(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+                                        TOX_ERR_CONFERENCE_PEER_QUERY *error)
+{
+    const Messenger *m = tox;
+    int ret = group_peernumber_is_ours((Group_Chats *)m->conferences_object, conference_number, peer_number);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND);
+            return false;
+
+        case -3:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_PEER_QUERY_OK);
+    return ret;
+}
+
+bool tox_conference_invite(Tox *tox, uint32_t friend_number, uint32_t conference_number,
+                           TOX_ERR_CONFERENCE_INVITE *error)
+{
+    Messenger *m = tox;
+    int ret = invite_friend((Group_Chats *)m->conferences_object, friend_number, conference_number);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_FAIL_SEND);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_INVITE_OK);
+    return true;
+}
+
+uint32_t tox_conference_join(Tox *tox, uint32_t friend_number, const uint8_t *cookie, size_t length,
+                             TOX_ERR_CONFERENCE_JOIN *error)
+{
+    Messenger *m = tox;
+    int ret = join_groupchat((Group_Chats *)m->conferences_object, friend_number, GROUPCHAT_TYPE_TEXT, cookie, length);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH);
+            return UINT32_MAX;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE);
+            return UINT32_MAX;
+
+        case -3:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND);
+            return UINT32_MAX;
+
+        case -4:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_DUPLICATE);
+            return UINT32_MAX;
+
+        case -5:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_INIT_FAIL);
+            return UINT32_MAX;
+
+        case -6:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_FAIL_SEND);
+            return UINT32_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_JOIN_OK);
+    return ret;
+}
+
+bool tox_conference_send_message(Tox *tox, uint32_t conference_number, TOX_MESSAGE_TYPE type, const uint8_t *message,
+                                 size_t length, TOX_ERR_CONFERENCE_SEND_MESSAGE *error)
+{
+    Messenger *m = tox;
+    int ret = 0;
+
+    if (type == TOX_MESSAGE_TYPE_NORMAL) {
+        ret = group_message_send((Group_Chats *)m->conferences_object, conference_number, message, length);
+    } else {
+        ret = group_action_send((Group_Chats *)m->conferences_object, conference_number, message, length);
+    }
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG);
+            return false;
+
+        case -3:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION);
+            return false;
+
+        case -4:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_SEND_MESSAGE_OK);
+    return true;
+}
+
+size_t tox_conference_get_title_size(const Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_TITLE *error)
+{
+    const Messenger *m = tox;
+    int ret = group_title_get_size((Group_Chats *)m->conferences_object, conference_number);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
+            return -1;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
+            return -1;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
+    return ret;
+}
+
+bool tox_conference_get_title(const Tox *tox, uint32_t conference_number, uint8_t *title,
+                              TOX_ERR_CONFERENCE_TITLE *error)
+{
+    const Messenger *m = tox;
+    int ret = group_title_get((Group_Chats *)m->conferences_object, conference_number, title);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
+    return true;
+}
+
+bool tox_conference_set_title(Tox *tox, uint32_t conference_number, const uint8_t *title, size_t length,
+                              TOX_ERR_CONFERENCE_TITLE *error)
+{
+    Messenger *m = tox;
+    int ret = group_title_send((Group_Chats *)m->conferences_object, conference_number, title, length);
+
+    switch (ret) {
+        case -1:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND);
+            return false;
+
+        case -2:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH);
+            return false;
+
+        case -3:
+            SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_FAIL_SEND);
+            return false;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_TITLE_OK);
+    return true;
+}
+
+size_t tox_conference_get_chatlist_size(const Tox *tox)
+{
+    const Messenger *m = tox;
+    return count_chatlist((Group_Chats *)m->conferences_object);
+}
+
+void tox_conference_get_chatlist(const Tox *tox, uint32_t *chatlist)
+{
+    const Messenger *m = tox;
+    size_t list_size = tox_conference_get_chatlist_size(tox);
+    copy_chatlist((Group_Chats *)m->conferences_object, chatlist, list_size);
+}
+
+TOX_CONFERENCE_TYPE tox_conference_get_type(const Tox *tox, uint32_t conference_number,
+        TOX_ERR_CONFERENCE_GET_TYPE *error)
+{
+    const Messenger *m = tox;
+    int ret = group_get_type((Group_Chats *)m->conferences_object, conference_number);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_GET_TYPE_CONFERENCE_NOT_FOUND);
+        return (TOX_CONFERENCE_TYPE)ret;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_CONFERENCE_GET_TYPE_OK);
+    return (TOX_CONFERENCE_TYPE)ret;
 }
 
 static void set_custom_packet_error(int ret, TOX_ERR_FRIEND_CUSTOM_PACKET *error)
@@ -1192,21 +1474,21 @@ bool tox_friend_send_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_
         return 0;
     }
 
-    int ret = send_custom_lossy_packet(m, friend_number, data, length);
+    int ret = m_send_custom_lossy_packet(m, friend_number, data, length);
 
     set_custom_packet_error(ret, error);
 
     if (ret == 0) {
         return 1;
-    } else {
-        return 0;
     }
+
+    return 0;
 }
 
-void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *function, void *user_data)
+void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *callback)
 {
     Messenger *m = tox;
-    custom_lossy_packet_registerhandler(m, function, user_data);
+    custom_lossy_packet_registerhandler(m, callback);
 }
 
 bool tox_friend_send_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
@@ -1230,29 +1512,29 @@ bool tox_friend_send_lossless_packet(Tox *tox, uint32_t friend_number, const uin
 
     if (ret == 0) {
         return 1;
-    } else {
-        return 0;
     }
+
+    return 0;
 }
 
-void tox_callback_friend_lossless_packet(Tox *tox, tox_friend_lossless_packet_cb *function, void *user_data)
+void tox_callback_friend_lossless_packet(Tox *tox, tox_friend_lossless_packet_cb *callback)
 {
     Messenger *m = tox;
-    custom_lossless_packet_registerhandler(m, function, user_data);
+    custom_lossless_packet_registerhandler(m, callback);
 }
 
 void tox_self_get_dht_id(const Tox *tox, uint8_t *dht_id)
 {
     if (dht_id) {
         const Messenger *m = tox;
-        memcpy(dht_id , m->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+        memcpy(dht_id, dht_get_self_public_key(m->dht), CRYPTO_PUBLIC_KEY_SIZE);
     }
 }
 
 uint16_t tox_self_get_udp_port(const Tox *tox, TOX_ERR_GET_PORT *error)
 {
     const Messenger *m = tox;
-    uint16_t port = htons(m->net->port);
+    uint16_t port = net_htons(net_port(m->net));
 
     if (port) {
         SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_OK);
@@ -1270,10 +1552,8 @@ uint16_t tox_self_get_tcp_port(const Tox *tox, TOX_ERR_GET_PORT *error)
     if (m->tcp_server) {
         SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_OK);
         return m->options.tcp_server_port;
-    } else {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_NOT_BOUND);
-        return 0;
     }
-}
 
-#include "tox_old_code.h"
+    SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_NOT_BOUND);
+    return 0;
+}
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 1655d9c1..d5834095 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -1,26 +1,26 @@
-/* tox.h
- *
+/*
  * The Tox public API.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *  This file is part of Tox.
- *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * This file is part of Tox, the free peer to peer instant messenger.
  *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifndef TOX_H
 #define TOX_H
 
@@ -35,8 +35,8 @@ extern "C" {
 
 /*******************************************************************************
  * `tox.h` SHOULD *NOT* BE EDITED MANUALLY – any changes should be made to   *
- * `tox.in.h`, located in `other/apidsl/`. For instructions on how to        *
- * generate `tox.h` from `tox.in.h` please refer to `other/apidsl/README.md` *
+ * `tox.api.h`, located in `toxcore/`. For instructions on how to            *
+ * generate `tox.h` from `tox.api.h` please refer to `docs/apidsl.md`        *
  ******************************************************************************/
 
 
@@ -75,6 +75,9 @@ extern "C" {
  * enumeration value is outside the valid range of the type. If possible, the
  * function will try to use a sane default, but there will be no error code,
  * and one possible action for the function to take is to have no effect.
+ *
+ * Integer constants and the memory layout of publicly exposed structs are not
+ * part of the ABI.
  */
 /** \subsection events Events and callbacks
  *
@@ -84,6 +87,19 @@ extern "C" {
  * callback will result in no callback being registered for that event. Only
  * one callback per event can be registered, so if a client needs multiple
  * event listeners, it needs to implement the dispatch functionality itself.
+ *
+ * The last argument to a callback is the user data pointer. It is passed from
+ * tox_iterate to each callback in sequence.
+ *
+ * The user data pointer is never stored or dereferenced by any library code, so
+ * can be any pointer, including NULL. Callbacks must all operate on the same
+ * object type. In the apidsl code (tox.in.h), this is denoted with `any`. The
+ * `any` in tox_iterate must be the same `any` as in all callbacks. In C,
+ * lacking parametric polymorphism, this is a pointer to void.
+ *
+ * Old style callbacks that are registered together with a user data pointer
+ * receive that pointer as argument when they are called. They can each have
+ * their own user data pointer of their own type.
  */
 /** \subsection threading Threading implications
  *
@@ -142,55 +158,52 @@ typedef struct Tox Tox;
 /**
  * The major version number. Incremented when the API or ABI changes in an
  * incompatible way.
+ *
+ * The function variants of these constants return the version number of the
+ * library. They can be used to display the Tox library version or to check
+ * whether the client is compatible with the dynamically linked version of Tox.
  */
-#define TOX_VERSION_MAJOR               0u
+#define TOX_VERSION_MAJOR              0
+
+uint32_t tox_version_major(void);
 
 /**
  * The minor version number. Incremented when functionality is added without
  * breaking the API or ABI. Set to 0 when the major version number is
  * incremented.
  */
-#define TOX_VERSION_MINOR               0u
+#define TOX_VERSION_MINOR              2
+
+uint32_t tox_version_minor(void);
 
 /**
  * The patch or revision number. Incremented when bugfixes are applied without
  * changing any functionality or API or ABI.
  */
-#define TOX_VERSION_PATCH               0u
-
-/**
- * A macro to check at preprocessing time whether the client code is compatible
- * with the installed version of Tox.
- */
-#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)      \
-  (TOX_VERSION_MAJOR == MAJOR &&                                \
-   (TOX_VERSION_MINOR > MINOR ||                                \
-    (TOX_VERSION_MINOR == MINOR &&                              \
-     TOX_VERSION_PATCH >= PATCH)))
-
-/**
- * A macro to make compilation fail if the client code is not compatible with
- * the installed version of Tox.
- */
-#define TOX_VERSION_REQUIRE(MAJOR, MINOR, PATCH)                \
-  typedef char tox_required_version[TOX_IS_COMPATIBLE(MAJOR, MINOR, PATCH) ? 1 : -1]
-
-/**
- * Return the major version number of the library. Can be used to display the
- * Tox library version or to check whether the client is compatible with the
- * dynamically linked version of Tox.
- */
-uint32_t tox_version_major(void);
+#define TOX_VERSION_PATCH              2
 
-/**
- * Return the minor version number of the library.
- */
-uint32_t tox_version_minor(void);
+uint32_t tox_version_patch(void);
 
 /**
- * Return the patch number of the library.
- */
-uint32_t tox_version_patch(void);
+ * A macro to check at preprocessing time whether the client code is compatible
+ * with the installed version of Tox. Leading zeros in the version number are
+ * ignored. E.g. 0.1.5 is to 0.1.4 what 1.5 is to 1.4, that is: it can add new
+ * features, but can't break the API.
+ */
+#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)              \
+  ((TOX_VERSION_MAJOR > 0 && TOX_VERSION_MAJOR == MAJOR) && (           \
+    /* 1.x.x, 2.x.x, etc. with matching major version. */               \
+    TOX_VERSION_MINOR > MINOR ||                                        \
+    (TOX_VERSION_MINOR == MINOR && TOX_VERSION_PATCH >= PATCH)          \
+  )) || ((TOX_VERSION_MAJOR == 0 && MAJOR == 0) && (                    \
+    /* 0.x.x makes minor behave like major above. */                    \
+    ((TOX_VERSION_MINOR > 0 && TOX_VERSION_MINOR == MINOR) && (         \
+      TOX_VERSION_PATCH >= PATCH                                        \
+    )) || ((TOX_VERSION_MINOR == 0 && MINOR == 0) && (                  \
+      /* 0.0.x and 0.0.y are only compatible if x == y. */              \
+      TOX_VERSION_PATCH == PATCH                                        \
+    ))                                                                  \
+  ))
 
 /**
  * Return whether the compiled library version is compatible with the passed
@@ -210,6 +223,10 @@ bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch);
  *
  * :: Numeric constants
  *
+ * The values of these are not part of the ABI. Prefer to use the function
+ * versions of them for code that should remain compatible with future versions
+ * of toxcore.
+ *
  ******************************************************************************/
 
 
@@ -219,11 +236,22 @@ bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch);
  */
 #define TOX_PUBLIC_KEY_SIZE            32
 
+uint32_t tox_public_key_size(void);
+
 /**
  * The size of a Tox Secret Key in bytes.
  */
 #define TOX_SECRET_KEY_SIZE            32
 
+uint32_t tox_secret_key_size(void);
+
+/**
+ * The size of the nospam in bytes when written in a Tox address.
+ */
+#define TOX_NOSPAM_SIZE                (sizeof(uint32_t))
+
+uint32_t tox_nospam_size(void);
+
 /**
  * The size of a Tox address in bytes. Tox addresses are in the format
  * [Public Key (TOX_PUBLIC_KEY_SIZE bytes)][nospam (4 bytes)][checksum (2 bytes)].
@@ -232,48 +260,78 @@ bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch);
  * byte is an XOR of all the even bytes (0, 2, 4, ...), the second byte is an
  * XOR of all the odd bytes (1, 3, 5, ...) of the Public Key and nospam.
  */
-#define TOX_ADDRESS_SIZE               (TOX_PUBLIC_KEY_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
+#define TOX_ADDRESS_SIZE               (TOX_PUBLIC_KEY_SIZE + TOX_NOSPAM_SIZE + sizeof(uint16_t))
+
+uint32_t tox_address_size(void);
 
 /**
  * Maximum length of a nickname in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_NAME_LENGTH            128
 
+uint32_t tox_max_name_length(void);
+
 /**
  * Maximum length of a status message in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_STATUS_MESSAGE_LENGTH  1007
 
+uint32_t tox_max_status_message_length(void);
+
 /**
  * Maximum length of a friend request message in bytes.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_FRIEND_REQUEST_LENGTH  1016
 
+uint32_t tox_max_friend_request_length(void);
+
 /**
  * Maximum length of a single message after which it should be split.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_MESSAGE_LENGTH         1372
 
+uint32_t tox_max_message_length(void);
+
 /**
- * Maximum size of custom packets. TODO: should be LENGTH?
+ * Maximum size of custom packets. TODO(iphydf): should be LENGTH?
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_CUSTOM_PACKET_SIZE     1373
 
+uint32_t tox_max_custom_packet_size(void);
+
 /**
  * The number of bytes in a hash generated by tox_hash.
  */
 #define TOX_HASH_LENGTH                32
 
+uint32_t tox_hash_length(void);
+
 /**
  * The number of bytes in a file id.
  */
 #define TOX_FILE_ID_LENGTH             32
 
+uint32_t tox_file_id_length(void);
+
 /**
  * Maximum file name length for file transfers.
+ *
+ * @deprecated The macro will be removed in 0.3.0. Use the function instead.
  */
 #define TOX_MAX_FILENAME_LENGTH        255
 
+uint32_t tox_max_filename_length(void);
+
 
 /*******************************************************************************
  *
@@ -309,7 +367,7 @@ typedef enum TOX_USER_STATUS {
 
 
 /**
- * Represents message types for tox_friend_send_message and group chat
+ * Represents message types for tox_friend_send_message and conference
  * messages.
  */
 typedef enum TOX_MESSAGE_TYPE {
@@ -371,12 +429,12 @@ typedef enum TOX_SAVEDATA_TYPE {
     TOX_SAVEDATA_TYPE_NONE,
 
     /**
-     * Savedata is one that was obtained from tox_get_savedata
+     * Savedata is one that was obtained from tox_get_savedata.
      */
     TOX_SAVEDATA_TYPE_TOX_SAVE,
 
     /**
-     * Savedata is a secret key of length TOX_SECRET_KEY_SIZE
+     * Savedata is a secret key of length TOX_SECRET_KEY_SIZE.
      */
     TOX_SAVEDATA_TYPE_SECRET_KEY,
 
@@ -384,9 +442,71 @@ typedef enum TOX_SAVEDATA_TYPE {
 
 
 /**
- * This struct contains all the startup options for Tox. You can either allocate
- * this object yourself, and pass it to tox_options_default, or call
- * tox_options_new to get a new default options object.
+ * Severity level of log messages.
+ */
+typedef enum TOX_LOG_LEVEL {
+
+    /**
+     * Very detailed traces including all network activity.
+     */
+    TOX_LOG_LEVEL_TRACE,
+
+    /**
+     * Debug messages such as which port we bind to.
+     */
+    TOX_LOG_LEVEL_DEBUG,
+
+    /**
+     * Informational log messages such as video call status changes.
+     */
+    TOX_LOG_LEVEL_INFO,
+
+    /**
+     * Warnings about internal inconsistency or logic errors.
+     */
+    TOX_LOG_LEVEL_WARNING,
+
+    /**
+     * Severe unexpected errors caused by external or internal inconsistency.
+     */
+    TOX_LOG_LEVEL_ERROR,
+
+} TOX_LOG_LEVEL;
+
+
+/**
+ * This event is triggered when the toxcore library logs an internal message.
+ * This is mostly useful for debugging. This callback can be called from any
+ * function, not just tox_iterate. This means the user data lifetime must at
+ * least extend between registering and unregistering it or tox_kill.
+ *
+ * Other toxcore modules such as toxav may concurrently call this callback at
+ * any time. Thus, user code must make sure it is equipped to handle concurrent
+ * execution, e.g. by employing appropriate mutex locking.
+ *
+ * @param level The severity of the log message.
+ * @param file The source file from which the message originated.
+ * @param line The source line from which the message originated.
+ * @param func The function from which the message originated.
+ * @param message The log message.
+ * @param user_data The user data pointer passed to tox_new in options.
+ */
+typedef void tox_log_cb(Tox *tox, TOX_LOG_LEVEL level, const char *file, uint32_t line, const char *func,
+                        const char *message, void *user_data);
+
+
+/**
+ * This struct contains all the startup options for Tox. You must tox_options_new to
+ * allocate an object of this type.
+ *
+ * WARNING: Although this struct happens to be visible in the API, it is
+ * effectively private. Do not allocate this yourself or access members
+ * directly, as it *will* break binary compatibility frequently.
+ *
+ * @deprecated The memory layout of this struct (size, alignment, and field
+ * order) is not part of the ABI. To remain compatible, prefer to use tox_options_new to
+ * allocate the object and accessor functions to set the members. The struct
+ * will become opaque (i.e. the definition will become private) in v0.3.0.
  */
 struct Tox_Options {
 
@@ -412,6 +532,14 @@ struct Tox_Options {
 
 
     /**
+     * Enable local network peer discovery.
+     *
+     * Disabling this will cause Tox to not look for peers on the local network.
+     */
+    bool local_discovery_enabled;
+
+
+    /**
      * Pass communications through a proxy.
      */
     TOX_PROXY_TYPE proxy_type;
@@ -425,6 +553,9 @@ struct Tox_Options {
      * (255 chars + 1 NUL byte).
      *
      * This member is ignored (it can be NULL) if proxy_type is TOX_PROXY_TYPE_NONE.
+     *
+     * The data pointed at by this member is owned by the user, so must
+     * outlive the options object.
      */
     const char *proxy_host;
 
@@ -474,6 +605,12 @@ struct Tox_Options {
 
 
     /**
+     * Enables or disables UDP hole-punching in toxcore. (Default: enabled).
+     */
+    bool hole_punching_enabled;
+
+
+    /**
      * The type of savedata to load from.
      */
     TOX_SAVEDATA_TYPE savedata_type;
@@ -481,6 +618,9 @@ struct Tox_Options {
 
     /**
      * The savedata.
+     *
+     * The data pointed at by this member is owned by the user, so must
+     * outlive the options object.
      */
     const uint8_t *savedata_data;
 
@@ -490,9 +630,81 @@ struct Tox_Options {
      */
     size_t savedata_length;
 
+
+    /**
+     * Logging callback for the new tox instance.
+     */
+    tox_log_cb *log_callback;
+
+
+    /**
+     * User data pointer passed to the logging callback.
+     */
+    void *log_user_data;
+
 };
 
 
+bool tox_options_get_ipv6_enabled(const struct Tox_Options *options);
+
+void tox_options_set_ipv6_enabled(struct Tox_Options *options, bool ipv6_enabled);
+
+bool tox_options_get_udp_enabled(const struct Tox_Options *options);
+
+void tox_options_set_udp_enabled(struct Tox_Options *options, bool udp_enabled);
+
+bool tox_options_get_local_discovery_enabled(const struct Tox_Options *options);
+
+void tox_options_set_local_discovery_enabled(struct Tox_Options *options, bool local_discovery_enabled);
+
+TOX_PROXY_TYPE tox_options_get_proxy_type(const struct Tox_Options *options);
+
+void tox_options_set_proxy_type(struct Tox_Options *options, TOX_PROXY_TYPE type);
+
+const char *tox_options_get_proxy_host(const struct Tox_Options *options);
+
+void tox_options_set_proxy_host(struct Tox_Options *options, const char *host);
+
+uint16_t tox_options_get_proxy_port(const struct Tox_Options *options);
+
+void tox_options_set_proxy_port(struct Tox_Options *options, uint16_t port);
+
+uint16_t tox_options_get_start_port(const struct Tox_Options *options);
+
+void tox_options_set_start_port(struct Tox_Options *options, uint16_t start_port);
+
+uint16_t tox_options_get_end_port(const struct Tox_Options *options);
+
+void tox_options_set_end_port(struct Tox_Options *options, uint16_t end_port);
+
+uint16_t tox_options_get_tcp_port(const struct Tox_Options *options);
+
+void tox_options_set_tcp_port(struct Tox_Options *options, uint16_t tcp_port);
+
+bool tox_options_get_hole_punching_enabled(const struct Tox_Options *options);
+
+void tox_options_set_hole_punching_enabled(struct Tox_Options *options, bool hole_punching_enabled);
+
+TOX_SAVEDATA_TYPE tox_options_get_savedata_type(const struct Tox_Options *options);
+
+void tox_options_set_savedata_type(struct Tox_Options *options, TOX_SAVEDATA_TYPE type);
+
+const uint8_t *tox_options_get_savedata_data(const struct Tox_Options *options);
+
+void tox_options_set_savedata_data(struct Tox_Options *options, const uint8_t *data, size_t length);
+
+size_t tox_options_get_savedata_length(const struct Tox_Options *options);
+
+void tox_options_set_savedata_length(struct Tox_Options *options, size_t length);
+
+tox_log_cb *tox_options_get_log_callback(const struct Tox_Options *options);
+
+void tox_options_set_log_callback(struct Tox_Options *options, tox_log_cb *callback);
+
+void *tox_options_get_log_user_data(const struct Tox_Options *options);
+
+void tox_options_set_log_user_data(struct Tox_Options *options, void *user_data);
+
 /**
  * Initialises a Tox_Options object with the default options.
  *
@@ -651,8 +863,8 @@ size_t tox_get_savedata_size(const Tox *tox);
 /**
  * Store all information associated with the tox instance to a byte array.
  *
- * @param data A memory region large enough to store the tox instance data.
- *   Call tox_get_savedata_size to find the number of bytes required. If this parameter
+ * @param savedata A memory region large enough to store the tox instance
+ *   data. Call tox_get_savedata_size to find the number of bytes required. If this parameter
  *   is NULL, this function has no effect.
  */
 void tox_get_savedata(const Tox *tox, uint8_t *savedata);
@@ -756,6 +968,9 @@ typedef enum TOX_CONNECTION {
 /**
  * Return whether we are connected to the DHT. The return value is equal to the
  * last value received through the `self_connection_status` callback.
+ *
+ * @deprecated This getter is deprecated. Use the event and store the status
+ * in the client state.
  */
 TOX_CONNECTION tox_self_get_connection_status(const Tox *tox);
 
@@ -774,9 +989,9 @@ typedef void tox_self_connection_status_cb(Tox *tox, TOX_CONNECTION connection_s
  * amounts of time. Clients should therefore not immediately bootstrap on
  * receiving a disconnect.
  *
- * TODO: how long should a client wait before bootstrapping again?
+ * TODO(iphydf): how long should a client wait before bootstrapping again?
  */
-void tox_callback_self_connection_status(Tox *tox, tox_self_connection_status_cb *callback, void *user_data);
+void tox_callback_self_connection_status(Tox *tox, tox_self_connection_status_cb *callback);
 
 /**
  * Return the time in milliseconds before tox_iterate() should be called again
@@ -788,7 +1003,7 @@ uint32_t tox_iteration_interval(const Tox *tox);
  * The main loop that needs to be run in intervals of tox_iteration_interval()
  * milliseconds.
  */
-void tox_iterate(Tox *tox);
+void tox_iterate(Tox *tox, void *user_data);
 
 
 /*******************************************************************************
@@ -811,14 +1026,17 @@ void tox_iterate(Tox *tox);
 void tox_self_get_address(const Tox *tox, uint8_t *address);
 
 /**
- * Set the 4-byte nospam part of the address.
+ * Set the 4-byte nospam part of the address. This value is expected in host
+ * byte order. I.e. 0x12345678 will form the bytes [12, 34, 56, 78] in the
+ * nospam part of the Tox friend address.
  *
  * @param nospam Any 32 bit unsigned integer.
  */
 void tox_self_set_nospam(Tox *tox, uint32_t nospam);
 
 /**
- * Get the 4-byte nospam part of the address.
+ * Get the 4-byte nospam part of the address. This value is returned in host
+ * byte order.
  */
 uint32_t tox_self_get_nospam(const Tox *tox);
 
@@ -936,15 +1154,15 @@ size_t tox_self_get_status_message_size(const Tox *tox);
  * Call tox_self_get_status_message_size to find out how much memory to allocate for
  * the result.
  *
- * @param status A valid memory location large enough to hold the status message.
- *   If this parameter is NULL, the function has no effect.
+ * @param status_message A valid memory location large enough to hold the
+ *   status message. If this parameter is NULL, the function has no effect.
  */
 void tox_self_get_status_message(const Tox *tox, uint8_t *status_message);
 
 /**
  * Set the client's user status.
  *
- * @param user_status One of the user statuses listed in the enumeration above.
+ * @param status One of the user statuses listed in the enumeration above.
  */
 void tox_self_set_status(Tox *tox, TOX_USER_STATUS status);
 
@@ -1145,8 +1363,8 @@ size_t tox_self_get_friend_list_size(const Tox *tox);
  *
  * Call tox_self_get_friend_list_size to determine the number of elements to allocate.
  *
- * @param list A memory region with enough space to hold the friend list. If
- *   this parameter is NULL, this function has no effect.
+ * @param friend_list A memory region with enough space to hold the friend
+ *   list. If this parameter is NULL, this function has no effect.
  */
 void tox_self_get_friend_list(const Tox *tox, uint32_t *friend_list);
 
@@ -1274,7 +1492,7 @@ typedef void tox_friend_name_cb(Tox *tox, uint32_t friend_number, const uint8_t
  *
  * This event is triggered when a friend changes their name.
  */
-void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *callback, void *user_data);
+void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *callback);
 
 /**
  * Return the length of the friend's status message. If the friend number is
@@ -1314,7 +1532,7 @@ typedef void tox_friend_status_message_cb(Tox *tox, uint32_t friend_number, cons
  *
  * This event is triggered when a friend changes their status message.
  */
-void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *callback, void *user_data);
+void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *callback);
 
 /**
  * Return the friend's user status (away/busy/...). If the friend number is
@@ -1322,6 +1540,9 @@ void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *
  *
  * The status returned is equal to the last status received through the
  * `friend_status` callback.
+ *
+ * @deprecated This getter is deprecated. Use the event and store the status
+ *   in the client state.
  */
 TOX_USER_STATUS tox_friend_get_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
@@ -1338,7 +1559,7 @@ typedef void tox_friend_status_cb(Tox *tox, uint32_t friend_number, TOX_USER_STA
  *
  * This event is triggered when a friend changes their user status.
  */
-void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *callback, void *user_data);
+void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *callback);
 
 /**
  * Check whether a friend is currently connected to this client.
@@ -1351,6 +1572,9 @@ void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *callback, void *
  *
  * @return the friend's connection status as it was received through the
  *   `friend_connection_status` event.
+ *
+ * @deprecated This getter is deprecated. Use the event and store the status
+ *   in the client state.
  */
 TOX_CONNECTION tox_friend_get_connection_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
@@ -1373,7 +1597,7 @@ typedef void tox_friend_connection_status_cb(Tox *tox, uint32_t friend_number, T
  * This callback is not called when adding friends. It is assumed that when
  * adding friends, their connection status is initially offline.
  */
-void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *callback, void *user_data);
+void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *callback);
 
 /**
  * Check whether a friend is currently typing a message.
@@ -1383,6 +1607,9 @@ void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_statu
  * @return true if the friend is typing.
  * @return false if the friend is not typing, or the friend number was
  *   invalid. Inspect the error code to determine which case it is.
+ *
+ * @deprecated This getter is deprecated. Use the event and store the status
+ *   in the client state.
  */
 bool tox_friend_get_typing(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
@@ -1400,7 +1627,7 @@ typedef void tox_friend_typing_cb(Tox *tox, uint32_t friend_number, bool is_typi
  *
  * This event is triggered when a friend starts or stops typing.
  */
-void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *callback, void *user_data);
+void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *callback);
 
 
 /*******************************************************************************
@@ -1518,7 +1745,7 @@ typedef void tox_friend_read_receipt_cb(Tox *tox, uint32_t friend_number, uint32
  * This event is triggered when the friend receives the message sent with
  * tox_friend_send_message with the corresponding message ID.
  */
-void tox_callback_friend_read_receipt(Tox *tox, tox_friend_read_receipt_cb *callback, void *user_data);
+void tox_callback_friend_read_receipt(Tox *tox, tox_friend_read_receipt_cb *callback);
 
 
 /*******************************************************************************
@@ -1531,11 +1758,6 @@ void tox_callback_friend_read_receipt(Tox *tox, tox_friend_read_receipt_cb *call
 
 /**
  * @param public_key The Public Key of the user who sent the friend request.
- * @param time_delta A delta in seconds between when the message was composed
- *   and when it is being transmitted. For messages that are sent immediately,
- *   it will be 0. If a message was written and couldn't be sent immediately
- *   (due to a connection failure, for example), the time_delta is an
- *   approximation of when it was composed.
  * @param message The message they sent along with the request.
  * @param length The size of the message byte array.
  */
@@ -1548,15 +1770,12 @@ typedef void tox_friend_request_cb(Tox *tox, const uint8_t *public_key, const ui
  *
  * This event is triggered when a friend request is received.
  */
-void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *callback, void *user_data);
+void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *callback);
 
 /**
  * @param friend_number The friend number of the friend who sent the message.
- * @param time_delta Time between composition and sending.
  * @param message The message data they sent.
  * @param length The size of the message byte array.
- *
- * @see friend_request for more information on time_delta.
  */
 typedef void tox_friend_message_cb(Tox *tox, uint32_t friend_number, TOX_MESSAGE_TYPE type, const uint8_t *message,
                                    size_t length, void *user_data);
@@ -1567,7 +1786,7 @@ typedef void tox_friend_message_cb(Tox *tox, uint32_t friend_number, TOX_MESSAGE
  *
  * This event is triggered when a message from a friend is received.
  */
-void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *callback, void *user_data);
+void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *callback);
 
 
 /*******************************************************************************
@@ -1735,7 +1954,7 @@ typedef void tox_file_recv_control_cb(Tox *tox, uint32_t friend_number, uint32_t
  * This event is triggered when a file control command is received from a
  * friend.
  */
-void tox_callback_file_recv_control(Tox *tox, tox_file_recv_control_cb *callback, void *user_data);
+void tox_callback_file_recv_control(Tox *tox, tox_file_recv_control_cb *callback);
 
 typedef enum TOX_ERR_FILE_SEEK {
 
@@ -2039,7 +2258,7 @@ typedef void tox_file_chunk_request_cb(Tox *tox, uint32_t friend_number, uint32_
  *
  * This event is triggered when Core is ready to send more file data.
  */
-void tox_callback_file_chunk_request(Tox *tox, tox_file_chunk_request_cb *callback, void *user_data);
+void tox_callback_file_chunk_request(Tox *tox, tox_file_chunk_request_cb *callback);
 
 
 /*******************************************************************************
@@ -2077,7 +2296,7 @@ typedef void tox_file_recv_cb(Tox *tox, uint32_t friend_number, uint32_t file_nu
  *
  * This event is triggered when a file transfer request is received.
  */
-void tox_callback_file_recv(Tox *tox, tox_file_recv_cb *callback, void *user_data);
+void tox_callback_file_recv(Tox *tox, tox_file_recv_cb *callback);
 
 /**
  * When length is 0, the transfer is finished and the client should release the
@@ -2105,25 +2324,462 @@ typedef void tox_file_recv_chunk_cb(Tox *tox, uint32_t friend_number, uint32_t f
  * This event is first triggered when a file transfer request is received, and
  * subsequently when a chunk of file data for an accepted request was received.
  */
-void tox_callback_file_recv_chunk(Tox *tox, tox_file_recv_chunk_cb *callback, void *user_data);
+void tox_callback_file_recv_chunk(Tox *tox, tox_file_recv_chunk_cb *callback);
 
 
 /*******************************************************************************
  *
- * :: Group chat management
+ * :: Conference management
  *
  ******************************************************************************/
 
 
 
+/**
+ * Conference types for the conference_invite event.
+ */
+typedef enum TOX_CONFERENCE_TYPE {
 
-/*******************************************************************************
+    /**
+     * Text-only conferences that must be accepted with the tox_conference_join function.
+     */
+    TOX_CONFERENCE_TYPE_TEXT,
+
+    /**
+     * Video conference. The function to accept these is in toxav.
+     */
+    TOX_CONFERENCE_TYPE_AV,
+
+} TOX_CONFERENCE_TYPE;
+
+
+/**
+ * The invitation will remain valid until the inviting friend goes offline
+ * or exits the conference.
  *
- * :: Group chat message sending and receiving
+ * @param friend_number The friend who invited us.
+ * @param type The conference type (text only or audio/video).
+ * @param cookie A piece of data of variable length required to join the
+ *   conference.
+ * @param length The length of the cookie.
+ */
+typedef void tox_conference_invite_cb(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type, const uint8_t *cookie,
+                                      size_t length, void *user_data);
+
+
+/**
+ * Set the callback for the `conference_invite` event. Pass NULL to unset.
  *
- ******************************************************************************/
+ * This event is triggered when the client is invited to join a conference.
+ */
+void tox_callback_conference_invite(Tox *tox, tox_conference_invite_cb *callback);
+
+/**
+ * @param conference_number The conference number of the conference the message is intended for.
+ * @param peer_number The ID of the peer who sent the message.
+ * @param type The type of message (normal, action, ...).
+ * @param message The message data.
+ * @param length The length of the message.
+ */
+typedef void tox_conference_message_cb(Tox *tox, uint32_t conference_number, uint32_t peer_number,
+                                       TOX_MESSAGE_TYPE type, const uint8_t *message, size_t length, void *user_data);
+
+
+/**
+ * Set the callback for the `conference_message` event. Pass NULL to unset.
+ *
+ * This event is triggered when the client receives a conference message.
+ */
+void tox_callback_conference_message(Tox *tox, tox_conference_message_cb *callback);
+
+/**
+ * @param conference_number The conference number of the conference the title change is intended for.
+ * @param peer_number The ID of the peer who changed the title.
+ * @param title The title data.
+ * @param length The title length.
+ */
+typedef void tox_conference_title_cb(Tox *tox, uint32_t conference_number, uint32_t peer_number, const uint8_t *title,
+                                     size_t length, void *user_data);
+
+
+/**
+ * Set the callback for the `conference_title` event. Pass NULL to unset.
+ *
+ * This event is triggered when a peer changes the conference title.
+ *
+ * If peer_number == UINT32_MAX, then author is unknown (e.g. initial joining the conference).
+ */
+void tox_callback_conference_title(Tox *tox, tox_conference_title_cb *callback);
+
+/**
+ * @param conference_number The conference number of the conference the
+ *   peer is in.
+ * @param peer_number The ID of the peer who changed their nickname.
+ * @param name A byte array containing the new nickname.
+ * @param length The size of the name byte array.
+ */
+typedef void tox_conference_peer_name_cb(Tox *tox, uint32_t conference_number, uint32_t peer_number,
+        const uint8_t *name, size_t length, void *user_data);
+
+
+/**
+ * Set the callback for the `conference_peer_name` event. Pass NULL to unset.
+ *
+ * This event is triggered when a peer changes their name.
+ */
+void tox_callback_conference_peer_name(Tox *tox, tox_conference_peer_name_cb *callback);
+
+/**
+ * @param conference_number The conference number of the conference the
+ *   peer is in.
+ */
+typedef void tox_conference_peer_list_changed_cb(Tox *tox, uint32_t conference_number, void *user_data);
+
+
+/**
+ * Set the callback for the `conference_peer_list_changed` event. Pass NULL to unset.
+ *
+ * This event is triggered when a peer joins or leaves the conference.
+ */
+void tox_callback_conference_peer_list_changed(Tox *tox, tox_conference_peer_list_changed_cb *callback);
+
+typedef enum TOX_ERR_CONFERENCE_NEW {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_NEW_OK,
+
+    /**
+     * The conference instance failed to initialize.
+     */
+    TOX_ERR_CONFERENCE_NEW_INIT,
+
+} TOX_ERR_CONFERENCE_NEW;
+
+
+/**
+ * Creates a new conference.
+ *
+ * This function creates a new text conference.
+ *
+ * @return conference number on success, or UINT32_MAX on failure.
+ */
+uint32_t tox_conference_new(Tox *tox, TOX_ERR_CONFERENCE_NEW *error);
+
+typedef enum TOX_ERR_CONFERENCE_DELETE {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_DELETE_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_DELETE_CONFERENCE_NOT_FOUND,
+
+} TOX_ERR_CONFERENCE_DELETE;
+
+
+/**
+ * This function deletes a conference.
+ *
+ * @param conference_number The conference number of the conference to be deleted.
+ *
+ * @return true on success.
+ */
+bool tox_conference_delete(Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_DELETE *error);
+
+/**
+ * Error codes for peer info queries.
+ */
+typedef enum TOX_ERR_CONFERENCE_PEER_QUERY {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_PEER_QUERY_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND,
+
+    /**
+     * The peer number passed did not designate a valid peer.
+     */
+    TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND,
+
+    /**
+     * The client is not connected to the conference.
+     */
+    TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION,
+
+} TOX_ERR_CONFERENCE_PEER_QUERY;
+
+
+/**
+ * Return the number of peers in the conference. Return value is unspecified on failure.
+ */
+uint32_t tox_conference_peer_count(const Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_PEER_QUERY *error);
+
+/**
+ * Return the length of the peer's name. Return value is unspecified on failure.
+ */
+size_t tox_conference_peer_get_name_size(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+        TOX_ERR_CONFERENCE_PEER_QUERY *error);
+
+/**
+ * Copy the name of peer_number who is in conference_number to name.
+ * name must be at least TOX_MAX_NAME_LENGTH long.
+ *
+ * @return true on success.
+ */
+bool tox_conference_peer_get_name(const Tox *tox, uint32_t conference_number, uint32_t peer_number, uint8_t *name,
+                                  TOX_ERR_CONFERENCE_PEER_QUERY *error);
+
+/**
+ * Copy the public key of peer_number who is in conference_number to public_key.
+ * public_key must be TOX_PUBLIC_KEY_SIZE long.
+ *
+ * @return true on success.
+ */
+bool tox_conference_peer_get_public_key(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+                                        uint8_t *public_key, TOX_ERR_CONFERENCE_PEER_QUERY *error);
+
+/**
+ * Return true if passed peer_number corresponds to our own.
+ */
+bool tox_conference_peer_number_is_ours(const Tox *tox, uint32_t conference_number, uint32_t peer_number,
+                                        TOX_ERR_CONFERENCE_PEER_QUERY *error);
+
+typedef enum TOX_ERR_CONFERENCE_INVITE {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_INVITE_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND,
+
+    /**
+     * The invite packet failed to send.
+     */
+    TOX_ERR_CONFERENCE_INVITE_FAIL_SEND,
+
+} TOX_ERR_CONFERENCE_INVITE;
+
+
+/**
+ * Invites a friend to a conference.
+ *
+ * @param friend_number The friend number of the friend we want to invite.
+ * @param conference_number The conference number of the conference we want to invite the friend to.
+ *
+ * @return true on success.
+ */
+bool tox_conference_invite(Tox *tox, uint32_t friend_number, uint32_t conference_number,
+                           TOX_ERR_CONFERENCE_INVITE *error);
+
+typedef enum TOX_ERR_CONFERENCE_JOIN {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_JOIN_OK,
+
+    /**
+     * The cookie passed has an invalid length.
+     */
+    TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH,
+
+    /**
+     * The conference is not the expected type. This indicates an invalid cookie.
+     */
+    TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE,
+
+    /**
+     * The friend number passed does not designate a valid friend.
+     */
+    TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND,
+
+    /**
+     * Client is already in this conference.
+     */
+    TOX_ERR_CONFERENCE_JOIN_DUPLICATE,
+
+    /**
+     * Conference instance failed to initialize.
+     */
+    TOX_ERR_CONFERENCE_JOIN_INIT_FAIL,
+
+    /**
+     * The join packet failed to send.
+     */
+    TOX_ERR_CONFERENCE_JOIN_FAIL_SEND,
+
+} TOX_ERR_CONFERENCE_JOIN;
+
+
+/**
+ * Joins a conference that the client has been invited to.
+ *
+ * @param friend_number The friend number of the friend who sent the invite.
+ * @param cookie Received via the `conference_invite` event.
+ * @param length The size of cookie.
+ *
+ * @return conference number on success, UINT32_MAX on failure.
+ */
+uint32_t tox_conference_join(Tox *tox, uint32_t friend_number, const uint8_t *cookie, size_t length,
+                             TOX_ERR_CONFERENCE_JOIN *error);
+
+typedef enum TOX_ERR_CONFERENCE_SEND_MESSAGE {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_SEND_MESSAGE_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND,
+
+    /**
+     * The message is too long.
+     */
+    TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG,
+
+    /**
+     * The client is not connected to the conference.
+     */
+    TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION,
 
+    /**
+     * The message packet failed to send.
+     */
+    TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND,
 
+} TOX_ERR_CONFERENCE_SEND_MESSAGE;
+
+
+/**
+ * Send a text chat message to the conference.
+ *
+ * This function creates a conference message packet and pushes it into the send
+ * queue.
+ *
+ * The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
+ * must be split by the client and sent as separate messages. Other clients can
+ * then reassemble the fragments.
+ *
+ * @param conference_number The conference number of the conference the message is intended for.
+ * @param type Message type (normal, action, ...).
+ * @param message A non-NULL pointer to the first element of a byte array
+ *   containing the message text.
+ * @param length Length of the message to be sent.
+ *
+ * @return true on success.
+ */
+bool tox_conference_send_message(Tox *tox, uint32_t conference_number, TOX_MESSAGE_TYPE type, const uint8_t *message,
+                                 size_t length, TOX_ERR_CONFERENCE_SEND_MESSAGE *error);
+
+typedef enum TOX_ERR_CONFERENCE_TITLE {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_TITLE_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND,
+
+    /**
+     * The title is too long or empty.
+     */
+    TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH,
+
+    /**
+     * The title packet failed to send.
+     */
+    TOX_ERR_CONFERENCE_TITLE_FAIL_SEND,
+
+} TOX_ERR_CONFERENCE_TITLE;
+
+
+/**
+ * Return the length of the conference title. Return value is unspecified on failure.
+ *
+ * The return value is equal to the `length` argument received by the last
+ * `conference_title` callback.
+ */
+size_t tox_conference_get_title_size(const Tox *tox, uint32_t conference_number, TOX_ERR_CONFERENCE_TITLE *error);
+
+/**
+ * Write the title designated by the given conference number to a byte array.
+ *
+ * Call tox_conference_get_title_size to determine the allocation size for the `title` parameter.
+ *
+ * The data written to `title` is equal to the data received by the last
+ * `conference_title` callback.
+ *
+ * @param title A valid memory region large enough to store the title.
+ *   If this parameter is NULL, this function has no effect.
+ *
+ * @return true on success.
+ */
+bool tox_conference_get_title(const Tox *tox, uint32_t conference_number, uint8_t *title,
+                              TOX_ERR_CONFERENCE_TITLE *error);
+
+/**
+ * Set the conference title and broadcast it to the rest of the conference.
+ *
+ * Title length cannot be longer than TOX_MAX_NAME_LENGTH.
+ *
+ * @return true on success.
+ */
+bool tox_conference_set_title(Tox *tox, uint32_t conference_number, const uint8_t *title, size_t length,
+                              TOX_ERR_CONFERENCE_TITLE *error);
+
+/**
+ * Return the number of conferences in the Tox instance.
+ * This should be used to determine how much memory to allocate for `tox_conference_get_chatlist`.
+ */
+size_t tox_conference_get_chatlist_size(const Tox *tox);
+
+/**
+ * Copy a list of valid conference IDs into the array chatlist. Determine how much space
+ * to allocate for the array with the `tox_conference_get_chatlist_size` function.
+ */
+void tox_conference_get_chatlist(const Tox *tox, uint32_t *chatlist);
+
+/**
+ * Returns the type of conference (TOX_CONFERENCE_TYPE) that conference_number is. Return value is
+ * unspecified on failure.
+ */
+typedef enum TOX_ERR_CONFERENCE_GET_TYPE {
+
+    /**
+     * The function returned successfully.
+     */
+    TOX_ERR_CONFERENCE_GET_TYPE_OK,
+
+    /**
+     * The conference number passed did not designate a valid conference.
+     */
+    TOX_ERR_CONFERENCE_GET_TYPE_CONFERENCE_NOT_FOUND,
+
+} TOX_ERR_CONFERENCE_GET_TYPE;
+
+
+TOX_CONFERENCE_TYPE tox_conference_get_type(const Tox *tox, uint32_t conference_number,
+        TOX_ERR_CONFERENCE_GET_TYPE *error);
 
 
 /*******************************************************************************
@@ -2235,7 +2891,7 @@ typedef void tox_friend_lossy_packet_cb(Tox *tox, uint32_t friend_number, const
  * Set the callback for the `friend_lossy_packet` event. Pass NULL to unset.
  *
  */
-void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *callback, void *user_data);
+void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *callback);
 
 /**
  * @param friend_number The friend number of the friend who sent the packet.
@@ -2250,7 +2906,7 @@ typedef void tox_friend_lossless_packet_cb(Tox *tox, uint32_t friend_number, con
  * Set the callback for the `friend_lossless_packet` event. Pass NULL to unset.
  *
  */
-void tox_callback_friend_lossless_packet(Tox *tox, tox_friend_lossless_packet_cb *callback, void *user_data);
+void tox_callback_friend_lossless_packet(Tox *tox, tox_friend_lossless_packet_cb *callback);
 
 
 /*******************************************************************************
@@ -2301,8 +2957,6 @@ uint16_t tox_self_get_udp_port(const Tox *tox, TOX_ERR_GET_PORT *error);
  */
 uint16_t tox_self_get_tcp_port(const Tox *tox, TOX_ERR_GET_PORT *error);
 
-#include "tox_old.h"
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/toxcore/tox_api.c b/toxcore/tox_api.c
new file mode 100644
index 00000000..8fee8c80
--- /dev/null
+++ b/toxcore/tox_api.c
@@ -0,0 +1,100 @@
+#include "tox.h"
+
+#include "ccompat.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#define SET_ERROR_PARAMETER(param, x) {if(param) {*param = x;}}
+
+
+#define CONST_FUNCTION(lowercase, uppercase) \
+uint32_t tox_##lowercase(void) \
+{ \
+    return TOX_##uppercase; \
+}
+
+CONST_FUNCTION(version_major, VERSION_MAJOR)
+CONST_FUNCTION(version_minor, VERSION_MINOR)
+CONST_FUNCTION(version_patch, VERSION_PATCH)
+CONST_FUNCTION(public_key_size, PUBLIC_KEY_SIZE)
+CONST_FUNCTION(secret_key_size, SECRET_KEY_SIZE)
+CONST_FUNCTION(nospam_size, NOSPAM_SIZE)
+CONST_FUNCTION(address_size, ADDRESS_SIZE)
+CONST_FUNCTION(max_name_length, MAX_NAME_LENGTH)
+CONST_FUNCTION(max_status_message_length, MAX_STATUS_MESSAGE_LENGTH)
+CONST_FUNCTION(max_friend_request_length, MAX_FRIEND_REQUEST_LENGTH)
+CONST_FUNCTION(max_message_length, MAX_MESSAGE_LENGTH)
+CONST_FUNCTION(max_custom_packet_size, MAX_CUSTOM_PACKET_SIZE)
+CONST_FUNCTION(hash_length, HASH_LENGTH)
+CONST_FUNCTION(file_id_length, FILE_ID_LENGTH)
+CONST_FUNCTION(max_filename_length, MAX_FILENAME_LENGTH)
+
+
+#define ACCESSORS(type, ns, name) \
+type tox_options_get_##ns##name(const struct Tox_Options *options) \
+{ \
+    return options->ns##name; \
+} \
+void tox_options_set_##ns##name(struct Tox_Options *options, type name) \
+{ \
+    options->ns##name = name; \
+}
+
+ACCESSORS(bool,, ipv6_enabled)
+ACCESSORS(bool,, udp_enabled)
+ACCESSORS(TOX_PROXY_TYPE, proxy_, type)
+ACCESSORS(const char *, proxy_, host)
+ACCESSORS(uint16_t, proxy_, port)
+ACCESSORS(uint16_t,, start_port)
+ACCESSORS(uint16_t,, end_port)
+ACCESSORS(uint16_t,, tcp_port)
+ACCESSORS(bool,, hole_punching_enabled)
+ACCESSORS(TOX_SAVEDATA_TYPE, savedata_, type)
+ACCESSORS(size_t, savedata_, length)
+ACCESSORS(tox_log_cb *, log_, callback)
+ACCESSORS(void *, log_, user_data)
+ACCESSORS(bool,, local_discovery_enabled)
+
+const uint8_t *tox_options_get_savedata_data(const struct Tox_Options *options)
+{
+    return options->savedata_data;
+}
+
+void tox_options_set_savedata_data(struct Tox_Options *options, const uint8_t *data, size_t length)
+{
+    options->savedata_data = data;
+    options->savedata_length = length;
+}
+
+void tox_options_default(struct Tox_Options *options)
+{
+    if (options) {
+        struct Tox_Options default_options = { 0 };
+        *options = default_options;
+        tox_options_set_ipv6_enabled(options, true);
+        tox_options_set_udp_enabled(options, true);
+        tox_options_set_proxy_type(options, TOX_PROXY_TYPE_NONE);
+        tox_options_set_hole_punching_enabled(options, true);
+        tox_options_set_local_discovery_enabled(options, true);
+    }
+}
+
+struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error)
+{
+    struct Tox_Options *options = (struct Tox_Options *)malloc(sizeof(struct Tox_Options));
+
+    if (options) {
+        tox_options_default(options);
+        SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_OK);
+        return options;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_MALLOC);
+    return nullptr;
+}
+
+void tox_options_free(struct Tox_Options *options)
+{
+    free(options);
+}
diff --git a/toxcore/tox_old.h b/toxcore/tox_old.h
deleted file mode 100644
index a926cdf7..00000000
--- a/toxcore/tox_old.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/**********GROUP CHAT FUNCTIONS ************/
-
-/* Group chat types for tox_callback_group_invite function.
- *
- * TOX_GROUPCHAT_TYPE_TEXT groupchats must be accepted with the tox_join_groupchat() function.
- * The function to accept TOX_GROUPCHAT_TYPE_AV is in toxav.
- */
-enum {
-    TOX_GROUPCHAT_TYPE_TEXT,
-    TOX_GROUPCHAT_TYPE_AV
-};
-
-/* Set the callback for group invites.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t type, const uint8_t *data, uint16_t length, void *userdata)
- *
- * data of length is what needs to be passed to join_groupchat().
- *
- * for what type means see the enum right above this comment.
- */
-void tox_callback_group_invite(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, const uint8_t *, uint16_t,
-                               void *), void *userdata);
-
-/* Set the callback for group messages.
- *
- *  Function(Tox *tox, int groupnumber, int peernumber, const uint8_t * message, uint16_t length, void *userdata)
- */
-void tox_callback_group_message(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
-                                void *userdata);
-
-/* Set the callback for group actions.
- *
- *  Function(Tox *tox, int groupnumber, int peernumber, const uint8_t * action, uint16_t length, void *userdata)
- */
-void tox_callback_group_action(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
-                               void *userdata);
-
-/* Set callback function for title changes.
- *
- * Function(Tox *tox, int groupnumber, int peernumber, uint8_t * title, uint8_t length, void *userdata)
- * if peernumber == -1, then author is unknown (e.g. initial joining the group)
- */
-void tox_callback_group_title(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint8_t,
-                              void *), void *userdata);
-
-/* Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
- */
-typedef enum {
-    TOX_CHAT_CHANGE_PEER_ADD,
-    TOX_CHAT_CHANGE_PEER_DEL,
-    TOX_CHAT_CHANGE_PEER_NAME,
-} TOX_CHAT_CHANGE;
-
-void tox_callback_group_namelist_change(Tox *tox, void (*function)(Tox *tox, int, int, uint8_t, void *),
-                                        void *userdata);
-
-/* Creates a new groupchat and puts it in the chats array.
- *
- * return group number on success.
- * return -1 on failure.
- */
-int tox_add_groupchat(Tox *tox);
-
-/* Delete a groupchat from the chats array.
- *
- * return 0 on success.
- * return -1 if failure.
- */
-int tox_del_groupchat(Tox *tox, int groupnumber);
-
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least TOX_MAX_NAME_LENGTH long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name);
-
-/* Copy the public key of peernumber who is in groupnumber to public_key.
- * public_key must be TOX_PUBLIC_KEY_SIZE long.
- *
- * returns 0 on success
- * returns -1 on failure
- */
-int tox_group_peer_pubkey(const Tox *tox, int groupnumber, int peernumber, uint8_t *public_key);
-
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
- */
-int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber);
-
-/* Join a group (you need to have been invited first.) using data of length obtained
- * in the group invite callback.
- *
- * returns group number on success
- * returns -1 on failure.
- */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length);
-
-/* send a group message
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_message_send(Tox *tox, int groupnumber, const uint8_t *message, uint16_t length);
-
-/* send a group action
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_action_send(Tox *tox, int groupnumber, const uint8_t *action, uint16_t length);
-
-/* set the group's title, limited to MAX_NAME_LENGTH
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_set_title(Tox *tox, int groupnumber, const uint8_t *title, uint8_t length);
-
-/* Get group title from groupnumber and put it in title.
- * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
- *
- *  return length of copied title if success.
- *  return -1 if failure.
- */
-int tox_group_get_title(Tox *tox, int groupnumber, uint8_t *title, uint32_t max_length);
-
-/* Check if the current peernumber corresponds to ours.
- *
- * return 1 if the peernumber corresponds to ours.
- * return 0 on failure.
- */
-unsigned int tox_group_peernumber_is_ours(const Tox *tox, int groupnumber, int peernumber);
-
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
- */
-int tox_group_number_peers(const Tox *tox, int groupnumber);
-
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][TOX_MAX_NAME_LENGTH] array.
- *
- * Copies the lengths of the names to lengths[length]
- *
- * returns the number of peers on success.
- *
- * return -1 on failure.
- */
-int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
-                        uint16_t length);
-
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t tox_count_chatlist(const Tox *tox);
-
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_chatlist(const Tox *tox, int32_t *out_list, uint32_t list_size);
-
-/* return the type of groupchat (TOX_GROUPCHAT_TYPE_) that groupnumber is.
- *
- * return -1 on failure.
- * return type on success.
- */
-int tox_group_get_type(const Tox *tox, int groupnumber);
-
diff --git a/toxcore/tox_old_code.h b/toxcore/tox_old_code.h
deleted file mode 100644
index 2a422575..00000000
--- a/toxcore/tox_old_code.h
+++ /dev/null
@@ -1,237 +0,0 @@
-/**********GROUP CHAT FUNCTIONS: WARNING Group chats will be rewritten so this might change ************/
-
-/* Set the callback for group invites.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
- *
- * data of length is what needs to be passed to join_groupchat().
- */
-void tox_callback_group_invite(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, const uint8_t *, uint16_t,
-                               void *), void *userdata)
-{
-    Messenger *m = tox;
-    g_callback_group_invite(m->group_chat_object, function, userdata);
-}
-
-/* Set the callback for group messages.
- *
- *  Function(Tox *tox, int groupnumber, int peernumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void tox_callback_group_message(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
-                                void *userdata)
-{
-    Messenger *m = tox;
-    g_callback_group_message(m->group_chat_object, function, userdata);
-}
-
-/* Set the callback for group actions.
- *
- *  Function(Tox *tox, int groupnumber, int peernumber, uint8_t * action, uint16_t length, void *userdata)
- */
-void tox_callback_group_action(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
-                               void *userdata)
-{
-    Messenger *m = tox;
-    g_callback_group_action(m->group_chat_object, function, userdata);
-}
-
-/* Set callback function for title changes.
- *
- * Function(Tox *tox, int groupnumber, int peernumber, uint8_t * title, uint8_t length, void *userdata)
- * if peernumber == -1, then author is unknown (e.g. initial joining the group)
- */
-void tox_callback_group_title(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint8_t,
-                              void *), void *userdata)
-{
-    Messenger *m = tox;
-    g_callback_group_title(m->group_chat_object, function, userdata);
-}
-
-/* Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, void *userdata)
- */
-void tox_callback_group_namelist_change(Tox *tox, void (*function)(Tox *tox, int, int, uint8_t, void *), void *userdata)
-{
-    Messenger *m = tox;
-    g_callback_group_namelistchange(m->group_chat_object, function, userdata);
-}
-
-/* Creates a new groupchat and puts it in the chats array.
- *
- * return group number on success.
- * return -1 on failure.
- */
-int tox_add_groupchat(Tox *tox)
-{
-    Messenger *m = tox;
-    return add_groupchat(m->group_chat_object, GROUPCHAT_TYPE_TEXT);
-}
-
-/* Delete a groupchat from the chats array.
- *
- * return 0 on success.
- * return -1 if failure.
- */
-int tox_del_groupchat(Tox *tox, int groupnumber)
-{
-    Messenger *m = tox;
-    return del_groupchat(m->group_chat_object, groupnumber);
-}
-
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least MAX_NICK_BYTES long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name)
-{
-    const Messenger *m = tox;
-    return group_peername(m->group_chat_object, groupnumber, peernumber, name);
-}
-
-/* Copy the public key of peernumber who is in groupnumber to public_key.
- * public_key must be crypto_box_PUBLICKEYBYTES long.
- *
- * returns 0 on success
- * returns -1 on failure
- */
-int tox_group_peer_pubkey(const Tox *tox, int groupnumber, int peernumber, uint8_t *public_key)
-{
-    const Messenger *m = tox;
-    return group_peer_pubkey(m->group_chat_object, groupnumber, peernumber, public_key);
-}
-
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
- */
-int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber)
-{
-    Messenger *m = tox;
-    return invite_friend(m->group_chat_object, friendnumber, groupnumber);
-}
-
-/* Join a group (you need to have been invited first.) using data of length obtained
- * in the group invite callback.
- *
- * returns group number on success
- * returns -1 on failure.
- */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length)
-{
-    Messenger *m = tox;
-    return join_groupchat(m->group_chat_object, friendnumber, GROUPCHAT_TYPE_TEXT, data, length);
-}
-
-/* send a group message
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_message_send(Tox *tox, int groupnumber, const uint8_t *message, uint16_t length)
-{
-    Messenger *m = tox;
-    return group_message_send(m->group_chat_object, groupnumber, message, length);
-}
-
-/* send a group action
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_action_send(Tox *tox, int groupnumber, const uint8_t *action, uint16_t length)
-{
-    Messenger *m = tox;
-    return group_action_send(m->group_chat_object, groupnumber, action, length);
-}
-
-/* set the group's title, limited to MAX_NAME_LENGTH
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_set_title(Tox *tox, int groupnumber, const uint8_t *title, uint8_t length)
-{
-    Messenger *m = tox;
-    return group_title_send(m->group_chat_object, groupnumber, title, length);
-}
-
-/* Get group title from groupnumber and put it in title.
- * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
- *
- *  return length of copied title if success.
- *  return -1 if failure.
- */
-int tox_group_get_title(Tox *tox, int groupnumber, uint8_t *title, uint32_t max_length)
-{
-    Messenger *m = tox;
-    return group_title_get(m->group_chat_object, groupnumber, title, max_length);
-}
-
-/* Check if the current peernumber corresponds to ours.
- *
- * return 1 if the peernumber corresponds to ours.
- * return 0 on failure.
- */
-unsigned int tox_group_peernumber_is_ours(const Tox *tox, int groupnumber, int peernumber)
-{
-    const Messenger *m = tox;
-    return group_peernumber_is_ours(m->group_chat_object, groupnumber, peernumber);
-}
-
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
- */
-int tox_group_number_peers(const Tox *tox, int groupnumber)
-{
-    const Messenger *m = tox;
-    return group_number_peers(m->group_chat_object, groupnumber);
-}
-
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
- *
- * Copies the lengths of the names to lengths[length]
- *
- * returns the number of peers on success.
- *
- * return -1 on failure.
- */
-int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
-                        uint16_t length)
-{
-    const Messenger *m = tox;
-    return group_names(m->group_chat_object, groupnumber, names, lengths, length);
-}
-
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t tox_count_chatlist(const Tox *tox)
-{
-    const Messenger *m = tox;
-    return count_chatlist(m->group_chat_object);
-}
-
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_chatlist(const Tox *tox, int32_t *out_list, uint32_t list_size)
-{
-    const Messenger *m = tox;
-    return copy_chatlist(m->group_chat_object, out_list, list_size);
-}
-
-/* return the type of groupchat (TOX_GROUPCHAT_TYPE_) that groupnumber is.
- *
- * return -1 on failure.
- * return type on success.
- */
-int tox_group_get_type(const Tox *tox, int groupnumber)
-{
-    const Messenger *m = tox;
-    return group_get_type(m->group_chat_object, groupnumber);
-}
diff --git a/toxcore/util.c b/toxcore/util.c
index ea1988e4..082e453f 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -1,52 +1,61 @@
 /*
- * util.c -- Utilities.
+ * Utilities.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ * Copyright © 2013 plutooo
  *
+ * This file is part of Tox, the free peer to peer instant messenger.
  * This file is donated to the Tox Project.
- * Copyright 2013  plutooo
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  This file is part of Tox.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <time.h>
-
-/* for crypto_box_PUBLICKEYBYTES */
-#include "crypto_core.h"
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
 
 #include "util.h"
 
+#include "crypto_core.h" /* for CRYPTO_PUBLIC_KEY_SIZE */
+#include "network.h" /* for current_time_monotonic */
+
+#include <string.h>
+#include <time.h>
+
 
 /* don't call into system billions of times for no reason */
 static uint64_t unix_time_value;
 static uint64_t unix_base_time_value;
 
-void unix_time_update()
+/* XXX: note that this is not thread-safe; if multiple threads call unix_time_update() concurrently, the return value of
+ * unix_time() may fail to increase monotonically with increasing time */
+void unix_time_update(void)
 {
-    if (unix_base_time_value == 0)
-        unix_base_time_value = ((uint64_t)time(NULL) - (current_time_monotonic() / 1000ULL));
+    if (unix_base_time_value == 0) {
+        unix_base_time_value = ((uint64_t)time(nullptr) - (current_time_monotonic() / 1000ULL));
+    }
 
     unix_time_value = (current_time_monotonic() / 1000ULL) + unix_base_time_value;
 }
 
-uint64_t unix_time()
+uint64_t unix_time(void)
 {
     return unix_time_value;
 }
@@ -65,15 +74,15 @@ bool id_equal(const uint8_t *dest, const uint8_t *src)
 
 uint32_t id_copy(uint8_t *dest, const uint8_t *src)
 {
-    memcpy(dest, src, crypto_box_PUBLICKEYBYTES);
-    return crypto_box_PUBLICKEYBYTES;
+    memcpy(dest, src, CRYPTO_PUBLIC_KEY_SIZE);
+    return CRYPTO_PUBLIC_KEY_SIZE;
 }
 
 void host_to_net(uint8_t *num, uint16_t numbytes)
 {
 #ifndef WORDS_BIGENDIAN
     uint32_t i;
-    uint8_t buff[numbytes];
+    VLA(uint8_t, buff, numbytes);
 
     for (i = 0; i < numbytes; ++i) {
         buff[i] = num[numbytes - i - 1];
@@ -81,13 +90,12 @@ void host_to_net(uint8_t *num, uint16_t numbytes)
 
     memcpy(num, buff, numbytes);
 #endif
-    return;
 }
 
 uint16_t lendian_to_host16(uint16_t lendian)
 {
 #ifdef WORDS_BIGENDIAN
-    return  (lendian << 8) | (lendian >> 8 );
+    return (lendian << 8) | (lendian >> 8);
 #else
     return lendian;
 #endif
@@ -96,7 +104,7 @@ uint16_t lendian_to_host16(uint16_t lendian)
 void host_to_lendian32(uint8_t *dest,  uint32_t num)
 {
 #ifdef WORDS_BIGENDIAN
-    num = ((num << 8) & 0xFF00FF00 ) | ((num >> 8) & 0xFF00FF );
+    num = ((num << 8) & 0xFF00FF00) | ((num >> 8) & 0xFF00FF);
     num = (num << 16) | (num >> 16);
 #endif
     memcpy(dest, &num, sizeof(uint32_t));
@@ -107,25 +115,22 @@ void lendian_to_host32(uint32_t *dest, const uint8_t *lendian)
     uint32_t d;
     memcpy(&d, lendian, sizeof(uint32_t));
 #ifdef WORDS_BIGENDIAN
-    d = ((d << 8) & 0xFF00FF00 ) | ((d >> 8) & 0xFF00FF );
+    d = ((d << 8) & 0xFF00FF00) | ((d >> 8) & 0xFF00FF);
     d = (d << 16) | (d >> 16);
 #endif
     *dest = d;
 }
 
 /* state load/save */
-int load_state(load_state_callback_func load_state_callback, void *outer,
+int load_state(load_state_callback_func load_state_callback, Logger *log, void *outer,
                const uint8_t *data, uint32_t length, uint16_t cookie_inner)
 {
     if (!load_state_callback || !data) {
-#ifdef DEBUG
-        fprintf(stderr, "load_state() called with invalid args.\n");
-#endif
+        LOGGER_ERROR(log, "load_state() called with invalid args.\n");
         return -1;
     }
 
 
-    uint16_t type;
     uint32_t length_sub, cookie_type;
     uint32_t size_head = sizeof(uint32_t) * 2;
 
@@ -137,45 +142,42 @@ int load_state(load_state_callback_func load_state_callback, void *outer,
 
         if (length < length_sub) {
             /* file truncated */
-#ifdef DEBUG
-            fprintf(stderr, "state file too short: %u < %u\n", length, length_sub);
-#endif
+            LOGGER_ERROR(log, "state file too short: %u < %u\n", length, length_sub);
             return -1;
         }
 
         if (lendian_to_host16((cookie_type >> 16)) != cookie_inner) {
             /* something is not matching up in a bad way, give up */
-#ifdef DEBUG
-            fprintf(stderr, "state file garbeled: %04hx != %04hx\n", (cookie_type >> 16), cookie_inner);
-#endif
+            LOGGER_ERROR(log, "state file garbled: %04x != %04x\n", (cookie_type >> 16), cookie_inner);
             return -1;
         }
 
-        type = lendian_to_host16(cookie_type & 0xFFFF);
-
-        int ret = load_state_callback(outer, data, length_sub, type);
+        const uint16_t type = lendian_to_host16(cookie_type & 0xFFFF);
+        const int ret = load_state_callback(outer, data, length_sub, type);
 
         if (ret == -1) {
             return -1;
         }
 
         /* -2 means end of save. */
-        if (ret == -2)
+        if (ret == -2) {
             return 0;
+        }
 
         data += length_sub;
         length -= length_sub;
     }
 
     return length == 0 ? 0 : -1;
-};
+}
 
 int create_recursive_mutex(pthread_mutex_t *mutex)
 {
     pthread_mutexattr_t attr;
 
-    if (pthread_mutexattr_init(&attr) != 0)
+    if (pthread_mutexattr_init(&attr) != 0) {
         return -1;
+    }
 
     if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) {
         pthread_mutexattr_destroy(&attr);
@@ -193,86 +195,12 @@ int create_recursive_mutex(pthread_mutex_t *mutex)
     return 0;
 }
 
-
-struct RingBuffer {
-    uint16_t size; /* Max size */
-    uint16_t start;
-    uint16_t end;
-    void   **data;
-};
-
-bool rb_full(const RingBuffer *b)
-{
-    return (b->end + 1) % b->size == b->start;
-}
-bool rb_empty(const RingBuffer *b)
-{
-    return b->end == b->start;
-}
-void *rb_write(RingBuffer *b, void *p)
-{
-    void *rc = NULL;
-
-    if ((b->end + 1) % b->size == b->start) /* full */
-        rc = b->data[b->start];
-
-    b->data[b->end] = p;
-    b->end = (b->end + 1) % b->size;
-
-    if (b->end == b->start)
-        b->start = (b->start + 1) % b->size;
-
-    return rc;
-}
-bool rb_read(RingBuffer *b, void **p)
-{
-    if (b->end == b->start) { /* Empty */
-        *p = NULL;
-        return false;
-    }
-
-    *p = b->data[b->start];
-    b->start = (b->start + 1) % b->size;
-    return true;
-}
-RingBuffer *rb_new(int size)
-{
-    RingBuffer *buf = calloc(sizeof(RingBuffer), 1);
-
-    if (!buf) return NULL;
-
-    buf->size = size + 1; /* include empty elem */
-
-    if (!(buf->data = calloc(buf->size, sizeof(void *)))) {
-        free(buf);
-        return NULL;
-    }
-
-    return buf;
-}
-void rb_kill(RingBuffer *b)
+int32_t max_s32(int32_t a, int32_t b)
 {
-    if (b) {
-        free(b->data);
-        free(b);
-    }
+    return a > b ? a : b;
 }
-uint16_t rb_size(const RingBuffer *b)
-{
-    if (rb_empty(b))
-        return 0;
 
-    return
-        b->end > b->start ?
-        b->end - b->start :
-        (b->size - b->start) + b->end;
-}
-uint16_t rb_data(const RingBuffer *b, void **dest)
+uint64_t min_u64(uint64_t a, uint64_t b)
 {
-    uint16_t i = 0;
-
-    for (; i < rb_size(b); i++)
-        dest[i] = b->data[(b->start + i) % b->size];
-
-    return i;
+    return a < b ? a : b;
 }
diff --git a/toxcore/util.h b/toxcore/util.h
index bdbf7d3b..a9faa863 100644
--- a/toxcore/util.h
+++ b/toxcore/util.h
@@ -1,39 +1,46 @@
 /*
- * util.h -- Utilities.
+ * Utilities.
+ */
+
+/*
+ * Copyright © 2016-2017 The TokTok team.
+ * Copyright © 2013 Tox project.
+ * Copyright © 2013 plutooo
  *
+ * This file is part of Tox, the free peer to peer instant messenger.
  * This file is donated to the Tox Project.
- * Copyright 2013  plutooo
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+ * Tox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  This file is part of Tox.
+ * Tox is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- *  Tox is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Tox is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Tox.  If not, see <http://www.gnu.org/licenses/>.
  */
+#ifndef UTIL_H
+#define UTIL_H
 
-#ifndef __UTIL_H__
-#define __UTIL_H__
-
+#include <pthread.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <pthread.h>
+
+#include "logger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 #define MIN(a,b) (((a)<(b))?(a):(b))
 #define PAIR(TYPE1__, TYPE2__) struct { TYPE1__ first; TYPE2__ second; }
 
-void unix_time_update();
-uint64_t unix_time();
+void unix_time_update(void);
+uint64_t unix_time(void);
 int is_timeout(uint64_t timestamp, uint64_t timeout);
 
 
@@ -52,21 +59,17 @@ void lendian_to_host32(uint32_t *dest, const uint8_t *lendian);
 
 /* state load/save */
 typedef int (*load_state_callback_func)(void *outer, const uint8_t *data, uint32_t len, uint16_t type);
-int load_state(load_state_callback_func load_state_callback, void *outer,
+int load_state(load_state_callback_func load_state_callback, Logger *log, void *outer,
                const uint8_t *data, uint32_t length, uint16_t cookie_inner);
 
 /* Returns -1 if failed or 0 if success */
 int create_recursive_mutex(pthread_mutex_t *mutex);
 
-/* Ring buffer */
-typedef struct RingBuffer RingBuffer;
-bool rb_full(const RingBuffer *b);
-bool rb_empty(const RingBuffer *b);
-void *rb_write(RingBuffer *b, void *p);
-bool rb_read(RingBuffer *b, void **p);
-RingBuffer *rb_new(int size);
-void rb_kill(RingBuffer *b);
-uint16_t rb_size(const RingBuffer *b);
-uint16_t rb_data(const RingBuffer *b, void **dest);
-
-#endif /* __UTIL_H__ */
+int32_t max_s32(int32_t a, int32_t b);
+uint64_t min_u64(uint64_t a, uint64_t b);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif /* UTIL_H */
diff --git a/toxcore/util_test.cpp b/toxcore/util_test.cpp
new file mode 100644
index 00000000..8de63848
--- /dev/null
+++ b/toxcore/util_test.cpp
@@ -0,0 +1,55 @@
+#include "util.h"
+
+#include "crypto_core.h"
+
+#include <gtest/gtest.h>
+
+TEST(Util, UnixTimeIncreasesOverTime)
+{
+    unix_time_update();
+    uint64_t const start = unix_time();
+
+    while (start == unix_time()) {
+        unix_time_update();
+    }
+
+    uint64_t const end = unix_time();
+    EXPECT_GT(end, start);
+}
+
+TEST(Util, IsTimeout)
+{
+    uint64_t const start = unix_time();
+    EXPECT_FALSE(is_timeout(start, 1));
+
+    while (start == unix_time()) {
+        unix_time_update();
+    }
+
+    EXPECT_TRUE(is_timeout(start, 1));
+}
+
+TEST(Util, TwoRandomIdsAreNotEqual)
+{
+    uint8_t pk1[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t sk1[CRYPTO_SECRET_KEY_SIZE];
+    uint8_t pk2[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t sk2[CRYPTO_SECRET_KEY_SIZE];
+
+    crypto_new_keypair(pk1, sk1);
+    crypto_new_keypair(pk2, sk2);
+
+    EXPECT_FALSE(id_equal(pk1, pk2));
+}
+
+TEST(Util, IdCopyMakesKeysEqual)
+{
+    uint8_t pk1[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t sk1[CRYPTO_SECRET_KEY_SIZE];
+    uint8_t pk2[CRYPTO_PUBLIC_KEY_SIZE] = {0};
+
+    crypto_new_keypair(pk1, sk1);
+    id_copy(pk2, pk1);
+
+    EXPECT_TRUE(id_equal(pk1, pk2));
+}