Make DHT a module-private type.

11 files changed, 162 insertions, 94 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index a4251518..33ebc690 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -59,6 +59,94 @@
 
 #define ASSOC_COUNT 2
 
+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;
+
+    /* Note: this key should not be/is not used to transmit any sensitive materials */
+    uint8_t      secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE];
+    /* 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_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.
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index 8fdd80b0..808470fc 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -240,42 +240,22 @@ typedef struct {
 } Cryptopacket_Handles;
 
 #define DHT_DEFINED
-typedef struct DHT {
-    Logger *log;
-    Networking_Core *net;
+typedef struct DHT DHT;
 
-    bool hole_punching_enabled;
+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);
 
-    Client_data    close_clientlist[LCLIENT_LIST];
-    uint64_t       close_lastgetnodes;
-    uint32_t       close_bootstrap_times;
+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);
 
-    /* Note: this key should not be/is not used to transmit any sensitive materials */
-    uint8_t      secret_symmetric_key[CRYPTO_SYMMETRIC_KEY_SIZE];
-    /* DHT keypair */
-    uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
-    uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
+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);
 
-    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;
-} DHT;
 /*----------------------------------------------------------------------------------*/
 
 /* Shared key generations are costly, it is therefor smart to store commonly used
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index b5cf2c52..c0724ad9 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -356,7 +356,6 @@ static int handle_LANdiscovery(void *object, IP_Port source, const uint8_t *pack
 
     char ip_str[IP_NTOA_LEN] = { 0 };
     ip_ntoa(&source.ip, ip_str, sizeof(ip_str));
-    LOGGER_DEBUG(dht->log, "Found node in LAN: %s", ip_str);
 
     DHT_bootstrap(dht, source, packet + 1);
     return 0;
@@ -367,30 +366,30 @@ int lan_discovery_send(uint16_t port, DHT *dht)
 {
     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_PUBLIC_KEY_SIZE);
+    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 (net_family(dht->net) == TOX_AF_INET6) {
+    if (net_family(dht_get_net(dht)) == TOX_AF_INET6) {
         ip_port.ip = broadcast_ip(TOX_AF_INET6, TOX_AF_INET6);
 
         if (ip_isset(&ip_port.ip)) {
-            if (sendpacket(dht->net, ip_port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE) > 0) {
+            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 TOX_AF_INET6 */
-    ip_port.ip = broadcast_ip(net_family(dht->net), TOX_AF_INET);
+    ip_port.ip = broadcast_ip(net_family(dht_get_net(dht)), TOX_AF_INET);
 
     if (ip_isset(&ip_port.ip)) {
-        if (sendpacket(dht->net, ip_port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE)) {
+        if (sendpacket(dht_get_net(dht), ip_port, data, 1 + CRYPTO_PUBLIC_KEY_SIZE)) {
             res = 1;
         }
     }
@@ -401,10 +400,10 @@ int lan_discovery_send(uint16_t port, 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 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, NULL, NULL);
 }
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index fcee455c..3cb0fbb6 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -2010,7 +2010,8 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
     }
 
     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) {
             kill_friend_connections(m->fr_c);
@@ -2571,8 +2572,8 @@ void do_messenger(Messenger *m, void *userdata)
         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 = NULL;
             uint32_t a;
 
             for (a = 0, assoc = &cptr->assoc4; a < 2; a++, assoc = &cptr->assoc6) {
@@ -2597,7 +2598,7 @@ void do_messenger(Messenger *m, void *userdata)
         uint32_t friend_idx, dhtfriend;
 
         /* dht contains additional "friends" (requests) */
-        uint32_t num_dhtfriends = m->dht->num_friends;
+        uint32_t num_dhtfriends = dht_get_num_friends(m->dht);
         VLA(int32_t, m2dht, num_dhtfriends);
         VLA(int32_t, dht2m, num_dhtfriends);
 
@@ -2609,8 +2610,8 @@ void do_messenger(Messenger *m, void *userdata)
                 continue;
             }
 
-            for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++) {
-                if (id_equal(m->friendlist[friend_idx].real_pk, m->dht->friends_list[dhtfriend].public_key)) {
+            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;
                 }
@@ -2623,8 +2624,8 @@ void do_messenger(Messenger *m, void *userdata)
             }
         }
 
-        if (m->numfriends != m->dht->num_friends) {
-            LOGGER_TRACE(m->log, "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;
@@ -2637,7 +2638,7 @@ void do_messenger(Messenger *m, void *userdata)
                 msgfptr = NULL;
             }
 
-            dhtfptr = &m->dht->friends_list[friend_idx];
+            dhtfptr = dht_get_friend(m->dht, friend_idx);
 
             if (msgfptr) {
                 char id_str[IDSTRING_LEN];
diff --git a/toxcore/group.c b/toxcore/group.c
index 30f241ad..543b1f0a 100644
--- a/toxcore/group.c
+++ b/toxcore/group.c
@@ -744,7 +744,7 @@ int add_groupchat(Group_Chats *g_c, uint8_t type)
     g->identifier[0] = type;
     g->peer_number = 0; /* Founder is peer 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, g_c->m->dht->self_public_key, 0, NULL, false);
+    int peer_index = addpeer(g_c, groupnumber, g->real_pk, dht_get_self_public_key(g_c->m->dht), 0, NULL, false);
 
     if (peer_index == -1) {
         return -1;
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 521dad2f..f03ddb87 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -223,7 +223,7 @@ static int create_cookie_request(const Net_Crypto *c, uint8_t *packet, uint8_t *
     uint8_t nonce[CRYPTO_NONCE_SIZE];
     random_nonce(nonce);
     packet[0] = NET_PACKET_COOKIE_REQUEST;
-    memcpy(packet + 1, c->dht->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
+    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_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE);
@@ -362,7 +362,7 @@ static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t
         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;
     }
 
@@ -662,7 +662,7 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t
         crypto_connection_status(c, crypt_connection_id, &direct_connected, NULL);
 
         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;
             }
@@ -676,7 +676,7 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t
 
         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();
             }
@@ -2941,7 +2941,7 @@ Net_Crypto *new_net_crypto(Logger *log, DHT *dht, TCP_Proxy_Info *proxy_info)
 
     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) {
         free(temp);
@@ -2965,10 +2965,10 @@ Net_Crypto *new_net_crypto(Logger *log, 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);
 
@@ -3039,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);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_COOKIE_REQUEST, NULL, NULL);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_COOKIE_RESPONSE, NULL, NULL);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_CRYPTO_HS, NULL, NULL);
+    networking_registerhandler(dht_get_net(c->dht), NET_PACKET_CRYPTO_DATA, NULL, NULL);
     crypto_memzero(c, sizeof(Net_Crypto));
     free(c);
 }
diff --git a/toxcore/onion.c b/toxcore/onion.c
index fbaf7205..2279d4e3 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -120,8 +120,8 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
         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_PUBLIC_KEY_SIZE);
+    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_PUBLIC_KEY_SIZE];
     uint8_t random_secret_key[CRYPTO_SECRET_KEY_SIZE];
@@ -338,7 +338,7 @@ static int handle_send_initial(void *object, IP_Port source, const uint8_t *pack
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
-    get_shared_key(&onion->shared_keys_1, shared_key, onion->dht->self_secret_key, packet + 1 + CRYPTO_NONCE_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);
 
@@ -407,7 +407,7 @@ static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, ui
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
-    get_shared_key(&onion->shared_keys_2, shared_key, onion->dht->self_secret_key, packet + 1 + CRYPTO_NONCE_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);
 
@@ -463,7 +463,7 @@ static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, ui
 
     uint8_t plain[ONION_MAX_PACKET_SIZE];
     uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
-    get_shared_key(&onion->shared_keys_3, shared_key, onion->dht->self_secret_key, packet + 1 + CRYPTO_NONCE_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);
 
@@ -646,7 +646,7 @@ Onion *new_onion(DHT *dht)
     }
 
     onion->dht = dht;
-    onion->net = dht->net;
+    onion->net = dht_get_net(dht);
     new_symmetric_key(onion->secret_symmetric_key);
     onion->timestamp = unix_time();
 
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index ab96a546..0ff22a3d 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -343,7 +343,7 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
     }
 
     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;
         }
     }
@@ -358,7 +358,7 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
     memcpy(onion_a->entries[pos].data_public_key, data_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     onion_a->entries[pos].time = unix_time();
 
-    sort_onion_announce_list(onion_a->entries, ONION_ANNOUNCE_MAX_ENTRIES, onion_a->dht->self_public_key);
+    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);
 }
 
@@ -372,7 +372,7 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
 
     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, onion_a->dht->self_secret_key, packet_public_key);
+    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_PUBLIC_KEY_SIZE + CRYPTO_PUBLIC_KEY_SIZE +
                   ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
@@ -504,7 +504,7 @@ Onion_Announce *new_onion_announce(DHT *dht)
     }
 
     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);
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index f7ff41bd..c652d7f3 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -1133,7 +1133,7 @@ static int send_dht_dhtpk(const Onion_Client *onion_c, int friend_num, const uin
     }
 
     uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
-    len = create_request(onion_c->dht->self_public_key, onion_c->dht->self_secret_key, packet,
+    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) {
@@ -1192,7 +1192,7 @@ static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8
     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_PUBLIC_KEY_SIZE);
+    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);
@@ -1864,7 +1864,7 @@ Onion_Client *new_onion_client(Net_Crypto *c)
     }
 
     onion_c->dht = nc_get_dht(c);
-    onion_c->net = onion_c->dht->net;
+    onion_c->net = dht_get_net(onion_c->dht);
     onion_c->c = c;
     new_symmetric_key(onion_c->secret_symmetric_key);
     crypto_new_keypair(onion_c->temp_public_key, onion_c->temp_secret_key);
diff --git a/toxcore/ping.c b/toxcore/ping.c
index f2f56013..1e5892eb 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -64,7 +64,7 @@ int32_t ping_send_request(Ping *ping, IP_Port ipp, const uint8_t *public_key)
     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;
     }
 
@@ -87,7 +87,7 @@ int32_t ping_send_request(Ping *ping, IP_Port ipp, const uint8_t *public_key)
     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
+    id_copy(pk + 1, dht_get_self_public_key(ping->dht));     // Our pubkey
     random_nonce(pk + 1 + CRYPTO_PUBLIC_KEY_SIZE); // Generate new nonce
 
 
@@ -100,7 +100,7 @@ int32_t ping_send_request(Ping *ping, IP_Port ipp, const uint8_t *public_key)
         return 1;
     }
 
-    return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
+    return sendpacket(dht_get_net(ping->dht), ipp, pk, sizeof(pk));
 }
 
 static int ping_send_response(Ping *ping, IP_Port ipp, const uint8_t *public_key, uint64_t ping_id,
@@ -109,7 +109,7 @@ static int ping_send_response(Ping *ping, IP_Port ipp, const uint8_t *public_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;
     }
 
@@ -118,7 +118,7 @@ static int ping_send_response(Ping *ping, IP_Port ipp, const uint8_t *public_key
     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
+    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
@@ -131,7 +131,7 @@ static int ping_send_response(Ping *ping, IP_Port ipp, const uint8_t *public_key
         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 *object, IP_Port source, const uint8_t *packet, uint16_t length, void *userdata)
@@ -143,9 +143,9 @@ static int handle_ping_request(void *object, IP_Port source, const uint8_t *pack
         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;
     }
 
@@ -186,9 +186,9 @@ static int handle_ping_response(void *object, IP_Port source, const uint8_t *pac
         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;
     }
 
@@ -284,7 +284,7 @@ int32_t ping_add(Ping *ping, const uint8_t *public_key, IP_Port 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;
     }
 
@@ -309,7 +309,7 @@ int32_t ping_add(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;
     }
 
@@ -367,16 +367,16 @@ Ping *ping_new(DHT *dht)
     }
 
     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 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);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_REQUEST, NULL, NULL);
+    networking_registerhandler(dht_get_net(ping->dht), NET_PACKET_PING_RESPONSE, NULL, NULL);
     ping_array_kill(ping->ping_array);
 
     free(ping);
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 2fd478dc..a1f850d1 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -1519,7 +1519,7 @@ 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_PUBLIC_KEY_SIZE);
+        memcpy(dht_id, dht_get_self_public_key(m->dht), CRYPTO_PUBLIC_KEY_SIZE);
     }
 }