50 files changed, 1345 insertions, 1703 deletions

diff --git a/.gitignore b/.gitignore
index 4397a1c1..4d92363b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,3 +71,6 @@ toxcore-android-*
 
 # cscope files list
 cscope.files
+
+# rpm
+tox.spec
diff --git a/.travis.yml b/.travis.yml
index 304c52e5..c90a92f2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,7 +7,7 @@ before_script:
   #installing libsodium, needed for Core
   - git clone git://github.com/jedisct1/libsodium.git > /dev/null
   - cd libsodium
-  - git checkout tags/0.7.0 > /dev/null
+  - git checkout tags/1.0.0 > /dev/null
   - ./autogen.sh > /dev/null
   - ./configure > /dev/null
   - make check -j3 > /dev/null
diff --git a/INSTALL.md b/INSTALL.md
index 22865264..c2a8c0d9 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -105,6 +105,8 @@ sudo make install
 You need the latest XCode with the Developer Tools (Preferences -> Downloads -> Command Line Tools).
 The following libraries are required along with libsodium and cmake for Mountain Lion and XCode 4.6.3 install libtool, automake and autoconf. You can download them with Homebrew, or install them manually.
 
+**Note: OS X users can also install Toxcore using [osx_build_script_toxcore.sh](other/osx_build_script_toxcore.sh)**
+
 There are no binaries/executables going to /bin/ or /usr/bin/ now. Everything is compiled and ran from the inside your local branch. See [Usage](#usage) below.
 <a name="homebrew" />
 ####Homebrew:
diff --git a/Makefile.am b/Makefile.am
index 6b28280e..995620ef 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -11,7 +11,9 @@ CLEANFILES = $(top_builddir)/libtoxcore.pc
 
 
 EXTRA_DIST = \
+        README.md \
         libtoxcore.pc.in \
+        tox.spec \
         dist-build/android-arm.sh \
         dist-build/android-armv7.sh \
         dist-build/android-x86.sh \
diff --git a/README.md b/README.md
index e48d7ddb..2a7945f9 100644
--- a/README.md
+++ b/README.md
@@ -3,9 +3,8 @@
 
 With the rise of governmental monitoring programs, Tox, a FOSS initiative, aims to be an easy to use, all-in-one communication platform that ensures their users full privacy and secure message delivery.<br /> <br />
 
-[**Website**](https://tox.im) **|** [**Download**](https://wiki.tox.im/Binaries) **|** [**Wiki**](https://wiki.tox.im/) **|** [**Blog**](https://blog.libtoxcore.so/) **|** [**FAQ**](https://wiki.tox.im/FAQ) **|** [**Binaries**](https://wiki.tox.im/Binaries) **|** [**Clients**](https://wiki.tox.im/Client) **|** [**Compiling**](/INSTALL.md) **|** 
-[**API**](https://libtoxcore.so/)  **|** [**bugs**](http://tox.lighthouseapp.com/projects/123754-tox/tickets) **|** [**help and suggestions**](http://support.libtoxcore.so) **|**
-**IRC:** #tox@freenode
+[**Website**](https://tox.im) **|** [**Wiki**](https://wiki.tox.im/) **|** [**Blog**](https://blog.tox.im/) **|** [**FAQ**](https://wiki.tox.im/FAQ) **|** [**Binaries/Downloads**](https://wiki.tox.im/Binaries) **|** [**Clients**](https://wiki.tox.im/Client) **|** [**Compiling**](/INSTALL.md) **|** 
+[**API**](https://libtoxcore.so/)  **|** [**Bugs**](http://tox.lighthouseapp.com/) **|** [**Help and Suggestions**](http://support.libtoxcore.so) **|** **IRC Channel:** [#tox@freenode](https://webchat.freenode.net/?channels=tox)
 
 
 ## The Complex Stuff:
@@ -38,6 +37,7 @@ The goal of this project is to create a configuration-free P2P Skype replacement
 - [Compiling](/INSTALL.md)
 - [DHT Protocol](/docs/updates/DHT.md)<br />
 - [Crypto](/docs/updates/Crypto.md)<br />
-- [Ideas](https://wiki.tox.im/index.php/Ideas)
+
+Additional developer documentation can be found at [Libtoxcore.so](https://libtoxcore.so/)
 
 [String]: https://en.wikipedia.org/wiki/String_(computer_science)
diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index 566013d7..e222cf01 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -118,6 +118,7 @@ START_TEST(test_basic)
     ck_assert_msg(packet_resp_plain[0] == 1, "wrong packet id %u", packet_resp_plain[0]);
     ck_assert_msg(packet_resp_plain[1] == 0, "connection not refused %u", packet_resp_plain[1]);
     ck_assert_msg(memcmp(packet_resp_plain + 2, f_public_key, crypto_box_PUBLICKEYBYTES) == 0, "key in packet wrong");
+    kill_TCP_server(tcp_s);
 }
 END_TEST
 
@@ -175,6 +176,12 @@ struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
     return sec_c;
 }
 
+void kill_TCP_con(struct sec_TCP_con *con)
+{
+    kill_sock(con->sock);
+    free(con);
+}
+
 int write_packet_TCP_secure_connection(struct sec_TCP_con *con, uint8_t *data, uint16_t length)
 {
     uint8_t packet[sizeof(uint16_t) + length + crypto_box_MACBYTES];
@@ -290,6 +297,10 @@ START_TEST(test_some)
     ck_assert_msg(len == sizeof(ping_packet), "wrong len %u", len);
     ck_assert_msg(data[0] == 5, "wrong packet id %u", data[0]);
     ck_assert_msg(memcmp(ping_packet + 1, data + 1, sizeof(uint64_t)) == 0, "wrong packet data");
+    kill_TCP_server(tcp_s);
+    kill_TCP_con(con1);
+    kill_TCP_con(con2);
+    kill_TCP_con(con3);
 }
 END_TEST
 
@@ -457,6 +468,9 @@ START_TEST(test_client)
     do_TCP_connection(conn2);
     ck_assert_msg(status_callback_good == 1, "status callback not called");
     ck_assert_msg(status_callback_status == 1, "wrong status");
+    kill_TCP_server(tcp_s);
+    kill_TCP_connection(conn);
+    kill_TCP_connection(conn2);
 }
 END_TEST
 
@@ -488,6 +502,8 @@ START_TEST(test_client_invalid)
     do_TCP_connection(conn);
     ck_assert_msg(conn->status == TCP_CLIENT_DISCONNECTED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_DISCONNECTED,
                   conn->status);
+
+    kill_TCP_connection(conn);
 }
 END_TEST
 
diff --git a/auto_tests/assoc_test.c b/auto_tests/assoc_test.c
index b377cadf..bcf5d3fa 100644
--- a/auto_tests/assoc_test.c
+++ b/auto_tests/assoc_test.c
@@ -55,6 +55,7 @@ START_TEST(test_basics)
 
     uint8_t found = Assoc_get_close_entries(assoc, &close_entries);
     ck_assert_msg(found == 1, "get_close_entries(): expected %u, got %u", 1, found);
+    kill_Assoc(assoc);
 }
 END_TEST
 
@@ -130,6 +131,7 @@ START_TEST(test_fillup)
 
     ck_assert_msg(good == 8, "Entries found were not the closest ones. Only %u/8 were.", good);
     //printf("good: %u %u %u\n", good, a, ((uint32_t)current_time() - a));
+    kill_Assoc(assoc);
 }
 END_TEST
 
diff --git a/auto_tests/encryptsave_test.c b/auto_tests/encryptsave_test.c
index aa5bef3f..338c9ef1 100644
--- a/auto_tests/encryptsave_test.c
+++ b/auto_tests/encryptsave_test.c
@@ -114,6 +114,12 @@ START_TEST(test_save_friend)
     test = tox_get_client_id(tox4, 0, address5);
     ck_assert_msg(test == 0, "no friends! the third");
     ck_assert_msg(memcmp(address, address2, TOX_CLIENT_ID_SIZE) == 0, "addresses don't match! the third");
+
+    tox_kill(tox1);
+    tox_kill(tox2);
+    tox_kill(tox3);
+    tox_kill(tox4);
+    tox_kill(tox5);
 }
 END_TEST
 
@@ -160,8 +166,8 @@ Suite *encryptsave_suite(void)
     Suite *s = suite_create("encryptsave");
 
     DEFTESTCASE_SLOW(known_kdf, 60); /* is 5-10 seconds on my computer, but is directly dependent on CPU */
-    DEFTESTCASE(save_friend);
-    DEFTESTCASE(keys);
+    DEFTESTCASE_SLOW(save_friend, 20);
+    DEFTESTCASE_SLOW(keys, 30);
 
     return s;
 }
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 8e10eb11..f27fefb8 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -138,12 +138,12 @@ START_TEST(test_basic)
 
     IP_Port on1 = {ip, onion1->net->port};
     Node_format n1;
-    memcpy(n1.client_id, onion1->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(n1.public_key, onion1->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
     n1.ip_port = on1;
 
     IP_Port on2 = {ip, onion2->net->port};
     Node_format n2;
-    memcpy(n2.client_id, onion2->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(n2.public_key, onion2->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
     n2.ip_port = on2;
 
     Node_format nodes[4];
@@ -180,7 +180,7 @@ START_TEST(test_basic)
     randombytes(sb_data, sizeof(sb_data));
     uint64_t s;
     memcpy(&s, sb_data, sizeof(uint64_t));
-    memcpy(test_3_pub_key, nodes[3].client_id, crypto_box_PUBLICKEYBYTES);
+    memcpy(test_3_pub_key, nodes[3].public_key, crypto_box_PUBLICKEYBYTES);
     ret = send_announce_request(onion1->net, &path, nodes[3], onion1->dht->self_public_key,
                                 onion1->dht->self_secret_key,
                                 zeroes, onion1->dht->self_public_key, onion1->dht->self_public_key, s);
@@ -224,6 +224,39 @@ START_TEST(test_basic)
         do_onion(onion2);
         c_sleep(50);
     }
+
+    kill_onion_announce(onion1_a);
+    kill_onion_announce(onion2_a);
+
+    {
+        Onion *onion = onion1;
+
+        Networking_Core *net = onion->dht->net;
+        DHT *dht = onion->dht;
+        kill_onion(onion);
+        kill_DHT(dht);
+        kill_networking(net);
+    }
+
+    {
+        Onion *onion = onion2;
+
+        Networking_Core *net = onion->dht->net;
+        DHT *dht = onion->dht;
+        kill_onion(onion);
+        kill_DHT(dht);
+        kill_networking(net);
+    }
+
+    {
+        Onion *onion = onion3;
+
+        Networking_Core *net = onion->dht->net;
+        DHT *dht = onion->dht;
+        kill_onion(onion);
+        kill_DHT(dht);
+        kill_networking(net);
+    }
 }
 END_TEST
 
@@ -257,6 +290,18 @@ void do_onions(Onions *on)
     do_onion_client(on->onion_c);
 }
 
+void kill_onions(Onions *on)
+{
+    Networking_Core *net = on->onion->dht->net;
+    DHT *dht = on->onion->dht;
+    kill_onion_client(on->onion_c);
+    kill_onion_announce(on->onion_a);
+    kill_onion(on->onion);
+    kill_DHT(dht);
+    kill_networking(net);
+    free(on);
+}
+
 #define NUM_ONIONS 50
 
 START_TEST(test_announce)
@@ -334,6 +379,10 @@ START_TEST(test_announce)
     }
 
     ck_assert_msg(ip_port.port == onions[7]->onion->net->port, "Port in returned ip not correct.");
+
+    for (i = 0; i < NUM_ONIONS; ++i) {
+        kill_onions(onions[i]);
+    }
 }
 END_TEST
 
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index db1db3fb..3139c844 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -595,8 +595,12 @@ START_TEST(test_AV_flows)
         printf("\n");
     }
 
-
-
+    vpx_img_free(sample_image);
+    toxav_kill(status_control.Alice.av);
+    toxav_kill(status_control.Bob.av);
+    tox_kill(bootstrap_node);
+    tox_kill(Alice);
+    tox_kill(Bob);
 
     printf("Calls ended!\n");
 }
diff --git a/configure.ac b/configure.ac
index 3a45b35d..e43e8f78 100644
--- a/configure.ac
+++ b/configure.ac
@@ -6,7 +6,7 @@ AC_INIT([tox], [0.0.0], [https://tox.im])
 AC_CONFIG_AUX_DIR(configure_aux)
 AC_CONFIG_SRCDIR([toxcore/net_crypto.c])
 AC_CONFIG_HEADERS([config.h])
-AM_INIT_AUTOMAKE([1.10 -Wall subdir-objects])
+AM_INIT_AUTOMAKE([1.10 -Wall subdir-objects tar-ustar])
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 AC_CONFIG_MACRO_DIR([m4])
 
@@ -693,6 +693,7 @@ AM_CONDITIONAL(WIN32, test "x$WIN32" = "xyes")
 AC_CONFIG_FILES([Makefile
                  build/Makefile
                  libtoxcore.pc
+                 tox.spec
                 ])
 
 AM_COND_IF(BUILD_AV,
diff --git a/docs/Avatars.md b/docs/Avatars.md
index 1dcbba96..9dd43079 100644
--- a/docs/Avatars.md
+++ b/docs/Avatars.md
@@ -11,8 +11,8 @@ way for one user to identify another in the friend list.
 This document describes the implementation of avatars in the Tox protocol,
 according to the following design considerations:
 
-  - Avatars are handled as private information, i.e., they are only exchanged over
-    Tox encrypted channels among previously authenticated friends;
+  - Avatars are handled as private information, i.e., they are only exchanged
+    over Tox encrypted channels among previously authenticated friends.
 
   - The library treats all images as blobs and does not interpret or
     understand image formats. It only ensures that the avatar data sent by
@@ -33,7 +33,7 @@ according to the following design considerations:
   - The protocol MUST provide means to allow caching and avoid unnecessary
     data transfers.
 
-  - Avatars are transfered between clients in a background operation.
+  - Avatars are transferred between clients in a background operation.
 
   - Avatars are served on a "best effort" basis, without breaking clients
     which do not support them.
@@ -76,7 +76,7 @@ protocol. Moving this feature to the core protocol also:
 This is a very high level description. The usage patterns expected from
 client applications are described in the section "Using Avatars in Client
 Applications", and a low level protocol description is available in the
-section "Internal Protocol Description".)
+section "Internal Protocol Description").
 The avatar exchange is implemented with the following new elements in the
 Tox protocol:
 
@@ -84,15 +84,16 @@ Tox protocol:
     a user to another anytime, but are usually sent after one of them
     connects to the network, changes his avatar, or in reply to an **avatar
     information request**. They are delivered by a very lightweight message
-    but with information enough to allow a user to validate or discard an
-    avatar from the local cache and to decide if it is interesting to request the
-    avatar data from the peer.
+    but with enough information to allow a user to validate or discard an
+    avatar from the local cache and to decide if it is interesting to request
+    the avatar data from the peer.
 
     This event contains two data fields: (1) the image format, and (2) the
-    cryptographic hash of the actual image data. The image format may be NONE
-    (for users who have no avatar or removed their avatars) or PNG. The
+    cryptographic hash of the current image data. The image format may be
+    NONE (for users who have no avatar or removed their avatars) or PNG. The
     cryptographic hash is intended to be compared with the hash of the
-    currently cached avatar (if any) in order to check if it is still up to date.
+    currently cached avatar (if any) in order to check if it is still up to
+    date.
 
   - **Avatar Information Requests** are very lightweight messages sent by a
     user asking for an **avatar information notification**. They may be sent
@@ -114,7 +115,7 @@ Tox protocol:
 
     This event contains three data fields: (1) the image format, (2) the
     cryptographic hash of the image data, and (3) the raw image data. If the
-    image format is NONE (i.e. no avatar) the hash is zeroed and the image
+    image format is NONE (i.e. no avatar), the hash is zeroed and the image
     data is empty. The raw image data is locally validated and ensured to
     match the hash (the event is **not** triggered otherwise).
 
@@ -145,10 +146,13 @@ TOX_AVATAR_FORMAT;
 /* Set the user avatar image data. */
 int tox_set_avatar(Tox *tox, uint8_t format, const uint8_t *data, uint32_t length);
 
+/* Remove the user avatar image data. */
+int tox_unset_avatar(Tox *tox);
+
 /* Get avatar data from the current user. */
 int tox_get_self_avatar(const Tox *tox, uint8_t *format, uint8_t *buf, uint32_t *length, uint32_t maxlen, uint8_t *hash);
 
-/* Generates a cryptographic hash of the given data (usually a cached avatar). */
+/* Generate a cryptographic hash of the given data (usually a cached avatar). */
 int tox_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen);
 
 /* Request avatar information from a friend. */
@@ -177,17 +181,17 @@ void tox_callback_avatar_data(Tox *tox, void (*function)(Tox *tox, int32_t, uint
 
   - Clients MUST NOT imply the availability of avatars in other users.
     Avatars are an optional feature and not all users and clients may
-    support them;
+    support them.
 
   - Clients MUST NOT block waiting for avatar information and avatar data
-    packets;
+    packets.
 
-  - Clients MUST treat avatar data as insecure and potentially malicious;
+  - Clients MUST treat avatar data as insecure and potentially malicious.
     For example, users may accidentally use corrupted images as avatars,
-    a malicious user may send a specially crafted image to exploit a know
+    a malicious user may send a specially crafted image to exploit a known
     vulnerability in an image decoding library, etc. It is recommended to
     handle the avatar image data in the same way as an image downloaded
-    from an unknown Internet source;
+    from an unknown Internet source.
 
   - The peers MUST NOT assume any coupling between the operations of
     receiving an avatar information packet, sending unrequested avatar
@@ -196,31 +200,36 @@ void tox_callback_avatar_data(Tox *tox, void (*function)(Tox *tox, int32_t, uint
     For example, the following situations are valid:
 
       * A text-mode client may send avatars to other users, but never
-        request them;
+        request them.
 
       * A client may not understand a particular image format and ignore
-        avatars using it, but request and handle other formats;
+        avatars using it, but request and handle other formats.
+
+      * A client on a slow mobile network may ask for avatar information to
+        ensure its cached avatars are still valid, but not request avatar
+        data. The same client may start asking for avatar data once it
+        connects through a fast network.
 
-  - Clients SHOULD implement a local cache of avatars and do not request
-    avatar data from other peers unless necessary;
+  - Clients SHOULD implement a local cache of avatars and not request
+    avatar data from other peers unless necessary.
 
-  - When an avatar information is received, the client should delete the
+  - When avatar information is received, the client should delete the
     avatar if the new avatar format is NONE or compare the hash received
     from the peer with the hash of the currently cached avatar. If they
-    differ, send an avatar data request;
+    differ, send an avatar data request.
 
   - If the cached avatar is older than a given threshold, the client may
     also send an avatar info request to that friend once he is online and
     mark the avatar as updated *before* any avatar information is received
-    (to not spam the peer with such requests);
+    (to not spam the peer with such requests).
 
   - When an avatar data notification is received, the client must update
-    the cached avatar with the new one;
+    the cached avatar with the new one.
 
-  - Clients should resize or crop the image to the way it better adapts
-    to the client user interface;
+  - Clients should resize or crop the image such that it better adapts
+    to the client's user interface.
 
-  - If the user already have an avatar defined in the client configuration,
+  - If the user already has an avatar defined in the client configuration,
     it must be set before connecting to the network to avoid spurious avatar
     change notifications and unnecessary data transfers.
 
@@ -232,10 +241,10 @@ void tox_callback_avatar_data(Tox *tox, void (*function)(Tox *tox, int32_t, uint
 ### Interoperability and sharing avatars among different clients
 
 **This section is a tentative recommendation of how clients should store
-avatars to ensure local interoperability and should be revised if this
+avatars to ensure local interoperability, and should be revised if this
 code is accepted into Tox core.**
 
-It is desirable that the user avatar and the cached friends avatars could be
+It is desirable that the user avatar and the cached friends' avatars could be
 shared among different Tox clients in the same system, in the spirit of the
 proposed Single Tox Standard. This not only makes switching from one client
 to another easier, but also minimizes the need of data transfers, as avatars
@@ -244,7 +253,7 @@ already downloaded by other clients can be reused.
 Given the Tox data directory described in STS Draft v0.1.0:
 
   - Avatars are stored in a directory called "avatars" and named
-    as "xxxxx.png", where "xxxxx" is the complete client id (but not friend
+    as "xxxxx.png", where "xxxxx" is the complete public key (but not friend
     address!) encoded as an uppercase hexadecimal string and "png" is the
     extension for the PNG avatar. As new image formats may be used in the
     future, clients should ensure no other file "xxxxx.*" exists. No file
@@ -253,10 +262,10 @@ Given the Tox data directory described in STS Draft v0.1.0:
   - The client's own avatar is not special and is stored like any other. This
     is partially for simplicity, and partially in anticipation of profiles.
 
-  - The avatar should be stored as its recieved, before any modifications by
+  - The avatar should be stored as it was received, before any modifications by
     the client for display purposes.
 
-  - The hash, as calculated by toxcore and passed in to the data callback,
+  - The hash, as calculated by toxcore and passed into the data callback,
     should be saved in "avatars/xxxxx.hash" where "xxxxx" means the
     same thing as for avatars. (The filename is longer than the file :) )
 
@@ -264,12 +273,12 @@ Given the Tox data directory described in STS Draft v0.1.0:
     upper case strings, but lower case file names are more usual.
 
 
-Example for Linux and other Unix systems, assuming an user called "gildor":
+Example for Linux and other Unix systems, assuming a user called "gildor":
 
     Tox data directory: /home/gildor/.config/tox/
     Tox data file:      /home/gildor/.config/tox/data
     Avatar data dir:    /home/gildor/.config/tox/avatars/
-    Gildor's avatar:    /home/gildor/.config/tox/avatars/E5809EEF5F11AB29B9BDF543C05B58DDF454AB9CA176C235C7699FDC2757DC33.png
+    Gildor's avatar:    /home/gildor/.config/tox/avatars/446F4E6F744D6564646C65496E546865416666616972734F6657697A61726473.png
     Elrond's avatar:    /home/gildor/.config/tox/avatars/43656C65627269616E20646F6E277420546F782E426164206D656D6F72696573.png
     Elrond's hash:      /home/gildor/.config/tox/avatars/43656C65627269616E20646F6E277420546F782E426164206D656D6F72696573.hash
     Elladan's avatar:   /home/gildor/.config/tox/avatars/49486174655768656E48756D616E735468696E6B49416D4D7942726F74686572.png
@@ -285,13 +294,13 @@ This recommendation is partially implemented by "testing/test_avatars.c".
 
 ### Common operations
 
-These are minimal examples of how perform common operations with avatar
-functions. For a complete, working, example, see `testing/test_avatars.c`.
+These are minimal examples of how to perform common operations with avatar
+functions. For a complete working example, see `testing/test_avatars.c`.
 
 
 #### Setting an avatar for the current user
 
-In this example `load_data_file` is just an hypothetical function that loads
+In this example, `load_data_file` is just a hypothetical function that loads
 data from a file into the buffer and sets the length accordingly.
 
     uint8_t buf[TOX_AVATAR_MAX_DATA_LENGTH];
@@ -304,7 +313,7 @@ data from a file into the buffer and sets the length accordingly.
 If the user is connected, this function will also notify all connected
 friends about the avatar change.
 
-If the user already have an avatar defined in the client configuration, it
+If the user already has an avatar defined in the client configuration, it
 must be set before connecting to the network to avoid spurious avatar change
 notifications and unnecessary data transfers.
 
@@ -313,7 +322,12 @@ notifications and unnecessary data transfers.
 
 #### Removing the avatar from the current user
 
-To remove an avatar, an application must set it to `TOX_AVATAR_FORMAT_NONE`.
+To remove the current avatar, an application must call
+
+    tox_unset_avatar(tox);
+
+the effect is the same as setting the avatar format to `TOX_AVATAR_FORMAT_NONE`
+with no data:
 
     tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0);
 
@@ -343,7 +357,7 @@ As in this example:
         printf("\n");
     }
 
-And, somewhere in the Tox initialization calls, set if as the callback to be
+And, somewhere in the Tox initialization calls, set it as the callback to be
 triggered when an avatar information event arrives:
 
     tox_callback_avatar_info(tox, avatar_info_cb, NULL);
@@ -356,7 +370,7 @@ in the avatar information event and, if needed, request the avatar data.
 
 #### Receiving avatar data from friends
 
-Avatar data events are only delivered in reply of avatar data requests which
+Avatar data events are only delivered in reply to avatar data requests, which
 **should** only be sent after getting the user avatar information (format
 and hash) from an avatar information event and checking it against a local
 cache.
@@ -374,7 +388,7 @@ checks the local avatar cache and emits an avatar data request if necessary:
             delete_avatar_from_cache(tox, friendnumber);
         } else {
             /* Use the received hash to check if the cached avatar is
-               still updated. */
+               still up to date. */
             if (!is_user_cached_avatar_updated(tox, friendnumber, hash)) {
                 /* User avatar is outdated, send data request */
                 tox_request_avatar_data(tox, friendnumber);
@@ -406,9 +420,9 @@ calls:
     tox_callback_avatar_data(tox, avatar_data_cb, NULL);
 
 
-In the previous examples, implementation of the functions to check, store
+In the previous examples, implementation of the functions to check, store,
 and retrieve data from the cache were omitted for brevity. These functions
-will also need to get the friend client ID (public key) from they friend
+will also need to get the friend public key (client id) from the friend
 number and, usually, convert it from a byte string to a hexadecimal
 string. A complete, yet more complex, example is available in the file
 `testing/test_avatars.c`.
@@ -440,7 +454,7 @@ The avatar transfer protocol adds the following new packet types and ids:
 
 ### Requesting avatar information
 
-To request avatar information, an user must send a packet of type
+To request avatar information, a user must send a packet of type
 `PACKET_ID_AVATAR_INFO_REQ`. This packet has no data fields. Upon
 receiving this packet, a client which supports avatars should answer with
 a `PACKET_ID_AVATAR_INFO`. The sender must accept that the friend may
@@ -458,7 +472,7 @@ the following structure:
     Packet data size: 33 bytes
     [1: uint8_t format][32: uint8_t hash]
 
-Where 'format' is the image data format, one of the following:
+where 'format' is the image data format, one of the following:
 
     0 = AVATAR_FORMAT_NONE  (no avatar set)
     1 = AVATAR_FORMAT_PNG
@@ -478,21 +492,21 @@ connects, in the same way Tox sends name, status and action information.
 Transmission of avatar data is a multi-step procedure using three new packet
 types.
 
-  - Packet `PACKET_ID_AVATAR_DATA_CONTROL` have the format:
+  - Packet `PACKET_ID_AVATAR_DATA_CONTROL` has the format:
 
         PACKET_ID_AVATAR_DATA_CONTROL (54)
         Packet data size: 1 byte
         [1: uint8_t op]
 
-    where 'op' is a code signaling both an operation request or a status
-    return, which semantics are explained bellow. The following values are
+    where 'op' is a code signaling either an operation request or a status
+    return, the semantics of which are explained below. The following values are
     defined:
 
         0 = AVATAR_DATACONTROL_REQ
         1 = AVATAR_DATACONTROL_ERROR
 
 
-  - Packet `PACKET_ID_AVATAR_DATA_START` have the following format:
+  - Packet `PACKET_ID_AVATAR_DATA_START` has the following format:
 
         PACKET_ID_AVATAR_DATA_START (55)
         Packet data size: 37 bytes
@@ -501,13 +515,13 @@ types.
 
     where 'format' is the image format, with the same values accepted for
     the field 'format' in packet type `PACKET_ID_AVATAR_INFO`, 'hash' is
-    the SHA-256 cryptographic hash of the avatar raw data and 'data_length'
+    the SHA-256 cryptographic hash of the avatar raw data, and 'data_length'
     is the total number of bytes the raw avatar data.
 
 
   - Packet `PACKET_ID_AVATAR_DATA_PUSH` has no format structure, just up
     to `AVATAR_DATA_MAX_CHUNK_SIZE` bytes of raw avatar image data; this
-    value is defined according to the maximum amount of data a Tox crypted
+    value is defined according to the maximum amount of data a Tox encrypted
     packet can hold.
 
 
@@ -520,9 +534,9 @@ from a client "B":
     packet `PACKET_ID_AVATAR_DATA_CONTROL` with 'op' set to
     `AVATAR_DATACONTROL_REQ`.
 
-  - If "B" accepts this transfer, it answers by sending an
-    `PACKET_ID_AVATAR_DATA_START` with the fields 'format', 'hash' and
-    'data_length' set to the respective values from the current avatar.
+  - If "B" accepts this transfer, it answers by sending a
+    `PACKET_ID_AVATAR_DATA_START` with the fields 'format', 'hash', and
+    'data_length' set to the respective values of the current avatar.
     If "B" has no avatar set, 'format' must be `AVATAR_FORMAT_NONE`, 'hash'
     must be zeroed and 'data_length' must be zero.
 
@@ -531,12 +545,12 @@ from a client "B":
     `AVATAR_DATACONTROL_ERROR` or simply ignore this request. "A" must cope
     with this.
 
-    If "B" have an avatar, it sends a variable number of
+    If "B" has an avatar, it sends a variable number of
     `PACKET_ID_AVATAR_DATA_PUSH` packets with the avatar data in a single
     shot.
 
   - Upon receiving a `PACKET_ID_AVATAR_DATA_START`, "A" checks if it
-    has sent a data request to "B". If not, just ignores the packet.
+    has sent a data request to "B". If not, it simply ignores the packet.
 
     If "A" really requested avatar data and the format is `AVATAR_FORMAT_NONE`,
     it triggers the avatar data callback, and clears all the temporary data,
@@ -545,36 +559,36 @@ from a client "B":
 
   - Upon receiving a `PACKET_ID_AVATAR_DATA_PUSH`, "A" checks if it really
     sent an avatar data request and if the `PACKET_ID_AVATAR_DATA_START` was
-    already received. If this conditions are valid, it checks if the total
+    already received. If these conditions were met, it checks if the total
     length of the data already stored in the receiving buffer plus the data
     present in the push packet is still less or equal than
-    `TOX_AVATAR_MAX_DATA_LENGTH`. If invalid, it replies with a
+    `TOX_AVATAR_MAX_DATA_LENGTH`. If that is not the case, it replies with a
     `PACKET_ID_AVATAR_DATA_CONTROL` with the field 'op' set to
     `AVATAR_DATACONTROL_ERROR`.
 
     If valid, "A" updates the 'bytes_received' counter and concatenates the
     newly arrived data to the buffer.
 
-    The "A" checks if all the data was already received by comparing the
+    Then "A" checks if all the data has already been received, by comparing the
     counter 'bytes_received' with the field 'total_length'. If they are
     equal, "A" takes a SHA-256 hash of the data and compares it with the
-    hash stored in the field 'hash' received from the first
+    hash stored in the field 'hash' received with the first
     `PACKET_ID_AVATAR_DATA_START`.
 
-    If the hashes match, the avatar data was correctly received and "A"
-    triggers the avatar data callback, and clears all the temporary data,
+    If the hashes match, the avatar data was correctly received, and "A"
+    triggers the avatar data callback and clears all the temporary data,
     finishing the process.
 
     If not all data was received, "A" simply waits for more data.
 
     Client "A" is always responsible for controlling the transfer and
-    validating the data received. "B" don't need to keep any state for the
+    validating the data received. "B" doesn't need to keep any state for the
     protocol, have full control over the data sent and should implement
     some transfer limit for the data it sends.
 
   - Any peer receiving a `PACKET_ID_AVATAR_DATA_CONTROL` with the field 'op'
     set to `AVATAR_DATACONTROL_ERROR` clears any existing control state and
-    finishes sending or receiving data.
+    aborts sending or receiving data.
 
 
 
@@ -583,33 +597,33 @@ from a client "B":
 ## Security considerations
 
 The major security implication of background data transfers of large objects,
-like avatars, is the possibility of exhausting the network resources from a
+like avatars, is the possibility of exhausting the network resources of a
 client. This problem is exacerbated when there is the possibility of an
-amplification attack as happens, for example, when sending a very small
+amplification attack, as happens, for example, when sending a very small
 avatar request message will force the user to reply with a larger avatar
 data message.
 
 The present proposal mitigates this situation by:
 
-  - Only transferring data between previously authenticated friends;
+  - only transferring data between previously authenticated friends,
 
-  - Enforcing strict limits on the avatar data size;
+  - enforcing strict limits on the avatar data size,
 
-  - Providing an alternate, smaller, message to cooperative users refresh
-    avatar information when nothing has changed (`PACKET_ID_AVATAR_INFO`);
+  - providing an alternate, smaller message for cooperative users to refresh
+    avatar information when nothing has changed (`PACKET_ID_AVATAR_INFO`),
 
-  - Having per-friend data transfer limit. As the current protocol still
-    allows an user to request avatar data again and again, the implementation
+  - having a per-friend data transfer limit. As the current protocol still
+    allows a user to request avatar data again and again, the implementation
     limits the amount of data a particular user can request for some time. The
     exact values are defined in constants `AVATAR_DATA_TRANSFER_LIMIT` and
     `AVATAR_DATA_TRANSFER_TIMEOUT` in file `Messenger.c`.
 
-  - Making the requester responsible for storing partial data and state
-    information;
+  - making the requester responsible for storing partial data and state
+    information
 
-Another problem present in the avatars is the possibility of a friend send
+Another problem present in avatars is the possibility of a friend sending
 a maliciously crafted image intended to exploit vulnerabilities in image
-decoders. Without an intermediate server to recompress and validate and
+decoders. Without an intermediate server to recompress, validate, and
 convert the images to neutral formats, the client applications must handle
 this situation by themselves using stable and secure image libraries and
 imposing limits on the maximum amount of system resources the decoding
diff --git a/docs/TODO b/docs/TODO
index 16380c20..54137d0d 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -11,9 +11,11 @@ DHT:
     [IN PROGRESS] Hardening against attacks.
     [IN PROGRESS] Optimizing the code.
 
-[IN PROGRESS] Friend only group chats
-    [IN PROGRESS] Networking base.
-    [IN PROGRESS] Syncing chat state between clients (nicknames, list of who is in chat, etc...)
+[DONE] Friend only group chats
+    [DONE] Networking base.
+    [MOSTLY DONE] Syncing chat state between clients (nicknames, list of who is in chat, etc...)
+    [NOT STARTED] Private messages. (and adding friends from group chats using those private messages.)
+    [NOT STARTED] File transfers.
 
 [IN PROGRESS] Audio/Video
     [DONE] encoding/streaming/decoding
@@ -22,7 +24,7 @@ DHT:
     [IN PROGRESS] Auditing.
     [NEEDS TESTING] Video packet splitting.
     [IN PROGRESS] Prevent audio skew (seems to be easily solvable client side.)
-    [IN PROGRESS] Group chats.
+    [IN PROGRESS] Group chats, audio done.
 
 Friend_requests.c:
     [NOT STARTED] What happens when a friend request is received needs to be changed.
@@ -30,7 +32,7 @@ Friend_requests.c:
 
 [DONE] File transfers
 [NOT STARTED] Offline messaging
-[NOT STARTED] Friends list syncing
+[IN PROGRESS] Friends list syncing
 [DONE] IPV6 support
 
 [IN PROGRESS] Make toxcore thread safe.
@@ -38,14 +40,9 @@ Friend_requests.c:
 [NOT STARTED] Make the core save/datafile portable across client versions/different processor architectures.
 
 [MOSTLY DONE] A way for people to connect to people on Tox if they are behind a bad NAT that 
-blocks UDP (or is just unpunchable) (docs/TCP_Network.txt)
+blocks UDP (or is just unpunchable) (docs/TCP_Network.txt) (Current way doesn't scale very well.)
 
 [DONE] Encrypted Saves. (see: toxencryptsave)
 
 
-[IN PROGRESS] GUI (no official one chosen yet, a list of promising ones follows)
-https://github.com/notsecure/uTox
-https://github.com/tux3/qTox
-https://github.com/Reverp/Toxy
-
 [NOT STARTED] Security audit from professionals
diff --git a/docs/Tox_middle_level_network_protocol.txt b/docs/Tox_middle_level_network_protocol.txt
index ca561474..69ab9858 100644
--- a/docs/Tox_middle_level_network_protocol.txt
+++ b/docs/Tox_middle_level_network_protocol.txt
@@ -3,58 +3,58 @@ feature complete. Why doesn't Tox support TCP yet even if those parts are
 complete?
 
 The answer is that a way to ensure a smooth switchover between the TCP and UDP 
-needs to be added. If Tox first connects to the other user using TCP but then 
-due to pure chance manages to connect using the faster direct UDP connection 
+needs to be added. If Tox first connects to the other user using TCP but then, 
+due to pure chance, manages to connect using the faster direct UDP connection, 
 Tox must switch seamlessly from the TCP to the UDP connection without there 
 being any data loss or the other user going offline and then back online. The 
-transition must be seamless whatever both connected users are doing be it 
+transition must be seamless whatever both connected users are doing - be it 
 transferring files or simply chatting together.
 
 Possible evil/bad or simply TCP relays going offline must not impact the 
 connection between both clients.
 
-Typically Tox will use more than one TCP relay to connect to other peers for 
-maximum connection stability which means there must be a way for Tox to take 
-advantage of multiple relays in a way that the user will never be aware if one
+Typically, Tox will use more than one TCP relay to connect to other peers for 
+maximum connection stability, which means there must be a way for Tox to take 
+advantage of multiple relays in a way that the user will never be aware of, if one
 of them goes offline/tries to slow down the connection/decides to corrupt 
-packets/etc..
+packets/etc.
 
-To accomplish this Tox needs something between the low level protocol (TCP) and 
-high level Tox messaging protocol hence the name middle level.
+To accomplish this, Tox needs something between the low level protocol (TCP) and 
+high level Tox messaging protocol; hence the name middle level.
 
 The plan is to move some functionality from lossless_UDP to a higher level: 
-more specifically the functionality for detecting which packets a peer is 
-missing and the ability to request and send them again. lossless UDP uses plain 
-text packets to request missing packets from the other peer while Tox is 
+more specifically, the functionality for detecting which packets a peer is 
+missing, and the ability to request and send them again. Lossless UDP uses plain 
+text packets to request missing packets from the other peer, while Tox is 
 currently designed to kill the connection if any packet tampering is detected. 
 This works very well when connecting directly with someone because if the 
-attacker can modify packets it means he can kill your connection anyways. With 
-TCP relays however that is not the case as such the packets used to request 
+attacker can modify packets, it means he can kill your connection anyway. With 
+TCP relays, however, that is not the case. As such the packets used to request 
 missing packets must be encrypted. If it is detected that a packet has been 
 tampered, the connection must stay intact while the evil relay must be 
-disconnected from and replaced with a good relay, the behavior must be the same 
-as if the relay had just suddenly gone online. Of course something to protect 
+disconnected from and replaced with a good relay; the behavior must be the same 
+as if the relay had just suddenly gone offline. Of course, something to protect 
 from evil "friends" framing relays must also be implemented.
 
 Detailed implementation details:
 
 cookie request packet:
-[uint8_t 24][Senders DHT Public key (32 bytes)][Random nonce (24 
-bytes)][Encrypted message containing: [Senders real public key (32 
+[uint8_t 24][Sender's DHT Public key (32 bytes)][Random nonce (24 
+bytes)][Encrypted message containing: [Sender's real public key (32 
 bytes)][padding (32 bytes)][uint64_t number (must be sent 
 back untouched in cookie response)]]
-Encrypted message is encrypted with sender DHT private key, receivers DHT
+Encrypted message is encrypted with sender's DHT private key, receiver's DHT
 public key and the nonce.
 
 cookie response packet:
 [uint8_t 25][Random nonce (24 bytes)][Encrypted message containing: 
 [Cookie][uint64_t number (that was sent in the request)]]
-Encrypted message is encrypted with sender DHT private key, receivers DHT
+Encrypted message is encrypted with sender's DHT private key, receiver's DHT
 public key and the nonce.
 
 The Cookie should be basically:
-[nonce][encrypted data:[uint64_t time][Senders real public key (32 
-bytes)][Senders dht public key (32 bytes)]]
+[nonce][encrypted data:[uint64_t time][Sender's real public key (32 
+bytes)][Sender's DHT public key (32 bytes)]]
 
 Handshake packet:
 [uint8_t 26][Cookie][nonce][Encrypted message containing: [random 24 bytes base 
@@ -66,25 +66,25 @@ The handshake packet is encrypted using the real private key of the sender, the
 real public key of the receiver and the nonce.
 
 
-Alice wants to connect to bob.
+Alice wants to connect to Bob:
 
-Alice sends a cookie request packet to bob and gets a cookie response back.
+Alice sends a cookie request packet to Bob and gets a cookie response back.
 
 Alice then generates a nonce and a temporary public/private keypair.
 
 Alice then takes that nonce and just generated private key, the obtained 
-cookie, creates a new cookie and puts them in a handshake packet which she 
-sends to bob.
+cookie, creates a new cookie and puts them in a handshake packet, which she 
+sends to Bob.
 
 Bob gets the handshake packet, accepts the connection request, then generates a 
 nonce and a temporary public/private keypair and sends a handshake packet back 
 with this just generated information and with the cookie field being the Other 
 Cookie contained in the received handshake.
 
-Both then use these temporary keys to generate the session key with which every 
+Both then use these temporary keys to generate the session key, with which every 
 data packet sent and received will be encrypted and decrypted. The nonce sent 
 in the handshake will be used to encrypt the first data packet sent, the nonce 
-+ 1 the second, the nonce + 2 the third and so on.
++ 1 for the second, the nonce + 2 for the third, and so on.
 
 Data packets:
 
@@ -109,12 +109,12 @@ data ids:
 packet request packet: [uint8_t (1)][uint8_t num][uint8_t num][uint8_t 
 num]...[uint8_t num]
 
-the list of nums are a list of packet numbers the other is requesting.
-to get the real packet numbers from this list take the recvbuffers buffer_start
-from the packet, subtract 1 to it and put it in packet_num then start from the
-beginning of the num list: if num is zero, add 255 to packet_num then do the
-next num. if num isn't zero, add its value to packet_num, note that the other
-has requested we send this packet again to them then continue to the next num in
+The list of nums are a list of packet numbers the other is requesting.
+In order to get the real packet numbers from this list, take the recvbuffers buffer_start
+from the packet, subtract 1 from it and put it in packet_num, then start from the
+beginning of the num list: if num is zero, add 255 to packet_num, then do the
+next num. If num isn't zero, add its value to packet_num, note that the other
+has requested we send this packet again to them, then continue to the next num in
 the list.
 
 
diff --git a/other/bootstrap_daemon/README.md b/other/bootstrap_daemon/README.md
index 9a2dff4b..d0c16eb1 100644
--- a/other/bootstrap_daemon/README.md
+++ b/other/bootstrap_daemon/README.md
@@ -1,29 +1,32 @@
-##Instructions for Debian
+##Instructions 
+
+This instruction primarily tested on Linux but, may be, will work on other POSIX-compliant systems.
 
 For security reasons we run the daemon under its own user.
+
 Create a new user by executing the following:
 ```sh
-sudo useradd --system --shell /sbin/nologin --comment "Account to run Tox's DHT bootstrap daemon" --user-group tox-bootstrapd
+sudo useradd --home-dir /var/lib/tox-bootstrapd --create-home --system --shell /sbin/nologin --comment "Account to run Tox's DHT bootstrap daemon" --user-group tox-bootstrapd
 ```
 
-Create a directory where the daemon will store its keys:
-```sh
-sudo mkdir /var/lib/tox-bootstrapd/
-```
+Copy `tox-bootstrapd.conf` file to where `CFGFILE` variable from `tox-bootstrapd.sh` tells (for `init.d` users) or `ExecStart=` from `tox-bootstrap.service` ( for `systemd` users). By default it's `/etc/tox-bootstrapd.conf`.
+
+Go over everything in `tox-bootstrapd.conf`. Make sure `pid_file_path` matches `PIDFILE` from `tox-bootstrapd.sh` (`init.d`) or `PIDFile=` from `tox-bootstrap.service` AND file in `ExecStartPre`(`systemd`).
+
 
-Restrain other users from accessing the directory:
+Restrict access to home directory:
 ```sh
-sudo chown tox-bootstrapd:tox-bootstrapd /var/lib/tox-bootstrapd/
-sudo chmod 700 /var/lib/tox-bootstrapd/
+sudo chmod 700 /var/lib/tox-bootstrapd
 ```
 
-Look at the variable declarations in the beginning of `tox-bootstrapd.sh` init script to see if you need to change anything for it to work for you. The default values must be fine for most users and we assume that you use those next.
-
-Go over everything in `tox-bootstrapd.conf`. Make sure `pid_file_path` matches `PIDFILE` from `tox-bootstrapd.sh`.
+##For `init.d` users:
 
-Place `tox-bootstrapd.conf` file to where `CFGFILE` variable from `tox-bootstrapd.sh` tells. By default it's `/etc/tox-bootstrapd.conf`.
+Look at the variable declarations in the beginning of `tox-bootstrapd.sh` init script to see if you need to change anything for it to work for you. The default values must be fine for most users and we assume that you use those next.
 
-Place `tox-bootstrapd.sh` init file at `/etc/init.d/tox-bootstrapd` (note the disappearance of ".sh" ending).
+Copy `tox-bootstrapd.sh` init file to `/etc/init.d/tox-bootstrapd` (note the disappearance of ".sh" ending).
+```sh
+sudo cp tox-bootstrapd.sh /etc/init.d/tox-bootstrapd
+```
 
 Set permissions for the init system to run the script:
 ```sh
@@ -50,23 +53,56 @@ Get your public key and check that the daemon initialized correctly:
 sudo grep "tox-bootstrapd" /var/log/syslog
 ```
 
+##For `systemd` users:
+
+Copy tox-bootstrap.service to /etc/systemd/system/:
+```sh
+sudo cp tox-bootstrap.service /etc/systemd/system/
+```
+
+Make sure, that path to `chown` and `mkdir` is correct in `tox-bootstrap.service` (they may be different in some distributions, by default  `/bin/chown` and `/bin/mkdir`) 
+
+You must uncomment the next line in tox-bootstrap.service, if you want to use port number <1024 
+        
+        #CapabilityBoundingSet=CAP_NET_BIND_SERVICE
+
+and, possibly, install `libcap2-bin` or `libcap2` package, depending of your distribution.
+
 
+Reload systemd units definitions, enable service for automatic start (if needed), and start it: 
+```sh
+sudo systemctl daemon-reload
+sudo systemctl enable tox-bootstrap.service
+sudo systemctl start tox-bootstrap.service
+```
 ###Troubleshooting:
 
 - Check daemon's status:
 ```sh
+#init.d
 sudo service tox-bootstrapd status
+
+#systemd
+sudo systemctl status tox-bootstrap.service 
 ```
 
 - Check the log for errors: 
 ```sh
+#init.d
 sudo grep "tox-bootstrapd" /var/log/syslog
+
+#systemd
+sudo journalctl -f _SYSTEMD_UNIT=tox-bootstrap.service
 ```
 
+`init.d`:
 - Check that variables in the beginning of `/etc/init.d/tox-bootstrapd` are valid.
 
-- Make sure `pid_file_path` in `/etc/tox-bootstrapd.conf` matches `PIDFILE` from  `/etc/init.d/tox-bootstrapd`.
 
-- Make sure you have write permission for keys and pid files.
+Common:
+
+- Make sure tox-bootstrapd user has write permission for keys and pid files (in systemd pid file insured by unit definition).
+
+- Make sure tox-bootstrapd has read permission for the config file.
 
-- Make sure you have read permission for the config file.
+- Make sure tox-bootstrapd location matches its path in init scripts, if you specified non-default `--prefix`, when building. 
diff --git a/other/bootstrap_daemon/tox-bootstrapd.conf b/other/bootstrap_daemon/tox-bootstrapd.conf
index 4547d83d..d02eb3d0 100644
--- a/other/bootstrap_daemon/tox-bootstrapd.conf
+++ b/other/bootstrap_daemon/tox-bootstrapd.conf
@@ -24,8 +24,8 @@ enable_lan_discovery = true
 
 enable_tcp_relay = true
 
-// Tox uses 443, 3389 and 33445 ports by default, so it's highly encouraged to keep
-// them.
+// While Tox uses 33445 port by default, 443 (https) and 3389 (rdp) ports are very
+// common among nodes, so it's encouraged to keep them in place.
 tcp_relay_ports = [443, 3389, 33445]
 
 // Reply to MOTD (Message Of The Day) requests.
@@ -45,48 +45,21 @@ motd = "tox-bootstrapd"
 // in both cases this will be interpreted as if you don't want to bootstrap
 // from anyone.
 //
-// address = any ipv4 or ipv6 address and also any US-ASCII domain name.
+// address = any IPv4 or IPv6 address and also any US-ASCII domain name.
 bootstrap_nodes = (
-  {   
-    // NikolaiToryzin - US
-    address = "192.254.75.98"
+  { // Example Node 1 (IPv4)
+    address = "127.0.0.1"
     port = 33445
-    public_key = "951C88B7E75C867418ACDB5D273821372BB5BD652740BCDF623A4FA293E75D2F"
+    public_key = "728925473812C7AAC482BE7250BCCAD0B8CB9F737BF3D42ABD34459C1768F854"
   },
-  { 
-    // Proplex - US
-    address = "107.161.17.51"
+  { // Example Node 2 (IPv6)
+    address = "::1/128"
     port = 33445
-    public_key = "7BE3951B97CA4B9ECDDA768E8C52BA19E9E2690AB584787BF4C90E04DBB75111"
+    public_key = "3E78BACF0F84235B30054B54898F56793E1DEF8BD46B1038B9D822E8460FAB67"
   },
-  { 
-    // SonOfRa - DE
-    address = "144.76.60.215"
+  { // Example Node 3 (US-ASCII domain name)
+    address = "example.org"
     port = 33445
-    public_key = "04119E835DF3E78BACF0F84235B300546AF8B936F035185E2A8E9E0A67C8924F"
-  },
-  { 
-    // Astonex - FR
-    address = "37.59.102.176"
-    port = 33445
-    public_key = "B98A2CEAA6C6A2FADC2C3632D284318B60FE5375CCB41EFA081AB67F500C1B0B"
-  },
-  { 
-    // SylvieLorxu - NL
-    address = "178.21.112.187"
-    port = 33445
-    public_key = "4B2C19E924972CB9B57732FB172F8A8604DE13EEDA2A6234E348983344B23057"
-  },
-  { 
-    // aitjcize  - JP
-    address = "54.199.139.199"
-    port = 33445
-    public_key = "7F9C31FE850E97CEFD4C4591DF93FC757C7C12549DDD55F8EEAECC34FE76C029"
-  },
-  { 
-    // NikolaiToryzin - CH
-    address = "31.7.57.236"
-    port = 443
-    public_key = "2A4B50D1D525DA2E669592A20C327B5FAD6C7E5962DC69296F9FEC77C4436E4E"
+    public_key = "8CD5A9BF0A6CE358BA36F7A653F99FA6B258FF756E490F52C1F98CC420F78858"
   }
-)
+)
\ No newline at end of file
diff --git a/other/bootstrap_daemon/tox-bootstrapd.service b/other/bootstrap_daemon/tox-bootstrapd.service
new file mode 100644
index 00000000..4b499311
--- /dev/null
+++ b/other/bootstrap_daemon/tox-bootstrapd.service
@@ -0,0 +1,19 @@
+[Unit]
+Description=Tox DHT Bootstrap Daemon
+After=network.target
+
+[Service]
+Type=forking
+PermissionsStartOnly=true
+ExecStartPre=-/bin/mkdir /var/run/tox-bootstrapd -p
+ExecStartPre=/bin/chown tox-bootstrapd:tox-bootstrapd -R /var/run/tox-bootstrapd
+WorkingDirectory=/var/lib/tox-bootstrapd
+ExecStart=/usr/local/bin/tox-bootstrapd /etc/tox-bootstrapd.conf
+User=tox-bootstrapd
+Group=tox-bootstrapd
+PIDFile=/var/run/tox-bootstrapd/tox-bootstrapd.pid
+#CapabilityBoundingSet=CAP_NET_BIND_SERVICE
+
+[Install]
+WantedBy=multi-user.target
+
diff --git a/other/bootstrap_node_packets.c b/other/bootstrap_node_packets.c
index e8df3289..0bf9b9b0 100644
--- a/other/bootstrap_node_packets.c
+++ b/other/bootstrap_node_packets.c
@@ -34,7 +34,7 @@ static uint16_t bootstrap_motd_length;
 /* To request this packet just send a packet of length INFO_REQUEST_PACKET_LENGTH
  * with the first byte being BOOTSTRAP_INFO_PACKET_ID
  */
-static int handle_info_request(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_info_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     if (length != INFO_REQUEST_PACKET_LENGTH)
         return 1;
diff --git a/other/fun/make-funny-savefile.py b/other/fun/make-funny-savefile.py
new file mode 100755
index 00000000..43f14a6e
--- /dev/null
+++ b/other/fun/make-funny-savefile.py
@@ -0,0 +1,122 @@
+#!/usr/bin/python
+
+"""
+Generate a new (and empty) save file with predefined keys. Used to play
+with externally generated keys.
+
+(c) 2015 Alexandre Erwin Ittner
+
+Distributed under the GNU GPL v3 or later, WITHOUT ANY WARRANTY. See the
+file "COPYING" for license information.
+
+
+Usage:
+
+  ./make-funny-savefile.py <public key> <private key> <user name> <out file>
+
+  The new user profile will be saved to <out file>.
+
+  The keys must be an hex-encoded valid key pair generated by any means
+  (eg. strkey.c); username may be anything. A random nospam value will be
+  generated.
+
+  Once the savefile is done, load it in your favorite client to get some
+  DHT nodes, set status and status messages, add friends, etc.
+
+
+Example (of course, do not try using this key for anything real):
+
+  ./make-funny-savefile.py 123411DC8B1A4760B648E0C7243B65F01069E4858F45C612CE1A6F673B603830 CC39440CFC063E4A95B7F2FB2580210558BE5C073AFC1C9604D431CCA3132238 "Test user" test.tox
+
+
+"""
+
+
+PUBLIC_KEY_LENGTH = 32
+PRIVATE_KEY_LENGTH = 32
+
+# Constants taken from messenger.c
+MESSENGER_STATE_COOKIE_GLOBAL       = 0x15ed1b1f
+MESSENGER_STATE_COOKIE_TYPE         = 0x01ce
+MESSENGER_STATE_TYPE_NOSPAMKEYS     = 1
+MESSENGER_STATE_TYPE_DHT            = 2
+MESSENGER_STATE_TYPE_FRIENDS        = 3
+MESSENGER_STATE_TYPE_NAME           = 4
+MESSENGER_STATE_TYPE_STATUSMESSAGE  = 5
+MESSENGER_STATE_TYPE_STATUS         = 6
+MESSENGER_STATE_TYPE_TCP_RELAY      = 10
+MESSENGER_STATE_TYPE_PATH_NODE      = 11
+
+STATUS_MESSAGE = "New user".encode("utf-8")
+
+
+
+import sys
+import struct
+import os
+
+def abort(msg):
+    print(msg)
+    exit(1)
+
+
+
+if len(sys.argv) != 5:
+    abort("Usage: %s <public key> <private key> <user name> <out file>" % (sys.argv[0]))
+
+try:
+    public_key = sys.argv[1].decode("hex")
+except:
+    abort("Bad public key")
+
+try:
+    private_key = sys.argv[2].decode("hex")
+except:
+    abort("Bad private key")
+
+if len(public_key) != PUBLIC_KEY_LENGTH:
+    abort("Public key with wrong length")
+
+if len(private_key) != PRIVATE_KEY_LENGTH:
+    abort("Private key with wrong length")
+
+user_name = sys.argv[3].encode("utf-8")
+
+if len(user_name) > 32:
+    abort("User name too long (for this script, at least)")
+
+out_file_name = sys.argv[4]
+nospam = os.urandom(4)
+
+
+def make_subheader(h_type, h_length):
+    return (
+        struct.pack("<I", h_length) +
+        struct.pack("<H", h_type) +
+        struct.pack("<H", MESSENGER_STATE_COOKIE_TYPE))
+
+data = (
+    # Main header
+    struct.pack("<I", 0) +
+    struct.pack("<I", MESSENGER_STATE_COOKIE_GLOBAL) +
+
+    # Keys
+    make_subheader(MESSENGER_STATE_TYPE_NOSPAMKEYS,
+        len(nospam) + PUBLIC_KEY_LENGTH + PRIVATE_KEY_LENGTH) +
+    nospam + public_key + private_key +
+
+    # Name (not really needed, but helps)
+    make_subheader(MESSENGER_STATE_TYPE_NAME, len(user_name)) +
+    user_name +
+
+    # Status message (not really needed, but helps)
+    make_subheader(MESSENGER_STATE_TYPE_STATUSMESSAGE, len(STATUS_MESSAGE)) +
+    STATUS_MESSAGE
+)
+
+
+try:
+    with open(out_file_name, "wb") as fp:
+        fp.write(data)
+except Exception as e:
+    abort(str(e))
diff --git a/osx_build_script_toxcore.txt b/other/osx_build_script_toxcore.sh
index 8aea0d1c..8aea0d1c 100644
--- a/osx_build_script_toxcore.txt
+++ b/other/osx_build_script_toxcore.sh
diff --git a/testing/test_avatars.c b/testing/test_avatars.c
index 71a0330e..b4adc48f 100644
--- a/testing/test_avatars.c
+++ b/testing/test_avatars.c
@@ -18,7 +18,7 @@
  * Data dir MAY have:
  *
  *  - A directory named "avatars" with the user's avatar and cached avatars.
- *    The user avatar must be named in the format: "<uppercase user id>.png"
+ *    The user avatar must be named in the format: "<uppercase pub key>.png"
  *
  *
  * The bot will answer to these commands:
@@ -163,14 +163,14 @@ static void byte_to_hex_str(const uint8_t *buf, const size_t buflen, char *dst)
     dst[j++] = '\0';
 }
 
-/* Make the cache file name for a avatar of the given format for the given
- * client id.
+/* Make the cache file name for an avatar of the given format for the given
+ * public key.
  */
 static int make_avatar_file_name(char *dst, size_t dst_len, const char *base_dir,
-                                 const uint8_t format, uint8_t *client_id)
+                                 const uint8_t format, uint8_t *public_key)
 {
-    char client_id_str[2 * TOX_CLIENT_ID_SIZE + 1];
-    byte_to_hex_str(client_id, TOX_CLIENT_ID_SIZE, client_id_str);
+    char public_key_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
+    byte_to_hex_str(public_key, TOX_PUBLIC_KEY_SIZE, public_key_str);
 
     const char *suffix = get_avatar_suffix_from_format(format);
 
@@ -178,7 +178,7 @@ static int make_avatar_file_name(char *dst, size_t dst_len, const char *base_dir
         return -1;  /* Error */
 
     int n = snprintf(dst, dst_len, "%s/%s/%s.%s", base_dir, AVATAR_DIR_NAME,
-                     client_id_str, suffix);
+                     public_key_str, suffix);
     dst[dst_len - 1] = '\0';
 
     if (n >= dst_len)
@@ -196,7 +196,7 @@ static int make_avatar_file_name(char *dst, size_t dst_len, const char *base_dir
 static int load_user_avatar(Tox *tox, char *base_dir, int friendnum,
                             uint8_t format, uint8_t *hash, uint8_t *data, uint32_t *datalen)
 {
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
 
     if (tox_get_client_id(tox, friendnum, addr) != 0) {
         DEBUG("Bad client id, friendnumber=%d", friendnum);
@@ -224,14 +224,14 @@ static int load_user_avatar(Tox *tox, char *base_dir, int friendnum,
     return 0;
 }
 
-/* Save a user avatar into the cache. Gets the file name from client id and
- * the given data format.
+/* Save a user avatar into the cache. Gets the file name from the public key
+ * and the given data format.
  * Returns 0 on success, or -1 on error.
  */
 static int save_user_avatar(Tox *tox, char *base_dir, int friendnum,
                             uint8_t format, uint8_t *data, uint32_t datalen)
 {
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
 
     if (tox_get_client_id(tox, friendnum, addr) != 0) {
         DEBUG("Bad client id, friendnumber=%d", friendnum);
@@ -252,7 +252,7 @@ static int save_user_avatar(Tox *tox, char *base_dir, int friendnum,
 /* Delete all cached avatars for a given user */
 static int delete_user_avatar(Tox *tox, char *base_dir, int friendnum)
 {
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
 
     if (tox_get_client_id(tox, friendnum, addr) != 0) {
         DEBUG("Bad client id, friendnumber=%d", friendnum);
@@ -288,11 +288,11 @@ static int delete_user_avatar(Tox *tox, char *base_dir, int friendnum)
 
 static void friend_status_cb(Tox *tox, int n, uint8_t status, void *ud)
 {
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
-    char addr_str[2 * TOX_CLIENT_ID_SIZE + 1];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
+    char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
 
     if (tox_get_client_id(tox, n, addr) == 0) {
-        byte_to_hex_str(addr, TOX_CLIENT_ID_SIZE, addr_str);
+        byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str);
         printf("Receiving status from %s: %u\n", addr_str, status);
     }
 }
@@ -300,12 +300,12 @@ static void friend_status_cb(Tox *tox, int n, uint8_t status, void *ud)
 static void friend_avatar_info_cb(Tox *tox, int32_t n, uint8_t format, uint8_t *hash, void *ud)
 {
     char *base_dir = (char *) ud;
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
-    char addr_str[2 * TOX_CLIENT_ID_SIZE + 1];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
+    char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
     char hash_str[2 * TOX_HASH_LENGTH + 1];
 
     if (tox_get_client_id(tox, n, addr) == 0) {
-        byte_to_hex_str(addr, TOX_CLIENT_ID_SIZE, addr_str);
+        byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str);
         printf("Receiving avatar information from %s.\n", addr_str);
     } else {
         DEBUG("tox_get_client_id failed");
@@ -350,12 +350,12 @@ static void friend_avatar_data_cb(Tox *tox, int32_t n, uint8_t format,
                                   uint8_t *hash, uint8_t *data, uint32_t datalen, void *ud)
 {
     char *base_dir = (char *) ud;
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
-    char addr_str[2 * TOX_CLIENT_ID_SIZE + 1];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
+    char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
     char hash_str[2 * TOX_HASH_LENGTH + 1];
 
     if (tox_get_client_id(tox, n, addr) == 0) {
-        byte_to_hex_str(addr, TOX_CLIENT_ID_SIZE, addr_str);
+        byte_to_hex_str(addr, TOX_PUBLIC_KEY_SIZE, addr_str);
         printf("Receiving avatar data from %s.\n", addr_str);
     } else {
         DEBUG("tox_get_client_id failed");
@@ -382,8 +382,8 @@ static void friend_msg_cb(Tox *tox, int n, const uint8_t *msg, uint16_t len, voi
 {
     const char *base_dir = (char *) ud;
     const char *msg_str = (char *) msg;
-    uint8_t addr[TOX_CLIENT_ID_SIZE];
-    char addr_str[2 * TOX_CLIENT_ID_SIZE + 1];
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
+    char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
 
     if (tox_get_client_id(tox, n, addr) == 0) {
         byte_to_hex_str(addr, TOX_FRIEND_ADDRESS_SIZE, addr_str);
@@ -428,8 +428,8 @@ static void friend_msg_cb(Tox *tox, int n, const uint8_t *msg, uint16_t len, voi
 static void friend_request_cb(Tox *tox, const uint8_t *public_key,
                               const uint8_t *data, uint16_t length, void *ud)
 {
-    char addr_str[2 * TOX_CLIENT_ID_SIZE + 1];
-    byte_to_hex_str(public_key, TOX_CLIENT_ID_SIZE, addr_str);
+    char addr_str[2 * TOX_PUBLIC_KEY_SIZE + 1];
+    byte_to_hex_str(public_key, TOX_PUBLIC_KEY_SIZE, addr_str);
     printf("Accepting friend request from %s.\n   %s\n", addr_str, data);
     tox_add_friend_norequest(tox, public_key);
 }
diff --git a/tox.spec.in b/tox.spec.in
new file mode 100644
index 00000000..f6136dc7
--- /dev/null
+++ b/tox.spec.in
@@ -0,0 +1,67 @@
+Name:           @PACKAGE_NAME@
+Version:        @VERSION@
+Release:        1%{?dist}
+Summary:        All-in-one secure communication platform
+
+License:        GPLv3
+URL:            https://github.com/irungentoo/toxcore
+Source0:        https://github.com/irungentoo/toxcore/releases/tox-%{version}.tar.gz
+
+BuildRequires:  autoconf automake libtool libvpx-devel opus-devel
+BuildRequires:  libsodium-devel libconfig-devel
+
+%description
+With the rise of governmental monitoring programs, Tox, a FOSS initiative, aims to be an easy to use, all-in-one communication platform that ensures their users full privacy and secure message delivery.
+
+%package devel
+Summary:        Development files for @PACKAGE_NAME@
+Requires:       %{name} = %{version}-%{release}
+
+%description devel
+Development package for @PACKAGE_NAME@
+
+%prep
+%setup -q
+
+
+%build
+%configure \
+    --enable-shared \
+    --disable-static \
+    --enable-av \
+    --disable-ntox \
+    --disable-daemon \
+    --disable-testing
+
+make %{?_smp_mflags}
+
+
+%install
+%make_install
+
+# remove la files
+find %{buildroot} -name '*.la' -delete -print
+
+# not handling DHT_bootstrap yet
+rm -f %{buildroot}%{_bindir}/DHT_bootstrap
+
+%post
+/sbin/ldconfig
+
+%postun
+/sbin/ldconfig
+
+%files
+%defattr(-,root,root)
+%doc COPYING README.md
+%{_libdir}/libtox*.so.*
+
+%files devel
+%defattr(-, root, root)
+%{_includedir}/tox/
+%{_libdir}/libtox*.so
+%{_libdir}/pkgconfig/libtox*.pc
+
+%changelog
+* Tue Mar  3 2015 Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc> - 0.0.0-1
+- initial package
diff --git a/toxav/Makefile.inc b/toxav/Makefile.inc
index 6458260d..b61c1ea0 100644
--- a/toxav/Makefile.inc
+++ b/toxav/Makefile.inc
@@ -49,6 +49,7 @@ av_test_LDADD =       $(LIBSODIUM_LDFLAGS) \
                       libtoxcore.la \
                       $(LIBSODIUM_LIBS) \
                       $(NACL_OBJECTS) \
+                      -lopenal \
                       $(NACL_LIBS)
 
 
diff --git a/toxav/av_test.c b/toxav/av_test.c
index bb79eedc..01484249 100644
--- a/toxav/av_test.c
+++ b/toxav/av_test.c
@@ -1,6 +1,18 @@
 #include "toxav.h"
 #include "../toxcore/tox.h"
 
+#ifdef __APPLE__
+#       include <OpenAL/al.h>
+#       include <OpenAL/alc.h>
+#else
+#       include <AL/al.h>
+#       include <AL/alc.h>
+/* compatibility with older versions of OpenAL */
+#       ifndef ALC_ALL_DEVICES_SPECIFIER
+#               include <AL/alext.h>
+#       endif  /* ALC_ALL_DEVICES_SPECIFIER */
+#endif  /* __APPLE__ */
+
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,6 +26,16 @@
 #define c_sleep(x) usleep(1000*x)
 #endif
 
+/* Enable/disable tests */
+#define TEST_REGULAR_AV 0
+#define TEST_REGULAR_A 0
+#define TEST_REGULAR_V 0
+#define TEST_REJECT 0
+#define TEST_CANCEL 0
+#define TEST_MUTE_UNMUTE 0
+#define TEST_TRANSFER_A 1
+
+
 typedef struct {
     bool incoming;
     uint32_t state;
@@ -134,9 +156,201 @@ void iterate(Tox* Bsn, ToxAV* AliceAV, ToxAV* BobAV)
     c_sleep(20);
 }
 
+int device_read_frame(ALCdevice* device, int32_t frame_dur, int16_t* PCM, size_t max_size)
+{
+        int f_size = (48000 * frame_dur / 1000);
+        
+        if (max_size < f_size)
+                return -1;
+
+        /* Don't block if not enough data */
+        int32_t samples;
+        alcGetIntegerv(device, ALC_CAPTURE_SAMPLES, sizeof(int32_t), &samples);
+        if (samples < f_size) 
+                return 0;
+        
+        alcCaptureSamples(device, PCM, f_size);
+        return f_size;
+}
+
+int device_play_frame(uint32_t source, int16_t* PCM, size_t size)
+{
+        uint32_t bufid;
+    int32_t processed, queued;
+    alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
+    alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
+
+    if(processed) {
+        uint32_t bufids[processed];
+        alSourceUnqueueBuffers(source, processed, bufids);
+        alDeleteBuffers(processed - 1, bufids + 1);
+        bufid = bufids[0];
+    }
+    else if(queued < 16)
+                alGenBuffers(1, &bufid);
+    else
+        return 0;
+    
+
+    alBufferData(bufid, AL_FORMAT_STEREO16, PCM, size * 2 * 2, 48000);
+    alSourceQueueBuffers(source, 1, &bufid);
+
+    int32_t state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+
+    if(state != AL_PLAYING) 
+                alSourcePlay(source);
+        return 1;
+}
+
+int print_devices()
+{
+        const char* default_input;
+        const char* default_output;
+        
+        const char *device;
+
+        printf("Default input device: %s\n", alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
+        printf("Default output device: %s\n", alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER));
+        
+        printf("\n");
+        
+        printf("Input devices:\n");
+        
+        int i = 0;
+        for(device = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); *device; 
+                device += strlen( device ) + 1, ++i) {
+                printf("%d) %s\n", i, device);
+        }
+        
+        printf("\n");
+        printf("Output devices:\n");
+        
+        i = 0;
+        for(device = alcGetString(NULL, ALC_DEVICE_SPECIFIER); *device; 
+                device += strlen( device ) + 1, ++i) {
+                printf("%d) %s\n", i, device);
+        }
+        
+        return 0;
+}
+
+int print_help(const char* name, int rc)
+{
+        fprintf(stderr, "Usage: %s [-h] <in device> <out device>\n", name);
+        return rc;
+}
+
+long get_device_idx(const char* arg)
+{
+        if (strcmp(arg, "-") == 0)
+                return -1; /* Default */
+        
+        char *p;
+        long res = strtol(arg, &p, 10);
+        
+        if (*p) {
+                fprintf(stderr, "Invalid device!");
+                exit(1);
+        }
+        
+        return res;
+}
 
 int main (int argc, char** argv)
 {
+        if (argc == 2) {
+                if (strcmp(argv[1], "-d") == 0 || strcmp(argv[1], "--devices") == 0) {
+                        return print_devices();
+                }
+                if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
+                        return print_help(argv[0], 0);
+                }
+        }
+        
+        if (argc != 3) {
+                fprintf(stderr, "Invalid input!\n");
+                return print_help(argv[0], 1);
+        }
+        
+        int i;
+        
+        const char* in_device_name = "";
+        const char* out_device_name = "";
+        
+        {
+                long dev = get_device_idx(argv[1]);
+                if (dev == -1)
+                        in_device_name = alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
+                else
+                {
+                        const char* tmp;
+                        i = -1;
+                        for(tmp = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); *tmp && i != dev;
+                                tmp += strlen( tmp ) + 1, ++i)
+                                in_device_name = tmp;
+                }
+                
+                printf("Input device: %s\n", in_device_name);
+        }
+        
+        {
+                long dev = get_device_idx(argv[1]);
+                if (dev == -1)
+                        out_device_name = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
+                else
+                {
+                        const char* tmp;
+                        i = -1;
+                        for(tmp = alcGetString(NULL, ALC_DEVICE_SPECIFIER); *tmp && i != dev;
+                                tmp += strlen( tmp ) + 1, ++i)
+                                out_device_name = tmp;
+                }
+                
+                printf("Output device: %s\n", out_device_name);
+        }
+        
+        ALCdevice* out_device;
+        ALCcontext* out_ctx;
+        uint32_t source;
+        uint32_t buffers[5];
+        
+        { /* Open output device */
+                out_device = alcOpenDevice(out_device_name);
+                if ( !out_device ) {
+                        fprintf(stderr, "Failed to open playback device: %s: %d\n", out_device_name, alGetError());
+                        return 1;
+                }
+                
+                out_ctx = alcCreateContext(out_device, NULL);
+        alcMakeContextCurrent(out_ctx);
+                
+                alGenBuffers(5, buffers);
+                alGenSources((uint32_t)1, &source);
+                alSourcei(source, AL_LOOPING, AL_FALSE);
+                
+                uint16_t zeros[10000];
+                memset(zeros, 0, 10000);
+                
+                for ( i = 0; i < 5; ++i ) 
+                        alBufferData(buffers[i], AL_FORMAT_STEREO16, zeros, 10000, 48000);
+                
+                alSourceQueueBuffers(source, 5, buffers);
+                alSourcePlay(source);
+        }
+        
+        ALCdevice* in_device;
+        
+        { /* Open input device */
+                in_device = alcCaptureOpenDevice(in_device_name, 48000, AL_FORMAT_STEREO16, 10000);
+                if ( !in_device ) {
+                        fprintf(stderr, "Failed to open capture device: %s: %d\n", in_device_name, alGetError());
+                        return 1;
+                }
+                
+                alcCaptureStart(in_device);
+        }
+        
     Tox *Bsn = tox_new(0);
     Tox *Alice = tox_new(0);
     Tox *Bob = tox_new(0);
@@ -163,7 +377,7 @@ int main (int argc, char** argv)
     
 
 #define REGULAR_CALL_FLOW(A_BR, V_BR) \
-    { \
+        do { \
         memset(&AliceCC, 0, sizeof(CallControl)); \
         memset(&BobCC, 0, sizeof(CallControl)); \
         \
@@ -208,20 +422,26 @@ int main (int argc, char** argv)
             iterate(Bsn, AliceAV, BobAV); \
         } \
         printf("Success!\n");\
-    }
-    
-    printf("\nTrying regular call (Audio and Video)...\n");
-    REGULAR_CALL_FLOW(48, 4000);
-    
-    printf("\nTrying regular call (Audio only)...\n");
-    REGULAR_CALL_FLOW(48, 0);
-    
-    printf("\nTrying regular call (Video only)...\n");
-    REGULAR_CALL_FLOW(0, 4000);
+    } while(0)
     
+    if (TEST_REGULAR_AV) {
+                printf("\nTrying regular call (Audio and Video)...\n");
+                REGULAR_CALL_FLOW(48, 4000);
+        }
+        
+    if (TEST_REGULAR_A) {
+                printf("\nTrying regular call (Audio only)...\n");
+                REGULAR_CALL_FLOW(48, 0);
+        }
+        
+        if (TEST_REGULAR_V) {
+                printf("\nTrying regular call (Video only)...\n");
+                REGULAR_CALL_FLOW(0, 4000);
+        }
+        
 #undef REGULAR_CALL_FLOW
     
-    { /* Alice calls; Bob rejects */
+    if (TEST_REJECT) { /* Alice calls; Bob rejects */
         printf("\nTrying reject flow...\n");
         
         memset(&AliceCC, 0, sizeof(CallControl));
@@ -257,7 +477,7 @@ int main (int argc, char** argv)
         printf("Success!\n");
     }
     
-    { /* Alice calls; Alice cancels while ringing */
+    if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
         printf("\nTrying cancel (while ringing) flow...\n");
         
         memset(&AliceCC, 0, sizeof(CallControl));
@@ -294,10 +514,9 @@ int main (int argc, char** argv)
         printf("Success!\n");
     }
     
-    { /* Check Mute-Unmute etc */
+    if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
         printf("\nTrying mute functionality...\n");
         
-        
         memset(&AliceCC, 0, sizeof(CallControl));
         memset(&BobCC, 0, sizeof(CallControl));
         
@@ -382,7 +601,23 @@ int main (int argc, char** argv)
         printf("Success!\n");
     }
     
-    
+    if (TEST_TRANSFER_A) { /* Audio encoding/decoding and transfer */
+                printf("\nTrying audio enc/dec...\n");
+                
+                int16_t PCM[10000];
+                time_t start_time = time(NULL);
+                
+                /* Run for 5 seconds */
+                while ( start_time + 10 > time(NULL) ) {
+                        int frame_size = device_read_frame(in_device, 20, PCM, sizeof(PCM));
+                        if (frame_size > 0)
+                                device_play_frame(source, PCM, frame_size);
+//                      c_sleep(20);
+                }
+                
+                printf("Success!");
+        }
+        
     toxav_kill(BobAV);
     toxav_kill(AliceAV);
     tox_kill(Bob);
@@ -390,5 +625,8 @@ int main (int argc, char** argv)
     tox_kill(Bsn);
     
     printf("\nTest successful!\n");
+        
+        alcCloseDevice(out_device);
+        alcCaptureCloseDevice(in_device);
     return 0;
 }
\ No newline at end of file
diff --git a/toxav/codec.c b/toxav/codec.c
index 95e0beb4..bf94115e 100644
--- a/toxav/codec.c
+++ b/toxav/codec.c
@@ -41,7 +41,6 @@
 #define DEFAULT_JBUF 6
 
 /* Good quality encode. */
-#define MAX_ENCODE_TIME_US VPX_DL_GOOD_QUALITY
 #define MAX_DECODE_TIME_US 0
 
 #define MAX_VIDEOFRAME_SIZE 0x40000 /* 256KiB */
diff --git a/toxav/msi.c b/toxav/msi.c
index ac900dac..e21ec948 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -783,4 +783,4 @@ void handle_msi_packet ( Messenger *m, int friend_id, const uint8_t *data, uint1
         handle_pop(call, &msg); /* always kills the call */
     
     pthread_mutex_unlock(session->mutex);
-}
\ No newline at end of file
+}
diff --git a/toxav/toxav_new_1.c b/toxav/toxav_new_1.c
deleted file mode 100644
index 145dcf48..00000000
--- a/toxav/toxav_new_1.c
+++ /dev/null
@@ -1,688 +0,0 @@
-/**  toxav.c
- *
- *   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/>.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
-
-#define __TOX_DEFINED__
-typedef struct Messenger Tox;
-
-#define _GNU_SOURCE /* implicit declaration warning */
-
-#include "codec.h"
-#include "msi.h"
-#include "group.h"
-
-#include "../toxcore/logger.h"
-#include "../toxcore/util.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* Assume 24 fps*/
-#define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
-
-/* true if invalid call index */
-#define CALL_INVALID_INDEX(idx, max) (idx < 0 || idx >= max)
-
-const ToxAvCSettings av_DefaultSettings = {
-    av_TypeAudio,
-
-    500,
-    1280,
-    720,
-
-    32000,
-    20,
-    48000,
-    1
-};
-
-static const uint32_t jbuf_capacity = 6;
-static const uint8_t audio_index = 0, video_index = 1;
-
-typedef struct _ToxAvCall {
-    pthread_mutex_t mutex_control[1];
-    pthread_mutex_t mutex_encoding_audio[1];
-    pthread_mutex_t mutex_encoding_video[1];
-    pthread_mutex_t mutex_do[1];
-    RTPSession *crtps[2]; /** Audio is first and video is second */
-    CSSession *cs;
-    _Bool active;
-} ToxAvCall;
-
-struct _ToxAv {
-    Messenger *messenger;
-    MSISession *msi_session; /** Main msi session */
-    ToxAvCall *calls; /** Per-call params */
-    uint32_t max_calls;
-
-    PAIR(ToxAvAudioCallback, void *) acb;
-    PAIR(ToxAvVideoCallback, void *) vcb;
-
-    /* Decode time measure */
-    int32_t dectmsscount; /** Measure count */
-    int32_t dectmsstotal; /** Last cycle total */
-    int32_t avgdectms; /** Average decoding time in ms */
-};
-
-static const MSICSettings *msicsettings_cast (const ToxAvCSettings *from)
-{
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const MSICSettings *) from;
-}
-
-static const ToxAvCSettings *toxavcsettings_cast (const MSICSettings *from)
-{
-    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
-    return (const ToxAvCSettings *) from;
-
-}
-
-ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
-{
-    ToxAv *av = calloc ( sizeof(ToxAv), 1);
-
-    if (av == NULL) {
-        LOGGER_WARNING("Allocation failed!");
-        return NULL;
-    }
-
-    av->messenger = (Messenger *)messenger;
-    av->msi_session = msi_new(av->messenger, max_calls);
-    av->msi_session->agent_handler = av;
-    av->calls = calloc(sizeof(ToxAvCall), max_calls);
-    av->max_calls = max_calls;
-
-    unsigned int i;
-
-    for (i = 0; i < max_calls; ++i) {
-        if (create_recursive_mutex(av->calls[i].mutex_control) != 0 ) {
-            LOGGER_WARNING("Failed to init call(%u) mutex!", i);
-            msi_kill(av->msi_session);
-
-            free(av->calls);
-            free(av);
-            return NULL;
-        }
-    }
-
-    return av;
-}
-
-void toxav_kill ( ToxAv *av )
-{
-    uint32_t i;
-
-    for (i = 0; i < av->max_calls; i ++) {
-        if ( av->calls[i].crtps[audio_index] )
-            rtp_kill(av->calls[i].crtps[audio_index], av->msi_session->messenger_handle);
-
-
-        if ( av->calls[i].crtps[video_index] )
-            rtp_kill(av->calls[i].crtps[video_index], av->msi_session->messenger_handle);
-
-        if ( av->calls[i].cs )
-            cs_kill(av->calls[i].cs);
-
-        pthread_mutex_destroy(av->calls[i].mutex_control);
-    }
-
-    msi_kill(av->msi_session);
-
-    free(av->calls);
-    free(av);
-}
-
-uint32_t toxav_do_interval(ToxAv *av)
-{
-    int i = 0;
-    uint32_t rc = 200 + av->avgdectms; /* Return 200 if no call is active */
-
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-
-        if (av->calls[i].active) {
-            /* This should work. Video payload will always come in greater intervals */
-            rc = MIN(av->calls[i].cs->audio_decoder_frame_duration, rc);
-        }
-
-        pthread_mutex_unlock(av->calls[i].mutex_control);
-    }
-
-    return rc < av->avgdectms ? 0 : rc - av->avgdectms;
-}
-
-void toxav_do(ToxAv *av)
-{
-    msi_do(av->msi_session);
-    
-    uint64_t start = current_time_monotonic();
-    
-    uint32_t i = 0;
-    
-    for (; i < av->max_calls; i ++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-        
-        if (av->calls[i].active) {
-            pthread_mutex_lock(av->calls[i].mutex_do);
-            pthread_mutex_unlock(av->calls[i].mutex_control);
-            cs_do(av->calls[i].cs);
-            pthread_mutex_unlock(av->calls[i].mutex_do);
-        } else {
-            pthread_mutex_unlock(av->calls[i].mutex_control);
-        }
-    }
-    
-    uint64_t end = current_time_monotonic();
-    
-    /* TODO maybe use variable for sizes */
-    av->dectmsstotal += end - start;
-    
-    if (++av->dectmsscount == 3) {
-        av->avgdectms = av->dectmsstotal / 3 + 2 /* NOTE Magic Offset */;
-        av->dectmsscount = 0;
-        av->dectmsstotal = 0;
-    }
-}
-
-void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata )
-{
-    msi_register_callback(av->msi_session, (MSICallbackType)cb, (MSICallbackID) id, userdata);
-}
-
-void toxav_register_audio_callback(ToxAv *av, ToxAvAudioCallback cb, void *userdata)
-{
-    av->acb.first = cb;
-    av->acb.second = userdata;
-}
-
-void toxav_register_video_callback(ToxAv *av, ToxAvVideoCallback cb, void *userdata)
-{
-    av->vcb.first = cb;
-    av->vcb.second = userdata;
-}
-
-int toxav_call (ToxAv *av,
-                int32_t *call_index,
-                int user,
-                const ToxAvCSettings *csettings,
-                int ringing_seconds )
-{
-    return msi_invite(av->msi_session, call_index, msicsettings_cast(csettings), ringing_seconds * 1000, user);
-}
-
-int toxav_hangup ( ToxAv *av, int32_t call_index )
-{
-    return msi_hangup(av->msi_session, call_index);
-}
-
-int toxav_answer ( ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings )
-{
-    return msi_answer(av->msi_session, call_index, msicsettings_cast(csettings));
-}
-
-int toxav_reject ( ToxAv *av, int32_t call_index, const char *reason )
-{
-    return msi_reject(av->msi_session, call_index, reason);
-}
-
-int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reason )
-{
-    return msi_cancel(av->msi_session, call_index, peer_id, reason);
-}
-
-int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings)
-{
-    return msi_change_csettings(av->msi_session, call_index, msicsettings_cast(csettings));
-}
-
-int toxav_stop_call ( ToxAv *av, int32_t call_index )
-{
-    return msi_stopcall(av->msi_session, call_index);
-}
-
-int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, int support_video )
-{
-    if ( !av->msi_session || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) ||
-            !av->msi_session->calls[call_index] || !av->msi_session->calls[call_index]->csettings_peer) {
-        LOGGER_ERROR("Error while starting RTP session: invalid call!\n");
-        return av_ErrorNoCall;
-    }
-
-    ToxAvCall *call = &av->calls[call_index];
-
-    pthread_mutex_lock(call->mutex_control);
-
-    if (call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_ERROR("Error while starting RTP session: call already active!\n");
-        return av_ErrorAlreadyInCallWithPeer;
-    }
-
-    if (pthread_mutex_init(call->mutex_encoding_audio, NULL) != 0
-            || pthread_mutex_init(call->mutex_encoding_video, NULL) != 0 || pthread_mutex_init(call->mutex_do, NULL) != 0) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_ERROR("Error while starting RTP session: mutex initializing failed!\n");
-        return av_ErrorUnknown;
-    }
-
-    const ToxAvCSettings *c_peer = toxavcsettings_cast
-                                   (&av->msi_session->calls[call_index]->csettings_peer[0]);
-    const ToxAvCSettings *c_self = toxavcsettings_cast
-                                   (&av->msi_session->calls[call_index]->csettings_local);
-
-    LOGGER_DEBUG(
-        "Type: %u(s) %u(p)\n"
-        "Video bitrate: %u(s) %u(p)\n"
-        "Video height: %u(s) %u(p)\n"
-        "Video width: %u(s) %u(p)\n"
-        "Audio bitrate: %u(s) %u(p)\n"
-        "Audio framedur: %u(s) %u(p)\n"
-        "Audio sample rate: %u(s) %u(p)\n"
-        "Audio channels: %u(s) %u(p)\n",
-        c_self->call_type,              c_peer->call_type,
-        c_self->video_bitrate,          c_peer->video_bitrate,
-        c_self->max_video_height,       c_peer->max_video_height,
-        c_self->max_video_width,        c_peer->max_video_width,
-        c_self->audio_bitrate,          c_peer->audio_bitrate,
-        c_self->audio_frame_duration,   c_peer->audio_frame_duration,
-        c_self->audio_sample_rate,      c_peer->audio_sample_rate,
-        c_self->audio_channels,         c_peer->audio_channels );
-
-    if ( !(call->cs = cs_new(c_self, c_peer, jbuf_capacity, support_video)) ) {
-        LOGGER_ERROR("Error while starting Codec State!\n");
-        pthread_mutex_unlock(call->mutex_control);
-        return av_ErrorInitializingCodecs;
-    }
-
-    call->cs->agent = av;
-
-    call->cs->acb.first = av->acb.first;
-    call->cs->acb.second = av->acb.second;
-
-    call->cs->vcb.first = av->vcb.first;
-    call->cs->vcb.second = av->vcb.second;
-
-
-    call->crtps[audio_index] =
-        rtp_new(msi_TypeAudio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-
-    if ( !call->crtps[audio_index] ) {
-        LOGGER_ERROR("Error while starting audio RTP session!\n");
-        goto error;
-    }
-
-    call->crtps[audio_index]->cs = call->cs;
-
-    if ( support_video ) {
-        call->crtps[video_index] =
-            rtp_new(msi_TypeVideo, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-
-        if ( !call->crtps[video_index] ) {
-            LOGGER_ERROR("Error while starting video RTP session!\n");
-            goto error;
-        }
-
-        call->crtps[video_index]->cs = call->cs;
-    }
-
-    call->active = 1;
-    pthread_mutex_unlock(call->mutex_control);
-    return av_ErrorNone;
-error:
-    rtp_kill(call->crtps[audio_index], av->messenger);
-    call->crtps[audio_index] = NULL;
-    rtp_kill(call->crtps[video_index], av->messenger);
-    call->crtps[video_index] = NULL;
-    cs_kill(call->cs);
-    call->cs = NULL;
-    call->active = 0;
-    pthread_mutex_destroy(call->mutex_encoding_audio);
-    pthread_mutex_destroy(call->mutex_encoding_video);
-    pthread_mutex_destroy(call->mutex_do);
-
-    pthread_mutex_unlock(call->mutex_control);
-    return av_ErrorCreatingRtpSessions;
-}
-
-int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-
-    ToxAvCall *call = &av->calls[call_index];
-
-    pthread_mutex_lock(call->mutex_control);
-
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-
-    call->active = 0;
-
-    pthread_mutex_lock(call->mutex_encoding_audio);
-    pthread_mutex_unlock(call->mutex_encoding_audio);
-    pthread_mutex_lock(call->mutex_encoding_video);
-    pthread_mutex_unlock(call->mutex_encoding_video);
-    pthread_mutex_lock(call->mutex_do);
-    pthread_mutex_unlock(call->mutex_do);
-
-    rtp_kill(call->crtps[audio_index], av->messenger);
-    call->crtps[audio_index] = NULL;
-    rtp_kill(call->crtps[video_index], av->messenger);
-    call->crtps[video_index] = NULL;
-    cs_kill(call->cs);
-    call->cs = NULL;
-
-    pthread_mutex_destroy(call->mutex_encoding_audio);
-    pthread_mutex_destroy(call->mutex_encoding_video);
-    pthread_mutex_destroy(call->mutex_do);
-
-    pthread_mutex_unlock(call->mutex_control);
-
-    return av_ErrorNone;
-}
-
-static int toxav_send_rtp_payload(ToxAv *av,
-                                  ToxAvCall *call,
-                                  ToxAvCallType type,
-                                  const uint8_t *payload,
-                                  unsigned int length)
-{
-    if (call->crtps[type - av_TypeAudio]) {
-
-        /* Audio */
-        if (type == av_TypeAudio)
-            return rtp_send_msg(call->crtps[audio_index], av->messenger, payload, length);
-
-        /* Video */
-        int parts = cs_split_video_payload(call->cs, payload, length);
-
-        if (parts < 0) return parts;
-
-        uint16_t part_size;
-        const uint8_t *iter;
-
-        int i;
-
-        for (i = 0; i < parts; i++) {
-            iter = cs_iterate_split_video_frame(call->cs, &part_size);
-
-            if (rtp_send_msg(call->crtps[video_index], av->messenger, iter, part_size) < 0)
-                return av_ErrorSendingPayload;
-        }
-
-        return av_ErrorNone;
-
-    } else return av_ErrorNoRtpSession;
-}
-
-int toxav_prepare_video_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-
-
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-
-    if (cs_set_sending_video_resolution(call->cs, input->d_w, input->d_h) < 0) {
-        pthread_mutex_unlock(call->mutex_control);
-        return av_ErrorSettingVideoResolution;
-    }
-
-    pthread_mutex_lock(call->mutex_encoding_video);
-    pthread_mutex_unlock(call->mutex_control);
-
-    int rc = vpx_codec_encode(call->cs->v_encoder, input, call->cs->frame_counter, 1, 0, MAX_ENCODE_TIME_US);
-
-    if ( rc != VPX_CODEC_OK) {
-        LOGGER_ERROR("Could not encode video frame: %s\n", vpx_codec_err_to_string(rc));
-        pthread_mutex_unlock(call->mutex_encoding_video);
-        return av_ErrorEncodingVideo;
-    }
-
-    ++call->cs->frame_counter;
-
-    vpx_codec_iter_t iter = NULL;
-    const vpx_codec_cx_pkt_t *pkt;
-    int copied = 0;
-
-    while ( (pkt = vpx_codec_get_cx_data(call->cs->v_encoder, &iter)) ) {
-        if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
-            if ( copied + pkt->data.frame.sz > dest_max ) {
-                pthread_mutex_unlock(call->mutex_encoding_video);
-                return av_ErrorPacketTooLarge;
-            }
-
-            memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
-            copied += pkt->data.frame.sz;
-        }
-    }
-
-    pthread_mutex_unlock(call->mutex_encoding_video);
-    return copied;
-}
-
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size)
-{
-
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return av_ErrorNoCall;
-    }
-
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-
-
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-
-    int rc = toxav_send_rtp_payload(av, call, av_TypeVideo, frame, frame_size);
-    pthread_mutex_unlock(call->mutex_control);
-
-    return rc;
-}
-
-int toxav_prepare_audio_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                const int16_t *frame,
-                                int frame_size)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
-
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-
-    pthread_mutex_lock(call->mutex_encoding_audio);
-    pthread_mutex_unlock(call->mutex_control);
-    int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
-    pthread_mutex_unlock(call->mutex_encoding_audio);
-
-    if (rc < 0) {
-        LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
-        return av_ErrorEncodingAudio;
-    }
-
-    return rc;
-}
-
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *data, unsigned int size)
-{
-    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
-        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
-        return av_ErrorNoCall;
-    }
-
-    ToxAvCall *call = &av->calls[call_index];
-    pthread_mutex_lock(call->mutex_control);
-
-
-    if (!call->active) {
-        pthread_mutex_unlock(call->mutex_control);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return av_ErrorInvalidState;
-    }
-
-    int rc = toxav_send_rtp_payload(av, call, av_TypeAudio, data, size);
-    pthread_mutex_unlock(call->mutex_control);
-    return rc;
-}
-
-int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest )
-{
-    if ( peer < 0 || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) ||
-            !av->msi_session->calls[call_index] || av->msi_session->calls[call_index]->peer_count <= peer )
-        return av_ErrorNoCall;
-
-    *dest = *toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_peer[peer]);
-    return av_ErrorNone;
-}
-
-int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
-{
-    if ( peer < 0 || CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) || !av->msi_session->calls[call_index]
-            || av->msi_session->calls[call_index]->peer_count <= peer )
-        return av_ErrorNoCall;
-
-    return av->msi_session->calls[call_index]->peers[peer];
-}
-
-ToxAvCallState toxav_get_call_state(ToxAv *av, int32_t call_index)
-{
-    if ( CALL_INVALID_INDEX(call_index, av->msi_session->max_calls) || !av->msi_session->calls[call_index] )
-        return av_CallNonExistent;
-
-    return av->msi_session->calls[call_index]->state;
-
-}
-
-int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability )
-{
-}
-
-Tox *toxav_get_tox(ToxAv *av)
-{
-    return (Tox *)av->messenger;
-}
-
-int toxav_get_active_count(ToxAv *av)
-{
-    if (!av) return -1;
-
-    int rc = 0, i = 0;
-
-    for (; i < av->max_calls; i++) {
-        pthread_mutex_lock(av->calls[i].mutex_control);
-
-        if (av->calls[i].active) rc++;
-
-        pthread_mutex_unlock(av->calls[i].mutex_control);
-    }
-
-    return rc;
-}
-
-/* Create a new toxav group.
- *
- * return group number on success.
- * return -1 on failure.
- *
- * Audio data callback format:
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_add_av_groupchat(Tox *tox, void (*audio_callback)(Messenger *, int, int, const int16_t *, unsigned int,
-                           uint8_t, unsigned int, void *), void *userdata)
-{
-    Messenger *m = tox;
-    return add_av_groupchat(m->group_chat_object, audio_callback, userdata);
-}
-
-/* Join a AV group (you need to have been invited first.)
- *
- * returns group number on success
- * returns -1 on failure.
- *
- * Audio data callback format (same as the one for toxav_add_av_groupchat()):
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_join_av_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
-                            void (*audio_callback)(Messenger *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *),
-                            void *userdata)
-{
-    Messenger *m = tox;
-    return join_av_groupchat(m->group_chat_object, friendnumber, data, length, audio_callback, userdata);
-}
-
-/* Send audio to the group chat.
- *
- * return 0 on success.
- * return -1 on failure.
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- *
- * Valid number of samples are ((sample rate) * (audio length (Valid ones are: 2.5, 5, 10, 20, 40 or 60 ms)) / 1000)
- * Valid number of channels are 1 or 2.
- * Valid sample rates are 8000, 12000, 16000, 24000, or 48000.
- *
- * Recommended values are: samples = 960, channels = 1, sample_rate = 48000
- */
-int toxav_group_send_audio(Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
-                           unsigned int sample_rate)
-{
-    Messenger *m = tox;
-    return group_send_audio(m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
-}
-
diff --git a/toxav/toxav_new_1.h b/toxav/toxav_new_1.h
deleted file mode 100644
index 3696f961..00000000
--- a/toxav/toxav_new_1.h
+++ /dev/null
@@ -1,329 +0,0 @@
-/**  toxav.h
- *
- *   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 __TOXAV
-#define __TOXAV
-#include <inttypes.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _ToxAv ToxAv;
-
-/* vpx_image_t */
-#include <vpx/vpx_image.h>
-
-typedef void ( *ToxAVCallback ) ( void *agent, int32_t call_idx, void *arg );
-typedef void ( *ToxAvAudioCallback ) (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data);
-typedef void ( *ToxAvVideoCallback ) (void *agent, int32_t call_idx, const vpx_image_t *img, void *data);
-
-#ifndef __TOX_DEFINED__
-#define __TOX_DEFINED__
-typedef struct Tox Tox;
-#endif
-
-#define RTP_PAYLOAD_SIZE 65535
-
-
-/**
- * Callbacks ids that handle the call states.
- */
-typedef enum {
-    av_OnInvite, /* Incoming call */
-    av_OnRinging, /* When peer is ready to accept/reject the call */
-    av_OnStart, /* Call (RTP transmission) started */
-    av_OnCancel, /* The side that initiated call canceled invite */
-    av_OnReject, /* The side that was invited rejected the call */
-    av_OnEnd, /* Call that was active ended */
-    av_OnRequestTimeout, /* When the requested action didn't get response in specified time */
-    av_OnPeerTimeout, /* Peer timed out; stop the call */
-    av_OnPeerCSChange, /* Peer changing Csettings. Prepare for changed AV */
-    av_OnSelfCSChange /* Csettings change confirmation. Once triggered peer is ready to recv changed AV */
-} ToxAvCallbackID;
-
-
-/**
- * Call type identifier.
- */
-typedef enum {
-    av_TypeAudio = 192,
-    av_TypeVideo
-} ToxAvCallType;
-
-
-typedef enum {
-    av_CallNonExistent = -1,
-    av_CallInviting, /* when sending call invite */
-    av_CallStarting, /* when getting call invite */
-    av_CallActive,
-    av_CallHold,
-    av_CallHungUp
-} ToxAvCallState;
-
-/**
- * Error indicators. Values under -20 are reserved for toxcore.
- */
-typedef enum {
-    av_ErrorNone = 0,
-    av_ErrorUnknown = -1, /* Unknown error */
-    av_ErrorNoCall = -20, /* Trying to perform call action while not in a call */
-    av_ErrorInvalidState = -21, /* Trying to perform call action while in invalid state*/
-    av_ErrorAlreadyInCallWithPeer = -22, /* Trying to call peer when already in a call with peer */
-    av_ErrorReachedCallLimit = -23, /* Cannot handle more calls */
-    av_ErrorInitializingCodecs = -30, /* Failed creating CSSession */
-    av_ErrorSettingVideoResolution = -31, /* Error setting resolution */
-    av_ErrorSettingVideoBitrate = -32, /* Error setting bitrate */
-    av_ErrorSplittingVideoPayload = -33, /* Error splitting video payload */
-    av_ErrorEncodingVideo = -34, /* vpx_codec_encode failed */
-    av_ErrorEncodingAudio = -35, /* opus_encode failed */
-    av_ErrorSendingPayload = -40, /* Sending lossy packet failed */
-    av_ErrorCreatingRtpSessions = -41, /* One of the rtp sessions failed to initialize */
-    av_ErrorNoRtpSession = -50, /* Trying to perform rtp action on invalid session */
-    av_ErrorInvalidCodecState = -51, /* Codec state not initialized */
-    av_ErrorPacketTooLarge = -52, /* Split packet exceeds it's limit */
-} ToxAvError;
-
-
-/**
- * Locally supported capabilities.
- */
-typedef enum {
-    av_AudioEncoding = 1 << 0,
-    av_AudioDecoding = 1 << 1,
-    av_VideoEncoding = 1 << 2,
-    av_VideoDecoding = 1 << 3
-} ToxAvCapabilities;
-
-
-/**
- * Encoding settings.
- */
-typedef struct _ToxAvCSettings {
-    ToxAvCallType call_type;
-
-    uint32_t video_bitrate; /* In kbits/s */
-    uint16_t max_video_width; /* In px */
-    uint16_t max_video_height; /* In px */
-
-    uint32_t audio_bitrate; /* In bits/s */
-    uint16_t audio_frame_duration; /* In ms */
-    uint32_t audio_sample_rate; /* In Hz */
-    uint32_t audio_channels;
-} ToxAvCSettings;
-
-extern const ToxAvCSettings av_DefaultSettings;
-
-/**
- * Start new A/V session. There can only be one session at the time.
- */
-ToxAv *toxav_new(Tox *messenger, int32_t max_calls);
-
-/**
- * Remove A/V session.
- */
-void toxav_kill(ToxAv *av);
-
-/**
- * Returns the interval in milliseconds when the next toxav_do() should be called.
- * If no call is active at the moment returns 200.
- */
-uint32_t toxav_do_interval(ToxAv *av);
-
-/**
- * Main loop for the session. Best called right after tox_do();
- */
-void toxav_do(ToxAv *av);
-
-/**
- * Register callback for call state.
- */
-void toxav_register_callstate_callback (ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata);
-
-/**
- * Register callback for audio data.
- */
-void toxav_register_audio_callback (ToxAv *av, ToxAvAudioCallback cb, void *userdata);
-
-/**
- * Register callback for video data.
- */
-void toxav_register_video_callback (ToxAv *av, ToxAvVideoCallback cb, void *userdata);
-
-/**
- * Call user. Use its friend_id.
- */
-int toxav_call(ToxAv *av,
-               int32_t *call_index,
-               int friend_id,
-               const ToxAvCSettings *csettings,
-               int ringing_seconds);
-
-/**
- * Hangup active call.
- */
-int toxav_hangup(ToxAv *av, int32_t call_index);
-
-/**
- * Answer incoming call. Pass the csettings that you will use.
- */
-int toxav_answer(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings );
-
-/**
- * Reject incoming call.
- */
-int toxav_reject(ToxAv *av, int32_t call_index, const char *reason);
-
-/**
- * Cancel outgoing request.
- */
-int toxav_cancel(ToxAv *av, int32_t call_index, int peer_id, const char *reason);
-
-/**
- * Notify peer that we are changing codec settings.
- */
-int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings);
-
-/**
- * Terminate transmission. Note that transmission will be
- * terminated without informing remote peer. Usually called when we can't inform peer.
- */
-int toxav_stop_call(ToxAv *av, int32_t call_index);
-
-/**
- * Allocates transmission data. Must be call before calling toxav_prepare_* and toxav_send_*.
- * Also, it must be called when call is started
- */
-int toxav_prepare_transmission(ToxAv *av, int32_t call_index, int support_video);
-
-/**
- * Clears transmission data. Call this at the end of the transmission.
- */
-int toxav_kill_transmission(ToxAv *av, int32_t call_index);
-
-/**
- * Encode video frame.
- */
-int toxav_prepare_video_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                vpx_image_t *input);
-
-/**
- * Send encoded video packet.
- */
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, uint32_t frame_size);
-
-/**
- * Encode audio frame.
- */
-int toxav_prepare_audio_frame ( ToxAv *av,
-                                int32_t call_index,
-                                uint8_t *dest,
-                                int dest_max,
-                                const int16_t *frame,
-                                int frame_size);
-
-/**
- * Send encoded audio frame.
- */
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int size);
-
-/**
- * Get codec settings from the peer. These were exchanged during call initialization
- * or when peer send us new csettings.
- */
-int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest );
-
-/**
- * Get friend id of peer participating in conversation.
- */
-int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer );
-
-/**
- * Get current call state.
- */
-ToxAvCallState toxav_get_call_state ( ToxAv *av, int32_t call_index );
-
-/**
- * Is certain capability supported. Used to determine if encoding/decoding is ready.
- */
-int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability );
-
-/**
- * Returns tox reference.
- */
-Tox *toxav_get_tox (ToxAv *av);
-
-/**
- * Returns number of active calls or -1 on error.
- */
-int toxav_get_active_count (ToxAv *av);
-
-/* Create a new toxav group.
- *
- * return group number on success.
- * return -1 on failure.
- *
- * Audio data callback format:
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_add_av_groupchat(Tox *tox, void (*audio_callback)(Tox *, int, int, const int16_t *, unsigned int, uint8_t,
-                           unsigned int, void *), void *userdata);
-
-/* Join a AV group (you need to have been invited first.)
- *
- * returns group number on success
- * returns -1 on failure.
- *
- * Audio data callback format (same as the one for toxav_add_av_groupchat()):
- *   audio_callback(Tox *tox, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples, uint8_t channels, unsigned int sample_rate, void *userdata)
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- */
-int toxav_join_av_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
-                            void (*audio_callback)(Tox *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *), void *userdata);
-
-/* Send audio to the group chat.
- *
- * return 0 on success.
- * return -1 on failure.
- *
- * Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
- *
- * Valid number of samples are ((sample rate) * (audio length (Valid ones are: 2.5, 5, 10, 20, 40 or 60 ms)) / 1000)
- * Valid number of channels are 1 or 2.
- * Valid sample rates are 8000, 12000, 16000, 24000, or 48000.
- *
- * Recommended values are: samples = 960, channels = 1, sample_rate = 48000
- */
-int toxav_group_send_audio(Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
-                           unsigned int sample_rate);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __TOXAV */
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 919655a2..2d3d6ffe 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -207,7 +207,7 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_
         }
 
         if (ipv6 == 0) {
-            uint32_t size = 1 + sizeof(IP4) + sizeof(uint16_t) + CLIENT_ID_SIZE;
+            uint32_t size = 1 + sizeof(IP4) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES;
 
             if (packed_length + size > length)
                 return -1;
@@ -215,10 +215,10 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_
             data[packed_length] = net_family;
             memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip4, sizeof(IP4));
             memcpy(data + packed_length + 1 + sizeof(IP4), &nodes[i].ip_port.port, sizeof(uint16_t));
-            memcpy(data + packed_length + 1 + sizeof(IP4) + sizeof(uint16_t), nodes[i].client_id, CLIENT_ID_SIZE);
+            memcpy(data + packed_length + 1 + sizeof(IP4) + sizeof(uint16_t), nodes[i].public_key, crypto_box_PUBLICKEYBYTES);
             packed_length += size;
         } else if (ipv6 == 1) {
-            uint32_t size = 1 + sizeof(IP6) + sizeof(uint16_t) + CLIENT_ID_SIZE;
+            uint32_t size = 1 + sizeof(IP6) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES;
 
             if (packed_length + size > length)
                 return -1;
@@ -226,7 +226,7 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_
             data[packed_length] = net_family;
             memcpy(data + packed_length + 1, &nodes[i].ip_port.ip.ip6, sizeof(IP6));
             memcpy(data + packed_length + 1 + sizeof(IP6), &nodes[i].ip_port.port, sizeof(uint16_t));
-            memcpy(data + packed_length + 1 + sizeof(IP6) + sizeof(uint16_t), nodes[i].client_id, CLIENT_ID_SIZE);
+            memcpy(data + packed_length + 1 + sizeof(IP6) + sizeof(uint16_t), nodes[i].public_key, crypto_box_PUBLICKEYBYTES);
             packed_length += size;
         } else {
             return -1;
@@ -275,7 +275,7 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
         }
 
         if (ipv6 == 0) {
-            uint32_t size = 1 + sizeof(IP4) + sizeof(uint16_t) + CLIENT_ID_SIZE;
+            uint32_t size = 1 + sizeof(IP4) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES;
 
             if (len_processed + size > length)
                 return -1;
@@ -283,11 +283,11 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
             nodes[num].ip_port.ip.family = host_family;
             memcpy(&nodes[num].ip_port.ip.ip4, data + len_processed + 1, sizeof(IP4));
             memcpy(&nodes[num].ip_port.port, data + len_processed + 1 + sizeof(IP4), sizeof(uint16_t));
-            memcpy(nodes[num].client_id, data + len_processed + 1 + sizeof(IP4) + sizeof(uint16_t), CLIENT_ID_SIZE);
+            memcpy(nodes[num].public_key, data + len_processed + 1 + sizeof(IP4) + sizeof(uint16_t), crypto_box_PUBLICKEYBYTES);
             len_processed += size;
             ++num;
         } else if (ipv6 == 1) {
-            uint32_t size = 1 + sizeof(IP6) + sizeof(uint16_t) + CLIENT_ID_SIZE;
+            uint32_t size = 1 + sizeof(IP6) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES;
 
             if (len_processed + size > length)
                 return -1;
@@ -295,7 +295,7 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
             nodes[num].ip_port.ip.family = host_family;
             memcpy(&nodes[num].ip_port.ip.ip6, data + len_processed + 1, sizeof(IP6));
             memcpy(&nodes[num].ip_port.port, data + len_processed + 1 + sizeof(IP6), sizeof(uint16_t));
-            memcpy(nodes[num].client_id, data + len_processed + 1 + sizeof(IP6) + sizeof(uint16_t), CLIENT_ID_SIZE);
+            memcpy(nodes[num].public_key, data + len_processed + 1 + sizeof(IP6) + sizeof(uint16_t), crypto_box_PUBLICKEYBYTES);
             len_processed += size;
             ++num;
         } else {
@@ -397,12 +397,12 @@ static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const u
  *  return 1 if true.
  *  return 0 if false.
  */
-static int client_in_nodelist(const Node_format *list, uint16_t length, const uint8_t *client_id)
+static int client_in_nodelist(const Node_format *list, uint16_t length, const uint8_t *public_key)
 {
     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))
             return 1;
     }
 
@@ -484,9 +484,9 @@ static void get_close_nodes_inner(const uint8_t *client_id, Node_format *nodes_l
             continue;
 
         if (num_nodes < MAX_SENT_NODES) {
-            memcpy(nodes_list[num_nodes].client_id,
+            memcpy(nodes_list[num_nodes].public_key,
                    client->client_id,
-                   CLIENT_ID_SIZE );
+                   crypto_box_PUBLICKEYBYTES );
 
             nodes_list[num_nodes].ip_port = ipptp->ip_port;
             num_nodes++;
@@ -497,14 +497,14 @@ static void get_close_nodes_inner(const uint8_t *client_id, Node_format *nodes_l
              */
             for (j = 0; j < MAX_SENT_NODES; ++j) {
                 closest = id_closest(   client_id,
-                                        nodes_list[j].client_id,
+                                        nodes_list[j].public_key,
                                         client->client_id );
 
                 /* second client_id is closer than current: change to it */
                 if (closest == 2) {
-                    memcpy( nodes_list[j].client_id,
+                    memcpy( nodes_list[j].public_key,
                             client->client_id,
-                            CLIENT_ID_SIZE);
+                            crypto_box_PUBLICKEYBYTES);
 
                     nodes_list[j].ip_port = ipptp->ip_port;
                     break;
@@ -583,7 +583,7 @@ int get_close_nodes(const DHT *dht, const uint8_t *client_id, Node_format *nodes
         Client_data *client = result[i];
 
         if (client) {
-            id_copy(nodes_list[num_returned].client_id, client->client_id);
+            id_copy(nodes_list[num_returned].public_key, client->client_id);
 
             if (sa_family == AF_INET)
                 if (ipport_isset(&client->assoc4.ip_port)) {
@@ -647,6 +647,21 @@ static int cmp_dht_entry(const void *a, const void *b)
     return 0;
 }
 
+/* Is it ok to store node with client_id 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)
+{
+    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)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
 /* Replace a first bad (or empty) node with this one
  *  or replace a possibly bad node (tests failed or not done yet)
  *  that is further than any other in the list
@@ -674,8 +689,7 @@ static int replace_all(   Client_data    *list,
 
     Client_data *client = &list[0];
 
-    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)) {
+    if (store_node_ok(client, client_id, comp_client_id)) {
         IPPTsPng *ipptp_write = NULL;
         IPPTsPng *ipptp_clear = NULL;
 
@@ -704,6 +718,29 @@ static int replace_all(   Client_data    *list,
     return 0;
 }
 
+/* Check if the node obtained with a get_nodes with client_id 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)
+{
+    if (store_node_ok(&dht->close_clientlist[0], client_id, 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)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
 /* Attempt to add client with ip_port and client_id to the friends client list
  * and close_clientlist.
  *
@@ -860,7 +897,7 @@ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const
     uint8_t plain_message[sizeof(Node_format) * 2] = {0};
 
     Node_format receiver;
-    memcpy(receiver.client_id, public_key, CLIENT_ID_SIZE);
+    memcpy(receiver.public_key, public_key, CLIENT_ID_SIZE);
     receiver.ip_port = ip_port;
     memcpy(plain_message, &receiver, sizeof(receiver));
 
@@ -1004,7 +1041,7 @@ static uint8_t sent_getnode_to_node(DHT *dht, const uint8_t *client_id, IP_Port
     Node_format test;
     memcpy(&test, data, sizeof(Node_format));
 
-    if (!ipport_equal(&test.ip_port, &node_ip_port) || memcmp(test.client_id, client_id, CLIENT_ID_SIZE) != 0)
+    if (!ipport_equal(&test.ip_port, &node_ip_port) || memcmp(test.public_key, client_id, CLIENT_ID_SIZE) != 0)
         return 0;
 
     return 1;
@@ -1091,9 +1128,10 @@ static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *pa
     uint32_t i;
 
     for (i = 0; i < num_nodes; i++) {
-        if (ipport_isset(&plain_nodes[i].ip_port)) {
-            send_ping_request(dht->ping, plain_nodes[i].ip_port, plain_nodes[i].client_id);
-            returnedip_ports(dht, plain_nodes[i].ip_port, plain_nodes[i].client_id, packet + 1);
+        if (ipport_isset(&plain_nodes[i].ip_port) && (LAN_ip(plain_nodes[i].ip_port.ip) == 0
+                || ping_node_from_getnodes_ok(dht, plain_nodes[i].public_key))) {
+            send_ping_request(dht->ping, plain_nodes[i].ip_port, plain_nodes[i].public_key);
+            returnedip_ports(dht, plain_nodes[i].ip_port, plain_nodes[i].public_key, packet + 1);
         }
     }
 
@@ -1847,7 +1885,7 @@ static int send_hardening_req(DHT *dht, Node_format *sendto, uint8_t type, uint8
     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->client_id, data,
+    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)
@@ -1877,7 +1915,7 @@ static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto,
     data[0] = CHECK_TYPE_GETNODE_RES;
     memcpy(data + 1, queried_client_id, CLIENT_ID_SIZE);
     memcpy(data + 1 + CLIENT_ID_SIZE, nodes_data, nodes_data_length);
-    int len = create_request(dht->self_public_key, dht->self_secret_key, packet, sendto->client_id, data,
+    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)
@@ -1914,12 +1952,12 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
     uint32_t i;
 
     for (i = 0; i < num; ++i) {
-        if (id_equal(nodes[i].client_id, dht->self_public_key)) {
+        if (id_equal(nodes[i].public_key, dht->self_public_key)) {
             ++counter;
             continue;
         }
 
-        IPPTsPng *temp = get_closelist_IPPTsPng(dht, nodes[i].client_id, nodes[i].ip_port.ip.family);
+        IPPTsPng *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)) {
@@ -1952,10 +1990,10 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_
 
             Node_format node, tocheck_node;
             node.ip_port = source;
-            memcpy(node.client_id, source_pubkey, CLIENT_ID_SIZE);
+            memcpy(node.public_key, source_pubkey, crypto_box_PUBLICKEYBYTES);
             memcpy(&tocheck_node, packet + 1, sizeof(Node_format));
 
-            if (getnodes(dht, tocheck_node.ip_port, tocheck_node.client_id, 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;
@@ -2052,7 +2090,7 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
         }
 
         if (assoc != NULL) {
-            memcpy(nodes[count].client_id, list[i - 1].client_id, CLIENT_ID_SIZE);
+            memcpy(nodes[count].public_key, list[i - 1].client_id, CLIENT_ID_SIZE);
             nodes[count].ip_port = assoc->ip_port;
             ++count;
 
@@ -2091,16 +2129,16 @@ void do_hardening(DHT *dht)
                 if (!ipport_isset(&rand_node.ip_port))
                     continue;
 
-                if (id_equal(client_id, rand_node.client_id))
+                if (id_equal(client_id, rand_node.public_key))
                     continue;
 
                 Node_format to_test;
                 to_test.ip_port = cur_iptspng->ip_port;
-                memcpy(to_test.client_id, client_id, CLIENT_ID_SIZE);
+                memcpy(to_test.public_key, client_id, 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) {
-                    memcpy(cur_iptspng->hardening.send_nodes_pingedid, rand_node.client_id, CLIENT_ID_SIZE);
+                    memcpy(cur_iptspng->hardening.send_nodes_pingedid, rand_node.public_key, crypto_box_PUBLICKEYBYTES);
                     cur_iptspng->hardening.send_nodes_timestamp = unix_time();
                 }
             }
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index 47a828d7..318a6002 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -148,7 +148,7 @@ typedef struct {
 } DHT_Friend;
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     IP_Port     ip_port;
 }
 Node_format;
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index f87f1348..bc020d87 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -152,6 +152,11 @@ static void fetch_broadcast_info(uint16_t port)
         IP_Port *ip_port = &broadcast_ip_port[broadcast_count];
         ip_port->ip.family = AF_INET;
         ip_port->ip.ip4.in_addr = sock4->sin_addr;
+
+        if (ip_port->ip.ip4.uint32 == 0) {
+            continue;
+        }
+
         ip_port->port = port;
         broadcast_count++;
     }
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index c310412d..4cf0edeb 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -89,32 +89,32 @@ int realloc_friendlist(Messenger *m, uint32_t num)
 /*  return the friend id associated to that public key.
  *  return -1 if no such friend.
  */
-int32_t getfriend_id(const Messenger *m, const uint8_t *client_id)
+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(client_id, m->friendlist[i].client_id))
+            if (id_equal(real_pk, m->friendlist[i].real_pk))
                 return i;
     }
 
     return -1;
 }
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
+/* Copies the public key associated to that friend id into real_pk buffer.
+ * Make sure that real_pk is of size crypto_box_PUBLICKEYBYTES.
  *
  *  return 0 if success.
  *  return -1 if failure.
  */
-int getclient_id(const Messenger *m, int32_t friendnumber, uint8_t *client_id)
+int get_real_pk(const Messenger *m, int32_t friendnumber, uint8_t *real_pk)
 {
     if (friend_not_valid(m, friendnumber))
         return -1;
 
     if (m->friendlist[friendnumber].status > 0) {
-        memcpy(client_id, m->friendlist[friendnumber].client_id, CLIENT_ID_SIZE);
+        memcpy(real_pk, m->friendlist[friendnumber].real_pk, crypto_box_PUBLICKEYBYTES);
         return 0;
     }
 
@@ -149,7 +149,7 @@ static uint16_t address_checksum(const uint8_t *address, uint32_t len)
     return check;
 }
 
-/* Format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
+/* Format: [real_pk (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
  *
  *  return FRIEND_ADDRESS_SIZE byte address to give to others.
  */
@@ -183,6 +183,54 @@ 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 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)
+        return FAERR_NOMEM;
+
+    memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend));
+
+    int friendcon_id = new_friend_connection(m->fr_c, real_pk);
+
+    if (friendcon_id == -1)
+        return FAERR_UNKNOWN;
+
+    uint32_t i;
+
+    for (i = 0; i <= m->numfriends; ++i) {
+        if (m->friendlist[i].status == NOFRIEND) {
+            m->friendlist[i].status = status;
+            m->friendlist[i].friendcon_id = friendcon_id;
+            m->friendlist[i].friendrequest_lastsent = 0;
+            id_copy(m->friendlist[i].real_pk, real_pk);
+            m->friendlist[i].statusmessage = calloc(1, 1);
+            m->friendlist[i].statusmessage_length = 1;
+            m->friendlist[i].userstatus = USERSTATUS_NONE;
+            m->friendlist[i].avatar_info_sent = 0;
+            m->friendlist[i].avatar_recv_data = NULL;
+            m->friendlist[i].avatar_send_data.bytes_sent = 0;
+            m->friendlist[i].avatar_send_data.last_reset = 0;
+            m->friendlist[i].is_typing = 0;
+            m->friendlist[i].message_id = 0;
+            m->friendlist[i].receives_read_receipts = 1; /* Default: YES. */
+            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
+                                        &handle_custom_lossy_packet, m, i);
+
+            if (m->numfriends == i)
+                ++m->numfriends;
+
+            if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
+                send_online_packet(m, i);
+            }
+
+            return i;
+        }
+    }
+
+    return FAERR_UNKNOWN;
+}
+
 /*
  * Add a friend.
  * Set the data that will be sent along with friend request.
@@ -205,10 +253,10 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
     if (length > MAX_FRIEND_REQUEST_DATA_SIZE)
         return FAERR_TOOLONG;
 
-    uint8_t client_id[crypto_box_PUBLICKEYBYTES];
-    id_copy(client_id, address);
+    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    id_copy(real_pk, address);
 
-    if (!public_key_valid(client_id))
+    if (!public_key_valid(real_pk))
         return FAERR_BADCHECKSUM;
 
     uint16_t check, checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
@@ -220,10 +268,10 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
     if (length < 1)
         return FAERR_NOMESSAGE;
 
-    if (id_equal(client_id, m->net_crypto->self_public_key))
+    if (id_equal(real_pk, m->net_crypto->self_public_key))
         return FAERR_OWNKEY;
 
-    int32_t friend_id = getfriend_id(m, client_id);
+    int32_t friend_id = getfriend_id(m, real_pk);
 
     if (friend_id != -1) {
         if (m->friendlist[friend_id].status >= FRIEND_CONFIRMED)
@@ -239,111 +287,38 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
         return FAERR_SETNEWNOSPAM;
     }
 
-    /* Resize the friend list if necessary. */
-    if (realloc_friendlist(m, m->numfriends + 1) != 0)
-        return FAERR_NOMEM;
-
-    memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend));
-
-    int friendcon_id = new_friend_connection(m->fr_c, client_id);
+    int32_t ret = init_new_friend(m, real_pk, FRIEND_ADDED);
 
-    if (friendcon_id == -1)
-        return -1;
-
-    uint32_t i;
-
-    for (i = 0; i <= m->numfriends; ++i)  {
-        if (m->friendlist[i].status == NOFRIEND) {
-            m->friendlist[i].status = FRIEND_ADDED;
-            m->friendlist[i].friendcon_id = friendcon_id;
-            m->friendlist[i].friendrequest_lastsent = 0;
-            m->friendlist[i].friendrequest_timeout = FRIENDREQUEST_TIMEOUT;
-            id_copy(m->friendlist[i].client_id, client_id);
-            m->friendlist[i].statusmessage = calloc(1, 1);
-            m->friendlist[i].statusmessage_length = 1;
-            m->friendlist[i].userstatus = USERSTATUS_NONE;
-            m->friendlist[i].avatar_info_sent = 0;
-            m->friendlist[i].avatar_recv_data = NULL;
-            m->friendlist[i].avatar_send_data.bytes_sent = 0;
-            m->friendlist[i].avatar_send_data.last_reset = 0;
-            m->friendlist[i].is_typing = 0;
-            memcpy(m->friendlist[i].info, data, length);
-            m->friendlist[i].info_size = length;
-            m->friendlist[i].message_id = 0;
-            m->friendlist[i].receives_read_receipts = 1; /* Default: YES. */
-            memcpy(&(m->friendlist[i].friendrequest_nospam), address + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
-            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
-                                        &handle_custom_lossy_packet, m, i);
-
-            if (m->numfriends == i)
-                ++m->numfriends;
-
-            if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
-                send_online_packet(m, i);
-            }
-
-            return i;
-        }
+    if (ret < 0) {
+        return ret;
     }
 
-    return FAERR_UNKNOWN;
+    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));
+
+    return ret;
 }
 
-int32_t m_addfriend_norequest(Messenger *m, const uint8_t *client_id)
+int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk)
 {
-    if (getfriend_id(m, client_id) != -1)
+    if (getfriend_id(m, real_pk) != -1)
         return -1;
 
-    if (!public_key_valid(client_id))
+    if (!public_key_valid(real_pk))
         return -1;
 
-    /* Resize the friend list if necessary. */
-    if (realloc_friendlist(m, m->numfriends + 1) != 0)
+    if (id_equal(real_pk, m->net_crypto->self_public_key))
         return -1;
 
-    if (id_equal(client_id, m->net_crypto->self_public_key))
-        return -1;
-
-    memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend));
-
-    int friendcon_id = new_friend_connection(m->fr_c, client_id);
+    int32_t ret = init_new_friend(m, real_pk, FRIEND_CONFIRMED);
 
-    if (friendcon_id == -1)
+    if (ret < 0) {
         return -1;
-
-    uint32_t i;
-
-    for (i = 0; i <= m->numfriends; ++i) {
-        if (m->friendlist[i].status == NOFRIEND) {
-            m->friendlist[i].status = FRIEND_CONFIRMED;
-            m->friendlist[i].friendcon_id = friendcon_id;
-            m->friendlist[i].friendrequest_lastsent = 0;
-            id_copy(m->friendlist[i].client_id, client_id);
-            m->friendlist[i].statusmessage = calloc(1, 1);
-            m->friendlist[i].statusmessage_length = 1;
-            m->friendlist[i].userstatus = USERSTATUS_NONE;
-            m->friendlist[i].avatar_info_sent = 0;
-            m->friendlist[i].avatar_recv_data = NULL;
-            m->friendlist[i].avatar_send_data.bytes_sent = 0;
-            m->friendlist[i].avatar_send_data.last_reset = 0;
-            m->friendlist[i].is_typing = 0;
-            m->friendlist[i].message_id = 0;
-            m->friendlist[i].receives_read_receipts = 1; /* Default: YES. */
-            friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
-                                        &handle_custom_lossy_packet, m, i);
-
-            if (m->numfriends == i)
-                ++m->numfriends;
-
-            if (friend_con_connected(m->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
-                send_online_packet(m, i);
-            }
-
-            return i;
-        }
+    } else {
+        return ret;
     }
-
-    return -1;
 }
 
 /* Remove a friend.
@@ -361,7 +336,7 @@ int m_delfriend(Messenger *m, int32_t friendnumber)
 
     free(m->friendlist[friendnumber].statusmessage);
     free(m->friendlist[friendnumber].avatar_recv_data);
-    remove_request_received(&(m->fr), m->friendlist[friendnumber].client_id);
+    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);
     kill_friend_connection(m->fr_c, m->friendlist[friendnumber].friendcon_id);
 
@@ -513,6 +488,9 @@ int setname(Messenger *m, const uint8_t *name, uint16_t length)
     if (length > MAX_NAME_LENGTH || length == 0)
         return -1;
 
+    if (m->name_length == length && memcmp(name, m->name, length) == 0)
+        return 0;
+
     memcpy(m->name, name, length);
     m->name_length = length;
     uint32_t i;
@@ -572,6 +550,9 @@ int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length)
     if (length > MAX_STATUSMESSAGE_LENGTH)
         return -1;
 
+    if (m->statusmessage_length == length && memcmp(m->statusmessage, status, length) == 0)
+        return 0;
+
     memcpy(m->statusmessage, status, length);
     m->statusmessage_length = length;
 
@@ -585,9 +566,11 @@ int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length)
 
 int m_set_userstatus(Messenger *m, uint8_t status)
 {
-    if (status >= USERSTATUS_INVALID) {
+    if (status >= USERSTATUS_INVALID)
         return -1;
-    }
+
+    if (m->userstatus == status)
+        return 0;
 
     m->userstatus = status;
     uint32_t i;
@@ -813,13 +796,15 @@ uint64_t m_get_last_online(const Messenger *m, int32_t friendnumber)
 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))
         return -1;
 
+    if (m->friendlist[friendnumber].user_istyping == is_typing)
+        return 0;
+
     m->friendlist[friendnumber].user_istyping = is_typing;
     m->friendlist[friendnumber].user_istyping_sent = 0;
 
@@ -1543,11 +1528,11 @@ int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const
 }
 
 /* Function to filter out some friend requests*/
-static int friend_already_added(const uint8_t *client_id, void *data)
+static int friend_already_added(const uint8_t *real_pk, void *data)
 {
     const Messenger *m = data;
 
-    if (getfriend_id(m, client_id) == -1)
+    if (getfriend_id(m, real_pk) == -1)
         return 0;
 
     return -1;
@@ -1684,6 +1669,8 @@ static int handle_status(void *object, int i, uint8_t status)
         m->friendlist[i].name_sent = 0;
         m->friendlist[i].userstatus_sent = 0;
         m->friendlist[i].statusmessage_sent = 0;
+        m->friendlist[i].user_istyping_sent = 0;
+        m->friendlist[i].avatar_info_sent = 0;
         m->friendlist[i].ping_lastrecv = temp_time;
     } else { /* Went offline. */
         if (m->friendlist[i].status == FRIEND_ONLINE) {
@@ -2259,7 +2246,7 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
             int i;
 
             for (i = 0; i < n; i++) {
-                add_tcp_relay(m->net_crypto, nodes[i].ip_port, nodes[i].client_id);
+                add_tcp_relay(m->net_crypto, nodes[i].ip_port, nodes[i].public_key);
             }
 
             break;
@@ -2341,15 +2328,15 @@ void do_friends(Messenger *m)
 #ifdef LOGGING
 #define DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS 60UL
 static time_t lastdump = 0;
-static char IDString[CLIENT_ID_SIZE * 2 + 1];
-static char *ID2String(const uint8_t *client_id)
+static char IDString[crypto_box_PUBLICKEYBYTES * 2 + 1];
+static char *ID2String(const uint8_t *pk)
 {
     uint32_t i;
 
-    for (i = 0; i < CLIENT_ID_SIZE; i++)
-        sprintf(&IDString[i * 2], "%02X", client_id[i]);
+    for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++)
+        sprintf(&IDString[i * 2], "%02X", pk[i]);
 
-    IDString[CLIENT_ID_SIZE * 2] = 0;
+    IDString[crypto_box_PUBLICKEYBYTES * 2] = 0;
     return IDString;
 }
 #endif
@@ -2384,7 +2371,7 @@ void do_messenger(Messenger *m)
         int i;
 
         for (i = 0; i < NUM_SAVED_TCP_RELAYS; ++i) {
-            add_tcp_relay(m->net_crypto, m->loaded_relays[i].ip_port, m->loaded_relays[i].client_id);
+            add_tcp_relay(m->net_crypto, m->loaded_relays[i].ip_port, m->loaded_relays[i].public_key);
         }
     }
 
@@ -2446,7 +2433,7 @@ void do_messenger(Messenger *m)
                 continue;
 
             for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++)
-                if (id_equal(m->friendlist[friend].client_id, m->dht->friends_list[dhtfriend].client_id)) {
+                if (id_equal(m->friendlist[friend].real_pk, m->dht->friends_list[dhtfriend].client_id)) {
                     m2dht[friend] = dhtfriend;
                     break;
                 }
@@ -2480,7 +2467,7 @@ void do_messenger(Messenger *m)
 
                 LOGGER_TRACE("F[%2u:%2u] <%s> [%03u] %s",
                              dht2m[friend], friend, msgfptr->name,
-                             ping_lastrecv, ID2String(msgfptr->client_id));
+                             ping_lastrecv, ID2String(msgfptr->real_pk));
             } else {
                 LOGGER_TRACE("F[--:%2u] %s", friend, ID2String(dhtfptr->client_id));
             }
@@ -2527,7 +2514,7 @@ void do_messenger(Messenger *m)
 #define NUM_SAVED_PATH_NODES 8
 struct SAVED_FRIEND {
     uint8_t status;
-    uint8_t client_id[CLIENT_ID_SIZE];
+    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
     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];
@@ -2554,7 +2541,7 @@ static uint32_t friends_list_save(const Messenger *m, uint8_t *data)
             struct SAVED_FRIEND temp;
             memset(&temp, 0, sizeof(struct SAVED_FRIEND));
             temp.status = m->friendlist[i].status;
-            memcpy(temp.client_id, m->friendlist[i].client_id, CLIENT_ID_SIZE);
+            memcpy(temp.real_pk, m->friendlist[i].real_pk, crypto_box_PUBLICKEYBYTES);
 
             if (temp.status < 3) {
                 if (m->friendlist[i].info_size > SAVED_FRIEND_REQUEST_SIZE) {
@@ -2600,7 +2587,7 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
         memcpy(&temp, data + i * sizeof(struct SAVED_FRIEND), sizeof(struct SAVED_FRIEND));
 
         if (temp.status >= 3) {
-            int fnum = m_addfriend_norequest(m, temp.client_id);
+            int fnum = m_addfriend_norequest(m, temp.real_pk);
 
             if (fnum < 0)
                 continue;
@@ -2615,7 +2602,7 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
         } else if (temp.status != 0) {
             /* TODO: This is not a good way to do this. */
             uint8_t address[FRIEND_ADDRESS_SIZE];
-            id_copy(address, temp.client_id);
+            id_copy(address, temp.real_pk);
             memcpy(address + crypto_box_PUBLICKEYBYTES, &(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));
@@ -2792,7 +2779,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
             uint32_t i;
 
             for (i = 0; i < NUM_SAVED_PATH_NODES; ++i) {
-                onion_add_bs_path_node(m->onion_c, nodes[i].ip_port, nodes[i].client_id);
+                onion_add_bs_path_node(m->onion_c, nodes[i].ip_port, nodes[i].public_key);
             }
 
             break;
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 3851edf7..a9931d1f 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -191,7 +191,7 @@ enum {
 typedef struct Messenger Messenger;
 
 typedef struct {
-    uint8_t client_id[crypto_box_PUBLICKEYBYTES];
+    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
     int friendcon_id;
 
     uint64_t friendrequest_lastsent; // Time at which the last friend request was sent.
@@ -313,7 +313,7 @@ struct Messenger {
     Messenger_Options options;
 };
 
-/* Format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
+/* Format: [real_pk (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
  *
  *  return FRIEND_ADDRESS_SIZE byte address to give to others.
  */
@@ -342,20 +342,20 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
  *  return the friend number if success.
  *  return -1 if failure.
  */
-int32_t m_addfriend_norequest(Messenger *m, const uint8_t *client_id);
+int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk);
 
 /*  return the friend number associated to that client id.
  *  return -1 if no such friend.
  */
-int32_t getfriend_id(const Messenger *m, const uint8_t *client_id);
+int32_t getfriend_id(const Messenger *m, const uint8_t *real_pk);
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
+/* Copies the public key associated to that friend id into real_pk buffer.
+ * Make sure that real_pk is of size crypto_box_PUBLICKEYBYTES.
  *
  *  return 0 if success
  *  return -1 if failure
  */
-int getclient_id(const Messenger *m, int32_t friendnumber, uint8_t *client_id);
+int get_real_pk(const Messenger *m, int32_t friendnumber, uint8_t *real_pk);
 
 /*  return friend connection id on success.
  *  return -1 if failure.
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index 250d6c44..e85a506d 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -812,6 +812,7 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
                 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,
                              data + 1);
@@ -862,36 +863,42 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
 {
     int index = add_accepted(TCP_server, con);
 
-    if (index == -1)
+    if (index == -1) {
+        kill_TCP_connection(con);
         return -1;
+    }
+
+    memset(con, 0, sizeof(TCP_Secure_Connection));
 
     if (handle_TCP_packet(TCP_server, index, data, length) == -1) {
         kill_accepted(TCP_server, index);
+        return -1;
     }
 
     return index;
 }
 
-/* return 1 on success
- * return 0 on failure
+/* return index on success
+ * return -1 on failure
  */
 static int accept_connection(TCP_Server *TCP_server, sock_t sock)
 {
     if (!sock_valid(sock))
-        return 0;
+        return -1;
 
     if (!set_socket_nonblock(sock)) {
         kill_sock(sock);
-        return 0;
+        return -1;
     }
 
     if (!set_socket_nosigpipe(sock)) {
         kill_sock(sock);
-        return 0;
+        return -1;
     }
 
-    TCP_Secure_Connection *conn =
-        &TCP_server->incomming_connection_queue[TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS];
+    uint16_t index = TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
+
+    TCP_Secure_Connection *conn = &TCP_server->incomming_connection_queue[index];
 
     if (conn->status != TCP_STATUS_NO_STATUS)
         kill_TCP_connection(conn);
@@ -901,7 +908,7 @@ static int accept_connection(TCP_Server *TCP_server, sock_t sock)
     conn->next_packet_length = 0;
 
     ++TCP_server->incomming_connection_queue_index;
-    return 1;
+    return index;
 }
 
 static sock_t new_listening_TCP_socket(int family, uint16_t port)
@@ -912,11 +919,7 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
         return ~0;
     }
 
-#ifndef TCP_SERVER_USE_EPOLL
     int ok = set_socket_nonblock(sock);
-#else
-    int ok = 1;
-#endif
 
     if (ok && family == AF_INET6) {
         ok = set_socket_dualstack(sock);
@@ -983,7 +986,7 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin
 
         if (sock_valid(sock)) {
 #ifdef TCP_SERVER_USE_EPOLL
-            ev.events = EPOLLIN;
+            ev.events = EPOLLIN | EPOLLET;
             ev.data.u64 = sock | ((uint64_t)TCP_SOCKET_LISTENING << 32);
 
             if (epoll_ctl(temp->efd, EPOLL_CTL_ADD, sock, &ev) == -1) {
@@ -1027,7 +1030,7 @@ static void do_TCP_accept_new(TCP_Server *TCP_server)
 
         do {
             sock = accept(TCP_server->socks_listening[i], (struct sockaddr *)&addr, &addrlen);
-        } while (accept_connection(TCP_server, sock));
+        } while (accept_connection(TCP_server, sock) != -1);
     }
 }
 
@@ -1075,15 +1078,7 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
         kill_TCP_connection(conn);
         return -1;
     } else {
-        int index_new;
-
-        if ((index_new = confirm_TCP_connection(TCP_server, conn, packet, len)) == -1) {
-            kill_TCP_connection(conn);
-        } else {
-            memset(conn, 0, sizeof(TCP_Secure_Connection));
-        }
-
-        return index_new;
+        return confirm_TCP_connection(TCP_server, conn, packet, len);
     }
 }
 
@@ -1194,7 +1189,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
             sock_t sock = events[n].data.u64 & 0xFFFFFFFF;
             int status = (events[n].data.u64 >> 32) & 0xFFFF, index = (events[n].data.u64 >> 48);
 
-            if ((events[n].events & EPOLLERR) || (events[n].events & EPOLLHUP)) {
+            if ((events[n].events & EPOLLERR) || (events[n].events & EPOLLHUP) || (events[n].events & EPOLLRDHUP)) {
                 switch (status) {
                     case TCP_SOCKET_LISTENING: {
                         //should never happen
@@ -1230,24 +1225,29 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                     //socket is from socks_listening, accept connection
                     struct sockaddr_storage addr;
                     unsigned int addrlen = sizeof(addr);
-                    sock_t sock_new;
 
-                    sock_new = accept(sock, (struct sockaddr *)&addr, &addrlen);
+                    while (1) {
+                        sock_t sock_new = accept(sock, (struct sockaddr *)&addr, &addrlen);
 
-                    int index_new = TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
+                        if (!sock_valid(sock_new)) {
+                            break;
+                        }
 
-                    if (!accept_connection(TCP_server, sock_new)) {
-                        break;
-                    }
+                        int index_new = accept_connection(TCP_server, sock_new);
 
-                    struct epoll_event ev = {
-                        .events = EPOLLIN | EPOLLET,
-                        .data.u64 = sock_new | ((uint64_t)TCP_SOCKET_INCOMING << 32) | ((uint64_t)index_new << 48)
-                    };
+                        if (index_new == -1) {
+                            continue;
+                        }
 
-                    if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new, &ev) == -1) {
-                        kill_TCP_connection(&TCP_server->incomming_connection_queue[index_new]);
-                        break;
+                        struct epoll_event ev = {
+                            .events = EPOLLIN | EPOLLET | EPOLLRDHUP,
+                            .data.u64 = sock_new | ((uint64_t)TCP_SOCKET_INCOMING << 32) | ((uint64_t)index_new << 48)
+                        };
+
+                        if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new, &ev) == -1) {
+                            kill_TCP_connection(&TCP_server->incomming_connection_queue[index_new]);
+                            continue;
+                        }
                     }
 
                     break;
@@ -1257,7 +1257,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                     int index_new;
 
                     if ((index_new = do_incoming(TCP_server, index)) != -1) {
-                        events[n].events = EPOLLIN | EPOLLET;
+                        events[n].events = EPOLLIN | EPOLLET | EPOLLRDHUP;
                         events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_UNCONFIRMED << 32) | ((uint64_t)index_new << 48);
 
                         if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
@@ -1273,7 +1273,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
                     int index_new;
 
                     if ((index_new = do_unconfirmed(TCP_server, index)) != -1) {
-                        events[n].events = EPOLLIN | EPOLLET;
+                        events[n].events = EPOLLIN | EPOLLET | EPOLLRDHUP;
                         events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_CONFIRMED << 32) | ((uint64_t)index_new << 48);
 
                         if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
@@ -1333,5 +1333,6 @@ void kill_TCP_server(TCP_Server *TCP_server)
 #endif
 
     free(TCP_server->socks_listening);
+    free(TCP_server->accepted_connection_array);
     free(TCP_server);
 }
diff --git a/toxcore/crypto_core.h b/toxcore/crypto_core.h
index 58bdc2f3..afd2f7b8 100644
--- a/toxcore/crypto_core.h
+++ b/toxcore/crypto_core.h
@@ -122,6 +122,7 @@ void new_nonce(uint8_t *nonce);
 
 #define CRYPTO_PACKET_FRIEND_REQ    32  /* Friend request crypto packet ID. */
 #define CRYPTO_PACKET_HARDENING     48  /* Hardening crypto packet ID. */
+#define CRYPTO_PACKET_FAKEID        156
 #define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
 
 /* Create a request to peer.
diff --git a/toxcore/friend_requests.c b/toxcore/friend_requests.c
index 98937131..e4a10008 100644
--- a/toxcore/friend_requests.c
+++ b/toxcore/friend_requests.c
@@ -58,12 +58,12 @@ 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 *client_id)
+static void addto_receivedlist(Friend_Requests *fr, const uint8_t *real_pk)
 {
     if (fr->received_requests_index >= MAX_RECEIVED_STORED)
         fr->received_requests_index = 0;
 
-    id_copy(fr->received_requests[fr->received_requests_index], client_id);
+    id_copy(fr->received_requests[fr->received_requests_index], real_pk);
     ++fr->received_requests_index;
 }
 
@@ -72,28 +72,28 @@ static void addto_receivedlist(Friend_Requests *fr, const uint8_t *client_id)
  *  return 0 if it did not.
  *  return 1 if it did.
  */
-static int request_received(Friend_Requests *fr, const uint8_t *client_id)
+static int request_received(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], client_id))
+        if (id_equal(fr->received_requests[i], real_pk))
             return 1;
 
     return 0;
 }
 
-/* Remove client id from received_requests list.
+/* Remove real pk from received_requests list.
  *
  *  return 0 if it removed it successfully.
  *  return -1 if it didn't find it.
  */
-int remove_request_received(Friend_Requests *fr, const uint8_t *client_id)
+int remove_request_received(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], client_id)) {
+        if (id_equal(fr->received_requests[i], real_pk)) {
             memset(fr->received_requests[i], 0, crypto_box_PUBLICKEYBYTES);
             return 0;
         }
diff --git a/toxcore/friend_requests.h b/toxcore/friend_requests.h
index b7e07af4..86069f3b 100644
--- a/toxcore/friend_requests.h
+++ b/toxcore/friend_requests.h
@@ -51,12 +51,12 @@ typedef struct {
 void set_nospam(Friend_Requests *fr, uint32_t num);
 uint32_t get_nospam(const Friend_Requests *fr);
 
-/* Remove client id from received_requests list.
+/* Remove real_pk from received_requests list.
  *
  *  return 0 if it removed it successfully.
  *  return -1 if it didn't find it.
  */
-int remove_request_received(Friend_Requests *fr, const uint8_t *client_id);
+int remove_request_received(Friend_Requests *fr, const uint8_t *real_pk);
 
 /* Set the function that will be executed when a friend request for us is received.
  *  Function format is function(uint8_t * public_key, uint8_t * data, uint16_t length, void * userdata)
diff --git a/toxcore/group.c b/toxcore/group.c
index eb795721..c1a60851 100644
--- a/toxcore/group.c
+++ b/toxcore/group.c
@@ -447,7 +447,7 @@ static int remove_close_conn(Group_Chats *g_c, int groupnumber, int friendcon_id
         if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
             continue;
 
-        if (g->close[i].number == friendcon_id) {
+        if (g->close[i].number == (unsigned int)friendcon_id) {
             g->close[i].type = GROUPCHAT_CLOSE_NONE;
             kill_friend_connection(g_c->fr_c, friendcon_id);
             return 0;
@@ -576,7 +576,7 @@ static void set_conns_type_close(Group_Chats *g_c, int groupnumber, int friendco
         if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
             continue;
 
-        if (g->close[i].number != friendcon_id)
+        if (g->close[i].number != (unsigned int)friendcon_id)
             continue;
 
         if (type == GROUPCHAT_CLOSE_ONLINE) {
@@ -789,7 +789,7 @@ int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAM
     if (!g)
         return -1;
 
-    int i;
+    unsigned int i;
 
     for (i = 0; i < g->numpeers && i < length; ++i) {
         lengths[i] = group_peername(g_c, groupnumber, i, names[i]);
diff --git a/toxcore/logger.c b/toxcore/logger.c
index ac81a900..e8aef7e0 100644
--- a/toxcore/logger.c
+++ b/toxcore/logger.c
@@ -1,6 +1,6 @@
 /*  logger.c
  *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *  Copyright (C) 2013, 2015 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
  *
@@ -37,8 +37,10 @@
 #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
 
 
@@ -57,7 +59,7 @@ struct logger {
     pthread_mutex_t mutex[1];
 };
 
-logger *global = NULL;
+Logger *global = NULL;
 
 const char *LOG_LEVEL_STR [] = {
     [LOG_TRACE]   = "TRACE",
@@ -83,13 +85,13 @@ char *strtime(char *dest, size_t max_len)
 /**
  * Public Functions
  */
-logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
+Logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
 {
 #ifndef LOGGING /* Disabled */
     return NULL;
 #endif
 
-    logger *retu = calloc(1, sizeof(logger));
+    Logger *retu = calloc(1, sizeof(Logger));
 
     if (!retu)
         return NULL;
@@ -100,7 +102,7 @@ logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
     }
 
     if (!(retu->log_file = fopen(file_name, "ab"))) {
-        fprintf(stderr, "Error opening logger file: %s; info: %s\n", file_name, strerror(errno));
+        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;
@@ -109,16 +111,16 @@ logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
     if (!(retu->tstr = calloc(16, sizeof (char))) ||
             !(retu->posstr = calloc(300, sizeof (char))) ||
             !(retu->msg = calloc(4096, sizeof (char))) )
-        goto ERROR;
+        goto FAILURE;
 
     if (id) {
         if (!(retu->id = calloc(strlen(id) + 1, 1)))
-            goto ERROR;
+            goto FAILURE;
 
         strcpy(retu->id, id);
     } else {
         if (!(retu->id = malloc(8)))
-            goto ERROR;
+            goto FAILURE;
 
         snprintf(retu->id, 8, "%u", random_int());
     }
@@ -126,13 +128,13 @@ logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
     retu->level = level;
     retu->start_time = current_time_monotonic();
 
-    fprintf(retu->log_file, "Successfully created and running logger id: %s; time: %s\n",
+    fprintf(retu->log_file, "Successfully created and running logger id: %s; time: %s" WIN_CR "\n",
             retu->id, strtime(retu->tstr, 16));
 
     return retu;
 
-ERROR:
-    fprintf(stderr, "Failed to create logger!\n");
+FAILURE:
+    fprintf(stderr, "Failed to create logger!" WIN_CR "\n");
     pthread_mutex_destroy(retu->mutex);
     fclose(retu->log_file);
     free(retu->tstr);
@@ -143,7 +145,7 @@ ERROR:
     return NULL;
 }
 
-void logger_kill(logger *log)
+void logger_kill(Logger *log)
 {
 #ifndef LOGGING /* Disabled */
     return;
@@ -173,7 +175,7 @@ void logger_kill_global(void)
     global = NULL;
 }
 
-void logger_set_global(logger *log)
+void logger_set_global(Logger *log)
 {
 #ifndef LOGGING /* Disabled */
     return;
@@ -182,7 +184,7 @@ void logger_set_global(logger *log)
     global = log;
 }
 
-logger *logger_get_global(void)
+Logger *logger_get_global(void)
 {
 #ifndef LOGGING /* Disabled */
     return NULL;
@@ -191,7 +193,7 @@ logger *logger_get_global(void)
     return global;
 }
 
-void logger_write (logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...)
+void logger_write (Logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...)
 {
 #ifndef LOGGING /* Disabled */
     return;
@@ -204,10 +206,10 @@ void logger_write (logger *log, LOG_LEVEL level, const char *file, int line, con
         "%-5s  " /* Logger lever string */
         "%-20s " /* File:line string */
         "- %s"   /* Output message */
-        "\n";    /* Every new print new line */
+        WIN_CR "\n";    /* Every new print new line */
 
 
-    logger *this_log = log ? log : global;
+    Logger *this_log = log ? log : global;
 
     if (!this_log)
         return;
diff --git a/toxcore/logger.h b/toxcore/logger.h
index 6f1f6075..0513b32c 100644
--- a/toxcore/logger.h
+++ b/toxcore/logger.h
@@ -43,26 +43,26 @@ typedef enum {
     LOG_ERROR
 } LOG_LEVEL;
 
-typedef struct logger logger;
+typedef struct logger Logger;
 
 /**
  * Set 'level' as the lowest printable level. If id == NULL, random number is used.
  */
-logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id);
+Logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id);
 
-void logger_kill (logger *log);
+void logger_kill (Logger *log);
 void logger_kill_global (void);
 
 /**
  * Global logger setter and getter.
  */
-void logger_set_global (logger *log);
-logger *logger_get_global (void);
+void logger_set_global (Logger *log);
+Logger *logger_get_global (void);
 
 /**
  * Main write function. If logging disabled does nothing. If log == NULL uses global logger.
  */
-void logger_write (logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...);
+void logger_write (Logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...);
 
 
 /* To do some checks or similar only when logging, use this */
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 8af3cbbc..bd5616a2 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -608,6 +608,23 @@ static int clear_buffer_until(Packets_Array *array, uint32_t number)
     return 0;
 }
 
+static int clear_buffer(Packets_Array *array)
+{
+    uint32_t i;
+
+    for (i = array->buffer_start; i != array->buffer_end; ++i) {
+        uint32_t num = i % CRYPTO_PACKET_BUFFER_SIZE;
+
+        if (array->buffer[num]) {
+            free(array->buffer[num]);
+            array->buffer[num] = NULL;
+        }
+    }
+
+    array->buffer_start = i;
+    return 0;
+}
+
 /* Set array buffer end to number.
  *
  * return -1 on failure.
@@ -1378,12 +1395,18 @@ static int wipe_crypto_connection(Net_Crypto *c, int crypt_connection_id)
         return -1;
 
     uint32_t i;
-    pthread_mutex_destroy(&c->crypto_connections[crypt_connection_id].mutex);
+
+    /* Keep mutex, only destroy it when connection is realloced out. */
+    pthread_mutex_t mutex = c->crypto_connections[crypt_connection_id].mutex;
     memset(&(c->crypto_connections[crypt_connection_id]), 0 , sizeof(Crypto_Connection));
+    c->crypto_connections[crypt_connection_id].mutex = mutex;
 
     for (i = c->crypto_connections_length; i != 0; --i) {
-        if (c->crypto_connections[i - 1].status != CRYPTO_CONN_NO_CONNECTION)
+        if (c->crypto_connections[i - 1].status == CRYPTO_CONN_NO_CONNECTION) {
+            pthread_mutex_destroy(&c->crypto_connections[i - 1].mutex);
+        } else {
             break;
+        }
     }
 
     if (c->crypto_connections_length != i) {
@@ -1798,7 +1821,7 @@ static int tcp_response_callback(void *object, uint8_t connection_id, const uint
     uint32_t i;
 
     for (i = 0; i < conn->num_tcp_relays; ++i) {
-        if (memcmp(TCP_con->public_key, conn->tcp_relays[i].client_id, crypto_box_PUBLICKEYBYTES) == 0) {
+        if (memcmp(TCP_con->public_key, conn->tcp_relays[i].public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             set_conn_tcp_status(conn, location, STATUS_TCP_INVISIBLE);
             return 0;
         }
@@ -1977,7 +2000,7 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
     uint32_t i;
 
     for (i = 0; i < conn->num_tcp_relays; ++i) {
-        if (memcmp(conn->tcp_relays[i].client_id, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+        if (memcmp(conn->tcp_relays[i].public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             conn->tcp_relays[i].ip_port = ip_port;
             return 0;
         }
@@ -1986,10 +2009,10 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
     if (conn->num_tcp_relays == MAX_TCP_RELAYS_PEER) {
         uint16_t index = rand() % MAX_TCP_RELAYS_PEER;
         conn->tcp_relays[index].ip_port = ip_port;
-        memcpy(conn->tcp_relays[index].client_id, public_key, crypto_box_PUBLICKEYBYTES);
+        memcpy(conn->tcp_relays[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
     } else {
         conn->tcp_relays[conn->num_tcp_relays].ip_port = ip_port;
-        memcpy(conn->tcp_relays[conn->num_tcp_relays].client_id, public_key, crypto_box_PUBLICKEYBYTES);
+        memcpy(conn->tcp_relays[conn->num_tcp_relays].public_key, public_key, crypto_box_PUBLICKEYBYTES);
         ++conn->num_tcp_relays;
     }
 
@@ -2039,29 +2062,50 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key)
     return -1;
 }
 
-/* Send an onion packet via a random connected TCP relay.
+/* Return a random TCP connection number for use in send_tcp_onion_request.
  *
- * return 0 on success.
+ * TODO: 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.
  */
-int send_tcp_onion_request(Net_Crypto *c, const uint8_t *data, uint16_t length)
+int get_random_tcp_con_number(Net_Crypto *c)
 {
     unsigned int i, r = rand();
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
         if (c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS]) {
-            pthread_mutex_lock(&c->tcp_mutex);
-            int ret = send_onion_request(c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS], data, length);
-            pthread_mutex_unlock(&c->tcp_mutex);
-
-            if (ret == 1)
-                return 0;
+            return (i + r) % MAX_TCP_CONNECTIONS;
         }
     }
 
     return -1;
 }
 
+/* Send an onion packet via the TCP relay corresponding to TCP_conn_number.
+ *
+ * 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)
+{
+    if (TCP_conn_number > MAX_TCP_CONNECTIONS) {
+        return -1;
+    }
+
+    if (c->tcp_connections[TCP_conn_number]) {
+        pthread_mutex_lock(&c->tcp_mutex);
+        int ret = send_onion_request(c->tcp_connections[TCP_conn_number], data, length);
+        pthread_mutex_unlock(&c->tcp_mutex);
+
+        if (ret == 1)
+            return 0;
+    }
+
+    return -1;
+}
+
 /* Set the function to be called when an onion response packet is received by one of the TCP connections.
  */
 void tcp_onion_response_handler(Net_Crypto *c, int (*tcp_onion_callback)(void *object, const uint8_t *data,
@@ -2087,7 +2131,7 @@ unsigned int copy_connected_tcp_relays(const Net_Crypto *c, Node_format *tcp_rel
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
         if (c->tcp_connections[i] != NULL) {
-            memcpy(tcp_relays[copied].client_id, c->tcp_connections[i]->public_key, crypto_box_PUBLICKEYBYTES);
+            memcpy(tcp_relays[copied].public_key, c->tcp_connections[i]->public_key, crypto_box_PUBLICKEYBYTES);
             tcp_relays[copied].ip_port = c->tcp_connections[i]->ip_port;
 
             if (tcp_relays[copied].ip_port.ip.family == AF_INET) {
@@ -2391,7 +2435,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
 
 /* The dT for the average packet receiving rate calculations.
    Also used as the */
-#define PACKET_COUNTER_AVERAGE_INTERVAL 100
+#define PACKET_COUNTER_AVERAGE_INTERVAL 50
 
 /* Ratio of recv queue size / recv packet rate (in seconds) times
  * the number of ms between request packets to send at that ratio
@@ -2474,7 +2518,7 @@ static void send_crypto_packets(Net_Crypto *c)
                 double min_speed = 1000.0 * (((double)(total_sent)) / ((double)(CONGESTION_QUEUE_ARRAY_SIZE) *
                                              PACKET_COUNTER_AVERAGE_INTERVAL));
 
-                conn->packet_send_rate = min_speed * 1.3;
+                conn->packet_send_rate = min_speed * 1.2;
 
                 if (conn->packet_send_rate < CRYPTO_PACKET_MIN_RATE) {
                     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
@@ -2678,6 +2722,9 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id)
 
         disconnect_peer_tcp(c, crypt_connection_id);
         bs_list_remove(&c->ip_port_list, &conn->ip_port, crypt_connection_id);
+        clear_temp_packet(c, crypt_connection_id);
+        clear_buffer(&conn->send_array);
+        clear_buffer(&conn->recv_array);
         ret = wipe_crypto_connection(c, crypt_connection_id);
     }
 
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index b9fb1747..7e59475e 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -86,7 +86,7 @@
 
 /* Base current transfer speed on last CONGESTION_QUEUE_ARRAY_SIZE number of points taken
    at the dT defined in net_crypto.c */
-#define CONGESTION_QUEUE_ARRAY_SIZE 8
+#define CONGESTION_QUEUE_ARRAY_SIZE 24
 
 typedef struct {
     uint64_t time;
@@ -364,12 +364,19 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key);
 void tcp_onion_response_handler(Net_Crypto *c, int (*tcp_onion_callback)(void *object, const uint8_t *data,
                                 uint16_t length), void *object);
 
-/* Send an onion packet via a random connected TCP relay.
+/* Return a random TCP connection number for use in send_tcp_onion_request.
+ *
+ * return TCP connection number on success.
+ * return -1 on failure.
+ */
+int get_random_tcp_con_number(Net_Crypto *c);
+
+/* Send an onion packet via the TCP relay corresponding to TCP_conn_number.
  *
  * return 0 on success.
  * return -1 on failure.
  */
-int send_tcp_onion_request(Net_Crypto *c, const uint8_t *data, uint16_t length);
+int send_tcp_onion_request(Net_Crypto *c, unsigned int TCP_conn_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.
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 05dbaae6..c6093f0c 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -61,7 +61,7 @@ static void ip_pack(uint8_t *data, IP source)
 }
 
 /* return 0 on success, -1 on failure. */
-static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size)
+static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size, _Bool disable_family_check)
 {
     if (data_size < (1 + SIZE_IP6))
         return -1;
@@ -74,7 +74,12 @@ static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size)
         memcpy(target->ip6.uint8, data + 1, SIZE_IP6);
     }
 
-    return to_host_family(target);
+    if (!disable_family_check) {
+        return to_host_family(target);
+    } else {
+        to_host_family(target);
+        return 0;
+    }
 }
 
 static void ipport_pack(uint8_t *data, const IP_Port *source)
@@ -84,12 +89,12 @@ 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)
+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))
         return -1;
 
-    if (ip_unpack(&target->ip, data, data_size) == -1)
+    if (ip_unpack(&target->ip, data, data_size, disable_family_check) == -1)
         return -1;
 
     memcpy(&target->port, data + SIZE_IP, SIZE_PORT);
@@ -111,27 +116,27 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
     if (!new_path || !nodes)
         return -1;
 
-    encrypt_precompute(nodes[0].client_id, dht->self_secret_key, new_path->shared_key1);
+    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);
 
     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);
-    encrypt_precompute(nodes[1].client_id, random_secret_key, new_path->shared_key2);
+    encrypt_precompute(nodes[1].public_key, random_secret_key, new_path->shared_key2);
     memcpy(new_path->public_key2, random_public_key, crypto_box_PUBLICKEYBYTES);
 
     crypto_box_keypair(random_public_key, random_secret_key);
-    encrypt_precompute(nodes[2].client_id, random_secret_key, new_path->shared_key3);
+    encrypt_precompute(nodes[2].public_key, random_secret_key, new_path->shared_key3);
     memcpy(new_path->public_key3, random_public_key, crypto_box_PUBLICKEYBYTES);
 
     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].client_id, crypto_box_PUBLICKEYBYTES);
-    memcpy(new_path->node_public_key2, nodes[1].client_id, crypto_box_PUBLICKEYBYTES);
-    memcpy(new_path->node_public_key3, nodes[2].client_id, crypto_box_PUBLICKEYBYTES);
+    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);
 
     return 0;
 }
@@ -150,9 +155,9 @@ int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_
     nodes[1].ip_port = path->ip_port2;
     nodes[2].ip_port = path->ip_port3;
 
-    memcpy(nodes[0].client_id, path->node_public_key1, crypto_box_PUBLICKEYBYTES);
-    memcpy(nodes[1].client_id, path->node_public_key2, crypto_box_PUBLICKEYBYTES);
-    memcpy(nodes[2].client_id, path->node_public_key3, crypto_box_PUBLICKEYBYTES);
+    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);
     return 0;
 }
 
@@ -186,7 +191,7 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
     int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, sizeof(step1),
                                      step2 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != SIZE_IPPORT + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + length + crypto_box_MACBYTES)
         return -1;
 
     uint8_t step3[SIZE_IPPORT + SEND_BASE * 2 + length];
@@ -195,7 +200,7 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
     len = encrypt_data_symmetric(path->shared_key2, nonce, step2, sizeof(step2),
                                  step3 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
         return -1;
 
     packet[0] = NET_PACKET_ONION_SEND_INITIAL;
@@ -205,7 +210,7 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
     len = encrypt_data_symmetric(path->shared_key1, nonce, step3, sizeof(step3),
                                  packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE * 2 + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE * 2 + length + crypto_box_MACBYTES)
         return -1;
 
     return 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + len;
@@ -241,7 +246,7 @@ int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const O
     int len = encrypt_data_symmetric(path->shared_key3, nonce, step1, sizeof(step1),
                                      step2 + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != SIZE_IPPORT + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + length + crypto_box_MACBYTES)
         return -1;
 
     ipport_pack(packet + crypto_box_NONCEBYTES, &path->ip_port2);
@@ -249,7 +254,7 @@ int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const O
     len = encrypt_data_symmetric(path->shared_key2, nonce, step2, sizeof(step2),
                                  packet + crypto_box_NONCEBYTES + SIZE_IPPORT + crypto_box_PUBLICKEYBYTES);
 
-    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
+    if (len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
         return -1;
 
     memcpy(packet, nonce, crypto_box_NONCEBYTES);
@@ -319,7 +324,7 @@ static int handle_send_initial(void *object, IP_Port source, const uint8_t *pack
     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);
 
-    if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES))
+    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES))
         return 1;
 
     return onion_send_1(onion, plain, len, source, packet + 1);
@@ -335,7 +340,7 @@ int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
         return 1;
 
     uint8_t ip_port[SIZE_IPPORT];
@@ -380,12 +385,12 @@ static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, ui
     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);
 
-    if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1 + crypto_box_MACBYTES))
+    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_1 + crypto_box_MACBYTES))
         return 1;
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
         return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
@@ -430,12 +435,12 @@ static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, ui
     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);
 
-    if ((uint32_t)len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2 + crypto_box_MACBYTES))
+    if (len != length - (1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + RETURN_2 + crypto_box_MACBYTES))
         return 1;
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
         return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
@@ -482,7 +487,7 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
         return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
@@ -518,7 +523,7 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
         return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
@@ -554,7 +559,7 @@ static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, ui
 
     IP_Port send_to;
 
-    if (ipport_unpack(&send_to, plain, len) == -1)
+    if (ipport_unpack(&send_to, plain, len, 1) == -1)
         return 1;
 
     uint16_t data_len = length - (1 + RETURN_1);
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index 32442797..25f3e0f8 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -134,7 +134,7 @@ int send_announce_request(Networking_Core *net, const Onion_Path *path, Node_for
                           uint64_t sendback_data)
 {
     uint8_t request[ONION_ANNOUNCE_REQUEST_SIZE];
-    int len = create_announce_request(request, sizeof(request), dest.client_id, public_key, secret_key, ping_id, client_id,
+    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))
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index b02b7c24..61034167 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -38,7 +38,7 @@
  * return -1 on failure
  * return 0 on success
  */
-int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *client_id)
+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)
         return -1;
@@ -46,12 +46,12 @@ int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (memcmp(client_id, onion_c->path_nodes_bs[i].client_id, crypto_box_PUBLICKEYBYTES) == 0)
+        if (memcmp(public_key, onion_c->path_nodes_bs[i].public_key, crypto_box_PUBLICKEYBYTES) == 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].client_id, client_id,
+    memcpy(onion_c->path_nodes_bs[onion_c->path_nodes_index_bs % MAX_PATH_NODES].public_key, public_key,
            crypto_box_PUBLICKEYBYTES);
 
     uint16_t last = onion_c->path_nodes_index_bs;
@@ -68,7 +68,7 @@ int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t
  * return -1 on failure
  * return 0 on success
  */
-static int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *client_id)
+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)
         return -1;
@@ -76,12 +76,13 @@ static int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uin
     unsigned int i;
 
     for (i = 0; i < MAX_PATH_NODES; ++i) {
-        if (memcmp(client_id, onion_c->path_nodes[i].client_id, crypto_box_PUBLICKEYBYTES) == 0)
+        if (memcmp(public_key, onion_c->path_nodes[i].public_key, crypto_box_PUBLICKEYBYTES) == 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].client_id, client_id, crypto_box_PUBLICKEYBYTES);
+    memcpy(onion_c->path_nodes[onion_c->path_nodes_index % MAX_PATH_NODES].public_key, public_key,
+           crypto_box_PUBLICKEYBYTES);
 
     uint16_t last = onion_c->path_nodes_index;
     ++onion_c->path_nodes_index;
@@ -140,8 +141,15 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
             nodes[i] = onion_c->path_nodes[rand() % num_nodes];
         }
     } else {
+        int random_tcp = get_random_tcp_con_number(onion_c->c);
+
+        if (random_tcp == -1) {
+            return 0;
+        }
+
         if (num_nodes >= 2) {
             nodes[0].ip_port.ip.family = TCP_FAMILY;
+            nodes[0].ip_port.ip.ip4.uint32 = random_tcp;
 
             for (i = 1; i < max_num; ++i) {
                 nodes[i] = onion_c->path_nodes[rand() % num_nodes];
@@ -154,6 +162,7 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
                 return 0;
 
             nodes[0].ip_port.ip.family = TCP_FAMILY;
+            nodes[0].ip_port.ip.ip4.uint32 = random_tcp;
 
             for (i = 1; i < max_num; ++i) {
                 nodes[i] = onion_c->path_nodes_bs[rand() % num_nodes_bs];
@@ -249,9 +258,9 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
     Onion_Client_Paths *onion_paths;
 
     if (num == 0) {
-        onion_paths = &onion_c->onion_paths;
+        onion_paths = &onion_c->onion_paths_self;
     } else {
-        onion_paths = &onion_c->friends_list[num - 1].onion_paths;
+        onion_paths = &onion_c->onion_paths_friends;
     }
 
     if (onion_paths->paths[path_num % NUMBER_ONION_PATHS].path_num == path_num) {
@@ -265,7 +274,7 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
             unsigned int i;
 
             for (i = 0; i < path_len; ++i) {
-                onion_add_path_node(onion_c, nodes[i].ip_port, nodes[i].client_id);
+                onion_add_path_node(onion_c, nodes[i].ip_port, nodes[i].public_key);
             }
         }
 
@@ -301,7 +310,7 @@ static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Pa
         if (len == -1)
             return -1;
 
-        return send_tcp_onion_request(onion_c->c, packet, len);
+        return send_tcp_onion_request(onion_c->c, path->ip_port1.ip.ip4.uint32, packet, len);
     } else {
         return -1;
     }
@@ -377,10 +386,10 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
     Onion_Path path;
 
     if (num == 0) {
-        if (random_path(onion_c, &onion_c->onion_paths, 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->friends_list[num - 1].onion_paths, pathnum, &path) == -1)
+        if (random_path(onion_c, &onion_c->onion_paths_friends, pathnum, &path) == -1)
             return -1;
     }
 
@@ -401,7 +410,7 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
 
     } 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_client_id, zero_ping_id,
+                                      onion_c->friends_list[num - 1].temp_secret_key, ping_id, onion_c->friends_list[num - 1].real_public_key, zero_ping_id,
                                       sendback);
     }
 
@@ -430,7 +439,7 @@ static int cmp_entry(const void *a, const void *b)
     if (t2)
         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;
@@ -463,7 +472,7 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
             return -1;
 
         list_nodes = onion_c->friends_list[num - 1].clients_list;
-        reference_id = onion_c->friends_list[num - 1].real_client_id;
+        reference_id = onion_c->friends_list[num - 1].real_public_key;
     }
 
     memcpy(cmp_public_key, reference_id, crypto_box_PUBLICKEYBYTES);
@@ -473,12 +482,12 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
     unsigned int i;
 
     if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)
-            || id_closest(reference_id, list_nodes[0].client_id, public_key) == 2) {
+            || id_closest(reference_id, list_nodes[0].public_key, public_key) == 2) {
         index = 0;
     }
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-        if (memcmp(list_nodes[i].client_id, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+        if (memcmp(list_nodes[i].public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             index = i;
             stored = 1;
             break;
@@ -488,7 +497,7 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
     if (index == -1)
         return 0;
 
-    memcpy(list_nodes[index].client_id, public_key, CLIENT_ID_SIZE);
+    memcpy(list_nodes[index].public_key, public_key, crypto_box_PUBLICKEYBYTES);
     list_nodes[index].ip_port = ip_port;
 
     //TODO: remove this and find a better source of nodes to use for paths.
@@ -510,17 +519,17 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
     return 0;
 }
 
-static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, const uint8_t *client_id)
+static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, const uint8_t *public_key)
 {
     unsigned int i;
 
     for (i = 0; i < MAX_STORED_PINGED_NODES; ++i) {
         if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME))
-            if (memcmp(last_pinged[i].client_id, client_id, crypto_box_PUBLICKEYBYTES) == 0)
+            if (memcmp(last_pinged[i].public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0)
                 return 0;
     }
 
-    memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].client_id, client_id, crypto_box_PUBLICKEYBYTES);
+    memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].public_key, public_key, crypto_box_PUBLICKEYBYTES);
     last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].timestamp = unix_time();
     ++*last_pinged_index;
     return 1;
@@ -548,7 +557,7 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
         last_pinged_index = &onion_c->last_pinged_index;
     } else {
         list_nodes = onion_c->friends_list[num - 1].clients_list;
-        reference_id = onion_c->friends_list[num - 1].real_client_id;
+        reference_id = onion_c->friends_list[num - 1].real_public_key;
         last_pinged = onion_c->friends_list[num - 1].last_pinged;
         last_pinged_index = &onion_c->friends_list[num - 1].last_pinged_index;
     }
@@ -563,16 +572,16 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
                 continue;
 
         if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)
-                || id_closest(reference_id, list_nodes[0].client_id, nodes[i].client_id) == 2) {
+                || id_closest(reference_id, list_nodes[0].public_key, nodes[i].public_key) == 2) {
             /* check if node is already in list. */
             for (j = 0; j < MAX_ONION_CLIENTS; ++j) {
-                if (memcmp(list_nodes[j].client_id, nodes[i].client_id, crypto_box_PUBLICKEYBYTES) == 0) {
+                if (memcmp(list_nodes[j].public_key, nodes[i].public_key, crypto_box_PUBLICKEYBYTES) == 0) {
                     break;
                 }
             }
 
-            if (j == MAX_ONION_CLIENTS && good_to_ping(last_pinged, last_pinged_index, nodes[i].client_id)) {
-                client_send_announce_request(onion_c, num, nodes[i].ip_port, nodes[i].client_id, NULL, ~0);
+            if (j == MAX_ONION_CLIENTS && 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);
             }
         }
     }
@@ -670,17 +679,16 @@ static int handle_data_response(void *object, IP_Port source, const uint8_t *pac
             sizeof(plain));
 }
 
-#define FAKEID_DATA_ID 156
-#define FAKEID_DATA_MIN_LENGTH (1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES)
-#define FAKEID_DATA_MAX_LENGTH (FAKEID_DATA_MIN_LENGTH + sizeof(Node_format)*MAX_SENT_NODES)
-static int handle_fakeid_announce(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t length)
+#define DHTPK_DATA_MIN_LENGTH (1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES)
+#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)
 {
     Onion_Client *onion_c = object;
 
-    if (length < FAKEID_DATA_MIN_LENGTH)
+    if (length < DHTPK_DATA_MIN_LENGTH)
         return 1;
 
-    if (length > FAKEID_DATA_MAX_LENGTH)
+    if (length > DHTPK_DATA_MAX_LENGTH)
         return 1;
 
     int friend_num = onion_friend_num(onion_c, source_pubkey);
@@ -704,7 +712,7 @@ static int handle_fakeid_announce(void *object, const uint8_t *source_pubkey, co
     onion_set_friend_DHT_pubkey(onion_c, friend_num, data + 1 + sizeof(uint64_t));
     onion_c->friends_list[friend_num].last_seen = unix_time();
 
-    uint16_t len_nodes = length - FAKEID_DATA_MIN_LENGTH;
+    uint16_t len_nodes = length - DHTPK_DATA_MIN_LENGTH;
 
     if (len_nodes != 0) {
         Node_format nodes[MAX_SENT_NODES];
@@ -720,12 +728,12 @@ static int handle_fakeid_announce(void *object, const uint8_t *source_pubkey, co
             uint8_t family = nodes[i].ip_port.ip.family;
 
             if (family == AF_INET || family == AF_INET6) {
-                DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].client_id, onion_c->friends_list[friend_num].fake_client_id);
+                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) {
                 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;
-                    onion_c->friends_list[friend_num].tcp_relay_node_callback(obj, number, nodes[i].ip_port, nodes[i].client_id);
+                    onion_c->friends_list[friend_num].tcp_relay_node_callback(obj, number, nodes[i].ip_port, nodes[i].public_key);
                 }
             }
         }
@@ -759,7 +767,7 @@ static int handle_tcp_onion(void *object, const uint8_t *data, uint16_t length)
  * return the number of packets sent on success
  * return -1 on failure.
  */
-int send_onion_data(const Onion_Client *onion_c, int friend_num, 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)
         return -1;
@@ -770,19 +778,7 @@ int send_onion_data(const Onion_Client *onion_c, int friend_num, const uint8_t *
     if (length == 0)
         return -1;
 
-    uint8_t nonce[crypto_box_NONCEBYTES];
-    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_client_id, onion_c->c->self_secret_key, nonce, data,
-                           length, packet + crypto_box_PUBLICKEYBYTES);
-
-    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES != sizeof(packet))
-        return -1;
-
     unsigned int i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0;
-    Onion_Path path[MAX_ONION_CLIENTS];
     Onion_Node *list_nodes = onion_c->friends_list[friend_num].clients_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
@@ -792,9 +788,6 @@ int send_onion_data(const Onion_Client *onion_c, int friend_num, const uint8_t *
         ++num_nodes;
 
         if (list_nodes[i].is_stored) {
-            if (random_path(onion_c, &onion_c->friends_list[friend_num].onion_paths, ~0, &path[num_good]) == -1)
-                continue;
-
             good_nodes[num_good] = i;
             ++num_good;
         }
@@ -803,36 +796,52 @@ int send_onion_data(const Onion_Client *onion_c, int friend_num, const uint8_t *
     if (num_good < (num_nodes / 4) + 1)
         return -1;
 
+    uint8_t nonce[crypto_box_NONCEBYTES];
+    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);
+
+    if ((uint32_t)len + crypto_box_PUBLICKEYBYTES != sizeof(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)
+            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_client_id,
+        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));
 
         if (len == -1)
             continue;
 
-        if (send_onion_packet_tcp_udp(onion_c, &path[i], 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;
 }
 
-/* Try to send the fakeid via the DHT instead of onion
+/* Try to send the dht public key via the DHT instead of onion
  *
  * Even if this function succeeds, the friend might not receive any data.
  *
  * return the number of packets sent on success
  * return -1 on failure.
  */
-static int send_dht_fakeid(const Onion_Client *onion_c, int friend_num, const uint8_t *data, uint16_t length)
+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)
         return -1;
 
-    if (!onion_c->friends_list[friend_num].is_fake_clientid)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key)
         return -1;
 
     uint8_t nonce[crypto_box_NONCEBYTES];
@@ -841,7 +850,7 @@ static int send_dht_fakeid(const Onion_Client *onion_c, int friend_num, const ui
     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_client_id, onion_c->c->self_secret_key, nonce, data,
+    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);
 
     if ((uint32_t)len + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES != sizeof(temp))
@@ -849,37 +858,37 @@ static int send_dht_fakeid(const Onion_Client *onion_c, int friend_num, const ui
 
     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].fake_client_id, temp, sizeof(temp), FAKEID_DATA_ID);
+                         onion_c->friends_list[friend_num].dht_public_key, temp, sizeof(temp), CRYPTO_PACKET_FAKEID);
 
     if (len == -1)
         return -1;
 
-    return route_tofriend(onion_c->dht, onion_c->friends_list[friend_num].fake_client_id, packet, len);
+    return route_tofriend(onion_c->dht, onion_c->friends_list[friend_num].dht_public_key, packet, len);
 }
 
-static int handle_dht_fakeid(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                             uint16_t length)
+static int handle_dht_dhtpk(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
+                            uint16_t length)
 {
     Onion_Client *onion_c = object;
 
-    if (length < FAKEID_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
+    if (length < DHTPK_DATA_MIN_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
         return 1;
 
-    if (length > FAKEID_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
+    if (length > DHTPK_DATA_MAX_LENGTH + DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES)
         return 1;
 
-    uint8_t plain[FAKEID_DATA_MAX_LENGTH];
+    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);
 
-    if ((uint32_t)len != length - (DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES))
+    if (len != length - (DATA_IN_RESPONSE_MIN_SIZE + crypto_box_NONCEBYTES))
         return 1;
 
     if (memcmp(source_pubkey, plain + 1 + sizeof(uint64_t), crypto_box_PUBLICKEYBYTES) != 0)
         return 1;
 
-    return handle_fakeid_announce(onion_c, packet, plain, len);
+    return handle_dhtpk_announce(onion_c, packet, plain, len);
 }
 /* Send the packets to tell our friends what our DHT public key is.
  *
@@ -890,13 +899,13 @@ static int handle_dht_fakeid(void *object, IP_Port source, const uint8_t *source
  * return the number of packets sent on success
  * return -1 on failure.
  */
-static int send_fakeid_announce(const Onion_Client *onion_c, uint16_t friend_num, uint8_t onion_dht_both)
+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)
         return -1;
 
-    uint8_t data[FAKEID_DATA_MAX_LENGTH];
-    data[0] = FAKEID_DATA_ID;
+    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));
@@ -908,7 +917,7 @@ static int send_fakeid_announce(const Onion_Client *onion_c, uint16_t friend_num
     int nodes_len = 0;
 
     if (num_nodes != 0) {
-        nodes_len = pack_nodes(data + FAKEID_DATA_MIN_LENGTH, FAKEID_DATA_MAX_LENGTH - FAKEID_DATA_MIN_LENGTH, nodes,
+        nodes_len = pack_nodes(data + DHTPK_DATA_MIN_LENGTH, DHTPK_DATA_MAX_LENGTH - DHTPK_DATA_MIN_LENGTH, nodes,
                                num_nodes);
 
         if (nodes_len <= 0)
@@ -918,10 +927,10 @@ static int send_fakeid_announce(const Onion_Client *onion_c, uint16_t friend_num
     int num1 = -1, num2 = -1;
 
     if (onion_dht_both != 1)
-        num1 = send_onion_data(onion_c, friend_num, data, FAKEID_DATA_MIN_LENGTH + nodes_len);
+        num1 = send_onion_data(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
 
     if (onion_dht_both != 0)
-        num2 = send_dht_fakeid(onion_c, friend_num, data, FAKEID_DATA_MIN_LENGTH + nodes_len);
+        num2 = send_dht_dhtpk(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len);
 
     if (num1 == -1)
         return num2;
@@ -937,7 +946,7 @@ static int send_fakeid_announce(const Onion_Client *onion_c, uint16_t friend_num
  * return -1 on failure.
  * return friend number on success.
  */
-int onion_friend_num(const Onion_Client *onion_c, const uint8_t *client_id)
+int onion_friend_num(const Onion_Client *onion_c, const uint8_t *public_key)
 {
     unsigned int i;
 
@@ -945,7 +954,7 @@ int onion_friend_num(const Onion_Client *onion_c, const uint8_t *client_id)
         if (onion_c->friends_list[i].status == 0)
             continue;
 
-        if (memcmp(client_id, onion_c->friends_list[i].real_client_id, crypto_box_PUBLICKEYBYTES) == 0)
+        if (memcmp(public_key, onion_c->friends_list[i].real_public_key, crypto_box_PUBLICKEYBYTES) == 0)
             return i;
     }
 
@@ -979,9 +988,9 @@ static int realloc_onion_friends(Onion_Client *onion_c, uint32_t num)
  * return -1 on failure.
  * return the friend number on success or if the friend was already added.
  */
-int onion_addfriend(Onion_Client *onion_c, const uint8_t *client_id)
+int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key)
 {
-    int num = onion_friend_num(onion_c, client_id);
+    int num = onion_friend_num(onion_c, public_key);
 
     if (num != -1)
         return num;
@@ -1005,7 +1014,7 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *client_id)
     }
 
     onion_c->friends_list[index].status = 1;
-    memcpy(onion_c->friends_list[index].real_client_id, client_id, crypto_box_PUBLICKEYBYTES);
+    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);
     return index;
 }
@@ -1020,8 +1029,8 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
     if ((uint32_t)friend_num >= onion_c->num_friends)
         return -1;
 
-    //if (onion_c->friends_list[friend_num].is_fake_clientid)
-    //    DHT_delfriend(onion_c->dht, onion_c->friends_list[friend_num].fake_client_id, 0);
+    //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);
 
     memset(&(onion_c->friends_list[friend_num]), 0, sizeof(Onion_Friend));
     unsigned int i;
@@ -1092,17 +1101,17 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
     if (onion_c->friends_list[friend_num].status == 0)
         return -1;
 
-    if (onion_c->friends_list[friend_num].is_fake_clientid) {
-        if (memcmp(dht_key, onion_c->friends_list[friend_num].fake_client_id, crypto_box_PUBLICKEYBYTES) == 0) {
+    if (onion_c->friends_list[friend_num].know_dht_public_key) {
+        if (memcmp(dht_key, onion_c->friends_list[friend_num].dht_public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             return -1;
         }
 
-        onion_c->friends_list[friend_num].is_fake_clientid = 0;
+        onion_c->friends_list[friend_num].know_dht_public_key = 0;
     }
 
     onion_c->friends_list[friend_num].last_seen = unix_time();
-    onion_c->friends_list[friend_num].is_fake_clientid = 1;
-    memcpy(onion_c->friends_list[friend_num].fake_client_id, dht_key, crypto_box_PUBLICKEYBYTES);
+    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);
 
     return 0;
 }
@@ -1120,18 +1129,18 @@ unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_
     if (onion_c->friends_list[friend_num].status == 0)
         return 0;
 
-    if (!onion_c->friends_list[friend_num].is_fake_clientid)
+    if (!onion_c->friends_list[friend_num].know_dht_public_key)
         return 0;
 
-    memcpy(dht_key, onion_c->friends_list[friend_num].fake_client_id, crypto_box_PUBLICKEYBYTES);
+    memcpy(dht_key, onion_c->friends_list[friend_num].dht_public_key, crypto_box_PUBLICKEYBYTES);
     return 1;
 }
 
 /* Get the ip of friend friendnum and put it in 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 onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_port)
@@ -1176,15 +1185,15 @@ int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_on
 static void populate_path_nodes(Onion_Client *onion_c)
 {
     Node_format nodes_list[MAX_SENT_NODES];
-    uint8_t client_id[crypto_box_PUBLICKEYBYTES];
+    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
     uint32_t random_num = rand();
-    memcpy(client_id, &random_num, sizeof(random_num));
+    memcpy(public_key, &random_num, sizeof(random_num));
 
-    unsigned int num_nodes = get_close_nodes(onion_c->dht, client_id, nodes_list, (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
+    unsigned int num_nodes = get_close_nodes(onion_c->dht, public_key, nodes_list, (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
     unsigned int i;
 
     for (i = 0; i < num_nodes; ++i) {
-        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].client_id);
+        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].public_key);
     }
 }
 
@@ -1196,7 +1205,7 @@ static void populate_path_nodes_tcp(Onion_Client *onion_c)
     unsigned int i;
 
     for (i = 0; i < num_nodes; ++i) {
-        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].client_id);
+        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].public_key);
     }
 }
 
@@ -1236,7 +1245,7 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
             }
 
             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].client_id, 0, ~0) == 0) {
+                if (client_send_announce_request(onion_c, friendnum + 1, list_nodes[i].ip_port, list_nodes[i].public_key, 0, ~0) == 0) {
                     list_nodes[i].last_pinged = unix_time();
                 }
             }
@@ -1256,7 +1265,7 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
                 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].client_id, 0, ~0);
+                                                 onion_c->path_nodes[num].public_key, 0, ~0);
                 }
 
                 ++onion_c->friends_list[friendnum].run_count;
@@ -1265,14 +1274,14 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
             ++onion_c->friends_list[friendnum].run_count;
         }
 
-        /* send packets to friend telling them our fake DHT id. */
-        if (is_timeout(onion_c->friends_list[friendnum].last_fakeid_onion_sent, ONION_FAKEID_INTERVAL))
-            if (send_fakeid_announce(onion_c, friendnum, 0) >= 1)
-                onion_c->friends_list[friendnum].last_fakeid_onion_sent = unix_time();
+        /* 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)
+                onion_c->friends_list[friendnum].last_dht_pk_onion_sent = unix_time();
 
-        if (is_timeout(onion_c->friends_list[friendnum].last_fakeid_dht_sent, DHT_FAKEID_INTERVAL))
-            if (send_fakeid_announce(onion_c, friendnum, 1) >= 1)
-                onion_c->friends_list[friendnum].last_fakeid_dht_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)
+                onion_c->friends_list[friendnum].last_dht_pk_dht_sent = unix_time();
 
     }
 }
@@ -1312,7 +1321,7 @@ static void do_announce(Onion_Client *onion_c)
         }
 
         if (is_timeout(list_nodes[i].last_pinged, interval)) {
-            if (client_send_announce_request(onion_c, 0, list_nodes[i].ip_port, list_nodes[i].client_id,
+            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].last_pinged = unix_time();
             }
@@ -1335,7 +1344,7 @@ static void do_announce(Onion_Client *onion_c)
             if (num_nodes != 0) {
                 for (i = 0; i < (MAX_ONION_CLIENTS / 2); ++i) {
                     unsigned int num = rand() % num_nodes;
-                    client_send_announce_request(onion_c, 0, path_nodes[num].ip_port, path_nodes[num].client_id, 0, ~0);
+                    client_send_announce_request(onion_c, 0, path_nodes[num].ip_port, path_nodes[num].public_key, 0, ~0);
                 }
             }
         }
@@ -1386,8 +1395,8 @@ Onion_Client *new_onion_client(Net_Crypto *c)
     crypto_box_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, FAKEID_DATA_ID, &handle_fakeid_announce, onion_c);
-    cryptopacket_registerhandler(onion_c->dht, FAKEID_DATA_ID, &handle_dht_fakeid, onion_c);
+    oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, &handle_dhtpk_announce, onion_c);
+    cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_FAKEID, &handle_dht_dhtpk, onion_c);
     tcp_onion_response_handler(onion_c->c, &handle_tcp_onion, onion_c);
 
     return onion_c;
@@ -1402,8 +1411,8 @@ void kill_onion_client(Onion_Client *onion_c)
     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, FAKEID_DATA_ID, NULL, NULL);
-    cryptopacket_registerhandler(onion_c->dht, FAKEID_DATA_ID, NULL, NULL);
+    oniondata_registerhandler(onion_c, ONION_DATA_DHTPK, NULL, NULL);
+    cryptopacket_registerhandler(onion_c->dht, CRYPTO_PACKET_FAKEID, NULL, NULL);
     tcp_onion_response_handler(onion_c->c, NULL, NULL);
     memset(onion_c, 0, sizeof(Onion_Client));
     free(onion_c);
diff --git a/toxcore/onion_client.h b/toxcore/onion_client.h
index fe586c5b..b4e7a1b7 100644
--- a/toxcore/onion_client.h
+++ b/toxcore/onion_client.h
@@ -33,8 +33,8 @@
 #define ONION_NODE_TIMEOUT (ONION_NODE_PING_INTERVAL * 3)
 
 /* The interval in seconds at which to tell our friends where we are */
-#define ONION_FAKEID_INTERVAL 30
-#define DHT_FAKEID_INTERVAL 20
+#define ONION_DHTPK_SEND_INTERVAL 30
+#define DHT_DHTPK_SEND_INTERVAL 20
 
 #define NUMBER_ONION_PATHS 6
 
@@ -55,8 +55,12 @@
  */
 #define ONION_OFFLINE_TIMEOUT (ONION_NODE_PING_INTERVAL * 1.25)
 
+/* Onion data packet ids. */
+#define ONION_DATA_FRIEND_REQ CRYPTO_PACKET_FRIEND_REQ
+#define ONION_DATA_DHTPK CRYPTO_PACKET_FAKEID
+
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    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];
@@ -79,7 +83,7 @@ typedef struct {
 } Onion_Client_Paths;
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     uint64_t    timestamp;
 } Last_Pinged;
 
@@ -87,23 +91,21 @@ 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 is_fake_clientid; /* 0 if we don't know the fake client id of the other 1 if we do. */
-    uint8_t fake_client_id[crypto_box_PUBLICKEYBYTES];
-    uint8_t real_client_id[crypto_box_PUBLICKEYBYTES];
+    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_fakeid_onion_sent;
-    uint64_t last_fakeid_dht_sent;
+    uint64_t last_dht_pk_onion_sent;
+    uint64_t last_dht_pk_dht_sent;
 
     uint64_t last_noreplay;
 
     uint64_t last_seen;
 
-    Onion_Client_Paths onion_paths;
-
     Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
     uint8_t last_pinged_index;
 
@@ -130,7 +132,8 @@ typedef struct {
 
     Onion_Node clients_announce_list[MAX_ONION_CLIENTS];
 
-    Onion_Client_Paths onion_paths;
+    Onion_Client_Paths onion_paths_self;
+    Onion_Client_Paths onion_paths_friends;
 
     uint8_t secret_symmetric_key[crypto_box_KEYBYTES];
     uint64_t last_run;
@@ -162,7 +165,7 @@ typedef struct {
  * return -1 on failure
  * return 0 on success
  */
-int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *client_id);
+int onion_add_bs_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *public_key);
 
 /* Put up to max_num nodes in nodes.
  *
@@ -175,14 +178,14 @@ uint16_t onion_backup_nodes(const Onion_Client *onion_c, Node_format *nodes, uin
  * return -1 on failure.
  * return the friend number on success or if the friend was already added.
  */
-int onion_friend_num(const Onion_Client *onion_c, const uint8_t *client_id);
+int onion_friend_num(const Onion_Client *onion_c, const uint8_t *public_key);
 
 /* Add a friend who we want to connect to.
  *
  * return -1 on failure.
  * return the friend number on success.
  */
-int onion_addfriend(Onion_Client *onion_c, const uint8_t *client_id);
+int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key);
 
 /* Delete a friend.
  *
@@ -204,9 +207,9 @@ int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_on
 
 /* Get the ip of friend friendnum and put it in 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 onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_port);
@@ -262,7 +265,7 @@ unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_
  * return the number of packets sent on success
  * return -1 on failure.
  */
-int send_onion_data(const Onion_Client *onion_c, int friend_num, 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);
 
 /* 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.c b/toxcore/ping.c
index a29c1a12..1c3564a3 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -269,12 +269,12 @@ int add_to_ping(PING *ping, const uint8_t *client_id, 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].client_id, client_id, CLIENT_ID_SIZE);
+            memcpy(ping->to_ping[i].public_key, client_id, CLIENT_ID_SIZE);
             ipport_copy(&ping->to_ping[i].ip_port, &ip_port);
             return 0;
         }
 
-        if (memcmp(ping->to_ping[i].client_id, client_id, CLIENT_ID_SIZE) == 0) {
+        if (memcmp(ping->to_ping[i].public_key, client_id, 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].client_id, client_id) == 2) {
-            memcpy(ping->to_ping[(i + r) % MAX_TO_PING].client_id, client_id, CLIENT_ID_SIZE);
+        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);
             ipport_copy(&ping->to_ping[(i + r) % MAX_TO_PING].ip_port, &ip_port);
             return 0;
         }
@@ -311,7 +311,7 @@ void do_to_ping(PING *ping)
         if (!ip_isset(&ping->to_ping[i].ip_port.ip))
             return;
 
-        send_ping_request(ping, ping->to_ping[i].ip_port, ping->to_ping[i].client_id);
+        send_ping_request(ping, ping->to_ping[i].ip_port, ping->to_ping[i].public_key);
         ip_reset(&ping->to_ping[i].ip_port.ip);
     }
 }
diff --git a/toxcore/tox.c b/toxcore/tox.c
index a4a73838..82beb561 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -36,7 +36,7 @@ typedef struct Messenger Tox;
 
 /*
  * returns a FRIEND_ADDRESS_SIZE byte address to give to others.
- * Format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
+ * Format: [public_key (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
  *
  */
 void tox_get_address(const Tox *tox, uint8_t *address)
@@ -73,31 +73,31 @@ int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, ui
  *  return the friend number if success.
  *  return -1 if failure.
  */
-int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id)
+int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *public_key)
 {
     Messenger *m = tox;
-    return m_addfriend_norequest(m, client_id);
+    return m_addfriend_norequest(m, public_key);
 }
 
 /*  return the friend number associated to that client id.
  *  return -1 if no such friend.
  */
-int32_t tox_get_friend_number(const Tox *tox, const uint8_t *client_id)
+int32_t tox_get_friend_number(const Tox *tox, const uint8_t *public_key)
 {
     const Messenger *m = tox;
-    return getfriend_id(m, client_id);
+    return getfriend_id(m, public_key);
 }
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
+/* Copies the public key associated to that friend id into public_key buffer.
+ * Make sure that public_key is of size crypto_box_PUBLICKEYBYTES.
  *
  *  return 0 if success.
  *  return -1 if failure.
  */
-int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id)
+int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *public_key)
 {
     const Messenger *m = tox;
-    return getclient_id(m, friendnumber, client_id);
+    return get_real_pk(m, friendnumber, public_key);
 }
 
 /* Remove a friend. */
@@ -643,16 +643,16 @@ int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t
     return group_peername(m->group_chat_object, groupnumber, peernumber, name);
 }
 
-/* Copy the public key of peernumber who is in groupnumber to pk.
- * pk must be TOX_CLIENT_ID_SIZE long.
+/* 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 *pk)
+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, pk);
+    return group_peer_pubkey(m->group_chat_object, groupnumber, peernumber, public_key);
 }
 
 /* invite friendnumber to groupnumber
@@ -1012,8 +1012,8 @@ uint32_t tox_do_interval(Tox *tox)
  */
 Tox *tox_new(Tox_Options *options)
 {
-    logger_set_global(logger_new(LOGGER_OUTPUT_FILE, LOGGER_LEVEL, "toxcore"));
-
+    if (!logger_get_global())
+        logger_set_global(logger_new(LOGGER_OUTPUT_FILE, LOGGER_LEVEL, "toxcore"));
 
     Messenger_Options m_options = {0};
 
diff --git a/toxcore/tox.h b/toxcore/tox.h
index db1b1033..ee678cc1 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -38,11 +38,14 @@ extern "C" {
 #define TOX_MAX_STATUSMESSAGE_LENGTH 1007
 #define TOX_MAX_FRIENDREQUEST_LENGTH 1016
 
-#define TOX_CLIENT_ID_SIZE 32
+#define TOX_PUBLIC_KEY_SIZE 32
+/* TODO: remove */
+#define TOX_CLIENT_ID_SIZE TOX_PUBLIC_KEY_SIZE
+
 #define TOX_AVATAR_MAX_DATA_LENGTH 16384
 #define TOX_HASH_LENGTH /*crypto_hash_sha256_BYTES*/ 32
 
-#define TOX_FRIEND_ADDRESS_SIZE (TOX_CLIENT_ID_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
+#define TOX_FRIEND_ADDRESS_SIZE (TOX_PUBLIC_KEY_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
 
 #define TOX_ENABLE_IPV6_DEFAULT 1
 
@@ -97,7 +100,7 @@ typedef struct Tox Tox;
  */
 
 /*  return TOX_FRIEND_ADDRESS_SIZE byte address to give to others.
- * format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
+ * format: [public_key (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
  */
 void tox_get_address(const Tox *tox, uint8_t *address);
 
@@ -124,18 +127,18 @@ int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, ui
  *  return the friend number if success.
  *  return -1 if failure.
  */
-int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id);
+int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *public_key);
 
 /*  return the friend number associated to that client id.
     return -1 if no such friend */
-int32_t tox_get_friend_number(const Tox *tox, const uint8_t *client_id);
+int32_t tox_get_friend_number(const Tox *tox, const uint8_t *public_key);
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
+/* Copies the public key associated to that friend id into public_key buffer.
+ * Make sure that public_key is of size TOX_PUBLIC_KEY_SIZE.
  *  return 0 if success.
  *  return -1 if failure.
  */
-int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id);
+int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *public_key);
 
 /* Remove a friend.
  *
@@ -500,13 +503,13 @@ int tox_del_groupchat(Tox *tox, int groupnumber);
  */
 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 pk.
- * pk must be TOX_CLIENT_ID_SIZE long.
+/* 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 *pk);
+int tox_group_peer_pubkey(const Tox *tox, int groupnumber, int peernumber, uint8_t *public_key);
 
 /* invite friendnumber to groupnumber
  * return 0 on success
diff --git a/toxencryptsave/toxencryptsave.c b/toxencryptsave/toxencryptsave.c
index b6453a89..9172f512 100644
--- a/toxencryptsave/toxencryptsave.c
+++ b/toxencryptsave/toxencryptsave.c
@@ -121,7 +121,7 @@ int tox_derive_key_with_salt(uint8_t *passphrase, uint32_t pplength, uint8_t *sa
     /* note that, according to the documentation, a generic pwhash interface will be created
      * once the pwhash competition (https://password-hashing.net/) is over */
     if (crypto_pwhash_scryptsalsa208sha256(
-                key, sizeof(key), passkey, sizeof(passkey), salt,
+                key, sizeof(key), (char *)passkey, sizeof(passkey), salt,
                 crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 2, /* slightly stronger */
                 crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE) != 0) {
         /* out of memory most likely */
@@ -280,7 +280,7 @@ int tox_pass_decrypt(const uint8_t *data, uint32_t length, uint8_t *passphrase,
 
     if (crypto_pwhash_scryptsalsa208sha256(
                 key + crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
-                crypto_box_KEYBYTES, passkey, sizeof(passkey), salt,
+                crypto_box_KEYBYTES, (char *)passkey, sizeof(passkey), salt,
                 crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 2, /* slightly stronger */
                 crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE) != 0) {
         /* out of memory most likely */