6 files changed, 163 insertions, 162 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 12789098..e21ff824 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -65,21 +65,21 @@
 /* Number of get node requests to send to quickly find close nodes. */
 #define MAX_BOOTSTRAP_TIMES 10
 
-/* Compares client_id1 and client_id2 with client_id.
+/* Compares pk1 and pk2 with pk.
  *
  *  return 0 if both are same distance.
- *  return 1 if client_id1 is closer.
- *  return 2 if client_id2 is closer.
+ *  return 1 if pk1 is closer.
+ *  return 2 if pk2 is closer.
  */
-int id_closest(const uint8_t *id, const uint8_t *id1, const uint8_t *id2)
+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 < CLIENT_ID_SIZE; ++i) {
+    for (i = 0; i < crypto_box_PUBLICKEYBYTES; ++i) {
 
-        distance1 = id[i] ^ id1[i];
-        distance2 = id[i] ^ id2[i];
+        distance1 = pk[i] ^ pk1[i];
+        distance2 = pk[i] ^ pk2[i];
 
         if (distance1 < distance2)
             return 1;
@@ -97,15 +97,15 @@ int id_closest(const uint8_t *id, const uint8_t *id1, const uint8_t *id2)
  * If shared key is already in shared_keys, copy it to shared_key.
  * else generate it into shared_key and copy it to shared_keys
  */
-void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t *secret_key, const uint8_t *client_id)
+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;
 
     for (i = 0; i < MAX_KEYS_PER_SLOT; ++i) {
-        int index = client_id[30] * MAX_KEYS_PER_SLOT + i;
+        int index = public_key[30] * MAX_KEYS_PER_SLOT + i;
 
         if (shared_keys->keys[index].stored) {
-            if (memcmp(client_id, shared_keys->keys[index].client_id, CLIENT_ID_SIZE) == 0) {
+            if (memcmp(public_key, shared_keys->keys[index].public_key, crypto_box_PUBLICKEYBYTES) == 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();
@@ -129,31 +129,31 @@ void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t
         }
     }
 
-    encrypt_precompute(client_id, secret_key, shared_key);
+    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].client_id, client_id, CLIENT_ID_SIZE);
+        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();
     }
 }
 
-/* Copy shared_key to encrypt/decrypt DHT packet from client_id into shared_key
+/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
  * for packets that we receive.
  */
-void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *client_id)
+void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *public_key)
 {
-    get_shared_key(&dht->shared_keys_recv, shared_key, dht->self_secret_key, client_id);
+    get_shared_key(&dht->shared_keys_recv, shared_key, dht->self_secret_key, public_key);
 }
 
-/* Copy shared_key to encrypt/decrypt DHT packet from client_id into shared_key
+/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
  * for packets that we send.
  */
-void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *client_id)
+void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *public_key)
 {
-    get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, client_id);
+    get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, public_key);
 }
 
 void to_net_family(IP *ip)
@@ -333,21 +333,21 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
 
 
 
-/* Check if client with client_id is already in 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: Maybe optimize this.
  *
  *  return True(1) or False(0)
  */
-static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const uint8_t *client_id, IP_Port ip_port)
+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 client_id is in list, find it and maybe overwrite ip_port */
+    /* if public_key is in list, find it and maybe overwrite ip_port */
     for (i = 0; i < length; ++i)
-        if (id_equal(list[i].client_id, client_id)) {
+        if (id_equal(list[i].public_key, public_key)) {
             /* Refresh the client timestamp. */
             if (ip_port.ip.family == AF_INET) {
 
@@ -382,18 +382,18 @@ static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const u
             return 1;
         }
 
-    /* client_id not in list yet: see if we can find an identical ip_port, in
-     * that case we kill the old client_id by overwriting it with the new one
-     * TODO: maybe we SHOULDN'T do that if that client_id is in a friend_list
-     * and the one who is the actual friend's client_id/address set? */
+    /* 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].client_id, client_id, CLIENT_ID_SIZE);
+            memcpy(list[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
 
-            LOGGER_DEBUG("coipil[%u]: switching client_id (ipv4)", i);
+            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));
@@ -401,9 +401,9 @@ static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const u
         } 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].client_id, client_id, CLIENT_ID_SIZE);
+            memcpy(list[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
 
-            LOGGER_DEBUG("coipil[%u]: switching client_id (ipv6)", i);
+            LOGGER_DEBUG("coipil[%u]: switching public_key (ipv6)", i);
 
             /* kill the other address, if it was set */
             memset(&list[i].assoc4, 0, sizeof(list[i].assoc4));
@@ -414,7 +414,7 @@ static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const u
     return 0;
 }
 
-/* Check if client with client_id is already in node format list of length length.
+/* Check if client with public_key is already in node format list of length length.
  *
  *  return 1 if true.
  *  return 0 if false.
@@ -431,15 +431,15 @@ static int client_in_nodelist(const Node_format *list, uint16_t length, const ui
     return 0;
 }
 
-/*  return friend number from the client_id.
+/*  return friend number from the public_key.
  *  return -1 if a failure occurs.
  */
-static int friend_number(const DHT *dht, const uint8_t *client_id)
+static int friend_number(const DHT *dht, const uint8_t *public_key)
 {
     uint32_t i;
 
     for (i = 0; i < dht->num_friends; ++i) {
-        if (id_equal(dht->friends_list[i].client_id, client_id))
+        if (id_equal(dht->friends_list[i].public_key, public_key))
             return i;
     }
 
@@ -461,7 +461,7 @@ 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 *client_id, Node_format *nodes_list,
+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,
                                   uint32_t *num_nodes_ptr, uint8_t is_LAN, uint8_t want_good)
 {
@@ -476,7 +476,7 @@ static void get_close_nodes_inner(const uint8_t *client_id, Node_format *nodes_l
         const Client_data *client = &client_list[i];
 
         /* node already in list? */
-        if (client_in_nodelist(nodes_list, MAX_SENT_NODES, client->client_id))
+        if (client_in_nodelist(nodes_list, MAX_SENT_NODES, client->public_key))
             continue;
 
         const IPPTsPng *ipptp = NULL;
@@ -502,30 +502,30 @@ static void get_close_nodes_inner(const uint8_t *client_id, Node_format *nodes_l
             continue;
 
         if (LAN_ip(ipptp->ip_port.ip) != 0 && want_good && hardening_correct(&ipptp->hardening) != HARDENING_ALL_OK
-                && !id_equal(client_id, client->client_id))
+                && !id_equal(public_key, client->public_key))
             continue;
 
         if (num_nodes < MAX_SENT_NODES) {
             memcpy(nodes_list[num_nodes].public_key,
-                   client->client_id,
+                   client->public_key,
                    crypto_box_PUBLICKEYBYTES );
 
             nodes_list[num_nodes].ip_port = ipptp->ip_port;
             num_nodes++;
         } else {
-            /* see if node_list contains a client_id that's "further away"
+            /* see if node_list contains a public_key that's "further away"
              * compared to the one we're looking at at the moment, if there
              * is, replace it
              */
             for (j = 0; j < MAX_SENT_NODES; ++j) {
-                closest = id_closest(   client_id,
+                closest = id_closest(   public_key,
                                         nodes_list[j].public_key,
-                                        client->client_id );
+                                        client->public_key );
 
-                /* second client_id is closer than current: change to it */
+                /* second public_key is closer than current: change to it */
                 if (closest == 2) {
                     memcpy( nodes_list[j].public_key,
-                            client->client_id,
+                            client->public_key,
                             crypto_box_PUBLICKEYBYTES);
 
                     nodes_list[j].ip_port = ipptp->ip_port;
@@ -658,7 +658,7 @@ static int cmp_dht_entry(const void *a, const void *b)
             return 1;
     }
 
-    int close = id_closest(cmp_public_key, entry1.client_id, entry2.client_id);
+    int close = id_closest(cmp_public_key, entry1.public_key, entry2.public_key);
 
     if (close == 1)
         return 1;
@@ -669,15 +669,15 @@ static int cmp_dht_entry(const void *a, const void *b)
     return 0;
 }
 
-/* Is it ok to store node with client_id in client.
+/* Is it ok to store node with public_key in client.
  *
  * return 0 if node can't be stored.
  * return 1 if it can.
  */
-static unsigned int store_node_ok(const Client_data *client, const uint8_t *client_id, const uint8_t *comp_client_id)
+static unsigned int store_node_ok(const Client_data *client, const uint8_t *public_key, const uint8_t *comp_client_id)
 {
     if ((is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT))
-            || (id_closest(comp_client_id, client->client_id, client_id) == 2)) {
+            || (id_closest(comp_client_id, client->public_key, public_key) == 2)) {
         return 1;
     } else {
         return 0;
@@ -690,16 +690,16 @@ static unsigned int store_node_ok(const Client_data *client, const uint8_t *clie
  *  from the comp_client_id
  *  or replace a good node that is further
  *  than any other in the list from the comp_client_id
- *  and further than client_id.
+ *  and further than public_key.
  *
  * Do not replace any node if the list has no bad or possibly bad nodes
  *  and all nodes in the list are closer to comp_client_id
- *  than client_id.
+ *  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  *client_id,
+                          const uint8_t  *public_key,
                           IP_Port         ip_port,
                           const uint8_t  *comp_client_id )
 {
@@ -711,7 +711,7 @@ static int replace_all(   Client_data    *list,
 
     Client_data *client = &list[0];
 
-    if (store_node_ok(client, client_id, comp_client_id)) {
+    if (store_node_ok(client, public_key, comp_client_id)) {
         IPPTsPng *ipptp_write = NULL;
         IPPTsPng *ipptp_clear = NULL;
 
@@ -723,7 +723,7 @@ static int replace_all(   Client_data    *list,
             ipptp_clear = &client->assoc4;
         }
 
-        id_copy(client->client_id, client_id);
+        id_copy(client->public_key, public_key);
         ipptp_write->ip_port = ip_port;
         ipptp_write->timestamp = unix_time();
 
@@ -740,22 +740,22 @@ static int replace_all(   Client_data    *list,
     return 0;
 }
 
-/* Check if the node obtained with a get_nodes with client_id should be pinged.
+/* 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.
  */
-static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *client_id)
+static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_key)
 {
-    if (store_node_ok(&dht->close_clientlist[0], client_id, dht->self_public_key)) {
+    if (store_node_ok(&dht->close_clientlist[0], public_key, dht->self_public_key)) {
         return 1;
     }
 
     unsigned int i;
 
     for (i = 0; i < dht->num_friends; ++i) {
-        if (store_node_ok(&dht->friends_list[i].client_list[0], client_id, dht->self_public_key)) {
+        if (store_node_ok(&dht->friends_list[i].client_list[0], public_key, dht->self_public_key)) {
             return 1;
         }
     }
@@ -763,12 +763,12 @@ static unsigned int ping_node_from_getnodes_ok(DHT *dht, const uint8_t *client_i
     return 0;
 }
 
-/* Attempt to add client with ip_port and client_id to the friends client list
+/* Attempt to add client with ip_port and public_key to the friends client list
  * and close_clientlist.
  *
  *  returns 1+ if the item is used in any list, 0 else
  */
-int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
+int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key)
 {
     uint32_t i, used = 0;
 
@@ -781,8 +781,8 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
     /* 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, client_id, ip_port)) {
-        if (replace_all(dht->close_clientlist, LCLIENT_LIST, client_id, ip_port, dht->self_public_key))
+    if (!client_or_ip_port_in_list(dht->close_clientlist, LCLIENT_LIST, public_key, ip_port)) {
+        if (replace_all(dht->close_clientlist, LCLIENT_LIST, public_key, ip_port, dht->self_public_key))
             used++;
     } else
         used++;
@@ -791,13 +791,13 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
 
     for (i = 0; i < dht->num_friends; ++i) {
         if (!client_or_ip_port_in_list(dht->friends_list[i].client_list,
-                                       MAX_FRIEND_CLIENTS, client_id, ip_port)) {
+                                       MAX_FRIEND_CLIENTS, public_key, ip_port)) {
             if (replace_all(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
-                            client_id, ip_port, dht->friends_list[i].client_id)) {
+                            public_key, ip_port, dht->friends_list[i].public_key)) {
 
                 DHT_Friend *friend = &dht->friends_list[i];
 
-                if (memcmp(client_id, friend->client_id, CLIENT_ID_SIZE) == 0) {
+                if (memcmp(public_key, friend->public_key, CLIENT_ID_SIZE) == 0) {
                     friend_foundip = friend;
                 }
 
@@ -806,7 +806,7 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
         } else {
             DHT_Friend *friend = &dht->friends_list[i];
 
-            if (memcmp(client_id, friend->client_id, CLIENT_ID_SIZE) == 0) {
+            if (memcmp(public_key, friend->public_key, CLIENT_ID_SIZE) == 0) {
                 friend_foundip = friend;
             }
 
@@ -832,17 +832,17 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
         ippts.ip_port = ip_port;
         ippts.timestamp = unix_time();
 
-        Assoc_add_entry(dht->assoc, client_id, &ippts, NULL, used ? 1 : 0);
+        Assoc_add_entry(dht->assoc, public_key, &ippts, NULL, used ? 1 : 0);
     }
 
 #endif
     return used;
 }
 
-/* If client_id is a friend or us, update ret_ip_port
+/* If public_key is a friend or us, update ret_ip_port
  * nodeclient_id is the id of the node that sent us this info.
  */
-static int returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *client_id, const uint8_t *nodeclient_id)
+static int returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t *nodeclient_id)
 {
     uint32_t i, j;
     uint64_t temp_time = unix_time();
@@ -855,9 +855,9 @@ static int returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *client_id,
         ip_port.ip.ip4.uint32 = ip_port.ip.ip6.uint32[3];
     }
 
-    if (id_equal(client_id, dht->self_public_key)) {
+    if (id_equal(public_key, dht->self_public_key)) {
         for (i = 0; i < LCLIENT_LIST; ++i) {
-            if (id_equal(nodeclient_id, dht->close_clientlist[i].client_id)) {
+            if (id_equal(nodeclient_id, 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;
@@ -872,9 +872,9 @@ static int returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *client_id,
         }
     } else {
         for (i = 0; i < dht->num_friends; ++i) {
-            if (id_equal(client_id, dht->friends_list[i].client_id)) {
+            if (id_equal(public_key, dht->friends_list[i].public_key)) {
                 for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                    if (id_equal(nodeclient_id, dht->friends_list[i].client_list[j].client_id)) {
+                    if (id_equal(nodeclient_id, 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;
@@ -900,7 +900,7 @@ end:
         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, client_id, &ippts, NULL, used ? 1 : 0);
+        Assoc_add_entry(dht->assoc, public_key, &ippts, NULL, used ? 1 : 0);
     }
 
 #endif
@@ -1197,7 +1197,7 @@ int DHT_addfriend(DHT *dht, const uint8_t *client_id, void (*ip_callback)(void *
     dht->friends_list = temp;
     DHT_Friend *friend = &dht->friends_list[dht->num_friends];
     memset(friend, 0, sizeof(DHT_Friend));
-    memcpy(friend->client_id, client_id, CLIENT_ID_SIZE);
+    memcpy(friend->public_key, client_id, CLIENT_ID_SIZE);
 
     friend->nat.NATping_id = random_64b();
     ++dht->num_friends;
@@ -1291,7 +1291,7 @@ int DHT_delfriend(DHT *dht, const uint8_t *client_id, uint16_t lock_count)
 }
 
 /* TODO: Optimize this. */
-int DHT_getfriendip(const DHT *dht, const uint8_t *client_id, IP_Port *ip_port)
+int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port)
 {
     uint32_t i, j;
 
@@ -1300,11 +1300,11 @@ int DHT_getfriendip(const DHT *dht, const uint8_t *client_id, IP_Port *ip_port)
 
     for (i = 0; i < dht->num_friends; ++i) {
         /* Equal */
-        if (id_equal(dht->friends_list[i].client_id, client_id)) {
+        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->client_id, client_id)) {
+                if (id_equal(client->public_key, public_key)) {
                     IPPTsPng *assoc = NULL;
                     uint32_t a;
 
@@ -1324,7 +1324,7 @@ int DHT_getfriendip(const DHT *dht, const uint8_t *client_id, 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 *client_id,
+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)
 {
     uint32_t i;
@@ -1346,7 +1346,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co
                 not_kill++;
 
                 if (is_timeout(assoc->last_pinged, PING_INTERVAL)) {
-                    send_ping_request(dht->ping, assoc->ip_port, client->client_id );
+                    send_ping_request(dht->ping, assoc->ip_port, client->public_key );
                     assoc->last_pinged = temp_time;
                 }
 
@@ -1361,8 +1361,8 @@ 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;
-        getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->client_id,
-                 client_id, NULL);
+        getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->public_key,
+                 public_key, NULL);
         *lastgetnode = temp_time;
         ++*bootstrap_times;
     }
@@ -1378,7 +1378,7 @@ static void do_DHT_friends(DHT *dht)
     uint32_t i;
 
     for (i = 0; i < dht->num_friends; ++i)
-        do_ping_and_sendnode_requests(dht, &dht->friends_list[i].lastgetnode, dht->friends_list[i].client_id,
+        do_ping_and_sendnode_requests(dht, &dht->friends_list[i].lastgetnode, dht->friends_list[i].public_key,
                                       dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &dht->friends_list[i].bootstrap_times);
 }
 
@@ -1459,16 +1459,16 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
         return 0;
 }
 
-/* Send the given packet to node with client_id
+/* Send the given packet to node with public_key
  *
  *  return -1 if failure.
  */
-int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint16_t length)
+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) {
-        if (id_equal(client_id, dht->close_clientlist[i].client_id)) {
+        if (id_equal(public_key, dht->close_clientlist[i].public_key)) {
             const Client_data *client = &dht->close_clientlist[i];
 
             if (ip_isset(&client->assoc6.ip_port.ip))
@@ -1517,7 +1517,7 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
             ++num_ipv6s;
         }
 
-        if (id_equal(client->client_id, friend->client_id))
+        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))
                 return 0; /* direct connectivity */
     }
@@ -1792,7 +1792,7 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports,
         IP_Port pinging;
         ip_copy(&pinging.ip, &ip);
         pinging.port = htons(firstport);
-        send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].client_id);
+        send_ping_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. */
@@ -1800,7 +1800,7 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports,
             IP_Port pinging;
             ip_copy(&pinging.ip, &ip);
             pinging.port = htons(port);
-            send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].client_id);
+            send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
         }
 
         dht->friends_list[friend_num].nat.punching_index = i;
@@ -1814,7 +1814,7 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports,
 
         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].client_id);
+            send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].public_key);
         }
 
         dht->friends_list[friend_num].nat.punching_index2 = i - (MAX_PUNCHING_PORTS / 2);
@@ -1837,7 +1837,7 @@ static void do_NAT(DHT *dht)
             continue;
 
         if (dht->friends_list[i].nat.NATping_timestamp + PUNCH_INTERVAL < temp_time) {
-            send_NATping(dht, dht->friends_list[i].client_id, dht->friends_list[i].nat.NATping_id, NAT_PING_REQUEST);
+            send_NATping(dht, dht->friends_list[i].public_key, dht->friends_list[i].nat.NATping_id, NAT_PING_REQUEST);
             dht->friends_list[i].nat.NATping_timestamp = temp_time;
         }
 
@@ -1921,12 +1921,12 @@ static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto,
 }
 
 /* TODO: improve */
-static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *client_id, sa_family_t sa_family)
+static IPPTsPng *get_closelist_IPPTsPng(DHT *dht, const uint8_t *public_key, sa_family_t sa_family)
 {
     uint32_t i;
 
     for (i = 0; i < LCLIENT_LIST; ++i) {
-        if (memcmp(dht->close_clientlist[i].client_id, client_id, CLIENT_ID_SIZE) != 0)
+        if (memcmp(dht->close_clientlist[i].public_key, public_key, CLIENT_ID_SIZE) != 0)
             continue;
 
         if (sa_family == AF_INET)
@@ -2086,7 +2086,7 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
         }
 
         if (assoc != NULL) {
-            memcpy(nodes[count].public_key, list[i - 1].client_id, CLIENT_ID_SIZE);
+            memcpy(nodes[count].public_key, list[i - 1].public_key, CLIENT_ID_SIZE);
             nodes[count].ip_port = assoc->ip_port;
             ++count;
 
@@ -2105,7 +2105,7 @@ void do_hardening(DHT *dht)
     for (i = 0; i < LCLIENT_LIST * 2; ++i) {
         IPPTsPng  *cur_iptspng;
         sa_family_t sa_family;
-        uint8_t   *client_id = dht->close_clientlist[i / 2].client_id;
+        uint8_t   *public_key = dht->close_clientlist[i / 2].public_key;
 
         if (i % 2 == 0) {
             cur_iptspng = &dht->close_clientlist[i / 2].assoc4;
@@ -2125,12 +2125,12 @@ void do_hardening(DHT *dht)
                 if (!ipport_isset(&rand_node.ip_port))
                     continue;
 
-                if (id_equal(client_id, 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, client_id, crypto_box_PUBLICKEYBYTES);
+                memcpy(to_test.public_key, public_key, crypto_box_PUBLICKEYBYTES);
 
                 //TODO: The search id should maybe not be ours?
                 if (send_hardening_getnode_req(dht, &rand_node, &to_test, dht->self_public_key) > 0) {
@@ -2341,13 +2341,13 @@ void DHT_save(DHT *dht, uint8_t *data)
 
     for (num = 0, i = 0; i < LCLIENT_LIST; ++i) {
         if (dht->close_clientlist[i].assoc4.timestamp != 0) {
-            memcpy(clients[num].public_key, dht->close_clientlist[i].client_id, crypto_box_PUBLICKEYBYTES);
+            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, crypto_box_PUBLICKEYBYTES);
             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].client_id, crypto_box_PUBLICKEYBYTES);
+            memcpy(clients[num].public_key, dht->close_clientlist[i].public_key, crypto_box_PUBLICKEYBYTES);
             clients[num].ip_port = dht->close_clientlist[i].assoc6.ip_port;
             ++num;
         }
@@ -2358,13 +2358,13 @@ void DHT_save(DHT *dht, uint8_t *data)
 
         for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
             if (fr->client_list[j].assoc4.timestamp != 0) {
-                memcpy(clients[num].public_key, fr->client_list[j].client_id, crypto_box_PUBLICKEYBYTES);
+                memcpy(clients[num].public_key, fr->client_list[j].public_key, crypto_box_PUBLICKEYBYTES);
                 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].client_id, crypto_box_PUBLICKEYBYTES);
+                memcpy(clients[num].public_key, fr->client_list[j].public_key, crypto_box_PUBLICKEYBYTES);
                 clients[num].ip_port = fr->client_list[j].assoc6.ip_port;
                 ++num;
             }
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index 933bdcaf..a36ea252 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -104,7 +104,7 @@ typedef struct {
 } IPPTsPng;
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     IPPTsPng    assoc4;
     IPPTsPng    assoc6;
 } Client_data;
@@ -127,7 +127,7 @@ typedef struct {
 #define DHT_FRIEND_MAX_LOCKS 32
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     Client_data client_list[MAX_FRIEND_CLIENTS];
 
     /* Time at which the last get_nodes request was sent. */
@@ -182,7 +182,7 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
 #define KEYS_TIMEOUT 600
 typedef struct {
     struct {
-        uint8_t client_id[CLIENT_ID_SIZE];
+        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 */
@@ -241,22 +241,23 @@ typedef struct {
  * If shared key is already in shared_keys, copy it to shared_key.
  * else generate it into shared_key and copy it to shared_keys
  */
-void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t *secret_key, const uint8_t *client_id);
+void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t *secret_key,
+                    const uint8_t *public_key);
 
-/* Copy shared_key to encrypt/decrypt DHT packet from client_id into shared_key
+/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
  * for packets that we receive.
  */
-void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *client_id);
+void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *public_key);
 
-/* Copy shared_key to encrypt/decrypt DHT packet from client_id into shared_key
+/* Copy shared_key to encrypt/decrypt DHT packet from public_key into shared_key
  * for packets that we send.
  */
-void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *client_id);
+void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *public_key);
 
 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.
- * client_id must be CLIENT_ID_SIZE bytes long.
+ * public_key must be crypto_box_PUBLICKEYBYTES 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.
@@ -267,39 +268,39 @@ void DHT_getnodes(DHT *dht, const IP_Port *from_ipp, const uint8_t *from_id, con
  *  return 0 if success.
  *  return -1 if failure (friends list is full).
  */
-int DHT_addfriend(DHT *dht, const uint8_t *client_id, void (*ip_callback)(void *data, int32_t number, IP_Port),
+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);
 
 /* Delete a friend from the friends list.
- * client_id must be CLIENT_ID_SIZE bytes long.
+ * public_key must be crypto_box_PUBLICKEYBYTES bytes long.
  *
  *  return 0 if success.
- *  return -1 if failure (client_id not in friends list).
+ *  return -1 if failure (public_key not in friends list).
  */
-int DHT_delfriend(DHT *dht, const uint8_t *client_id, uint16_t lock_count);
+int DHT_delfriend(DHT *dht, const uint8_t *public_key, uint16_t lock_count);
 
 /* Get ip of friend.
- *  client_id must be CLIENT_ID_SIZE bytes long.
+ *  public_key must be crypto_box_PUBLICKEYBYTES bytes long.
  *  ip must be 4 bytes long.
  *  port must be 2 bytes long.
  *
- * int DHT_getfriendip(DHT *dht, uint8_t *client_id, IP_Port *ip_port);
+ * int DHT_getfriendip(DHT *dht, uint8_t *public_key, IP_Port *ip_port);
  *
- *  return -1, -- if client_id does NOT refer to a friend
- *  return  0, -- if client_id refers to a friend and we failed to find the friend (yet)
- *  return  1, ip if client_id refers to a friend and we found him
+ *  return -1, -- if public_key does NOT refer to a friend
+ *  return  0, -- if public_key refers to a friend and we failed to find the friend (yet)
+ *  return  1, ip if public_key refers to a friend and we found him
  */
-int DHT_getfriendip(const DHT *dht, const uint8_t *client_id, IP_Port *ip_port);
+int DHT_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port);
 
-/* Compares client_id1 and client_id2 with client_id.
+/* Compares pk1 and pk2 with pk.
  *
  *  return 0 if both are same distance.
- *  return 1 if client_id1 is closer.
- *  return 2 if client_id2 is closer.
+ *  return 1 if pk1 is closer.
+ *  return 2 if pk2 is closer.
  */
-int id_closest(const uint8_t *id, const uint8_t *id1, const uint8_t *id2);
+int id_closest(const uint8_t *pk, const uint8_t *pk1, const uint8_t *pk2);
 
-/* Get the (maximum MAX_SENT_NODES) closest nodes to client_id we know
+/* 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)?
@@ -309,7 +310,7 @@ int id_closest(const uint8_t *id, const uint8_t *id1, const uint8_t *id2);
  * return the number of nodes returned.
  *
  */
-int get_close_nodes(const DHT *dht, const uint8_t *client_id, 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, sa_family_t sa_family,
                     uint8_t is_LAN, uint8_t want_good);
 
 
@@ -352,11 +353,11 @@ int DHT_connect_after_load(DHT *dht);
 
 /* ROUTING FUNCTIONS */
 
-/* Send the given packet to node with client_id.
+/* Send the given packet to node with public_key.
  *
  *  return -1 if failure.
  */
-int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint16_t length);
+int route_packet(const DHT *dht, const uint8_t *public_key, const uint8_t *packet, uint16_t length);
 
 /* Send the following packet to everyone who tells us they are connected to friend_id.
  *
@@ -399,7 +400,7 @@ int DHT_isconnected(const DHT *dht);
 int DHT_non_lan_connected(const DHT *dht);
 
 
-int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id);
+int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
 
 #endif
 
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 166e44f4..16e03cbc 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -2340,7 +2340,7 @@ void do_messenger(Messenger *m)
 
                     LOGGER_TRACE("C[%2u] %s:%u [%3u] %s",
                                  client, ip_ntoa(&assoc->ip_port.ip), ntohs(assoc->ip_port.port),
-                                 last_pinged, ID2String(cptr->client_id));
+                                 last_pinged, ID2String(cptr->public_key));
                 }
         }
 
@@ -2360,7 +2360,7 @@ void do_messenger(Messenger *m)
                 continue;
 
             for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++)
-                if (id_equal(m->friendlist[friend].real_pk, m->dht->friends_list[dhtfriend].client_id)) {
+                if (id_equal(m->friendlist[friend].real_pk, m->dht->friends_list[dhtfriend].public_key)) {
                     m2dht[friend] = dhtfriend;
                     break;
                 }
@@ -2390,7 +2390,7 @@ void do_messenger(Messenger *m)
                              dht2m[friend], friend, msgfptr->name,
                              ID2String(msgfptr->real_pk));
             } else {
-                LOGGER_TRACE("F[--:%2u] %s", friend, ID2String(dhtfptr->client_id));
+                LOGGER_TRACE("F[--:%2u] %s", friend, ID2String(dhtfptr->public_key));
             }
 
             for (client = 0; client < MAX_FRIEND_CLIENTS; client++) {
@@ -2408,7 +2408,7 @@ void do_messenger(Messenger *m)
                         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->client_id));
+                                     ID2String(cptr->public_key));
                     }
             }
         }
diff --git a/toxcore/assoc.c b/toxcore/assoc.c
index 2e03dabe..553f4339 100644
--- a/toxcore/assoc.c
+++ b/toxcore/assoc.c
@@ -157,13 +157,13 @@ static Client_entry *dist_index_entry(Assoc *assoc, uint64_t dist_ind)
     return NULL;
 }
 
-/* get actual entry's client_id to a distance_index */
+/* 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.client_id;
+        return entry->client.public_key;
 
     return NULL;
 }
@@ -356,7 +356,7 @@ static uint8_t candidates_search(const Assoc *assoc, const uint8_t *id, hash_t h
         Client_entry *entry = &cnd_bckt->list[pos];
 
         if (entry->hash == hash)
-            if (id_equal(entry->client.client_id, id)) {
+            if (id_equal(entry->client.public_key, id)) {
                 *entryptr = entry;
                 return 1;
             }
@@ -476,7 +476,7 @@ static uint8_t candidates_create_new(const Assoc *assoc, hash_t hash, const uint
         return 0;
 
     entry->hash = hash;
-    id_copy(entry->client.client_id, id);
+    id_copy(entry->client.public_key, id);
 
     if (used)
         entry->used_at = unix_time();
@@ -536,7 +536,7 @@ static void client_id_self_update(Assoc *assoc)
         Client_entry *entry = &cnd_bckt->list[pos];
 
         if (entry->hash == assoc->self_hash)
-            if (id_equal(entry->client.client_id, assoc->self_client_id))
+            if (id_equal(entry->client.public_key, assoc->self_client_id))
                 entry->hash = 0;
     }
 }
@@ -648,7 +648,7 @@ uint8_t Assoc_get_close_entries(Assoc *assoc, Assoc_close_entries *state)
                             continue;
                 }
 
-                uint64_t dist = state->distance_absolute_func(assoc, state->custom_data, state->wanted_id, entry->client.client_id);
+                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;
             }
@@ -914,7 +914,7 @@ void do_Assoc(Assoc *assoc, DHT *dht)
                         continue;
 
                     if (!target_id)
-                        target_id = entry->client.client_id;
+                        target_id = entry->client.public_key;
 
                     if (entry->seen_at) {
                         if (!seen)
@@ -940,9 +940,9 @@ void do_Assoc(Assoc *assoc, DHT *dht)
             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.client_id, 8), ip_ntoa(&ippts->ip_port.ip), htons(ippts->ip_port.port));
+                         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.client_id, target_id);
+            DHT_getnodes(dht, &ippts->ip_port, seen->client.public_key, target_id);
             seen->getnodes = unix_time();
         }
 
@@ -950,9 +950,9 @@ void do_Assoc(Assoc *assoc, DHT *dht)
             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.client_id, 8), ip_ntoa(&ipp->ip), htons(ipp->port));
+                         idpart2str(heard->client.public_key, 8), ip_ntoa(&ipp->ip), htons(ipp->port));
 
-            DHT_getnodes(dht, ipp, heard->client.client_id, target_id);
+            DHT_getnodes(dht, ipp, heard->client.public_key, target_id);
             heard->getnodes = unix_time();
         }
 
@@ -1012,7 +1012,7 @@ void Assoc_status(const Assoc *assoc)
                 total++;
 
                 LOGGER_TRACE("[%3i:%3i] %08x => [%s...] %i, %i(%c), %i(%c)\n",
-                             (int)bid, (int)cid, entry->hash, idpart2str(entry->client.client_id, 8),
+                             (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' : '?')) : '?',
diff --git a/toxcore/ping.c b/toxcore/ping.c
index 2decca0a..543ceec5 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -58,22 +58,22 @@ struct PING {
 #define DHT_PING_SIZE (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + PING_PLAIN_SIZE + crypto_box_MACBYTES)
 #define PING_DATA_SIZE (CLIENT_ID_SIZE + sizeof(IP_Port))
 
-int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *client_id)
+int send_ping_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(client_id, ping->dht->self_public_key))
+    if (id_equal(public_key, ping->dht->self_public_key))
         return 1;
 
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
 
     // generate key to encrypt ping_id with recipient privkey
-    DHT_get_shared_key_sent(ping->dht, shared_key, client_id);
+    DHT_get_shared_key_sent(ping->dht, shared_key, public_key);
     // Generate random ping_id.
     uint8_t data[PING_DATA_SIZE];
-    id_copy(data, client_id);
+    id_copy(data, public_key);
     memcpy(data + CLIENT_ID_SIZE, &ipp, sizeof(IP_Port));
     ping_id = ping_array_add(&ping->ping_array, data, sizeof(data));
 
@@ -100,13 +100,13 @@ int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *client_id)
     return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
 }
 
-static int send_ping_response(PING *ping, IP_Port ipp, const uint8_t *client_id, uint64_t ping_id,
+static int send_ping_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(client_id, ping->dht->self_public_key))
+    if (id_equal(public_key, ping->dht->self_public_key))
         return 1;
 
     uint8_t ping_plain[PING_PLAIN_SIZE];
@@ -220,17 +220,17 @@ static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packe
     return 0;
 }
 
-/* Check if client_id with ip_port is in the list.
+/* Check if public_key with ip_port is in the list.
  *
  * return 1 if it is.
  * return 0 if it isn't.
  */
-static int in_list(const Client_data *list, uint16_t length, const uint8_t *client_id, IP_Port ip_port)
+static int in_list(const Client_data *list, uint16_t length, const uint8_t *public_key, IP_Port ip_port)
 {
     uint32_t i;
 
     for (i = 0; i < length; ++i) {
-        if (id_equal(list[i].client_id, client_id)) {
+        if (id_equal(list[i].public_key, public_key)) {
             const IPPTsPng *ipptp;
 
             if (ip_port.ip.family == AF_INET) {
@@ -250,31 +250,31 @@ static int in_list(const Client_data *list, uint16_t length, const uint8_t *clie
 /* Add nodes to the to_ping list.
  * All nodes in this list are pinged every TIME_TO_PING seconds
  * and are then removed from the list.
- * If the list is full the nodes farthest from our client_id are replaced.
+ * 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.
  */
-int add_to_ping(PING *ping, const uint8_t *client_id, IP_Port ip_port)
+int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port)
 {
     if (!ip_isset(&ip_port.ip))
         return -1;
 
-    if (in_list(ping->dht->close_clientlist, LCLIENT_LIST, client_id, ip_port))
+    if (in_list(ping->dht->close_clientlist, LCLIENT_LIST, public_key, ip_port))
         return -1;
 
     uint32_t i;
 
     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, client_id, CLIENT_ID_SIZE);
+            memcpy(ping->to_ping[i].public_key, public_key, CLIENT_ID_SIZE);
             ipport_copy(&ping->to_ping[i].ip_port, &ip_port);
             return 0;
         }
 
-        if (memcmp(ping->to_ping[i].public_key, client_id, CLIENT_ID_SIZE) == 0) {
+        if (memcmp(ping->to_ping[i].public_key, public_key, CLIENT_ID_SIZE) == 0) {
             return -1;
         }
     }
@@ -282,8 +282,8 @@ int add_to_ping(PING *ping, const uint8_t *client_id, IP_Port ip_port)
     uint32_t r = rand();
 
     for (i = 0; i < MAX_TO_PING; ++i) {
-        if (id_closest(ping->dht->self_public_key, ping->to_ping[(i + r) % MAX_TO_PING].public_key, client_id) == 2) {
-            memcpy(ping->to_ping[(i + r) % MAX_TO_PING].public_key, client_id, CLIENT_ID_SIZE);
+        if (id_closest(ping->dht->self_public_key, ping->to_ping[(i + r) % MAX_TO_PING].public_key, public_key) == 2) {
+            memcpy(ping->to_ping[(i + r) % MAX_TO_PING].public_key, public_key, CLIENT_ID_SIZE);
             ipport_copy(&ping->to_ping[(i + r) % MAX_TO_PING].ip_port, &ip_port);
             return 0;
         }
diff --git a/toxcore/ping.h b/toxcore/ping.h
index c19c912a..904ad844 100644
--- a/toxcore/ping.h
+++ b/toxcore/ping.h
@@ -29,19 +29,19 @@ typedef struct PING PING;
 /* 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 client_id are replaced.
+ * 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.
  */
-int add_to_ping(PING *ping, const uint8_t *client_id, IP_Port ip_port);
+int add_to_ping(PING *ping, const uint8_t *public_key, IP_Port ip_port);
 void do_to_ping(PING *ping);
 
 PING *new_ping(DHT *dht);
 void kill_ping(PING *ping);
 
-int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *client_id);
+int send_ping_request(PING *ping, IP_Port ipp, const uint8_t *public_key);
 
 #endif /* __PING_H__ */