111 files changed, 16802 insertions, 7023 deletions

diff --git a/.gitignore b/.gitignore
index 75714388..4397a1c1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,6 @@ nbproject
 # Android buildscript
 android-toolchain-*
 toxcore-android-*
+
+# cscope files list
+cscope.files
diff --git a/.travis.yml b/.travis.yml
index ca14c884..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.4.2 > /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 b/INSTALL
index 007e9396..20998407 100644
--- a/INSTALL
+++ b/INSTALL
@@ -12,8 +12,8 @@ without warranty of any kind.
 Basic Installation
 ==================
 
-   Briefly, the shell commands `./configure; make; make install' should
-configure, build, and install this package.  The following
+   Briefly, the shell command `./configure && make && make install'
+should configure, build, and install this package.  The following
 more-detailed instructions are generic; see the `README' file for
 instructions specific to this package.  Some packages provide this
 `INSTALL' file but do not implement all of the features documented
diff --git a/INSTALL.md b/INSTALL.md
index 0430c1ab..c2a8c0d9 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -53,14 +53,16 @@ pkg install net-im/tox
 ```
 Note, if you install from ports select NaCl for performance, and sodium if you want it to be portable.
 
+**For A/V support, also install the dependences listed in the [libtoxav] (#libtoxav) section.**
+
 You should get and install [libsodium](https://github.com/jedisct1/libsodium):
 ```bash
 git clone git://github.com/jedisct1/libsodium.git
 cd libsodium
-git checkout tags/0.5.0
+git checkout tags/1.0.0
 ./autogen.sh
 ./configure && make check
-sudo checkinstall --install --pkgname libsodium --pkgversion 0.5.0 --nodoc
+sudo checkinstall --install --pkgname libsodium --pkgversion 1.0.0 --nodoc
 sudo ldconfig
 cd ..
 ```
@@ -72,7 +74,7 @@ this will install the libs to /usr/local/lib and the headers to /usr/local/inclu
 ```bash
 git clone git://github.com/jedisct1/libsodium.git
 cd libsodium
-git checkout tags/0.5.0
+git checkout tags/1.0.0
 ./autogen.sh
 ./configure
 make check
@@ -88,8 +90,8 @@ sudo ldconfig
 
 Then clone this repo and generate makefile:
 ```bash
-git clone git://github.com/irungentoo/ProjectTox-Core.git
-cd ProjectTox-Core
+git clone git://github.com/irungentoo/toxcore.git
+cd toxcore
 autoreconf -i
 ./configure
 make
@@ -103,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:
@@ -118,8 +122,8 @@ brew install libtool automake autoconf libsodium check
 ```
 Then clone this repo and generate makefile:
 ```bash
-git clone git://github.com/irungentoo/ProjectTox-Core.git
-cd ProjectTox-Core
+git clone git://github.com/irungentoo/toxcore.git
+cd toxcore
 autoreconf -i
 ./configure
 make
@@ -135,7 +139,7 @@ brew list libsodium
 
 Configure include and lib folder and build again:
 ```bash
-./configure --with-libsodium-headers=/usr/local/Cellar/libsodium/0.4.5/include/ --with-libsodium-libs=/usr/local/Cellar/libsodium/0.4.5/lib/
+./configure --with-libsodium-headers=/usr/local/Cellar/libsodium/1.0.0/include/ --with-libsodium-libs=/usr/local/Cellar/libsodium/1.0.0/lib/
 make
 make install
 ```
@@ -150,12 +154,34 @@ Grab the following packages:
   * https://gnu.org/software/automake/
   * https://github.com/jedisct1/libsodium
   * http://check.sourceforge.net/
-  * http://yasm.tortall.net/Download.html
+  * http://yasm.tortall.net/Download.html (install before libvpx)
   * https://code.google.com/p/webm/downloads/list
   * http://www.opus-codec.org/downloads/
   * http://www.freedesktop.org/wiki/Software/pkg-config/
 
-You must install yasm before installing libvpx, otherwise libvpx will fail to make correctly.
+Macports: (https://www.macports.org/)
+All toxcore dependencies can be installed from MacPorts. This is often easier on PowerPC Macs,
+and any version of OS X prior to 10.6, since Homebrew is supported on 10.6 and up, but not much
+(or at all) on older systems. A few packages have slightly different names from the corresponding
+package in Debian.
+
+Same: libtool autoconf automake libsodium check yasm
+Different: libvpx (webm) libopus pkgconfig gettext
+
+(the libintl, from gettext, built into OS X 10.5 is missing libintl_setlocale, but the Macports build has it)
+
+Verify where libintl is on your system: (MacPorts puts it in /opt/local)
+$ for d in /usr/local/lib /opt/local/lib /usr/lib /lib; do ls -l $d/libintl.*; done
+
+Check if that copy has libintl_setlocale:
+nm /opt/local/lib/libintl.8.dylib | grep _libintl_setlocale
+
+Certain other tools may not be installed, or outdated, and should also be installed from MacPorts for simplicity: git cmake
+
+If libsodium was installed with MacPorts, you may want to symlink the copy in /opt/local/lib to /usr/local/lib. That way you don't need special configure switches for toxcore to find libsodium, and every time MacPorts updates libsodium, the new version will be linked to toxcore every time you build:
+ln -s /opt/local/lib/libsodium.dylib /usr/local/lib/libsodium.dylib
+
+Much of the build can then be done as for other platforms: git clone, and so on. Differences will be noted with (OS X 10.5 specific)
 
 pkg-config is important for enabling a/v support in tox core, failure to install pkg-config will prevent tox core form finding the required libopus/libvpx libraries. (pkg-config may not configure properly, if you get an error about GLIB, run configure with the following parameter, --with-internal-glib).
 
@@ -170,11 +196,23 @@ sudo make install
 Compiling and installing Tox Core
 
 ```bash
-cd ProjectTox-Core
+cd toxcore
 autoreconf -i
-./configure
+./configure (OS X 10.5 specific)
+./configure CC="gcc -arch ppc -arch i386" CXX="g++ -arch ppc -arch i386" CPP="gcc -E" CXXCPP="g++ -E"
 make
-make install
+make install (OS X 10.5 specific)
+should be: sudo make install
+If it worked, you should have all the toxcore dylibs in /usr/local/lib: (besides the four below, the rest are symlinks to these)
+$ ls -la /usr/local/lib/libtox*.dylib
+libtoxav.0.dylib
+libtoxcore.0.dylib
+libtoxdns.0.dylib
+libtoxencryptsave.0.dylib
+to check what CPU architecture they're compiled for:
+$ lipo -i /usr/local/lib/libtoxencryptsave.0.dylib
+You should now be able to move on to compiling Toxic/Venom or some other client application
+There is also a shell script called "osx_build_script_toxcore.txt" which automates everything from "git pull" to "sudo make install", once the dependencies are already taken care of by MacPorts.
 ```
 
 If after running ./configure you get an error about core being unable to find libsodium (and you have installed it) run the following in place of ./configure;
@@ -318,7 +356,7 @@ Now we will build sodium crypto library:
 ```bash
 git clone https://github.com/jedisct1/libsodium/
 cd libsodium
-git checkout tags/0.6.1
+git checkout tags/1.0.0
 ./autogen.sh
 ./configure --host="$WINDOWS_TOOLCHAIN" --prefix="$PREFIX_DIR" --disable-shared --enable-static
 make
@@ -345,6 +383,7 @@ cd tmp
 $WINDOWS_TOOLCHAIN-ar x ../lib/libtoxcore.a
 $WINDOWS_TOOLCHAIN-ar x ../lib/libtoxav.a
 $WINDOWS_TOOLCHAIN-ar x ../lib/libtoxdns.a
+$WINDOWS_TOOLCHAIN-ar x ../lib/libtoxencryptsave.a
 $WINDOWS_TOOLCHAIN-gcc -Wl,--export-all-symbols -Wl,--out-implib=libtox.dll.a -shared -o libtox.dll *.o ../lib/*.a /usr/$WINDOWS_TOOLCHAIN/lib/libwinpthread.a -liphlpapi -lws2_32 -static-libgcc
 ```
 
@@ -372,10 +411,10 @@ When installing MinGW, make sure to select the MSYS option in the installer.
 MinGW will install an "MinGW shell" (you should get a shortcut for it), make sure to perform all operations (i.e., generating/running configure script, compiling, etc.) from the MinGW shell.
 
 First download the source tarball from https://download.libsodium.org/libsodium/releases/ and build it.
-Assuming that you got the libsodium-0.5.0.tar.gz release:
+Assuming that you got the libsodium-1.0.0.tar.gz release:
 ```cmd
-tar -zxvf libsodium-0.5.0.tar.gz
-cd libsodium-0.5.0
+tar -zxvf libsodium-1.0.0.tar.gz
+cd libsodium-1.0.0
 ./configure
 make
 make install
@@ -384,12 +423,12 @@ cd ..
 
 You can also use a precompiled win32 binary of libsodium, however you will have to place the files in places where they can be found, i.e., dll's go to /bin headers to /include and libraries to /lib directories in your MinGW shell.
 
-Next, install ProjectTox-Core library, should either clone this repo by using git, or just download a [zip of current Master branch](https://github.com/irungentoo/ProjectTox-Core/archive/master.zip) and extract it somewhere.
+Next, install toxcore library, should either clone this repo by using git, or just download a [zip of current Master branch](https://github.com/irungentoo/toxcore/archive/master.zip) and extract it somewhere.
 
-Assuming that you now have the sources in the ProjectTox-Core directory:
+Assuming that you now have the sources in the toxcore directory:
 
 ```cmd
-cd ProjectTox-Core
+cd toxcore
 autoreconf -i
 ./configure
 make
@@ -440,12 +479,12 @@ There are 2 dependencies required for libtoxav: libopus and libvpx. If they are
 
 Install on fedora:
 ```bash
-yum install libopus-devel libvpx-devel
+yum install opus-devel libvpx-devel
 ```
 
 Install on ubuntu:
 ```bash
-sudo apt-get install libopus-dev libvpx-dev
+sudo apt-get install libopus-dev libvpx-dev pkg-config
 ```
 If you get the "Unable to locate package libopus-dev" message, add the following ppa and try again:
 ```bash
@@ -499,7 +538,7 @@ OS X homebrew:
 brew install libconfig
 ```
 OS X non-homebrew:
-Grab the following [package] (http://www.hyperrealm.com/libconfig/), uncompress and install
+Grab the following [package](http://www.hyperrealm.com/libconfig/), uncompress and install
 
 See this [readme](other/bootstrap_daemon/README.md) on how to set up the bootstrap daemon.
 
diff --git a/README.md b/README.md
index 82f5beae..6fd2c5e6 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/)  **|** 
-**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:
@@ -22,12 +21,12 @@ Every peer is represented as a [byte string][String] (the public key [Tox ID] of
 
 ## Q&A:
 
-### What are your goals of Tox?
+### What are your goals with Tox?
 
 We want Tox to be as simple as possible while remaining as secure as possible.
 
 ### Why are you doing this? There are already a bunch of free Skype alternatives.
-The goal of this project is to create a configuration-free P2P Skype replacement. Configuration-free means that the user will simply have to open the program and without any account configuration will be capable of adding people to his or her's friends list and start conversing with them. There are many so-called Skype replacements and all of them are either hard to configure for the normal user or suffer from being way too centralized.
+The goal of this project is to create a configuration-free P2P Skype replacement. “Configuration-free” means that the user will simply have to open the program and will be capable of adding people and communicating with them without having to set up an account. There are many so-called Skype replacements, but all of them are either hard to configure for the normal user or suffer from being way too centralized.
 
 ## TODO:
 - [TODO](/docs/TODO)
diff --git a/auto_tests/Makefile.inc b/auto_tests/Makefile.inc
index c68f313b..d78a6a5a 100644
--- a/auto_tests/Makefile.inc
+++ b/auto_tests/Makefile.inc
@@ -1,7 +1,7 @@
 if BUILD_TESTS
 
-TESTS = messenger_autotest crypto_test network_test assoc_test onion_test TCP_test tox_test dht_autotest
-check_PROGRAMS = messenger_autotest crypto_test network_test assoc_test onion_test TCP_test tox_test dht_autotest
+TESTS = encryptsave_test messenger_autotest crypto_test network_test assoc_test onion_test TCP_test tox_test dht_autotest
+check_PROGRAMS = encryptsave_test messenger_autotest crypto_test network_test assoc_test onion_test TCP_test tox_test dht_autotest
 
 AUTOTEST_CFLAGS = \
                          $(LIBSODIUM_CFLAGS) \
@@ -12,6 +12,7 @@ AUTOTEST_LDADD = \
                         $(LIBSODIUM_LDFLAGS) \
                         $(NACL_LDFLAGS) \
                         libtoxcore.la \
+                        libtoxencryptsave.la \
                         $(LIBSODIUM_LIBS) \
                         $(NACL_OBJECTS) \
                         $(NACL_LIBS) \
@@ -98,4 +99,12 @@ endif
 
 endif
 
-EXTRA_DIST += $(top_srcdir)/auto_tests/friends_test.c
\ No newline at end of file
+
+encryptsave_test_SOURCES = ../auto_tests/encryptsave_test.c
+
+encryptsave_test_CFLAGS = $(AUTOTEST_CFLAGS)
+
+encryptsave_test_LDADD = $(AUTOTEST_LDADD)
+
+
+EXTRA_DIST += $(top_srcdir)/auto_tests/friends_test.c
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/dht_test.c b/auto_tests/dht_test.c
index 6d7e70ad..acbc3acb 100644
--- a/auto_tests/dht_test.c
+++ b/auto_tests/dht_test.c
@@ -45,6 +45,7 @@ void mark_good(IPPTsPng *ipptp)
 void mark_all_good(Client_data *list, uint32_t length, uint8_t ipv6)
 {
     uint32_t i;
+
     for (i = 0; i < length; ++i) {
         if (ipv6)
             mark_good(&list[i].assoc6);
@@ -58,18 +59,22 @@ void mark_all_good(Client_data *list, uint32_t length, uint8_t ipv6)
 uint8_t is_furthest(const uint8_t *comp_client_id, Client_data *list, uint32_t length, const uint8_t *client_id)
 {
     uint32_t i;
+
     for (i = 0; i < length; ++i)
         if (id_closest(comp_client_id, client_id, list[i].client_id) == 1)
             return 0;
+
     return 1;
 }
 
 int client_in_list(Client_data *list, uint32_t length, const uint8_t *client_id)
 {
     int i;
+
     for (i = 0; i < (int)length; ++i)
         if (id_equal(client_id, list[i].client_id))
             return i;
+
     return -1;
 }
 
@@ -93,7 +98,8 @@ void test_addto_lists_update(DHT            *dht,
     // it is possible to have ip_port duplicates in the list, so ip_port @ found not always equal to ip_port @ test
     found = client_in_list(list, length, test_id);
     ck_assert_msg(found >= 0, "Client id is not in the list");
-    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[found].assoc6.ip_port : &list[found].assoc4.ip_port), "Client IP_Port is incorrect");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[found].assoc6.ip_port : &list[found].assoc4.ip_port),
+                  "Client IP_Port is incorrect");
 
     // check ip_port update for existing id
     test = rand() % length;
@@ -104,7 +110,8 @@ void test_addto_lists_update(DHT            *dht,
     ck_assert_msg(used >= 1, "Wrong number of added clients");
     // it is not possible to have id duplicates in the list, so id @ found must be equal id @ test
     ck_assert_msg(client_in_list(list, length, test_id) == test, "Client id is not in the list");
-    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test].assoc6.ip_port : &list[test].assoc4.ip_port), "Client IP_Port is incorrect");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test].assoc6.ip_port : &list[test].assoc4.ip_port),
+                  "Client IP_Port is incorrect");
 
     // check ip_port update for existing id and ip_port (... port ... id ...)
     test1 = rand() % (length / 2);
@@ -112,11 +119,15 @@ void test_addto_lists_update(DHT            *dht,
 
     ipport_copy(&test_ipp, ipv6 ? &list[test1].assoc6.ip_port : &list[test1].assoc4.ip_port);
     id_copy(test_id, list[test2].client_id);
-    if (ipv6) list[test2].assoc6.ip_port.port = -1; else list[test2].assoc4.ip_port.port = -1;
+
+    if (ipv6) list[test2].assoc6.ip_port.port = -1;
+    else list[test2].assoc4.ip_port.port = -1;
+
     used = addto_lists(dht, test_ipp, test_id);
     ck_assert_msg(used >= 1, "Wrong number of added clients");
     ck_assert_msg(client_in_list(list, length, test_id) == test2, "Client id is not in the list");
-    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test2].assoc6.ip_port : &list[test2].assoc4.ip_port), "Client IP_Port is incorrect");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test2].assoc6.ip_port : &list[test2].assoc4.ip_port),
+                  "Client IP_Port is incorrect");
 
     // check ip_port update for existing id and ip_port (... id ... port ...)
     test1 = rand() % (length / 2);
@@ -124,11 +135,15 @@ void test_addto_lists_update(DHT            *dht,
 
     ipport_copy(&test_ipp, ipv6 ? &list[test2].assoc6.ip_port : &list[test2].assoc4.ip_port);
     id_copy(test_id, list[test1].client_id);
-    if (ipv6) list[test1].assoc6.ip_port.port = -1; else list[test1].assoc4.ip_port.port = -1;
+
+    if (ipv6) list[test1].assoc6.ip_port.port = -1;
+    else list[test1].assoc4.ip_port.port = -1;
+
     used = addto_lists(dht, test_ipp, test_id);
     ck_assert_msg(used >= 1, "Wrong number of added clients");
     ck_assert_msg(client_in_list(list, length, test_id) == test1, "Client id is not in the list");
-    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test1].assoc6.ip_port : &list[test1].assoc4.ip_port), "Client IP_Port is incorrect");
+    ck_assert_msg(ipport_equal(&test_ipp, ipv6 ? &list[test1].assoc6.ip_port : &list[test1].assoc4.ip_port),
+                  "Client IP_Port is incorrect");
 }
 
 void test_addto_lists_bad(DHT            *dht,
@@ -149,9 +164,9 @@ void test_addto_lists_bad(DHT            *dht,
     test3 = rand() % (length / 3) + 2 * length / 3;
     ck_assert_msg(!(test1 == test2 || test1 == test3 || test2 == test3), "Wrong test indices are chosen");
 
-    id_copy((uint8_t*)&test_id1, list[test1].client_id);
-    id_copy((uint8_t*)&test_id2, list[test2].client_id);
-    id_copy((uint8_t*)&test_id3, list[test3].client_id);
+    id_copy((uint8_t *)&test_id1, list[test1].client_id);
+    id_copy((uint8_t *)&test_id2, list[test2].client_id);
+    id_copy((uint8_t *)&test_id3, list[test3].client_id);
 
     // mark nodes as "bad"
     if (ipv6) {
@@ -169,9 +184,8 @@ void test_addto_lists_bad(DHT            *dht,
     ck_assert_msg(used >= 1, "Wrong number of added clients");
 
     ck_assert_msg(client_in_list(list, length, client_id) >= 0, "Client id is not in the list");
-    ck_assert_msg(id_equal(client_id, list[test1].client_id), "Wrong bad client removed");
-    ck_assert_msg(id_equal(test_id2, list[test2].client_id), "Wrong bad client removed");
-    ck_assert_msg(id_equal(test_id3, list[test3].client_id), "Wrong bad client removed");
+    ck_assert_msg(client_in_list(list, length, test_id2) >= 0, "Wrong bad client removed");
+    ck_assert_msg(client_in_list(list, length, test_id3) >= 0, "Wrong bad client removed");
 }
 
 void test_addto_lists_possible_bad(DHT            *dht,
@@ -193,9 +207,9 @@ void test_addto_lists_possible_bad(DHT            *dht,
     test3 = rand() % (length / 3) + 2 * length / 3;
     ck_assert_msg(!(test1 == test2 || test1 == test3 || test2 == test3), "Wrong test indices are chosen");
 
-    id_copy((uint8_t*)&test_id1, list[test1].client_id);
-    id_copy((uint8_t*)&test_id2, list[test2].client_id);
-    id_copy((uint8_t*)&test_id3, list[test3].client_id);
+    id_copy((uint8_t *)&test_id1, list[test1].client_id);
+    id_copy((uint8_t *)&test_id2, list[test2].client_id);
+    id_copy((uint8_t *)&test_id3, list[test3].client_id);
 
     // mark nodes as "possibly bad"
     if (ipv6) {
@@ -221,14 +235,20 @@ void test_addto_lists_possible_bad(DHT            *dht,
     ck_assert_msg(inlist_id1 + inlist_id2 + inlist_id3 == 2, "Wrong client removed");
 
     if (!inlist_id1) {
-        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id1) == 1, "Id has been removed but is closer to than another one");
-        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id1) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id1) == 1,
+                      "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id1) == 1,
+                      "Id has been removed but is closer to than another one");
     } else if (!inlist_id2) {
-        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id2) == 1, "Id has been removed but is closer to than another one");
-        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id2) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id2) == 1,
+                      "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id3, test_id2) == 1,
+                      "Id has been removed but is closer to than another one");
     } else if (!inlist_id3) {
-        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id3) == 1, "Id has been removed but is closer to than another one");
-        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id3) == 1, "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id1, test_id3) == 1,
+                      "Id has been removed but is closer to than another one");
+        ck_assert_msg(id_closest(comp_client_id, test_id2, test_id3) == 1,
+                      "Id has been removed but is closer to than another one");
     }
 }
 
@@ -247,6 +267,7 @@ void test_addto_lists_good(DHT            *dht,
     do {
         randombytes(client_id, sizeof(client_id));
     } while (is_furthest(comp_client_id, list, length, client_id));
+
     ip_port->port += 1;
     addto_lists(dht, *ip_port, client_id);
     ck_assert_msg(client_in_list(list, length, client_id) >= 0, "Good client id is not in the list");
@@ -263,10 +284,10 @@ void test_addto_lists_good(DHT            *dht,
 
 void test_addto_lists(IP ip)
 {
-    Networking_Core* net = new_networking(ip, TOX_PORT_DEFAULT);
+    Networking_Core *net = new_networking(ip, TOX_PORT_DEFAULT);
     ck_assert_msg(net != 0, "Failed to create Networking_Core");
 
-    DHT* dht = new_DHT(net);
+    DHT *dht = new_DHT(net);
     ck_assert_msg(dht != 0, "Failed to create DHT");
 
     IP_Port ip_port = { .ip = ip, .port = TOX_PORT_DEFAULT };
@@ -296,23 +317,30 @@ void test_addto_lists(IP ip)
     /*check: Current behavior if there are two clients with the same id is
      * to replace the first ip by the second. */
     test_addto_lists_update(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port);
+
     for (i = 0; i < dht->num_friends; ++i)
         test_addto_lists_update(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port);
 
     // check "bad" entries
     test_addto_lists_bad(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port);
+
     for (i = 0; i < dht->num_friends; ++i)
         test_addto_lists_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port);
 
     // check "possibly bad" entries
+    /*
     test_addto_lists_possible_bad(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
-    for (i = 0; i < dht->num_friends; ++i)
-        test_addto_lists_possible_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port, dht->friends_list[i].client_id);
 
+    for (i = 0; i < dht->num_friends; ++i)
+        test_addto_lists_possible_bad(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port,
+                                      dht->friends_list[i].client_id);
+    */
     // check "good" entries
     test_addto_lists_good(dht, dht->close_clientlist, LCLIENT_LIST, &ip_port, dht->self_public_key);
+
     for (i = 0; i < dht->num_friends; ++i)
-        test_addto_lists_good(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port, dht->friends_list[i].client_id);
+        test_addto_lists_good(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &ip_port,
+                              dht->friends_list[i].client_id);
 
     kill_DHT(dht);
     kill_networking(net);
diff --git a/auto_tests/encryptsave_test.c b/auto_tests/encryptsave_test.c
new file mode 100644
index 00000000..338c9ef1
--- /dev/null
+++ b/auto_tests/encryptsave_test.c
@@ -0,0 +1,190 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <string.h>
+#include <check.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "helpers.h"
+
+#include "../toxcore/tox.h"
+
+#include "../toxencryptsave/toxencryptsave.h"
+#include "../toxcore/crypto_core.h"
+#ifdef VANILLA_NACL
+#include "../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h"
+#include "../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h" /* sodium_memzero */
+#endif
+
+unsigned char salt[32] = {0xB1, 0xC2, 0x09, 0xEE, 0x50, 0x6C, 0xF0, 0x20, 0xC4, 0xD6, 0xEB, 0xC0, 0x44, 0x51, 0x3B, 0x60, 0x4B, 0x39, 0x4A, 0xCF, 0x09, 0x53, 0x4F, 0xEA, 0x08, 0x41, 0xFA, 0xCA, 0x66, 0xD2, 0x68, 0x7F};
+unsigned char known_key[crypto_box_BEFORENMBYTES] = {0x29, 0x36, 0x1c, 0x9e, 0x65, 0xbb, 0x46, 0x8b, 0xde, 0xa1, 0xac, 0xf, 0xd5, 0x11, 0x81, 0xc8, 0x29, 0x28, 0x17, 0x23, 0xa6, 0xc3, 0x6b, 0x77, 0x2e, 0xd7, 0xd3, 0x10, 0xeb, 0xd2, 0xf7, 0xc8};
+char *pw = "hunter2";
+unsigned int pwlen = 7;
+
+unsigned char known_key2[crypto_box_BEFORENMBYTES] = {0x7a, 0xfa, 0x95, 0x45, 0x36, 0x8a, 0xa2, 0x5c, 0x40, 0xfd, 0xc0, 0xe2, 0x35, 0x8, 0x7, 0x88, 0xfa, 0xf9, 0x37, 0x86, 0xeb, 0xff, 0x50, 0x4f, 0x3, 0xe2, 0xf6, 0xd9, 0xef, 0x9, 0x17, 0x1};
+// same as above, except standard opslimit instead of extra ops limit for test_known_kdf, and hash pw before kdf for compat
+
+/* cause I'm shameless */
+void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (*((uint32_t *)userdata) != 974536)
+        return;
+
+    if (length == 7 && memcmp("Gentoo", data, 7) == 0) {
+        tox_add_friend_norequest(m, public_key);
+    }
+}
+
+START_TEST(test_known_kdf)
+{
+    unsigned char out[crypto_box_BEFORENMBYTES];
+    crypto_pwhash_scryptsalsa208sha256(out,
+                                       crypto_box_BEFORENMBYTES,
+                                       pw,
+                                       pwlen,
+                                       salt,
+                                       crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 8,
+                                       crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE);
+    ck_assert_msg(memcmp(out, known_key, crypto_box_BEFORENMBYTES) == 0, "derived key is wrong");
+}
+END_TEST
+
+START_TEST(test_save_friend)
+{
+    Tox *tox1 = tox_new(0);
+    Tox *tox2 = tox_new(0);
+    ck_assert_msg(tox1 || tox2, "Failed to create 2 tox instances");
+    uint32_t to_compare = 974536;
+    tox_callback_friend_request(tox2, accept_friend_request, &to_compare);
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(tox2, address);
+    int test = tox_add_friend(tox1, address, (uint8_t *)"Gentoo", 7);
+    ck_assert_msg(test == 0, "Failed to add friend error code: %i", test);
+
+    uint32_t size = tox_encrypted_size(tox1);
+    uint8_t data[size];
+    test = tox_encrypted_save(tox1, data, "correcthorsebatterystaple", 25);
+    ck_assert_msg(test == 0, "failed to encrypted save");
+    ck_assert_msg(tox_is_save_encrypted(data) == 1, "magic number missing");
+
+    Tox *tox3 = tox_new(0);
+    test = tox_encrypted_load(tox3, data, size, "correcthorsebatterystaple", 25);
+    ck_assert_msg(test == 0, "failed to encrypted load");
+    uint8_t address2[TOX_CLIENT_ID_SIZE];
+    test = tox_get_client_id(tox3, 0, address2);
+    ck_assert_msg(test == 0, "no friends!");
+    ck_assert_msg(memcmp(address, address2, TOX_CLIENT_ID_SIZE) == 0, "addresses don't match!");
+
+    size = tox_encrypted_size(tox3);
+    uint8_t data2[size];
+    uint8_t key[32 + crypto_box_BEFORENMBYTES];
+    memcpy(key, salt, 32);
+    memcpy(key + 32, known_key2, crypto_box_BEFORENMBYTES);
+    test = tox_encrypted_key_save(tox3, data2, key);
+    ck_assert_msg(test == 0, "failed to encrypted save the second");
+    ck_assert_msg(tox_is_save_encrypted(data2) == 1, "magic number the second missing");
+
+    // first test tox_encrypted_key_load
+    Tox *tox4 = tox_new(0);
+    test = tox_encrypted_key_load(tox4, data2, size, key);
+    ck_assert_msg(test == 0, "failed to encrypted load the second");
+    uint8_t address4[TOX_CLIENT_ID_SIZE];
+    test = tox_get_client_id(tox4, 0, address4);
+    ck_assert_msg(test == 0, "no friends! the second");
+    ck_assert_msg(memcmp(address, address2, TOX_CLIENT_ID_SIZE) == 0, "addresses don't match! the second");
+
+    // now test compaitibilty with tox_encrypted_load, first manually...
+    uint8_t out1[size], out2[size];
+    printf("Trying to decrypt from pw:\n");
+    uint32_t sz1 = tox_pass_decrypt(data2, size, pw, pwlen, out1);
+    uint32_t sz2 = tox_pass_key_decrypt(data2, size, key, out2);
+    ck_assert_msg(sz1 == sz2, "differing output sizes");
+    ck_assert_msg(memcmp(out1, out2, sz1) == 0, "differing output data");
+
+    // and now with the code in use (I only bothered with manually to debug this, and it seems a waste
+    // to remove the manual check now that it's there)
+    Tox *tox5 = tox_new(0);
+    test = tox_encrypted_load(tox5, data2, size, pw, pwlen);
+    ck_assert_msg(test == 0, "failed to encrypted load the third");
+    uint8_t address5[TOX_CLIENT_ID_SIZE];
+    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
+
+START_TEST(test_keys)
+{
+    uint8_t key[tox_pass_key_length()];
+    tox_derive_key_from_pass("123qweasdzxc", 12, key);
+    uint8_t *string = "No Patrick, mayonnaise is not an instrument."; // 44
+
+    uint8_t encrypted[44 + tox_pass_encryption_extra_length()];
+    int sz = tox_pass_key_encrypt(string, 44, key, encrypted);
+
+    uint8_t encrypted2[44 + tox_pass_encryption_extra_length()];
+    int sz2 = tox_pass_encrypt(string, 44, "123qweasdzxc", 12, encrypted2);
+
+    ck_assert_msg(sz == sz2, "an encryption failed");
+
+    uint8_t out1[44 + tox_pass_encryption_extra_length()];
+    uint8_t out2[44 + tox_pass_encryption_extra_length()];
+
+    sz = tox_pass_key_decrypt(encrypted, 44 + tox_pass_encryption_extra_length(), key, out1);
+    ck_assert_msg(sz == 44, "sz isn't right");
+    ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 1 failed");
+
+    sz2 = tox_pass_decrypt(encrypted2, 44 + tox_pass_encryption_extra_length(), "123qweasdzxc", 12, out2);
+    ck_assert_msg(sz2 == 44, "sz2 isn't right");
+    ck_assert_msg(memcmp(out2, string, 44) == 0, "decryption 2 failed");
+
+    // test that pass_decrypt can decrypt things from pass_key_encrypt
+    sz = tox_pass_decrypt(encrypted, 44 + tox_pass_encryption_extra_length(), "123qweasdzxc", 12, out1);
+    ck_assert_msg(sz == 44, "sz isn't right");
+    ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 3 failed");
+
+    uint8_t salt[tox_pass_salt_length()];
+    ck_assert_msg(0 == tox_get_salt(encrypted, salt), "couldn't get salt");
+    uint8_t key2[tox_pass_key_length()];
+    tox_derive_key_with_salt("123qweasdzxc", 12, salt, key2);
+    ck_assert_msg(0 == memcmp(key, key2, tox_pass_key_length()), "salt comparison failed");
+}
+END_TEST
+
+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_SLOW(save_friend, 20);
+    DEFTESTCASE_SLOW(keys, 30);
+
+    return s;
+}
+
+int main(int argc, char *argv[])
+{
+    srand((unsigned int) time(NULL));
+
+    Suite *encryptsave =  encryptsave_suite();
+    SRunner *test_runner = srunner_create(encryptsave);
+
+    int number_failed = 0;
+    srunner_run_all(test_runner, CK_NORMAL);
+    number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+}
+
diff --git a/auto_tests/network_test.c b/auto_tests/network_test.c
index 9d07fbb4..c1ac8084 100644
--- a/auto_tests/network_test.c
+++ b/auto_tests/network_test.c
@@ -134,22 +134,12 @@ START_TEST(test_ip_equal)
 }
 END_TEST
 
-START_TEST(test_struct_sizes)
-{
-    ck_assert_msg(sizeof(IP4) == 4, "sizeof(IP4): expected result 4, got %u.", sizeof(IP4));
-    ck_assert_msg(sizeof(IP6) == 16, "sizeof(IP6): expected result 16, got %u.", sizeof(IP6));
-    ck_assert_msg(sizeof(IP) == 17, "sizeof(IP): expected result 17, got %u.", sizeof(IP));
-    ck_assert_msg(sizeof(IP_Port) == 19, "sizeof(IP_Port): expected result 19, got %u.", sizeof(IP_Port));
-}
-END_TEST
-
 Suite *network_suite(void)
 {
     Suite *s = suite_create("Network");
 
     DEFTESTCASE(addr_resolv_localhost);
     DEFTESTCASE(ip_equal);
-    DEFTESTCASE(struct_sizes);
 
     return s;
 }
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 29f91308..f27fefb8 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -30,7 +30,7 @@ void do_onion(Onion *onion)
 }
 
 static int handled_test_1;
-static int handle_test_1(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_test_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -46,7 +46,7 @@ static int handle_test_1(void *object, IP_Port source, const uint8_t *packet, ui
 }
 
 static int handled_test_2;
-static int handle_test_2(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_test_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     if (length != sizeof("install Gentoo"))
         return 1;
@@ -72,7 +72,7 @@ uint8_t sb_data[ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
 static int handled_test_3;
 uint8_t test_3_pub_key[crypto_box_PUBLICKEYBYTES];
 uint8_t test_3_ping_id[crypto_hash_sha256_BYTES];
-static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -101,7 +101,7 @@ static int handle_test_3(void *object, IP_Port source, const uint8_t *packet, ui
 
 uint8_t nonce[crypto_box_NONCEBYTES];
 static int handled_test_4;
-static int handle_test_4(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_test_4(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -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
 
@@ -342,7 +391,7 @@ Suite *onion_suite(void)
     Suite *s = suite_create("Onion");
 
     DEFTESTCASE_SLOW(basic, 5);
-    DEFTESTCASE_SLOW(announce, 50);
+    //DEFTESTCASE_SLOW(announce, 50); //TODO: fix test.
     return s;
 }
 
diff --git a/auto_tests/tox_test.c b/auto_tests/tox_test.c
index 04dd3c22..2c157b1c 100644
--- a/auto_tests/tox_test.c
+++ b/auto_tests/tox_test.c
@@ -68,6 +68,27 @@ void print_typingchange(Tox *m, int friendnumber, uint8_t typing, void *userdata
         typing_changes = 2;
 }
 
+uint32_t custom_packet;
+
+int handle_custom_packet(Tox *m, int32_t friend_num, const uint8_t *data, uint32_t len, void *object)
+{
+    uint8_t number = *((uint32_t *)object);
+
+    if (len != TOX_MAX_CUSTOM_PACKET_SIZE)
+        return -1;
+
+    uint8_t f_data[len];
+    memset(f_data, number, len);
+
+    if (memcmp(f_data, data, len) == 0) {
+        ++custom_packet;
+    } else {
+        printf("Custom packet fail. %u\n", number );
+    }
+
+    return 0;
+}
+
 uint8_t filenum;
 uint32_t file_accepted;
 uint64_t file_size;
@@ -110,7 +131,7 @@ void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *dat
     if (*((uint32_t *)userdata) != 974536)
         return;
 
-    uint8_t *f_data = malloc(length);
+    uint8_t f_data[length];
     memset(f_data, num, length);
     ++num;
 
@@ -121,6 +142,60 @@ void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *dat
     }
 }
 
+START_TEST(test_one)
+{
+    Tox *tox1 = tox_new(0);
+    Tox *tox2 = tox_new(0);
+
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(tox1, address);
+    ck_assert_msg(tox_add_friend(tox1, address, (uint8_t *)"m", 1) == TOX_FAERR_OWNKEY, "Adding own address worked.");
+
+    tox_get_address(tox2, address);
+    uint8_t message[TOX_MAX_FRIENDREQUEST_LENGTH + 1];
+    ck_assert_msg(tox_add_friend(tox1, address, NULL, 0) == TOX_FAERR_NOMESSAGE, "Sending request with no message worked.");
+    ck_assert_msg(tox_add_friend(tox1, address, message, sizeof(message)) == TOX_FAERR_TOOLONG,
+                  "TOX_MAX_FRIENDREQUEST_LENGTH is too big.");
+
+    address[0]++;
+    ck_assert_msg(tox_add_friend(tox1, address, (uint8_t *)"m", 1) == TOX_FAERR_BADCHECKSUM,
+                  "Adding address with bad checksum worked.");
+
+    tox_get_address(tox2, address);
+    ck_assert_msg(tox_add_friend(tox1, address, message, TOX_MAX_FRIENDREQUEST_LENGTH) == 0, "Failed to add friend.");
+    ck_assert_msg(tox_add_friend(tox1, address, message, TOX_MAX_FRIENDREQUEST_LENGTH) == TOX_FAERR_ALREADYSENT,
+                  "Adding friend twice worked.");
+
+    uint8_t name[TOX_MAX_NAME_LENGTH];
+    int i;
+
+    for (i = 0; i < TOX_MAX_NAME_LENGTH; ++i) {
+        name[i] = rand();
+    }
+
+    tox_set_name(tox1, name, sizeof(name));
+    ck_assert_msg(tox_get_self_name_size(tox1) == sizeof(name), "Can't set name of TOX_MAX_NAME_LENGTH");
+
+    size_t save_size = tox_size(tox1);
+    uint8_t data[save_size];
+    tox_save(tox1, data);
+
+    tox_kill(tox2);
+    tox2 = tox_new(0);
+    ck_assert_msg(tox_load(tox2, data, save_size) == 0, "Load failed");
+
+    size_t length = tox_get_self_name_size(tox2);
+    ck_assert_msg(tox_get_self_name_size(tox2) == sizeof name, "Wrong name size.");
+
+    uint8_t new_name[TOX_MAX_NAME_LENGTH] = { 0 };
+    ck_assert_msg(tox_get_self_name(tox2, new_name) == TOX_MAX_NAME_LENGTH, "Wrong name length");
+    ck_assert_msg(memcmp(name, new_name, TOX_MAX_NAME_LENGTH) == 0, "Wrong name");
+
+    tox_kill(tox1);
+    tox_kill(tox2);
+}
+END_TEST
+
 START_TEST(test_few_clients)
 {
     long long unsigned int con_time, cur_time = time(NULL);
@@ -234,6 +309,53 @@ START_TEST(test_few_clients)
 
     ck_assert_msg(tox_get_is_typing(tox2, 0) == 0, "Typing fail");
 
+    uint32_t packet_number = 160;
+    int ret = tox_lossless_packet_registerhandler(tox3, 0, packet_number, &handle_custom_packet, &packet_number);
+    ck_assert_msg(ret == 0, "tox_lossless_packet_registerhandler fail %i", ret);
+    uint8_t data_c[TOX_MAX_CUSTOM_PACKET_SIZE + 1];
+    memset(data_c, ((uint8_t)packet_number), sizeof(data_c));
+    ret = tox_send_lossless_packet(tox2, 0, data_c, sizeof(data_c));
+    ck_assert_msg(ret == -1, "tox_send_lossless_packet bigger fail %i", ret);
+    ret = tox_send_lossless_packet(tox2, 0, data_c, TOX_MAX_CUSTOM_PACKET_SIZE);
+    ck_assert_msg(ret == 0, "tox_send_lossless_packet fail %i", ret);
+
+    while (1) {
+        custom_packet = 0;
+        tox_do(tox1);
+        tox_do(tox2);
+        tox_do(tox3);
+
+        if (custom_packet == 1)
+            break;
+        else
+            ck_assert_msg(custom_packet == 0, "Lossless packet fail");
+
+        c_sleep(50);
+    }
+
+    packet_number = 200;
+    ret = tox_lossy_packet_registerhandler(tox3, 0, packet_number, &handle_custom_packet, &packet_number);
+    ck_assert_msg(ret == 0, "tox_lossy_packet_registerhandler fail %i", ret);
+    memset(data_c, ((uint8_t)packet_number), sizeof(data_c));
+    ret = tox_send_lossy_packet(tox2, 0, data_c, sizeof(data_c));
+    ck_assert_msg(ret == -1, "tox_send_lossy_packet bigger fail %i", ret);
+    ret = tox_send_lossy_packet(tox2, 0, data_c, TOX_MAX_CUSTOM_PACKET_SIZE);
+    ck_assert_msg(ret == 0, "tox_send_lossy_packet fail %i", ret);
+
+    while (1) {
+        custom_packet = 0;
+        tox_do(tox1);
+        tox_do(tox2);
+        tox_do(tox3);
+
+        if (custom_packet == 1)
+            break;
+        else
+            ck_assert_msg(custom_packet == 0, "lossy packet fail");
+
+        c_sleep(50);
+    }
+
     filenum = file_accepted = file_size = file_sent = sendf_ok = size_recv = 0;
     long long unsigned int f_time = time(NULL);
     tox_callback_file_data(tox3, write_file, &to_compare);
@@ -244,7 +366,7 @@ START_TEST(test_few_clients)
     int fnum = tox_new_file_sender(tox2, 0, totalf_size, (uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"));
     ck_assert_msg(fnum != -1, "tox_new_file_sender fail");
     int fpiece_size = tox_file_data_size(tox2, 0);
-    uint8_t *f_data = malloc(fpiece_size);
+    uint8_t f_data[fpiece_size];
     uint8_t num = 0;
     memset(f_data, num, fpiece_size);
 
@@ -292,7 +414,7 @@ START_TEST(test_few_clients)
 END_TEST
 
 #define NUM_TOXES 66
-#define NUM_FRIENDS 20
+#define NUM_FRIENDS 50
 
 START_TEST(test_many_clients)
 {
@@ -354,11 +476,185 @@ loop_top:
         c_sleep(50);
     }
 
+    for (i = 0; i < NUM_TOXES; ++i) {
+        tox_kill(toxes[i]);
+    }
+
     printf("test_many_clients succeeded, took %llu seconds\n", time(NULL) - cur_time);
+}
+END_TEST
 
-    for (i = 0; i < NUM_TOXES; ++i) {
+#define NUM_GROUP_TOX 32
+
+void g_accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (*((uint32_t *)userdata) != 234212)
+        return;
+
+    if (length == 7 && memcmp("Gentoo", data, 7) == 0) {
+        tox_add_friend_norequest(m, public_key);
+    }
+}
+
+static Tox *invite_tox;
+static unsigned int invite_counter;
+
+void print_group_invite_callback(Tox *tox, int32_t friendnumber, uint8_t type, const uint8_t *data, uint16_t length,
+                                 void *userdata)
+{
+    if (*((uint32_t *)userdata) != 234212)
+        return;
+
+    if (type != TOX_GROUPCHAT_TYPE_TEXT)
+        return;
+
+    int g_num;
+
+    if ((g_num = tox_join_groupchat(tox, friendnumber, data, length)) == -1)
+        return;
+
+    ck_assert_msg(g_num == 0, "Group number was not 0");
+    ck_assert_msg(tox_join_groupchat(tox, friendnumber, data, length) == -1,
+                  "Joining groupchat twice should be impossible.");
+
+    invite_tox = tox;
+    invite_counter = 4;
+}
+
+static unsigned int num_recv;
+
+void print_group_message(Tox *tox, int groupnumber, int peernumber, const uint8_t *message, uint16_t length,
+                         void *userdata)
+{
+    if (*((uint32_t *)userdata) != 234212)
+        return;
+
+    if (length == (sizeof("Install Gentoo") - 1) && memcmp(message, "Install Gentoo", sizeof("Install Gentoo") - 1) == 0) {
+        ++num_recv;
+    }
+}
+
+START_TEST(test_many_group)
+{
+    long long unsigned int cur_time = time(NULL);
+    Tox *toxes[NUM_GROUP_TOX];
+    unsigned int i, j, k;
+
+    uint32_t to_comp = 234212;
+
+    for (i = 0; i < NUM_GROUP_TOX; ++i) {
+        toxes[i] = tox_new(0);
+        ck_assert_msg(toxes[i] != 0, "Failed to create tox instances %u", i);
+        tox_callback_friend_request(toxes[i], &g_accept_friend_request, &to_comp);
+        tox_callback_group_invite(toxes[i], &print_group_invite_callback, &to_comp);
+    }
+
+    uint8_t address[TOX_FRIEND_ADDRESS_SIZE];
+    tox_get_address(toxes[NUM_GROUP_TOX - 1], address);
+
+    for (i = 0; i < NUM_GROUP_TOX; ++i) {
+        ck_assert_msg(tox_add_friend(toxes[i], address, (uint8_t *)"Gentoo", 7) == 0, "Failed to add friend");
+
+        tox_get_address(toxes[i], address);
+    }
+
+    while (1) {
+        for (i = 0; i < NUM_GROUP_TOX; ++i) {
+            if (tox_get_friend_connection_status(toxes[i], 0) != 1) {
+                break;
+            }
+        }
+
+        if (i == NUM_GROUP_TOX)
+            break;
+
+        for (i = 0; i < NUM_GROUP_TOX; ++i) {
+            tox_do(toxes[i]);
+        }
+
+        c_sleep(50);
+    }
+
+    printf("friends connected, took %llu seconds\n", time(NULL) - cur_time);
+
+    ck_assert_msg(tox_add_groupchat(toxes[0]) != -1, "Failed to create group");
+    ck_assert_msg(tox_invite_friend(toxes[0], 0, 0) == 0, "Failed to invite friend");
+    ck_assert_msg(tox_group_set_title(toxes[0], 0, "Gentoo", sizeof("Gentoo") - 1) == 0, "Failed to set group title");
+    invite_counter = ~0;
+
+    unsigned int done = ~0;
+    done -= 5;
+
+    while (1) {
+        for (i = 0; i < NUM_GROUP_TOX; ++i) {
+            tox_do(toxes[i]);
+        }
+
+        if (!invite_counter) {
+            ck_assert_msg(tox_invite_friend(invite_tox, 0, 0) == 0, "Failed to invite friend");
+        }
+
+        if (done == invite_counter) {
+            break;
+        }
+
+        --invite_counter;
+        c_sleep(50);
+    }
+
+    for (i = 0; i < NUM_GROUP_TOX; ++i) {
+        int num_peers = tox_group_number_peers(toxes[i], 0);
+        ck_assert_msg(num_peers == NUM_GROUP_TOX, "Bad number of group peers. expected: %u got: %i, tox %u", NUM_GROUP_TOX,
+                      num_peers, i);
+
+        uint8_t title[2048];
+        int ret = tox_group_get_title(toxes[i], 0, title, sizeof(title));
+        ck_assert_msg(ret == sizeof("Gentoo") - 1, "Wrong title length");
+        ck_assert_msg(memcmp("Gentoo", title, ret) == 0, "Wrong title");
+    }
+
+    printf("group connected\n");
+
+    for (i = 0; i < NUM_GROUP_TOX; ++i) {
+        tox_callback_group_message(toxes[i], &print_group_message, &to_comp);
+    }
+
+    ck_assert_msg(tox_group_message_send(toxes[rand() % NUM_GROUP_TOX], 0, (uint8_t *)"Install Gentoo",
+                                         sizeof("Install Gentoo") - 1) == 0, "Failed to send group message.");
+    num_recv = 0;
+
+    for (j = 0; j < 20; ++j) {
+        for (i = 0; i < NUM_GROUP_TOX; ++i) {
+            tox_do(toxes[i]);
+        }
+
+        c_sleep(50);
+    }
+
+    ck_assert_msg(num_recv == NUM_GROUP_TOX, "Failed to recv group messages.");
+
+    for (k = NUM_GROUP_TOX; k != 0 ; --k) {
+        tox_del_groupchat(toxes[k - 1], 0);
+
+        for (j = 0; j < 10; ++j) {
+            for (i = 0; i < NUM_GROUP_TOX; ++i) {
+                tox_do(toxes[i]);
+            }
+
+            c_sleep(50);
+        }
+
+        for (i = 0; i < (k - 1); ++i) {
+            int num_peers = tox_group_number_peers(toxes[i], 0);
+            ck_assert_msg(num_peers == (k - 1), "Bad number of group peers. expected: %u got: %i, tox %u", (k - 1), num_peers, i);
+        }
+    }
+
+    for (i = 0; i < NUM_GROUP_TOX; ++i) {
         tox_kill(toxes[i]);
     }
+
+    printf("test_many_group succeeded, took %llu seconds\n", time(NULL) - cur_time);
 }
 END_TEST
 
@@ -366,8 +662,10 @@ Suite *tox_suite(void)
 {
     Suite *s = suite_create("Tox");
 
+    DEFTESTCASE(one);
     DEFTESTCASE_SLOW(few_clients, 50);
     DEFTESTCASE_SLOW(many_clients, 150);
+    DEFTESTCASE_SLOW(many_group, 100);
     return s;
 }
 
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index c6481366..3139c844 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -11,6 +11,8 @@
 #include <time.h>
 #include <assert.h>
 
+#include <vpx/vpx_image.h>
+
 #include "../toxcore/tox.h"
 #include "../toxcore/logger.h"
 #include "../toxcore/crypto_core.h"
@@ -33,7 +35,7 @@ typedef enum _CallStatus {
     Ringing,
     Ended,
     Rejected,
-    Cancel,
+    Canceled,
     TimedOut
 
 } CallStatus;
@@ -66,36 +68,23 @@ void callback_recv_invite ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
 
-    /* Bob always receives invite */
-    cast->Bob.status = Ringing;
-    cast->Bob.call_index = call_index;
+    if (cast->Alice.av == av) {
+        // ...
+    } else if (cast->Bob.av == av) {
+        /* Bob always receives invite */
+        cast->Bob.status = Ringing;
+        cast->Bob.call_index = call_index;
+    }
 }
 void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
 
-    /* Alice always sends invite */
-    cast->Alice.status = Ringing;
-}
-void callback_recv_starting ( void *av, int32_t call_index, void *_arg )
-{
-    Status *cast = _arg;
-
-    /* Alice always sends invite */
-    printf("Call started on Alice side...\n");
-    cast->Alice.status = InCall;
-    toxav_prepare_transmission(av, call_index, av_jbufdc, av_VADd, 1);
-}
-void callback_recv_ending ( void *av, int32_t call_index, void *_arg )
-{
-    Status *cast = _arg;
-
-    if ( cast->Alice.status == Rejected) {
-        printf ( "Call ended for Bob!\n" );
-        cast->Bob.status = Ended;
-    } else {
-        printf ( "Call ended for Alice!\n" );
-        cast->Alice.status = Ended;
+    if (cast->Alice.av == av) {
+        /* Alice always sends invite */
+        cast->Alice.status = Ringing;
+    } else if (cast->Bob.av == av) {
+        // ...
     }
 }
 
@@ -104,17 +93,26 @@ void callback_call_started ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
 
-    /* Alice always sends invite */
-    printf("Call started on Bob side...\n");
-    cast->Bob.status = InCall;
-    toxav_prepare_transmission(av, call_index, av_jbufdc, av_VADd, 1);
+    if (cast->Alice.av == av) {
+        printf("Call started on Alices side...\n");
+        cast->Alice.status = InCall;
+        toxav_prepare_transmission(av, call_index, 1);
+    } else if (cast->Bob.av == av) {
+        printf("Call started on Bob side...\n");
+        cast->Bob.status = InCall;
+        toxav_prepare_transmission(av, call_index, 1);
+    }
 }
 void callback_call_canceled ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
 
-    printf ( "Call Canceled for Bob!\n" );
-    cast->Bob.status = Cancel;
+    if (cast->Alice.av == av) {
+        // ...
+    } else if (cast->Bob.av == av) {
+        printf ( "Call Canceled for Bob!\n" );
+        cast->Bob.status = Canceled;
+    }
 }
 void callback_call_rejected ( void *av, int32_t call_index, void *_arg )
 {
@@ -122,23 +120,58 @@ void callback_call_rejected ( void *av, int32_t call_index, void *_arg )
 
     printf ( "Call rejected by Bob!\n"
              "Call ended for Alice!\n" );
+
     /* If Bob rejects, call is ended for alice and she sends ending */
-    cast->Alice.status = Rejected;
+    if (cast->Alice.av == av) {
+        cast->Alice.status = Rejected;
+    } else if (cast->Bob.av == av) {
+        //... ignor
+    }
 }
 void callback_call_ended ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
 
-    printf ( "Call ended for Bob!\n" );
-    cast->Bob.status = Ended;
+    if (cast->Alice.av == av) {
+        printf ( "Call ended for Alice!\n" );
+        cast->Alice.status = Ended;
+    } else if (cast->Bob.av == av) {
+        printf ( "Call ended for Bob!\n" );
+        cast->Bob.status = Ended;
+    }
 }
 
-void callback_call_type_change ( void *av, int32_t call_index, void *_arg )
+void callback_peer_cs_change ( void *av, int32_t call_index, void *_arg )
 {
     ToxAvCSettings csettings;
     toxav_get_peer_csettings(av, call_index, 0, &csettings);
 
-    printf("New settings: \n"
+    printf("Peer changing settings to: \n"
+           "Type: %u \n"
+           "Video bitrate: %u \n"
+           "Video height: %u \n"
+           "Video width: %u \n"
+           "Audio bitrate: %u \n"
+           "Audio framedur: %u \n"
+           "Audio sample rate: %u \n"
+           "Audio channels: %u \n",
+           csettings.call_type,
+           csettings.video_bitrate,
+           csettings.max_video_height,
+           csettings.max_video_width,
+           csettings.audio_bitrate,
+           csettings.audio_frame_duration,
+           csettings.audio_sample_rate,
+           csettings.audio_channels
+          );
+}
+
+void callback_self_cs_change ( void *av, int32_t call_index, void *_arg )
+{
+    ToxAvCSettings csettings;
+    toxav_get_peer_csettings(av, call_index, 0, &csettings);
+
+    printf("Changed settings to: \n"
            "Type: %u \n"
            "Video bitrate: %u \n"
            "Video height: %u \n"
@@ -162,16 +195,19 @@ void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     printf("Call timed-out!\n");
-    cast->Alice.status = TimedOut;
-}
 
-static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length, void *userdata)
-{
+    if (cast->Alice.av == av) {
+        cast->Alice.status = TimedOut;
+    } else if (cast->Bob.av == av) {
+        cast->Bob.status = TimedOut;
+    }
 }
 
-static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img, void *userdata)
-{
-}
+void callback_audio (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data)
+{}
+
+void callback_video (void *agent, int32_t call_idx, const vpx_image_t *img, void *data)
+{}
 
 void register_callbacks(ToxAv *av, void *data)
 {
@@ -180,17 +216,12 @@ void register_callbacks(ToxAv *av, void *data)
     toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data);
     toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data);
     toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data);
-
     toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
-    toxav_register_callstate_callback(av, callback_recv_starting, av_OnStarting, data);
-    toxav_register_callstate_callback(av, callback_recv_ending, av_OnEnding, data);
-
     toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
-    toxav_register_callstate_callback(av, callback_call_type_change, av_OnMediaChange, data);
-
-
-    toxav_register_audio_recv_callback(av, callback_audio, NULL);
-    toxav_register_video_recv_callback(av, callback_video, NULL);
+    toxav_register_callstate_callback(av, callback_peer_cs_change, av_OnPeerCSChange, data);
+    toxav_register_callstate_callback(av, callback_self_cs_change, av_OnSelfCSChange, data);
+    toxav_register_audio_callback(av, callback_audio, NULL);
+    toxav_register_video_callback(av, callback_video, NULL);
 }
 
 
@@ -202,6 +233,7 @@ void register_callbacks(ToxAv *av, void *data)
 #define CALL_AND_START_LOOP(AliceCallType, BobCallType) \
 { int step = 0, running = 1; while (running) {\
     tox_do(bootstrap_node); tox_do(Alice); tox_do(Bob); \
+    toxav_do(status_control.Bob.av); toxav_do(status_control.Alice.av); \
     switch ( step ) {\
         case 0: /* Alice */  printf("Alice is calling...\n");\
             toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, &muhcaps, 10); step++; break;\
@@ -496,6 +528,10 @@ START_TEST(test_AV_flows)
             tox_do(Alice);
             tox_do(Bob);
 
+            toxav_do(status_control.Alice.av);
+            toxav_do(status_control.Bob.av);
+
+
             switch ( step ) {
                 case 0: /* Alice */
                     printf("Alice is calling...\n");
@@ -514,7 +550,7 @@ START_TEST(test_AV_flows)
                     break;
 
                 case 2:  /* Wait for Both to have status ended */
-                    if (status_control.Bob.status == Cancel) running = 0;
+                    if (status_control.Bob.status == Canceled) running = 0;
 
                     break;
             }
@@ -537,6 +573,9 @@ START_TEST(test_AV_flows)
             tox_do(Alice);
             tox_do(Bob);
 
+            toxav_do(status_control.Alice.av);
+            toxav_do(status_control.Bob.av);
+
             switch ( step ) {
                 case 0:
                     printf("Alice is calling...\n");
@@ -556,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/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index d9c588f7..99012992 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -11,6 +11,8 @@
 #include <time.h>
 #include <assert.h>
 
+#include <vpx/vpx_image.h>
+
 #include "../toxcore/tox.h"
 #include "../toxcore/logger.h"
 #include "../toxcore/crypto_core.h"
@@ -32,7 +34,7 @@ typedef enum _CallStatus {
     Ringing,
     Ended,
     Rejected,
-    Cancel
+    Canceled
 
 } CallStatus;
 
@@ -67,66 +69,51 @@ void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *dat
 /******************************************************************************/
 void callback_recv_invite ( void *av, int32_t call_index, void *_arg )
 {
-    /*
-       Status *cast = _arg;
-
-       cast->calls[call_index].Callee.status = Ringing;*/
+    Status *cast = _arg;
+    cast->calls[call_index].Callee.status = Ringing;
 }
 void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = Ringing;
 }
-void callback_recv_starting ( void *av, int32_t call_index, void *_arg )
-{
-    Status *cast = _arg;
-    cast->calls[call_index].Caller.status = InCall;
-}
-void callback_recv_ending ( void *av, int32_t call_index, void *_arg )
+void callback_call_ended ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-    cast->calls[call_index].Caller.status = Ended;
-}
 
+    if (av == cast->calls[call_index].Caller.av)
+        cast->calls[call_index].Caller.status = Ended;
+    else
+        cast->calls[call_index].Callee.status = Ended;
+}
 void callback_call_started ( void *av, int32_t call_index, void *_arg )
 {
-    /*
-       Status *cast = _arg;
+    Status *cast = _arg;
 
-       cast->calls[call_index].Callee.status = InCall;*/
+    if (av == cast->calls[call_index].Caller.av)
+        cast->calls[call_index].Caller.status = InCall;
+    else
+        cast->calls[call_index].Callee.status = InCall;
 }
 void callback_call_canceled ( void *av, int32_t call_index, void *_arg )
 {
-    /*
-       Status *cast = _arg;
-
-       cast->calls[call_index].Callee.status = Cancel;*/
 }
 void callback_call_rejected ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = Rejected;
 }
-void callback_call_ended ( void *av, int32_t call_index, void *_arg )
-{
-    /*
-       Status *cast = _arg;
-
-       cast->calls[call_index].Callee.status = Ended;*/
-}
 
 void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
 {
-    //ck_assert_msg(0, "No answer!");
+    ck_assert_msg(0, "No answer!");
 }
 
-static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length, void *userdata)
-{
-}
+void callback_audio (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data)
+{}
 
-static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img, void *userdata)
-{
-}
+void callback_video (void *agent, int32_t call_idx, const vpx_image_t *img, void *data)
+{}
 
 void register_callbacks(ToxAv *av, void *data)
 {
@@ -135,16 +122,12 @@ void register_callbacks(ToxAv *av, void *data)
     toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data);
     toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data);
     toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data);
-
     toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
-    toxav_register_callstate_callback(av, callback_recv_starting, av_OnStarting, data);
-    toxav_register_callstate_callback(av, callback_recv_ending, av_OnEnding, data);
-
     toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
 
 
-    toxav_register_audio_recv_callback(av, callback_audio, NULL);
-    toxav_register_video_recv_callback(av, callback_video, NULL);
+    toxav_register_audio_callback(av, callback_audio, NULL);
+    toxav_register_video_callback(av, callback_video, NULL);
 }
 /*************************************************************************************************/
 
@@ -159,8 +142,6 @@ void *in_thread_call (void *arg)
     int step = 0;
     int call_idx;
 
-    call_running[this_call->idx] = 1;
-
     const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
     int16_t sample_payload[frame_size];
     randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size);
@@ -171,8 +152,12 @@ void *in_thread_call (void *arg)
     register_callbacks(this_call->Callee.av, arg);
 
     /* NOTE: CALLEE WILL ALWAHYS NEED CALL_IDX == 0 */
+    pthread_mutex_lock(&muhmutex);
+
     while (call_running[this_call->idx]) {
 
+        pthread_mutex_unlock(&muhmutex);
+
         switch ( step ) {
             case 0: /* CALLER */
                 toxav_call(this_call->Caller.av, &call_idx, this_call->Callee.id, &av_DefaultSettings, 10);
@@ -181,28 +166,36 @@ void *in_thread_call (void *arg)
                 break;
 
             case 1: /* CALLEE */
+                pthread_mutex_lock(&muhmutex);
+
                 if (this_call->Caller.status == Ringing) {
                     call_print(call_idx, "Callee answers ...");
+                    pthread_mutex_unlock(&muhmutex);
                     toxav_answer(this_call->Callee.av, 0, &av_DefaultSettings);
                     step++;
                     start = time(NULL);
+                    pthread_mutex_lock(&muhmutex);
                 }
 
+                pthread_mutex_unlock(&muhmutex);
                 break;
 
             case 2: /* Rtp transmission */
+                pthread_mutex_lock(&muhmutex);
+
                 if (this_call->Caller.status == InCall) { /* I think this is okay */
                     call_print(call_idx, "Sending rtp ...");
+                    pthread_mutex_unlock(&muhmutex);
 
                     c_sleep(1000); /* We have race condition here */
-                    toxav_prepare_transmission(this_call->Callee.av, 0, 3, 0, 1);
-                    toxav_prepare_transmission(this_call->Caller.av, call_idx, 3, 0, 1);
+                    toxav_prepare_transmission(this_call->Callee.av, 0, 1);
+                    toxav_prepare_transmission(this_call->Caller.av, call_idx, 1);
 
                     int payload_size = toxav_prepare_audio_frame(this_call->Caller.av, call_idx, prepared_payload, RTP_PAYLOAD_SIZE,
                                        sample_payload, frame_size);
 
                     if ( payload_size < 0 ) {
-                        //ck_assert_msg ( 0, "Failed to encode payload" );
+                        ck_assert_msg ( 0, "Failed to encode payload" );
                     }
 
 
@@ -229,24 +222,36 @@ void *in_thread_call (void *arg)
                     /* Call over CALLER hangs up */
                     toxav_hangup(this_call->Caller.av, call_idx);
                     call_print(call_idx, "Hanging up ...");
+
+                    pthread_mutex_lock(&muhmutex);
                 }
 
+                pthread_mutex_unlock(&muhmutex);
                 break;
 
             case 3: /* Wait for Both to have status ended */
+                pthread_mutex_lock(&muhmutex);
+
                 if (this_call->Caller.status == Ended) {
+                    pthread_mutex_unlock(&muhmutex);
                     c_sleep(1000); /* race condition */
+                    pthread_mutex_lock(&muhmutex);
                     this_call->Callee.status = Ended;
                     call_running[this_call->idx] = 0;
                 }
 
+                pthread_mutex_unlock(&muhmutex);
+
                 break;
 
         }
 
         c_sleep(20);
+
+        pthread_mutex_lock(&muhmutex);
     }
 
+    pthread_mutex_unlock(&muhmutex);
     call_print(call_idx, "Call ended successfully!");
     pthread_exit(NULL);
 }
@@ -255,8 +260,8 @@ void *in_thread_call (void *arg)
 
 
 
-// START_TEST(test_AV_three_calls)
-void test_AV_three_calls()
+START_TEST(test_AV_three_calls)
+// void test_AV_three_calls()
 {
     long long unsigned int cur_time = time(NULL);
     Tox *bootstrap_node = tox_new(0);
@@ -268,12 +273,12 @@ void test_AV_three_calls()
     };
 
 
-    //ck_assert_msg(bootstrap_node != NULL, "Failed to create bootstrap node");
+    ck_assert_msg(bootstrap_node != NULL, "Failed to create bootstrap node");
 
     int i = 0;
 
     for (; i < 3; i ++) {
-        //ck_assert_msg(callees[i] != NULL, "Failed to create 3 tox instances");
+        ck_assert_msg(callees[i] != NULL, "Failed to create 3 tox instances");
     }
 
     for ( i = 0; i < 3; i ++ ) {
@@ -283,7 +288,7 @@ void test_AV_three_calls()
         tox_get_address(callees[i], address);
 
         int test = tox_add_friend(caller, address, (uint8_t *)"gentoo", 7);
-        //ck_assert_msg( test == i, "Failed to add friend error code: %i", test);
+        ck_assert_msg( test == i, "Failed to add friend error code: %i", test);
     }
 
     uint8_t off = 1;
@@ -333,8 +338,10 @@ void test_AV_three_calls()
 
     pthread_mutex_init(&muhmutex, NULL);
 
-    for ( i = 0; i < 3; i++ )
+    for ( i = 0; i < 3; i++ ) {
+        call_running[i] = 1;
         pthread_create(&status_control.calls[i].tid, NULL, in_thread_call, &status_control.calls[i]);
+    }
 
     /* Now start 3 calls and they'll run for 10 s */
 
@@ -350,6 +357,13 @@ void test_AV_three_calls()
         tox_do(callees[1]);
         tox_do(callees[2]);
 
+        for ( i = 0; i < 3; i++ )
+            toxav_do(status_control.calls[0].Caller.av);
+
+        toxav_do(status_control.calls[0].Callee.av);
+        toxav_do(status_control.calls[1].Callee.av);
+        toxav_do(status_control.calls[2].Callee.av);
+
         pthread_mutex_unlock(&muhmutex);
         c_sleep(20);
     }
@@ -366,7 +380,7 @@ void test_AV_three_calls()
         tox_kill(callees[i]);
 
 }
-// END_TEST
+END_TEST
 
 
 
@@ -382,21 +396,22 @@ Suite *tox_suite(void)
 
     return s;
 }
+
 int main(int argc, char *argv[])
 {
-//     Suite *tox = tox_suite();
-//     SRunner *test_runner = srunner_create(tox);
-//
-//     setbuf(stdout, NULL);
-//
-//     srunner_run_all(test_runner, CK_NORMAL);
-//     int number_failed = srunner_ntests_failed(test_runner);
-//
-//     srunner_free(test_runner);
-//
-//     return number_failed;
-
-    test_AV_three_calls();
-
-    return 0;
+    Suite *tox = tox_suite();
+    SRunner *test_runner = srunner_create(tox);
+
+    setbuf(stdout, NULL);
+
+    srunner_run_all(test_runner, CK_NORMAL);
+    int number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+
+//     test_AV_three_calls();
+
+//     return 0;
 }
diff --git a/build/Makefile.am b/build/Makefile.am
index c2667d5d..c0e59645 100644
--- a/build/Makefile.am
+++ b/build/Makefile.am
@@ -6,6 +6,7 @@ EXTRA_DIST=
 
 include ../toxcore/Makefile.inc
 include ../toxdns/Makefile.inc
+include ../toxencryptsave/Makefile.inc
 include ../toxav/Makefile.inc
 include ../other/Makefile.inc
 include ../testing/Makefile.inc
diff --git a/configure.ac b/configure.ac
index b694652d..3a45b35d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -82,37 +82,40 @@ AC_ARG_ENABLE([randombytes-stir],
     ]
 )
 
-AC_ARG_ENABLE([logging],
-    [AC_HELP_STRING([--enable-logging], [enable logging (default: auto)]) ],
+AC_ARG_ENABLE([log],
+    [AC_HELP_STRING([--enable-log], [enable logging (default: auto)]) ],
     [
         if test "x$enableval" = "xyes"; then
             LOGGING="yes"
             
             AC_DEFINE([LOGGING], [], [If logging enabled])
-            AC_DEFINE([LOGGER_LEVEL], [DEBUG], [LoggerLevel value])
+            AC_DEFINE([LOGGER_LEVEL], [LOG_DEBUG], [LOG_LEVEL value])
             AC_DEFINE_UNQUOTED([LOGGER_OUTPUT_FILE], ["$LOGGING_OUTNAM"], [Output of logger])
         fi
     ]
 )
 
-AC_ARG_WITH(logger-level,
-    AC_HELP_STRING([--with-logger-level=LEVEL],
-                   [Logger levels: INFO; DEBUG; WARNING; ERROR ]),
+AC_ARG_WITH(log-level,
+    AC_HELP_STRING([--with-log-level=LEVEL],
+                   [Logger levels: TRACE; DEBUG; INFO; WARNING; ERROR ]),
     [
         if test "x$LOGGING" = "xno"; then
             AC_MSG_WARN([Logging disabled!])
         else
-            if test "x$withval" = "xINFO"; then
-                AC_DEFINE([LOGGER_LEVEL], [INFO], [LoggerLevel value])
-                
+            if test "x$withval" = "xTRACE"; then
+                AC_DEFINE([LOGGER_LEVEL], [LOG_TRACE], [LOG_LEVEL value])
+            
             elif test "x$withval" = "xDEBUG"; then
-                AC_DEFINE([LOGGER_LEVEL], [DEBUG], [LoggerLevel value])
-                
+                AC_DEFINE([LOGGER_LEVEL], [LOG_DEBUG], [LOG_LEVEL value])
+            
+            elif test "x$withval" = "xINFO"; then
+                AC_DEFINE([LOGGER_LEVEL], [LOG_INFO], [LOG_LEVEL value])
+            
             elif test "x$withval" = "xWARNING"; then
-                AC_DEFINE([LOGGER_LEVEL], [WARNING], [LoggerLevel value])
+                AC_DEFINE([LOGGER_LEVEL], [LOG_WARNING], [LOG_LEVEL value])
                 
             elif test "x$withval" = "xERROR"; then
-                AC_DEFINE([LOGGER_LEVEL], [ERROR], [LoggerLevel value])
+                AC_DEFINE([LOGGER_LEVEL], [LOG_ERROR], [LOG_LEVEL value])
             else
                 AC_MSG_WARN([Invalid logger level: $withval. Using default 'DEBUG'])
             fi
@@ -120,8 +123,8 @@ AC_ARG_WITH(logger-level,
     ]
 )
 
-AC_ARG_WITH(logger-path,
-    AC_HELP_STRING([--with-logger-path=DIR],
+AC_ARG_WITH(log-path,
+    AC_HELP_STRING([--with-log-path=DIR],
                    [Path of logger output]),
     [
         if test "x$LOGGING" = "xno"; then
@@ -371,20 +374,20 @@ else
     LDFLAGS_SAVE="$LDFLAGS"
     if test -n "$LIBSODIUM_SEARCH_LIBS"; then
         LDFLAGS="-L$LIBSODIUM_SEARCH_LIBS $LDFLAGS"
-        AC_CHECK_LIB(sodium, randombytes_random,
+        AC_CHECK_LIB(sodium, crypto_pwhash_scryptsalsa208sha256,
             [
                 LIBSODIUM_LDFLAGS="-L$LIBSODIUM_SEARCH_LIBS"
                 LIBSODIUM_LIBS="-lsodium"
             ],
             [
-                AC_MSG_ERROR([required library libsodium was not found in requested location $LIBSODIUM_SEARCH_LIBS])
+                AC_MSG_ERROR([required library libsodium was not found in requested location $LIBSODIUM_SEARCH_LIBS or library version is too old])
             ]
         )
     else
-        AC_CHECK_LIB(sodium, randombytes_random,
+        AC_CHECK_LIB(sodium, crypto_pwhash_scryptsalsa208sha256,
             [],
             [
-                AC_MSG_ERROR([required library libsodium was not found on your system, please check http://download.libsodium.org/libsodium/releases/])
+                AC_MSG_ERROR([required library libsodium was not found on your system, please check http://download.libsodium.org/libsodium/releases/ or library version is too old])
             ]
         )
     fi
@@ -489,6 +492,13 @@ AX_PTHREAD(
     ]
 )
 
+AC_CHECK_LIB([pthread], [pthread_self],
+    [
+        PTHREAD_LDFLAGS="-lpthread"
+        AC_SUBST(PTHREAD_LDFLAGS)
+    ]
+)
+
 if test "x$BUILD_AV" = "xyes"; then
     PKG_CHECK_MODULES([OPUS], [opus],
         [],
@@ -512,8 +522,7 @@ fi
 if test "x$BUILD_AV" = "xyes"; then
     # toxcore lib needs an global?
     # So far this works okay
-    ## What about pthread?
-    AV_LIBS="$OPUS_LIBS $VPX_LIBS -pthread"
+    AV_LIBS="$OPUS_LIBS $VPX_LIBS"
     AC_SUBST(AV_LIBS)
 
     AV_CFLAGS="$OPUS_CFLAGS $VPX_CFLAGS"
diff --git a/docs/Avatars.md b/docs/Avatars.md
new file mode 100644
index 00000000..31138af7
--- /dev/null
+++ b/docs/Avatars.md
@@ -0,0 +1,631 @@
+# User avatars in Tox
+
+
+
+## Introduction and rationale
+
+User avatars are small icons or images used to identify users in the friend
+list; they exist in virtually all VoIP and IM protocols and provide an easy
+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;
+
+  - The library treats all images as blobs and does not interpret or
+    understand image formats. It only ensures that the avatar data sent by
+    a user is correctly received by the other. The client application is
+    responsible for validating, decoding, resizing, and presenting the
+    image to the user.
+
+  - There is a strict limit of 16 KiB to the avatar raw data size -- this
+    seems suitable for practical use as, for example, the raw data of an
+    uncompressed 64 x 64 pixels 24 bpp RGB bitmap is 12288 bytes long; the
+    data limit provides enough space for larger bitmaps if the usual
+    compressed formats are used.
+
+    **Notice:** As designed, this limit can be changed in the future without
+    breaking the protocol compatibility, but clients using the original
+    limit will reject larger avatars.
+
+  - The protocol MUST provide means to allow caching and avoid unnecessary
+    data transfers.
+
+  - Avatars are transfered between clients in a background operation.
+
+  - Avatars are served on a "best effort" basis, without breaking clients
+    which do not support them.
+
+  - The protocol MUST resist to malicious users.
+
+  - The protocol MUST work with both UDP and TCP networks.
+
+
+The Single Tox Standard Draft v.0.1.0 recommends implementing avatars as
+a purely client-side feature through a procedure that can be summarized as
+sending a specially named file as a file transfer request and accepting
+it silently. This procedure can be improved to provide the previously stated
+design considerations, but this requires a higher integration with the core
+protocol. Moving this feature to the core protocol also:
+
+  - provides a simpler and cleaner interface for client applications;
+
+  - hides protocol complexities from the client;
+
+  - avoids code duplication and ad-hoc protocols in the clients;
+
+  - avoids incompatibility between client implementations;
+
+  - allows important optimizations, such as lightweight notification of
+    removed and updated avatars;
+
+  - plays well with cache schemes;
+
+  - makes avatar transfer essentially a background operation.
+
+
+
+
+
+
+## High level description
+
+
+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".)
+The avatar exchange is implemented with the following new elements in the
+Tox protocol:
+
+  - **Avatar Information Notifications** are events which may be sent by
+    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.
+
+    This event contains two data fields: (1) the image format, and (2) 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.
+
+  - **Avatar Information Requests** are very lightweight messages sent by a
+    user asking for an **avatar information notification**. They may be sent
+    as part of the login process or when the client thinks the currently
+    cached avatar is outdated. The receiver may or may not answer to this
+    request. This message contains no data fields.
+
+  - An **Avatar Data Request** is sent by a user asking another for his
+    complete avatar data. It is sent only when the requesting user decides
+    the avatar does not exist in the local cache or is outdated. The receiver
+    may or may not answer to this request. This message contains no data
+    fields.
+
+  - An **Avatar Data Notification** is an event signaling the client that
+    the complete avatar image data of another user is available. The actual
+    data transfer is implemented using several data and control messages,
+    but the details are hidden from the client applications. This event can
+    only arrive in reply to an **avatar data request**.
+
+    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
+    data is empty. The raw image data is locally validated and ensured to
+    match the hash (the event is **not** triggered otherwise).
+
+
+
+
+
+## API
+
+To implement this feature, the following public symbols were added. The
+complete API documentation is available in `tox.h`.
+
+
+```
+#define TOX_AVATAR_MAX_DATA_LENGTH 16384
+#define TOX_HASH_LENGTH 32
+
+
+/* Data formats for user avatar images */
+typedef enum {
+    TOX_AVATAR_FORMAT_NONE,
+    TOX_AVATAR_FORMAT_PNG
+}
+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);
+
+/* Removes 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). */
+int tox_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen);
+
+/* Request avatar information from a friend. */
+int tox_request_avatar_info(const Tox *tox, const int32_t friendnumber);
+
+/* Send an unrequested avatar information to a friend. */
+int tox_send_avatar_info(Tox *tox, const int32_t friendnumber);
+
+/* Request the avatar data from a friend. */
+int tox_request_avatar_data(const Tox *tox, const int32_t friendnumber);
+
+/* Set the callback function for avatar data. */
+void tox_callback_avatar_info(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, uint8_t*, void *), void *userdata);
+
+/* Set the callback function for avatar data.  */
+void tox_callback_avatar_data(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, uint8_t*, uint8_t*, uint32_t, void *), void *userdata);
+```
+
+
+
+
+## Using Avatars in Client Applications
+
+
+### General recommendations
+
+  - 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;
+
+  - Clients MUST NOT block waiting for avatar information and avatar data
+    packets;
+
+  - 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
+    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;
+
+  - The peers MUST NOT assume any coupling between the operations of
+    receiving an avatar information packet, sending unrequested avatar
+    information packets, requesting avatar data, or receiving avatar data.
+
+    For example, the following situations are valid:
+
+      * A text-mode client may send avatars to other users, but never
+        request them;
+
+      * A client may not understand a particular image format and ignore
+        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 do 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;
+
+  - When an 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;
+
+  - 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);
+
+  - When an avatar data notification is received, the client must update
+    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;
+
+  - If the user already have 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.
+
+  - If no avatar data is available for a given friend, the client should
+    show a placeholder image.
+
+
+
+### 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
+code is accepted into Tox core.**
+
+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
+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 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
+    should be kept for a user who has no avatar.
+
+  - 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 received, before any modifications by
+    the client for display purposes.
+
+  - The hash, as calculated by toxcore and passed in to 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 :) )
+
+    **To be discussed:** User keys are usually presented in Tox clients as
+    upper case strings, but lower case file names are more usual.
+
+
+Example for Linux and other Unix systems, assuming an 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/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
+    Elladan's hash:     /home/gildor/.config/tox/avatars/49486174655768656E48756D616E735468696E6B49416D4D7942726F74686572.hash
+    Elrohir's avatar    /home/gildor/.config/tox/avatars/726568746F7242794D6D41496B6E696854736E616D75486E6568576574614849.png
+    Elrohir's hash:     /home/gildor/.config/tox/avatars/726568746F7242794D6D41496B6E696854736E616D75486E6568576574614849.hash
+
+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`.
+
+
+#### Setting an avatar for the current user
+
+In this example `load_data_file` is just an hypothetical function that loads
+data from a file into the buffer and sets the length accordingly.
+
+    uint8_t buf[TOX_AVATAR_MAX_DATA_LENGTH];
+    uint32_t len;
+
+    if (load_data_file("avatar.png", buf, &len) == 0)
+        if (tox_set_avatar(tox, TOX_AVATAR_FORMAT_PNG, buf, len) != 0)
+            fprintf(stderr, "Failed to set avatar.\n");
+
+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
+must be set before connecting to the network to avoid spurious avatar change
+notifications and unnecessary data transfers.
+
+
+
+
+#### Removing the avatar from the current user
+
+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`
+and with no data:
+
+    tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0);
+
+If the user is connected, this function will also notify all connected
+friends about the avatar change.
+
+
+
+
+
+#### Receiving avatar information from friends
+
+All avatar information is passed to a callback function with the prototype:
+
+    void function(Tox *tox, int32_t friendnumber, uint8_t format,
+        uint8_t *hash, uint8_t *data, uint32_t datalen, void *userdata)
+
+As in this example:
+
+    static void avatar_info_cb(Tox *tox, int32_t friendnumber, uint8_t format,
+            uint8_t *hash, void *userdata)
+    {
+        printf("Receiving avatar information from friend %d. Format = %d\n",
+            friendnumber, format);
+        printf("Data hash: ");
+        hex_printf(hash, TOX_HASH_LENGTH);   /* Hypothetical function */
+        printf("\n");
+    }
+
+And, somewhere in the Tox initialization calls, set if as the callback to be
+triggered when an avatar information event arrives:
+
+    tox_callback_avatar_info(tox, avatar_info_cb, NULL);
+
+
+A typical client will test the currently cached avatar against the hash given
+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
+**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.
+
+For this, an application must define an avatar information callback which
+checks the local avatar cache and emits an avatar data request if necessary:
+
+    static void avatar_info_cb(Tox *tox, int32_t friendnumber, uint8_t format,
+            uint8_t *hash, void *userdata)
+    {
+        printf("Receiving avatar information from friend %d. Format = %d\n",
+            friendnumber, format);
+        if (format = TOX_AVATAR_FORMAT_NONE) {
+            /* User has no avatar or removed the avatar */
+            delete_avatar_from_cache(tox, friendnumber);
+        } else {
+            /* Use the received hash to check if the cached avatar is
+               still updated. */
+            if (!is_user_cached_avatar_updated(tox, friendnumber, hash)) {
+                /* User avatar is outdated, send data request */
+                tox_request_avatar_data(tox, friendnumber);
+            }
+        }
+    }
+
+
+Then define an avatar data callback to store the received data in the local
+cache:
+
+    static void avatar_data_cb(Tox *tox, int32_t friendnumber, uint8_t format,
+        uint8_t *hash, uint8_t *data, uint32_t datalen, void *userdata)
+    {
+        if (format = TOX_AVATAR_FORMAT_NONE) {
+            /* User has no avatar or removed the avatar */
+            delete_avatar_from_cache(tox, friendnumber);
+        } else {
+            save_avatar_data_to_cache(tox, friendnumber, format, hash,
+                data, datalen);
+        }
+    }
+
+
+And, finally, register both callbacks somewhere in the Tox initialization
+calls:
+
+    tox_callback_avatar_info(tox, avatar_info_cb, NULL);
+    tox_callback_avatar_data(tox, avatar_data_cb, NULL);
+
+
+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 public key (client id) from they 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`.
+
+
+
+
+
+
+
+
+
+
+
+## Internal Protocol Description
+
+### New packet types
+
+The avatar transfer protocol adds the following new packet types and ids:
+
+    PACKET_ID_AVATAR_INFO_REQ = 52
+    PACKET_ID_AVATAR_INFO = 53
+    PACKET_ID_AVATAR_DATA_CONTROL = 54
+    PACKET_ID_AVATAR_DATA_START = 55
+    PACKET_ID_AVATAR_DATA_PUSH = 56
+
+
+
+
+### Requesting avatar information
+
+To request avatar information, an 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
+not answer at all.
+
+
+
+
+### Receiving avatar information
+
+Avatar information arrives in a packet of type `PACKET_ID_AVATAR_INFO` with
+the following structure:
+
+    PACKET_ID_AVATAR_INFO (53)
+    Packet data size: 33 bytes
+    [1: uint8_t format][32: uint8_t hash]
+
+Where 'format' is the image data format, one of the following:
+
+    0 = AVATAR_FORMAT_NONE  (no avatar set)
+    1 = AVATAR_FORMAT_PNG
+
+and 'hash' is the SHA-256 message digest of the avatar data.
+
+This packet may be sent at any time and no previous request is required.
+Clients should send this packet upon connection or when a friend
+connects, in the same way Tox sends name, status and action information.
+
+
+
+
+
+### Requesting avatar data
+
+Transmission of avatar data is a multi-step procedure using three new packet
+types.
+
+  - Packet `PACKET_ID_AVATAR_DATA_CONTROL` have 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
+    defined:
+
+        0 = AVATAR_DATACONTROL_REQ
+        1 = AVATAR_DATACONTROL_ERROR
+
+
+  - Packet `PACKET_ID_AVATAR_DATA_START` have the following format:
+
+        PACKET_ID_AVATAR_DATA_START (55)
+        Packet data size: 37 bytes
+        [1: uint8_t format][32: uint8_t hash][1: uint32_t data_length]
+
+
+    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'
+    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
+    packet can hold.
+
+
+
+The following procedure assumes that a client "A" is requesting avatar data
+from a client "B":
+
+  - "A" must initialize its control structures and mark its data transfer
+    as not yet started. Then it requests avatar data from "B" by sending a
+    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" has no avatar set, 'format' must be `AVATAR_FORMAT_NONE`, 'hash'
+    must be zeroed and 'data_length' must be zero.
+
+    If "B" does not accept sending the avatar, it may send a packet
+    `PACKET_ID_AVATAR_DATA_CONTROL` with the field 'op' set to
+    `AVATAR_DATACONTROL_ERROR` or simply ignore this request. "A" must cope
+    with this.
+
+    If "B" have 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.
+
+    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,
+    finishing the process. For other formats, "A" just waits for packets
+    of type `PACKET_ID_AVATAR_DATA_PUSH`.
+
+  - 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
+    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
+    `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.
+
+    Then "A" checks if all the data was already 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
+    `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,
+    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
+    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.
+
+
+
+
+
+## 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
+client. This problem is exacerbated when there is the possibility of an
+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;
+
+  - 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`);
+
+  - Having per-friend data transfer limit. As the current protocol still
+    allows an 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;
+
+Another problem present in the avatars is the possibility of a friend send
+a maliciously crafted image intended to exploit vulnerabilities in image
+decoders. Without an intermediate server to recompress and 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
+process can take. Images coming from Tox friends must be treated in the same
+way as images coming from random Internet sources.
diff --git a/docs/Group-Chats.md b/docs/Group-Chats.md
index 5e00b550..e937d549 100644
--- a/docs/Group-Chats.md
+++ b/docs/Group-Chats.md
@@ -1,44 +1,52 @@
-Massive public group chats.
+Group chats.
 
-Note that not all this document has been implemented: only private (invite only) group chats are currently implemented.
+Note: we assume everyone in the chat trusts each other.
 
-Everyone generates a short term public private key pair right before joining 
-the chat.
+These group chats work by temporarily adding the 4 "closest" people defined by a distance function 
+in group.c in order to form a circle of connected peers. These peers then relay messages to each other.
 
-Note that for public group chats it is impossible to protect the chat from 
-being spied on by a very dedicated attacker, encryption is therefor used as a 
-form of spam/access control.
+A friend invites another friend to a group chat by sending them an invite packet. The friend either ignores 
+the invite or responds with a response packet if he wants to join the chat. The friend invite contains the type
+of groupchat (text only, A/V) the friend is being invited to.
 
-## Joining the chats
 
+TODO: write more of this.
 
 ## Protocol
 
+Invite packets:
+Invite packet:
+[uint8_t id 96][uint8_t id 0][uint16_t group chat number][33 bytes group chat identifier[1 byte type][32 bytes id]]
 
-Node format: 
-See DHT, currently uses the IPv6 Node_format.
+Response packet
+[uint8_t id 96][uint8_t id 1][uint16_t group chat number(local)][uint16_t group chat number to join][33 bytes group chat identifier[1 byte type][32 bytes id]]
 
-Get nodes (Request):
-Packet contents: 
-```
-[char with a value of 48][Bob's (The receiver's) Public key (client_id) (32 bytes))][Alice's (The sender's) Public key (client_id) (32 bytes)][Random nonce (24 bytes)][Encrypted with the nonce, private key of the sender and public key of the receiver:[char with a value of 48][random 8 byte (ping_id)]
-```
-Valid replies: a send_nodes packet
 
-Send_nodes (response): 
-```
-[char with a value of 48][Bob's (The receiver's) Public key (client_id) (32 bytes))][Alice's (The sender's) Public key (client_id) (32 bytes)][Random nonce (24 bytes)][Encrypted with the nonce, private key of the sender and public key of the receiver:[char with a value of 49][random 8 byte (ping_id)][Nodes in node format, length=40 * (number of nodes (maximum of 6 nodes)) bytes]]
-```
+Peer online packet:
+[uint8_t id 97][uint16_t group chat number (local)][33 bytes group chat identifier[1 byte type][32 bytes id]]
 
-Broadcast packet:
-```
-[char with a value of 48][Bob's (The receiver's) Public key (client_id) (32 bytes))][Alice's (The sender's) Public key (client_id) (32 bytes)][nonce][Encrypted with the nonce, private key of the sender and public key of the receiver:[char with a value of 50][Data to send to everyone]]
-```
+Peer leave packet:
+[uint8_t id 98][uint16_t group chat number][uint8_t id 1]
 
+Peer query packet:
+[uint8_t id 98][uint16_t group chat number][uint8_t id 8]
+
+Peer response packet:
+[uint8_t id 98][uint16_t group chat number][uint8_t id 9][Repeated times number of peers: [uint16_t peer num][uint8_t 32bytes real public key][uint8_t 32bytes temp DHT public key][uint8_t name length][name]] 
+
+Title response packet:
+[uint8_t id 98][uint16_t group chat number][uint8_t id 10][title]
+
+Message packets:
+[uint8_t id 99][uint16_t group chat number][uint16_t peer number][uint32_t message number][uint8_t with a value representing id of message][data]
+
+Lossy Message packets:
+[uint8_t id 199][uint16_t group chat number][uint16_t peer number][uint16_t message number][uint8_t with a value representing id of message][data]
+
+Group chat types:
+0: text
+1: AV
 
-Data to send to everyone:
-TODO: signing and spam control + permissions.
-[client_id of sender][uint32_t message number][char with a value representing id of message][data]
 
 Note: the message number is increased by 1 for each sent message.
 
@@ -49,23 +57,22 @@ No data.
 
 16 - new_peer
 Tell everyone about a new peer in the chat.
-[uint8_t public_key[public_key_len]]
+[uint16_t peer_num][uint8_t 32bytes real public key][uint8_t 32bytes temp DHT public key]
 
-17 - ban_peer
-Ban a peer
-[uint8_t public_key[public_key_len]]
-
-18 - topic change
-[uint8_t topic[topiclen]]
+17 - kill_peer
+[uint16_t peer_num]
 
 48 - name change
 [uint8_t name[namelen]]
 
-49 - status change
-[uint8_t (status id)]
+49 - groupchat title change
+[uint8_t title[titlelen]]
 
 64 - chat message
 [uint8_t message[messagelen]]
 
 65 - action (/me)
 [uint8_t message[messagelen]]
+
+
+
diff --git a/docs/Prevent_Tracking.txt b/docs/Prevent_Tracking.txt
index d170103f..a641f02c 100644
--- a/docs/Prevent_Tracking.txt
+++ b/docs/Prevent_Tracking.txt
@@ -117,8 +117,10 @@ Data sent to us:
 announce response packet:
 [uint8_t packet id (132)][data to send back in response(fixed size)][nonce]
 encrypted with the DHT private key of Node D, the public key in the request and the nonce:[[uint8_t is_stored]
-[(32 bytes) ping_id if is_stored is 0, public key that must be used to send data packets if is_stored is not 0][Node_Format * (maximum of 8)]]
+[(32 bytes) ping_id if is_stored is 0 or 2, public key that must be used to send data packets if is_stored is 1][Node_Format * (maximum of 8)]]
 (if the is_stored is not 0, it means the information to reach the client id we are searching for is stored on this node)
+is_stored is 2 as a response to a peer trying to announce himself to tell the
+peer that he is currently announced successfully.
 
 data to route response packet:
 [uint8_t packet id (134)][nonce][temporary just generated public key]
diff --git a/docs/TODO b/docs/TODO
index dea513b2..54137d0d 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -3,7 +3,7 @@ TODO list.
 [IN PROGRESS] Add what is left to do to the TODO list.
 
 Networking:
-    [NOT STARTED] UPnP port forwarding.
+    [NEEDS TESTING] UPnP port forwarding. (https://github.com/irungentoo/toxcore/pull/969)
     [NOT STARTED] NAT-PMP port forwarding.
 
 DHT:
@@ -11,13 +11,11 @@ DHT:
     [IN PROGRESS] Hardening against attacks.
     [IN PROGRESS] Optimizing the code.
 
-Lossless UDP:
-    [DONE] Increase data send/receive rates.
-
-[IN PROGRESS] Massive IRC like group chats (text only)
+[DONE] Friend only group chats
     [DONE] Networking base.
-    [NOT STARTED] Syncing chat state between clients (nicknames, list of who is in chat, etc...)
-    [NOT STARTED] Make clients sign their messages so that peers can't modify them.
+    [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
@@ -26,7 +24,7 @@ Lossless UDP:
     [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.
@@ -34,29 +32,17 @@ Friend_requests.c:
 
 [DONE] File transfers
 [NOT STARTED] Offline messaging
-[NOT STARTED] Friends list syncing
-[IN PROGRESS] IPV6 support
-    [DONE] Networking
-    [DONE] DHT + Messenger
-    [NOT STARTED] Group chats (They work with IPv6 but some things need to be tested.)
-
+[IN PROGRESS] Friends list syncing
+[DONE] IPV6 support
 
 [IN PROGRESS] Make toxcore thread safe.
 
 [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)
-
-[NEEDS TESTING] Make the save made with tox_save_encrypted(...) harder to brute force.
-See: (https://github.com/jencka/ProjectTox-libtoxdata)
-
-[IN PROGRESS] GUI (no official one chosen yet, a list of promising ones follows)
-https://github.com/notsecure/uTox
-https://github.com/naxuroqa/Venom
-https://github.com/Impyy/Toxy
-https://github.com/lehitoskin/blight
-https://github.com/nurupo/ProjectTox-Qt-GUI
-https://github.com/Astonex/Antox
+blocks UDP (or is just unpunchable) (docs/TCP_Network.txt) (Current way doesn't scale very well.)
+
+[DONE] Encrypted Saves. (see: toxencryptsave)
+
 
 [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 a84132b6..ca561474 100644
--- a/docs/Tox_middle_level_network_protocol.txt
+++ b/docs/Tox_middle_level_network_protocol.txt
@@ -43,13 +43,13 @@ cookie request packet:
 bytes)][Encrypted message containing: [Senders 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, recievers DHT 
+Encrypted message is encrypted with sender DHT private key, receivers 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, recievers DHT 
+Encrypted message is encrypted with sender DHT private key, receivers DHT
 public key and the nonce.
 
 The Cookie should be basically:
@@ -63,7 +63,7 @@ Cookie sitting outside the encrypted part][Other Cookie (used by the other to
 respond to the handshake packet)]]
 
 The handshake packet is encrypted using the real private key of the sender, the 
-real private key of the receiver and the nonce.
+real public key of the receiver and the nonce.
 
 
 Alice wants to connect to bob.
@@ -110,11 +110,11 @@ 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, substract 1 to it and put it in packet_num then start from the 
-beggining 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. 
+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.
 
 
diff --git a/docs/updates/DHT.md b/docs/updates/DHT.md
index 17db70ce..9857b419 100644
--- a/docs/updates/DHT.md
+++ b/docs/updates/DHT.md
@@ -1,6 +1,8 @@
 DHT protocol
 ============
 
+NOTE: only the protocol section is up to date, the rest needs to be rewritten.
+
 Follows pretty much the principle of the torrent DHT: http://www.bittorrent.org/beps/bep_0005.html (READ IT)
 
 But:
@@ -36,39 +38,39 @@ Send a get nodes request every 20 seconds to a random good node in the client li
 
 When a client receives any request from another
 -----------------------------------------------
--Respond to the request
-    -Ping request is replied to with with a ping response containing the same encrypted data
-    -Get nodes request is replied with a send nodes reply containing the same encrypted data and the good nodes from the client list and/or the "friends" list that are closest to the requested_node_id
+- Respond to the request
+    - Ping request is replied to with with a ping response containing the same encrypted data
+    - Get nodes request is replied with a send nodes reply containing the same encrypted data and the good nodes from the client list and/or the "friends" list that are closest to the requested_node_id
 
--If the requesting client is not in the client list:
-    -If there are no bad clients in the list and the list is full:
-        -If the id of the other client is closer (mathematically see bittorrent doc) than at least one of the clients in the list or our "friends" list:
-            -Send a ping request to the client.
-        -if not forget about the client.
+- If the requesting client is not in the client list:
+    - If there are no bad clients in the list and the list is full:
+        - If the id of the other client is closer (mathematically see bittorrent doc) than at least one of the clients in the list or our "friends" list:
+            - Send a ping request to the client.
+        - if not forget about the client.
 
-    -If there are bad clients and/or the list isn't full:
-        -Send a ping request to the client 
+    - If there are bad clients and/or the list isn't full:
+        - Send a ping request to the client 
 
 When a client receives a response
 ---------------------------------
--Ping response
-    -If the node was previously pinged with a matching ping_id (check in the corresponding pinged list.)
-        -If the node is in the client list the matching client's timestamp is set to current time.
-        -If the node is in the "friends" list the matching client's timestamp is set to current time for every occurrence.
-        -If the node is not in the client list:
-            -If the list isn't full, add it to the list.
-            -If the list is full, the furthest away (mathematically see bittorrent doc) bad client is replaced by the new one.
-            -If the list is filled with good nodes replace the furthest client with it only if it is closer than the replaced node.
-        -for each friend in the "friends" list:
-            -If that friend's client list isn't full, add that client to it
-            -If that friend's client list contains bad clients, replace the furthest one with that client.
-            -If that friend's client list contains only good clients
-                -If the client is closer to the friend than one of the other clients, it replaces the farthest one
-                -If not, nothing happens.
+- Ping response
+    - If the node was previously pinged with a matching ping_id (check in the corresponding pinged list.)
+        - If the node is in the client list the matching client's timestamp is set to current time.
+        - If the node is in the "friends" list the matching client's timestamp is set to current time for every occurrence.
+        - If the node is not in the client list:
+            - If the list isn't full, add it to the list.
+            - If the list is full, the furthest away (mathematically see bittorrent doc) bad client is replaced by the new one.
+            - If the list is filled with good nodes replace the furthest client with it only if it is closer than the replaced node.
+        - for each friend in the "friends" list:
+            - If that friend's client list isn't full, add that client to it
+            - If that friend's client list contains bad clients, replace the furthest one with that client.
+            - If that friend's client list contains only good clients
+                - If the client is closer to the friend than one of the other clients, it replaces the farthest one
+                - If not, nothing happens.
 
-    -Send nodes
-        -If the ping_id matches what we sent previously (check in the corresponding pinged list.):
-            -Each node in the response is pinged.
+    - Send nodes
+        - If the ping_id matches what we sent previously (check in the corresponding pinged list.):
+            - Each node in the response is pinged.
 
 
 
@@ -95,11 +97,11 @@ ping_id = a random integer, the response must contain the exact same number as t
 Get nodes (Request):
 Packet contents: 
 ```
-[byte with value: 02][char array (client node_id), length=32 bytes][random 24 byte nonce][Encrypted with the nonce and private key of the sender:[char array: requested_node_id (node_id of which we want the ip), length=32 bytes][Sendback data (must be sent back unmodified by in the response), length=1 to NODES_ENCRYPTED_MESSAGE_LENGTH bytes]]
+[byte with value: 02][char array (client node_id), length=32 bytes][random 24 byte nonce][Encrypted with the nonce and private key of the sender:[char array: requested_node_id (node_id of which we want the ip), length=32 bytes][Sendback data (must be sent back unmodified by in the response), length=8 bytes]]
 ```
 Valid replies: a send_nodes packet
 
 Send_nodes (response (for all addresses)): 
 ```
-[byte with value: 04][char array  (client node_id), length=32 bytes][random 24 byte nonce][Encrypted with the nonce and private key of the sender:[uint8_t number of nodes in this packet][Nodes in node format, length=?? * (number of nodes (maximum of 8 nodes)) bytes][Sendback data, length=1 to NODES_ENCRYPTED_MESSAGE_LENGTH bytes]]
+[byte with value: 04][char array  (client node_id), length=32 bytes][random 24 byte nonce][Encrypted with the nonce and private key of the sender:[uint8_t number of nodes in this packet][Nodes in node format, length=?? * (number of nodes (maximum of 4 nodes)) bytes][Sendback data, length=8 bytes]]
 ```
diff --git a/libtoxav.pc.in b/libtoxav.pc.in
index 05493231..b36b5a91 100644
--- a/libtoxav.pc.in
+++ b/libtoxav.pc.in
@@ -5,7 +5,7 @@ includedir=@includedir@
 
 Name: libtoxav
 Description: Tox A/V library
-Requires:
+Requires: libtoxcore
 Version: @PACKAGE_VERSION@
 Libs: -L${libdir} -ltoxav @AV_LIBS@
-Cflags: -I${includedir}
\ No newline at end of file
+Cflags: -I${includedir}
diff --git a/libtoxcore.pc.in b/libtoxcore.pc.in
index a91a1fb7..0ff86827 100644
--- a/libtoxcore.pc.in
+++ b/libtoxcore.pc.in
@@ -7,5 +7,5 @@ Name: libtoxcore
 Description: Tox protocol library
 Requires:
 Version: @PACKAGE_VERSION@
-Libs: @NACL_OBJECTS_PKGCONFIG@ -L${libdir} @NACL_LDFLAGS@ -ltoxdns -ltoxcore @NACL_LIBS@ @LIBS@ @MATH_LDFLAGS@
+Libs: @NACL_OBJECTS_PKGCONFIG@ -L${libdir} @NACL_LDFLAGS@ -ltoxdns -ltoxencryptsave -ltoxcore @NACL_LIBS@ @LIBS@ @MATH_LDFLAGS@ @PTHREAD_LDFLAGS@
 Cflags: -I${includedir}
diff --git a/other/DHT_bootstrap.c b/other/DHT_bootstrap.c
index 462360c3..29aa5bcf 100644
--- a/other/DHT_bootstrap.c
+++ b/other/DHT_bootstrap.c
@@ -83,6 +83,11 @@ void manage_keys(DHT *dht)
         memcpy(keys + crypto_box_PUBLICKEYBYTES, dht->self_secret_key, crypto_box_SECRETKEYBYTES);
         keys_file = fopen("key", "w");
 
+        if (keys_file == NULL) {
+            printf("Error opening key file in write mode.\nKeys will not be saved.\n");
+            return;
+        }
+
         if (fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file) != KEYS_SIZE) {
             printf("Error while writing the key file.\nExiting.\n");
             exit(1);
diff --git a/other/bootstrap_daemon/README.md b/other/bootstrap_daemon/README.md
index a63ea5de..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` 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.
\ No newline at end of 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.c b/other/bootstrap_daemon/tox-bootstrapd.c
index a5d1c525..1bcae732 100644
--- a/other/bootstrap_daemon/tox-bootstrapd.c
+++ b/other/bootstrap_daemon/tox-bootstrapd.c
@@ -53,7 +53,7 @@
 
 
 #define DAEMON_NAME "tox-bootstrapd"
-#define DAEMON_VERSION_NUMBER 2014081600UL // yyyymmmddvv format: yyyy year, mm month, dd day, vv version change count for that day
+#define DAEMON_VERSION_NUMBER 2014101200UL // yyyymmmddvv format: yyyy year, mm month, dd day, vv version change count for that day
 
 #define SLEEP_TIME_MILLISECONDS 30
 #define sleep usleep(1000*SLEEP_TIME_MILLISECONDS)
@@ -61,7 +61,8 @@
 #define DEFAULT_PID_FILE_PATH         "tox-bootstrapd.pid"
 #define DEFAULT_KEYS_FILE_PATH        "tox-bootstrapd.keys"
 #define DEFAULT_PORT                  33445
-#define DEFAULT_ENABLE_IPV6           0 // 1 - true, 0 - false
+#define DEFAULT_ENABLE_IPV6           1 // 1 - true, 0 - false
+#define DEFAULT_ENABLE_IPV4_FALLBACK  1 // 1 - true, 0 - false
 #define DEFAULT_ENABLE_LAN_DISCOVERY  1 // 1 - true, 0 - false
 #define DEFAULT_ENABLE_TCP_RELAY      1 // 1 - true, 0 - false
 #define DEFAULT_TCP_RELAY_PORTS       443, 3389, 33445 // comma-separated list of ports. make sure to adjust DEFAULT_TCP_RELAY_PORTS_COUNT accordingly
@@ -88,7 +89,7 @@ int manage_keys(DHT *dht, char *keys_file_path)
     keys_file = fopen(keys_file_path, "r");
 
     if (keys_file != NULL) {
-        size_t read_size = fread(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
+        const size_t read_size = fread(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
 
         if (read_size != KEYS_SIZE) {
             fclose(keys_file);
@@ -104,7 +105,7 @@ int manage_keys(DHT *dht, char *keys_file_path)
 
         keys_file = fopen(keys_file_path, "w");
 
-        size_t write_size = fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
+        const size_t write_size = fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
 
         if (write_size != KEYS_SIZE) {
             fclose(keys_file);
@@ -161,7 +162,12 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
         }
 
         // the loop above skips invalid ports, so we adjust the allocated memory size
-        *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+        if ((*tcp_relay_port_count) > 0) {
+            *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+        } else {
+            free(*tcp_relay_ports);
+            *tcp_relay_ports = NULL;
+        }
 
         return;
     }
@@ -187,7 +193,7 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
         config_setting_t *elem = config_setting_get_elem(ports_array, i);
 
         if (elem == NULL) {
-            // it's NULL if `ports_array` is not an array (we have that check ealier) or if `i` is out of range, which should not be
+            // it's NULL if `ports_array` is not an array (we have that check earlier) or if `i` is out of range, which should not be
             syslog(LOG_WARNING, "Port #%d: Something went wrong while parsing the port. Stopping reading ports.\n", i);
             break;
         }
@@ -210,7 +216,12 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
     }
 
     // the loop above skips invalid ports, so we adjust the allocated memory size
-    *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+    if ((*tcp_relay_port_count) > 0) {
+        *tcp_relay_ports = realloc(*tcp_relay_ports, (*tcp_relay_port_count) * sizeof(uint16_t));
+    } else {
+        free(*tcp_relay_ports);
+        *tcp_relay_ports = NULL;
+    }
 }
 
 // Gets general config options
@@ -222,9 +233,10 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
 // returns 1 on success
 //         0 on failure, doesn't modify any data pointed by arguments
 
-int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_file_path, int *port, int *enable_ipv6,
-                       int *enable_lan_discovery, int *enable_tcp_relay, uint16_t **tcp_relay_ports, int *tcp_relay_port_count,
-                       int *enable_motd, char **motd)
+int get_general_config(const char *cfg_file_path, char **pid_file_path, char **keys_file_path, int *port,
+                       int *enable_ipv6,
+                       int *enable_ipv4_fallback, int *enable_lan_discovery, int *enable_tcp_relay, uint16_t **tcp_relay_ports,
+                       int *tcp_relay_port_count, int *enable_motd, char **motd)
 {
     config_t cfg;
 
@@ -232,6 +244,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
     const char *NAME_PID_FILE_PATH        = "pid_file_path";
     const char *NAME_KEYS_FILE_PATH       = "keys_file_path";
     const char *NAME_ENABLE_IPV6          = "enable_ipv6";
+    const char *NAME_ENABLE_IPV4_FALLBACK = "enable_ipv4_fallback";
     const char *NAME_ENABLE_LAN_DISCOVERY = "enable_lan_discovery";
     const char *NAME_ENABLE_TCP_RELAY     = "enable_tcp_relay";
     const char *NAME_ENABLE_MOTD          = "enable_motd";
@@ -284,6 +297,14 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
         *enable_ipv6 = DEFAULT_ENABLE_IPV6;
     }
 
+    // Get IPv4 fallback option
+    if (config_lookup_bool(&cfg, NAME_ENABLE_IPV4_FALLBACK, enable_ipv4_fallback) == CONFIG_FALSE) {
+        syslog(LOG_WARNING, "No '%s' setting in configuration file.\n", NAME_ENABLE_IPV4_FALLBACK);
+        syslog(LOG_WARNING, "Using default '%s': %s\n", NAME_ENABLE_IPV4_FALLBACK,
+               DEFAULT_ENABLE_IPV4_FALLBACK ? "true" : "false");
+        *enable_ipv4_fallback = DEFAULT_ENABLE_IPV4_FALLBACK;
+    }
+
     // Get LAN discovery option
     if (config_lookup_bool(&cfg, NAME_ENABLE_LAN_DISCOVERY, enable_lan_discovery) == CONFIG_FALSE) {
         syslog(LOG_WARNING, "No '%s' setting in configuration file.\n", NAME_ENABLE_LAN_DISCOVERY);
@@ -338,6 +359,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
     syslog(LOG_DEBUG, "'%s': %s\n", NAME_KEYS_FILE_PATH,       *keys_file_path);
     syslog(LOG_DEBUG, "'%s': %d\n", NAME_PORT,                 *port);
     syslog(LOG_DEBUG, "'%s': %s\n", NAME_ENABLE_IPV6,          *enable_ipv6          ? "true" : "false");
+    syslog(LOG_DEBUG, "'%s': %s\n", NAME_ENABLE_IPV4_FALLBACK, *enable_ipv4_fallback ? "true" : "false");
     syslog(LOG_DEBUG, "'%s': %s\n", NAME_ENABLE_LAN_DISCOVERY, *enable_lan_discovery ? "true" : "false");
 
     syslog(LOG_DEBUG, "'%s': %s\n", NAME_ENABLE_TCP_RELAY,     *enable_tcp_relay     ? "true" : "false");
@@ -370,7 +392,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
 // returns 1 on success, some or no bootstrap nodes were added
 //         0 on failure, a error accured while parsing config file
 
-int bootstrap_from_config(char *cfg_file_path, DHT *dht, int enable_ipv6)
+int bootstrap_from_config(const char *cfg_file_path, DHT *dht, int enable_ipv6)
 {
     const char *NAME_BOOTSTRAP_NODES = "bootstrap_nodes";
 
@@ -475,7 +497,7 @@ next:
 
 // Prints public key
 
-void print_public_key(uint8_t *public_key)
+void print_public_key(const uint8_t *public_key)
 {
     char buffer[2 * crypto_box_PUBLICKEYBYTES + 1];
     int index = 0;
@@ -502,10 +524,11 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    char *cfg_file_path = argv[1];
+    const char *cfg_file_path = argv[1];
     char *pid_file_path, *keys_file_path;
     int port;
     int enable_ipv6;
+    int enable_ipv4_fallback;
     int enable_lan_discovery;
     int enable_tcp_relay;
     uint16_t *tcp_relay_ports;
@@ -513,8 +536,8 @@ int main(int argc, char *argv[])
     int enable_motd;
     char *motd;
 
-    if (get_general_config(cfg_file_path, &pid_file_path, &keys_file_path, &port, &enable_ipv6, &enable_lan_discovery,
-                           &enable_tcp_relay, &tcp_relay_ports, &tcp_relay_port_count, &enable_motd, &motd)) {
+    if (get_general_config(cfg_file_path, &pid_file_path, &keys_file_path, &port, &enable_ipv6, &enable_ipv4_fallback,
+                           &enable_lan_discovery, &enable_tcp_relay, &tcp_relay_ports, &tcp_relay_port_count, &enable_motd, &motd)) {
         syslog(LOG_DEBUG, "General config read successfully\n");
     } else {
         syslog(LOG_ERR, "Couldn't read config file: %s. Exiting.\n", cfg_file_path);
@@ -537,7 +560,27 @@ int main(int argc, char *argv[])
     IP ip;
     ip_init(&ip, enable_ipv6);
 
-    DHT *dht = new_DHT(new_networking(ip, port));
+    Networking_Core *net = new_networking(ip, port);
+
+    if (net == NULL) {
+        if (enable_ipv6 && enable_ipv4_fallback) {
+            syslog(LOG_DEBUG, "Couldn't initialize IPv6 networking. Falling back to using IPv4.\n");
+            enable_ipv6 = 0;
+            ip_init(&ip, enable_ipv6);
+            net = new_networking(ip, port);
+
+            if (net == NULL) {
+                syslog(LOG_DEBUG, "Couldn't fallback to IPv4. Exiting.\n");
+                return 1;
+            }
+        } else {
+            syslog(LOG_DEBUG, "Couldn't initialize networking. Exiting.\n");
+            return 1;
+        }
+    }
+
+
+    DHT *dht = new_DHT(net);
 
     if (dht == NULL) {
         syslog(LOG_ERR, "Couldn't initialize Tox DHT instance. Exiting.\n");
@@ -613,10 +656,10 @@ int main(int argc, char *argv[])
     free(keys_file_path);
 
     // Fork off from the parent process
-    pid_t pid = fork();
+    const pid_t pid = fork();
 
     if (pid > 0) {
-        fprintf(pidf, "%d ", pid);
+        fprintf(pidf, "%d", pid);
         fclose(pidf);
         syslog(LOG_DEBUG, "Forked successfully: PID: %d.\n", pid);
         return 0;
@@ -650,7 +693,7 @@ int main(int argc, char *argv[])
     close(STDERR_FILENO);
 
     uint64_t last_LANdiscovery = 0;
-    uint16_t htons_port = htons(port);
+    const uint16_t htons_port = htons(port);
 
     int waiting_for_dht_connection = 1;
 
diff --git a/other/bootstrap_daemon/tox-bootstrapd.conf b/other/bootstrap_daemon/tox-bootstrapd.conf
index 60efb939..d02eb3d0 100644
--- a/other/bootstrap_daemon/tox-bootstrapd.conf
+++ b/other/bootstrap_daemon/tox-bootstrapd.conf
@@ -1,54 +1,65 @@
 // Tox DHT bootstrap daemon configuration file.
 
-// Listening port.
+// Listening port (UDP).
 port = 33445
 
 // A key file is like a password, so keep it where no one can read it.
 // If there is no key file, a new one will be generated.
-// The daemon should have permission to read/write to it.
+// The daemon should have permission to read/write it.
 keys_file_path = "/var/lib/tox-bootstrapd/keys"
 
-// The PID file written to by daemon.
-// Make sure that the user who runs the daemon has permissions to write to the
+// The PID file written to by the daemon.
+// Make sure that the user that daemon runs as has permissions to write to the
 // PID file.
 pid_file_path = "/var/run/tox-bootstrapd/tox-bootstrapd.pid"
 
 // Enable IPv6.
-enable_ipv6 = false
+enable_ipv6 = true
+
+// Fallback to IPv4 in case IPv6 fails.
+enable_ipv4_fallback = true
 
 // Automatically bootstrap with nodes on local area network.
 enable_lan_discovery = true
 
 enable_tcp_relay = true
 
-// Tox uses 443, 3389 and 33445 ports by default, so it's highly recommended 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]
 
-// It's planned to use message of the day as a convenient method of checking
-// whether a node is up or not, though there are other methods of doing that.
+// Reply to MOTD (Message Of The Day) requests.
 enable_motd = true
 
+// Just a message that is sent when someone requests MOTD.
+// Put anything you want, but note that it will be trimmed to fit into 255 bytes.
 motd = "tox-bootstrapd"
 
 // Any number of nodes the daemon will bootstrap itself off.
+//
 // Remember to replace the provided example with your own node list.
 // There is a maintained list of bootstrap nodes on Tox's wiki, if you need it
 // (http://wiki.tox.im/Nodes).
-// You may leave the list empty or remove "bootstrap_nodes" complitely,
+//
+// You may leave the list empty or remove "bootstrap_nodes" completely,
 // 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.
 bootstrap_nodes = (
-  { // Node 1
-    // Any ipv4 or ipv6, depending on whether `enable_ipv6` is set or not,
-    // and also any US-ASCII domain name.
-    address = "198.46.136.167"
+  { // Example Node 1 (IPv4)
+    address = "127.0.0.1"
     port = 33445
     public_key = "728925473812C7AAC482BE7250BCCAD0B8CB9F737BF3D42ABD34459C1768F854"
   },
-  { // Node 2
+  { // Example Node 2 (IPv6)
+    address = "::1/128"
+    port = 33445
+    public_key = "3E78BACF0F84235B30054B54898F56793E1DEF8BD46B1038B9D822E8460FAB67"
+  },
+  { // Example Node 3 (US-ASCII domain name)
     address = "example.org"
     port = 33445
     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_daemon/tox-bootstrapd.sh b/other/bootstrap_daemon/tox-bootstrapd.sh
index a6c137bd..1431bde0 100644
--- a/other/bootstrap_daemon/tox-bootstrapd.sh
+++ b/other/bootstrap_daemon/tox-bootstrapd.sh
@@ -23,7 +23,7 @@ USER=tox-bootstrapd
 GROUP=tox-bootstrapd
 
 # Exit if the package is not installed
-[ -x "$DAEMON" ] || exit 5
+[ -x "$DAEMON" ] || exit 0
 
 # Load the VERBOSE setting and other rcS variables
 . /lib/init/vars.sh
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/other/osx_build_script_toxcore.sh b/other/osx_build_script_toxcore.sh
new file mode 100644
index 00000000..8aea0d1c
--- /dev/null
+++ b/other/osx_build_script_toxcore.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# written by Lubo Diakov
+# hard coded toxcore directory, replace with other path or variable as needed
+cd ~/Downloads/toxcore
+echo "Now working in:"`pwd`
+
+# must have working git binary, and have done git clone at least once before
+git pull
+echo "If git pull responds: Already up-to-date. you can cancel the build"
+echo "by typing anything except y or Y below"
+read -p "Continue with build? (enter y to continue): " Last_Chance
+
+# blah blah
+if [[ $Last_Chance = [Yy] ]]; then echo "Continuing!";
+else echo "Aborted!"; exit
+fi
+sleep 3
+
+# if libsodium is built with macports, link it from /opt/local/ to /usr/local
+if [ ! -L "/usr/local/lib/libsodium.dylib" ]; then
+  # Control will enter here if $DIRECTORY doesn't exist.
+   ln -s /opt/local/lib/libsodium.dylib /usr/local/lib/libsodium.dylib
+fi
+echo "The symlink /usr/local/lib/libsodium.dylib exists."
+sleep 3
+
+# replace ppc, i386 as needed.
+./configure CC="gcc -arch ppc -arch i386" CXX="g++  -arch ppc -arch i386" CPP="gcc -E" CXXCPP="g++ -E" 
+
+# get rid of prior builds, start clean
+make clean
+make
+echo ""
+echo "Sudo is required for make install only, all other steps run without it."
+echo "Please type your sudo password below for make install:"
+sudo make install
+
+exit
diff --git a/testing/DHT_test.c b/testing/DHT_test.c
index 2636ed02..5cdd1823 100644
--- a/testing/DHT_test.c
+++ b/testing/DHT_test.c
@@ -208,7 +208,7 @@ int main(int argc, char *argv[])
         temp_id[strlen(temp_id) - 1] = '\0';
 
     uint8_t *bin_id = hex_string_to_bin(temp_id);
-    DHT_addfriend(dht, bin_id);
+    DHT_addfriend(dht, bin_id, 0, 0, 0, 0);
     free(bin_id);
 
     perror("Initialization");
diff --git a/testing/Makefile.inc b/testing/Makefile.inc
index 42d89e05..8b93c8ac 100644
--- a/testing/Makefile.inc
+++ b/testing/Makefile.inc
@@ -105,6 +105,35 @@ tox_shell_LDADD =        $(LIBSODIUM_LDFLAGS) \
                         $(NACL_LIBS) \
                         -lutil
 
+
+noinst_PROGRAMS +=      test_avatars
+
+test_avatars_SOURCES =   ../testing/test_avatars.c
+
+test_avatars_CFLAGS =    $(LIBSODIUM_CFLAGS) \
+                        $(NACL_CFLAGS)
+
+test_avatars_LDADD =    $(LIBSODIUM_LDFLAGS) \
+                        $(NACL_LDFLAGS) \
+                        libtoxcore.la \
+                        $(LIBSODIUM_LIBS) \
+                        $(NACL_OBJECTS) \
+                        $(NACL_LIBS)
+
+
+noinst_PROGRAMS +=      irc_syncbot
+
+irc_syncbot_SOURCES =   ../testing/irc_syncbot.c
+
+irc_syncbot_CFLAGS =    $(LIBSODIUM_CFLAGS) \
+                        $(NACL_CFLAGS)
+
+irc_syncbot_LDADD =    $(LIBSODIUM_LDFLAGS) \
+                        $(NACL_LDFLAGS) \
+                        libtoxcore.la \
+                        $(LIBSODIUM_LIBS) \
+                        $(NACL_OBJECTS) \
+                        $(NACL_LIBS)
 endif
 
 EXTRA_DIST +=                   $(top_srcdir)/testing/misc_tools.c
diff --git a/testing/irc_syncbot.c b/testing/irc_syncbot.c
new file mode 100644
index 00000000..f7486115
--- /dev/null
+++ b/testing/irc_syncbot.c
@@ -0,0 +1,350 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <time.h>
+
+
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <netdb.h>
+#include <unistd.h>
+
+#include <sys/ioctl.h>
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MACH__)
+#define MSG_NOSIGNAL 0
+#endif
+
+//IRC name and channel.
+#define IRC_NAME "Tox_syncbot"
+#define IRC_CHANNEL "#tox-real-ontopic"
+
+//IRC server ip and port.
+uint8_t ip[4] = {127, 0, 0, 1};
+uint16_t port = 6667;
+
+#define SILENT_TIMEOUT 20
+
+int sock;
+
+#define SERVER_CONNECT "NICK "IRC_NAME"\nUSER "IRC_NAME" 8 * :"IRC_NAME"\n"
+#define CHANNEL_JOIN "JOIN "IRC_CHANNEL"\n"
+
+/* In toxcore/network.c */
+uint64_t current_time_monotonic(void);
+
+uint64_t get_monotime_sec(void)
+{
+    return current_time_monotonic() / 1000;
+}
+
+int reconnect(void)
+{
+    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+
+    if (sock < 0) {
+        printf("error socket\n");
+        return -1;
+    }
+
+    struct sockaddr_storage addr = {0};
+
+    size_t addrsize;
+
+    struct sockaddr_in *addr4 = (struct sockaddr_in *)&addr;
+
+    addrsize = sizeof(struct sockaddr_in);
+
+    addr4->sin_family = AF_INET;
+
+    memcpy(&addr4->sin_addr, ip, 4);
+
+    addr4->sin_port = htons(port);
+
+    if (connect(sock, (struct sockaddr *)&addr, addrsize) != 0) {
+        printf("error connect\n");
+        return -1;
+    }
+
+    send(sock, SERVER_CONNECT, sizeof(SERVER_CONNECT) - 1, MSG_NOSIGNAL);
+
+    return sock;
+}
+
+#include "../toxcore/tox.h"
+#include "misc_tools.c"
+
+int current_group = -1;
+
+static void callback_group_invite(Tox *tox, int fid, uint8_t type, const uint8_t *data, uint16_t length, void *userdata)
+{
+    if (current_group == -1)
+        current_group = tox_join_groupchat(tox, fid, data, length);
+}
+
+void callback_friend_message(Tox *tox, int fid, const uint8_t *message, uint16_t length, void *userdata)
+{
+    if (length == 1 && *message == 'c') {
+        if (tox_del_groupchat(tox, current_group) == 0)
+            current_group = -1;
+    }
+
+    if (length == 1 && *message == 'i') {
+        tox_invite_friend(tox, fid, current_group);
+    }
+
+    if (length == 1 && *message == 'j' && sock >= 0) {
+        send(sock, CHANNEL_JOIN, sizeof(CHANNEL_JOIN) - 1, MSG_NOSIGNAL);
+    }
+}
+
+static void copy_groupmessage(Tox *tox, int groupnumber, int friendgroupnumber, const uint8_t *message, uint16_t length,
+                              void *userdata)
+{
+    if (tox_group_peernumber_is_ours(tox, groupnumber, friendgroupnumber))
+        return;
+
+    uint8_t name[TOX_MAX_NAME_LENGTH];
+    int namelen = tox_group_peername(tox, groupnumber, friendgroupnumber, name);
+
+    if (namelen == 0 || namelen == -1) {
+        memcpy(name, "<unknown>", 9);
+        namelen = 9;
+    }
+
+    uint8_t sendbuf[2048];
+    uint16_t send_len = 0;
+
+    memcpy(sendbuf, "PRIVMSG "IRC_CHANNEL" :", sizeof("PRIVMSG "IRC_CHANNEL" :"));
+    send_len += sizeof("PRIVMSG "IRC_CHANNEL" :") - 1;
+    memcpy(sendbuf + send_len, name, namelen);
+    send_len += namelen;
+    sendbuf[send_len] = ':';
+    send_len += 1;
+    sendbuf[send_len] = ' ';
+    send_len += 1;
+    memcpy(sendbuf + send_len, message, length);
+    send_len += length;
+    unsigned int i;
+
+    for (i = 0; i < send_len; ++i) {
+        if (sendbuf[i] == '\n')
+            sendbuf[i] = '|';
+
+        if (sendbuf[i] == 0)
+            sendbuf[i] = ' ';
+    }
+
+    sendbuf[send_len] = '\n';
+    send_len += 1;
+
+    if (sock >= 0)
+        send(sock, sendbuf, send_len, MSG_NOSIGNAL);
+}
+
+void send_irc_group(Tox *tox, uint8_t *msg, uint16_t len)
+{
+    if (len > 1350 || len == 0 || len == 1)
+        return;
+
+    --len;
+
+    if (*msg != ':')
+        return;
+
+    uint8_t req[len];
+    unsigned int i;
+
+    for (i = 0; i < (len - 1); ++i) {
+        if (msg[i + 1] == ':') {
+            break;
+        }
+
+        req[i] = msg[i + 1];
+    }
+
+    unsigned int req_len = i;
+    req[i] = 0;
+
+    uint8_t message[len];
+    uint16_t length = 0;
+
+    uint8_t *pmsg = (uint8_t *)strstr((char *)req, " PRIVMSG");
+
+    if (pmsg == NULL)
+        return;
+
+    uint8_t *dt = req;
+
+    for (dt = req, i = 0; dt != pmsg && *dt != '!'; ++dt, ++i) {
+        message[i] = *dt;
+        ++length;
+    }
+
+    message[length] = ':';
+    length += 1;
+    message[length] = ' ';
+    length += 1;
+
+    if ((req_len + 2) >= len)
+        return;
+
+    memcpy(message + length, msg + req_len + 2, len - (req_len + 2));
+    length += len - (req_len + 2);
+    tox_group_message_send(tox, current_group, message, length);
+}
+
+Tox *init_tox(int argc, char *argv[])
+{
+    uint8_t ipv6enabled = TOX_ENABLE_IPV6_DEFAULT; /* x */
+    int argvoffset = cmdline_parsefor_ipv46(argc, argv, &ipv6enabled);
+
+    if (argvoffset < 0)
+        exit(1);
+
+    /* with optional --ipvx, now it can be 1-4 arguments... */
+    if ((argc != argvoffset + 2) && (argc != argvoffset + 4)) {
+        printf("Usage: %s [--ipv4|--ipv6] ip port public_key (of the DHT bootstrap node)\n", argv[0]);
+        exit(0);
+    }
+
+    Tox *tox = tox_new(0);
+
+    if (!tox)
+        exit(1);
+
+    tox_set_name(tox, (uint8_t *)IRC_NAME, sizeof(IRC_NAME) - 1);
+    tox_callback_friend_message(tox, &callback_friend_message, 0);
+    tox_callback_group_invite(tox, &callback_group_invite, 0);
+    tox_callback_group_message(tox, &copy_groupmessage, 0);
+    tox_callback_group_action(tox, &copy_groupmessage, 0);
+
+    uint16_t port = atoi(argv[argvoffset + 2]);
+    unsigned char *binary_string = hex_string_to_bin(argv[argvoffset + 3]);
+    int res = tox_bootstrap_from_address(tox, argv[argvoffset + 1], port, binary_string);
+    free(binary_string);
+
+    char temp_id[128];
+    printf("\nEnter the address of irc_syncbots master (38 bytes HEX format):\n");
+
+    if (scanf("%s", temp_id) != 1) {
+        exit (1);
+    }
+
+    uint8_t *bin_id = hex_string_to_bin(temp_id);
+    int num = tox_add_friend(tox, bin_id, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo") - 1);
+    free(bin_id);
+
+    if (num < 0) {
+        printf("\nSomething went wrong when adding friend.\n");
+        exit(1);
+    }
+
+    return tox;
+}
+
+int main(int argc, char *argv[])
+{
+    Tox *tox = init_tox(argc, argv);
+
+    sock = reconnect();
+
+    if (sock < 0)
+        return 1;
+
+    uint64_t last_get = get_monotime_sec();
+    int connected = 0, ping_sent = 0;
+
+    while (1) {
+        int count = 0;
+        ioctl(sock, FIONREAD, &count);
+
+        if (count > 0) {
+            last_get = get_monotime_sec();
+            ping_sent = 0;
+            uint8_t data[count + 1];
+            data[count] = 0;
+            recv(sock, data, count, MSG_NOSIGNAL);
+            printf("%s", data);
+
+            if (!connected)
+                connected = 1;
+
+            if (count > 6 && data[0] == 'P' && data[1] == 'I' && data[2] == 'N' && data[3] == 'G') {
+                data[1] = 'O';
+                unsigned int i;
+
+                for (i = 0; i < count; ++i) {
+                    if (data[i] == '\n') {
+                        ++i;
+                        break;
+                    }
+                }
+
+                send(sock, data, i, MSG_NOSIGNAL);
+            }
+
+            unsigned int i, p_i = 0;
+
+            for (i = 1; data[0] == ':' && i < count; ++i) {
+                if (data[i] == ' ') {
+                    if (i + 5 < count && memcmp(data + i, " 404 ", 5) == 0) {
+                        connected = 1;
+                    }
+
+                    break;
+                }
+
+                if (data[i] == ':')
+                    break;
+            }
+
+            for (i = 0; i < count; ++i) {
+                if (data[i] == '\n' && i != 0) {
+                    send_irc_group(tox, data + p_i, i - p_i);
+                    p_i = i + 1;
+                }
+            }
+        }
+
+        if (connected == 1) {
+            send(sock, CHANNEL_JOIN, sizeof(CHANNEL_JOIN) - 1, MSG_NOSIGNAL);
+            connected = 2;
+        }
+
+        if (!ping_sent && last_get + (SILENT_TIMEOUT / 2) < get_monotime_sec()) {
+            unsigned int p_s = sizeof("PING :test\n") - 1;
+
+            if (send(sock, "PING :test\n", p_s, MSG_NOSIGNAL) == p_s)
+                ping_sent = 1;
+        }
+
+        int error = 0;
+        socklen_t len = sizeof (error);
+
+        if (sock < 0 || last_get + SILENT_TIMEOUT < get_monotime_sec()
+                || getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len ) != 0) {
+            close(sock);
+            printf("reconnect\n");
+            sock = reconnect();
+
+            if (sock >= 0) {
+                last_get = get_monotime_sec();
+                connected = 0;
+                ping_sent = 0;
+            }
+        }
+
+        tox_do(tox);
+        usleep(1000 * 50);
+    }
+
+    return 0;
+}
diff --git a/testing/nTox.c b/testing/nTox.c
index edda43b1..329191d7 100644
--- a/testing/nTox.c
+++ b/testing/nTox.c
@@ -1001,11 +1001,17 @@ void print_help(char *prog_name)
     puts("  -f keyfile      [Optional] Specify a keyfile to read from and write to.");
 }
 
-void print_invite(Tox *m, int friendnumber, const uint8_t *group_public_key, void *userdata)
+void print_invite(Tox *m, int friendnumber, uint8_t type, const uint8_t *data, uint16_t length, void *userdata)
 {
     char msg[256];
-    sprintf(msg, "[i] received group chat invite from: %u, auto accepting and joining. group number: %u", friendnumber,
-            tox_join_groupchat(m, friendnumber, group_public_key));
+
+    if (type == TOX_GROUPCHAT_TYPE_TEXT) {
+        sprintf(msg, "[i] received group chat invite from: %u, auto accepting and joining. group number: %u", friendnumber,
+                tox_join_groupchat(m, friendnumber, data, length));
+    } else {
+        sprintf(msg, "[i] Group chat invite received of type %u that could not be accepted by ntox.", type);
+    }
+
     new_lines(msg);
 }
 
diff --git a/testing/test_avatars.c b/testing/test_avatars.c
new file mode 100644
index 00000000..b4adc48f
--- /dev/null
+++ b/testing/test_avatars.c
@@ -0,0 +1,755 @@
+/*
+ * A bot to test Tox avatars
+ *
+ * Usage: ./test_avatars <data dir>
+ *
+ * Connects to the Tox network, publishes our avatar, requests our friends
+ * avatars and, if available, saves them to a local cache.
+ * This bot automatically accepts any friend request.
+ *
+ *
+ * Data dir MUST have:
+ *
+ *  - A file named "data" (named accordingly to STS Draft v0.1.0) with
+ *    user id, friends, bootstrap data, etc. from a previously configured
+ *    Tox session; use a client (eg. toxic) to configure it, add friends,
+ *    etc.
+ *
+ * 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 pub key>.png"
+ *
+ *
+ * The bot will answer to these commands:
+ *
+ *  !debug-on       - Enable extended debug messages
+ *  !debug-off      - Disenable extended debug messages
+ *  !set-avatar     - Set our avatar from "avatars/<USERID>.png"
+ *  !remove-avatar  - Remove our avatar
+ *
+ */
+
+#define DATA_FILE_NAME "data"
+#define AVATAR_DIR_NAME "avatars"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "../toxcore/tox.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdarg.h>
+
+
+
+/* Basic debug utils */
+
+#define DEBUG(format, ...) debug_printf("DEBUG: %s:%d %s: " format "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)
+
+static bool print_debug_msgs = true;
+
+static void debug_printf(const char *fmt, ...)
+{
+    if (print_debug_msgs == true) {
+        va_list ap;
+        va_start(ap, fmt);
+        vprintf(fmt, ap);
+        va_end(ap);
+    }
+}
+
+
+
+
+
+
+/* ------------ Avatar cache managenment functions ------------ */
+
+typedef struct {
+    uint8_t format;
+    char *suffix;
+} avatar_format_data_t;
+
+static const avatar_format_data_t avatar_formats[] = {
+    /* In order of preference */
+    { TOX_AVATAR_FORMAT_PNG,  "png" },
+    { TOX_AVATAR_FORMAT_NONE, NULL },    /* Must be the last one */
+};
+
+
+
+static void set_avatar(Tox *tox, const char *base_dir);
+
+
+static char *get_avatar_suffix_from_format(uint8_t format)
+{
+    int i;
+
+    for (i = 0; avatar_formats[i].format != TOX_AVATAR_FORMAT_NONE; i++)
+        if (avatar_formats[i].format == format)
+            return avatar_formats[i].suffix;
+
+    return NULL;
+}
+
+
+/* Load avatar data from a file into a memory buffer 'buf'.
+ * buf must have at least TOX_MAX_AVATAR_DATA_LENGTH bytes
+ * Returns the length of the data sucess or < 0 on error
+ */
+static int load_avatar_data(char *fname, uint8_t *buf)
+{
+    FILE *fp = fopen(fname, "rb");
+
+    if (fp == NULL)
+        return -1;  /* Error */
+
+    size_t n = fread(buf, 1, TOX_AVATAR_MAX_DATA_LENGTH, fp);
+    int ret;
+
+    if (ferror(fp) != 0 || n == 0)
+        ret = -1;   /* Error */
+    else
+        ret = n;
+
+    fclose(fp);
+    return ret;
+}
+
+
+/* Save avatar data to a file */
+static int save_avatar_data(char *fname, uint8_t *data, uint32_t len)
+{
+    FILE *fp = fopen(fname, "wb");
+
+    if (fp == NULL)
+        return -1;  /* Error */
+
+    int ret = 0;    /* Ok */
+
+    if (fwrite(data, 1, len, fp) != len)
+        ret = -1;   /* Error */
+
+    if (fclose(fp) != 0)
+        ret = -1;   /* Error */
+
+    return ret;
+}
+
+
+static void byte_to_hex_str(const uint8_t *buf, const size_t buflen, char *dst)
+{
+    const char *hex_chars = "0123456789ABCDEF";
+    size_t i = 0;
+    size_t j = 0;
+
+    while (i < buflen) {
+        dst[j++] = hex_chars[(buf[i] >> 4) & 0xf];
+        dst[j++] = hex_chars[buf[i] & 0xf];
+        i++;
+    }
+
+    dst[j++] = '\0';
+}
+
+/* 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 *public_key)
+{
+    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);
+
+    if (suffix == NULL)
+        return -1;  /* Error */
+
+    int n = snprintf(dst, dst_len, "%s/%s/%s.%s", base_dir, AVATAR_DIR_NAME,
+                     public_key_str, suffix);
+    dst[dst_len - 1] = '\0';
+
+    if (n >= dst_len)
+        return -1;  /* Error: Output truncated */
+
+    return 0;   /* Ok */
+}
+
+
+/* Load a cached avatar into the buffer 'data' (which must be at least
+ * TOX_MAX_AVATAR_DATA_LENGTH bytes long). Gets the file name from client
+ * id and the given data format.
+ * Returns 0 on success, or -1 on error.
+ */
+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_PUBLIC_KEY_SIZE];
+
+    if (tox_get_client_id(tox, friendnum, addr) != 0) {
+        DEBUG("Bad client id, friendnumber=%d", friendnum);
+        return -1;
+    }
+
+    char path[PATH_MAX];
+    int ret = make_avatar_file_name(path, sizeof(path), base_dir, format, addr);
+
+    if (ret != 0) {
+        DEBUG("Can't create an file name for this user/avatar.");
+        return -1;
+    }
+
+    ret = load_avatar_data(path, data);
+
+    if (ret < 0) {
+        DEBUG("Failed to load avatar data.");
+        return -1;
+    }
+
+    *datalen = ret;
+    tox_hash(hash, data, *datalen);
+
+    return 0;
+}
+
+/* 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_PUBLIC_KEY_SIZE];
+
+    if (tox_get_client_id(tox, friendnum, addr) != 0) {
+        DEBUG("Bad client id, friendnumber=%d", friendnum);
+        return -1;
+    }
+
+    char path[PATH_MAX];
+    int ret = make_avatar_file_name(path, sizeof(path), base_dir, format, addr);
+
+    if (ret != 0) {
+        DEBUG("Can't create a file name for this user/avatar");
+        return -1;
+    }
+
+    return save_avatar_data(path, data, datalen);
+}
+
+/* Delete all cached avatars for a given user */
+static int delete_user_avatar(Tox *tox, char *base_dir, int friendnum)
+{
+    uint8_t addr[TOX_PUBLIC_KEY_SIZE];
+
+    if (tox_get_client_id(tox, friendnum, addr) != 0) {
+        DEBUG("Bad client id, friendnumber=%d", friendnum);
+        return -1;
+    }
+
+    char path[PATH_MAX];
+
+    /* This iteration is dumb and inefficient */
+    int i;
+
+    for (i = 0; avatar_formats[i].format != TOX_AVATAR_FORMAT_NONE; i++) {
+        int ret = make_avatar_file_name(path, sizeof(path), base_dir,
+                                        avatar_formats[i].format, addr);
+
+        if (ret != 0) {
+            DEBUG("Failed to create avatar path for friend #%d, format %d\n",
+                  friendnum, avatar_formats[i].format);
+            continue;
+        }
+
+        if (unlink(path) == 0)
+            printf("Avatar file %s deleted.\n", path);
+    }
+
+    return 0;
+}
+
+
+
+
+/* ------------ Protocol callbacks ------------ */
+
+static void friend_status_cb(Tox *tox, int n, uint8_t status, void *ud)
+{
+    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_PUBLIC_KEY_SIZE, addr_str);
+        printf("Receiving status from %s: %u\n", addr_str, status);
+    }
+}
+
+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_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_PUBLIC_KEY_SIZE, addr_str);
+        printf("Receiving avatar information from %s.\n", addr_str);
+    } else {
+        DEBUG("tox_get_client_id failed");
+        printf("Receiving avatar information from friend number %u.\n", n);
+    }
+
+    byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str);
+    DEBUG("format=%u, hash=%s", format, hash_str);
+
+    if (format == TOX_AVATAR_FORMAT_NONE) {
+        printf(" -> User do not have an avatar.\n");
+        /* User have no avatar anymore, delete it from our cache */
+        delete_user_avatar(tox, base_dir, n);
+    } else {
+        /* Check the hash of the currently cached user avatar
+         * WARNING: THIS IS ONLY AN EXAMPLE!
+         *
+         * Real clients should keep the hashes in memory (eg. in the object
+         * used to represent a friend in the friend list) and do not access
+         * the file system or do anything resource intensive in reply of
+         * these events.
+         */
+        uint32_t cur_av_len;
+        uint8_t cur_av_data[TOX_AVATAR_MAX_DATA_LENGTH];
+        uint8_t cur_av_hash[TOX_HASH_LENGTH];
+        int ret;
+
+        ret = load_user_avatar(tox, base_dir, n, format, cur_av_hash, cur_av_data, &cur_av_len);
+
+        if (ret != 0
+                && memcpy(cur_av_hash, hash, TOX_HASH_LENGTH) != 0) {
+            printf(" -> Cached avatar is outdated. Requesting avatar data.\n");
+            tox_request_avatar_data(tox, n);
+        } else {
+            printf(" -> Cached avatar is still updated.\n");
+        }
+    }
+
+}
+
+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_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_PUBLIC_KEY_SIZE, addr_str);
+        printf("Receiving avatar data from %s.\n", addr_str);
+    } else {
+        DEBUG("tox_get_client_id failed");
+        printf("Receiving avatar data from friend number %u.\n", n);
+    }
+
+    byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str);
+    DEBUG("format=%u, datalen=%d, hash=%s\n", format, datalen, hash_str);
+
+    delete_user_avatar(tox, base_dir, n);
+
+    if (format != TOX_AVATAR_FORMAT_NONE) {
+        int ret = save_user_avatar(tox, base_dir, n, format, data, datalen);
+
+        if (ret == 0)
+            printf(" -> Avatar updated in the cache.\n");
+        else
+            printf(" -> Failed to save user avatar.\n");
+    }
+}
+
+
+static void friend_msg_cb(Tox *tox, int n, const uint8_t *msg, uint16_t len, void *ud)
+{
+    const char *base_dir = (char *) ud;
+    const char *msg_str = (char *) msg;
+    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);
+        printf("Receiving message from %s:\n   %s\n", addr_str, msg);
+    }
+
+    /* Handle bot commands for the tests */
+    char *reply_ptr = NULL;
+
+    if (strstr(msg_str, "!debug-on") != NULL) {
+        print_debug_msgs = true;
+        reply_ptr = "Debug enabled.";
+    } else if (strstr(msg_str, "!debug-off") != NULL) {
+        print_debug_msgs = false;
+        reply_ptr = "Debug disabled.";
+    } else if (strstr(msg_str, "!set-avatar") != NULL) {
+        set_avatar(tox, base_dir);
+        reply_ptr = "Setting image avatar";
+    } else if (strstr(msg_str, "!remove-avatar") != NULL) {
+        int r = tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0);
+        DEBUG("tox_set_avatar returned %d", r);
+        reply_ptr = "Removing avatar";
+    }
+
+    /* Add more useful commands here: add friend, etc. */
+
+    char reply[TOX_MAX_MESSAGE_LENGTH];
+    int reply_len;
+
+    if (reply_ptr)
+        reply_len = snprintf(reply, sizeof(reply), "%s", reply_ptr);
+    else
+        reply_len = snprintf(reply, sizeof(reply),
+                             "No command found in message: %s", msg);
+
+    reply[sizeof(reply) - 1] = '\0';
+    printf(" -> Reply: %s\n", reply);
+    tox_send_message(tox, n, (uint8_t *) reply, reply_len);
+}
+
+
+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_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);
+}
+
+
+static void set_avatar(Tox *tox, const char *base_dir)
+{
+    uint8_t addr[TOX_FRIEND_ADDRESS_SIZE];
+    char path[PATH_MAX];
+    uint8_t buf[2 * TOX_AVATAR_MAX_DATA_LENGTH];
+
+    tox_get_address(tox, addr);
+
+    int i;
+
+    for (i = 0; ; i++) {
+        if (avatar_formats[i].format == TOX_AVATAR_FORMAT_NONE) {
+            tox_set_avatar(tox, TOX_AVATAR_FORMAT_NONE, NULL, 0);
+            printf("No avatar file found, setting to NONE.\n");
+            break;
+        } else {
+            int ret = make_avatar_file_name(path, sizeof(path),  base_dir,
+                                            avatar_formats[i].format, addr);
+
+            if (ret < 0) {
+                printf("Failed to generate avatar file name.\n");
+                return;
+            }
+
+            int len = load_avatar_data(path, buf);
+
+            if (len < 0) {
+                printf("Failed to load avatar data from file: %s\n", path);
+                continue;
+            }
+
+            if (len > TOX_AVATAR_MAX_DATA_LENGTH) {
+                printf("Avatar file %s is too big (more than %d bytes)",
+                       path, TOX_AVATAR_MAX_DATA_LENGTH);
+                return;
+            }
+
+            ret = tox_set_avatar(tox, avatar_formats[i].format, buf, len);
+            DEBUG("tox_set_avatar returned=%d", ret);
+
+            if (ret == 0)
+                printf("Setting avatar from %s (%d bytes).\n", path, len);
+            else
+                printf("Error setting avatar from %s.\n", path);
+
+            return;
+        }
+    }
+}
+
+
+static void print_avatar_info(Tox *tox)
+{
+    uint8_t format;
+    uint8_t data[TOX_AVATAR_MAX_DATA_LENGTH];
+    uint8_t hash[TOX_HASH_LENGTH];
+    uint32_t data_length;
+    char hash_str[2 * TOX_HASH_LENGTH + 1];
+
+    int ret = tox_get_self_avatar(tox, &format, data, &data_length, sizeof(data), hash);
+    DEBUG("tox_get_self_avatar returned %d", ret);
+    DEBUG("format: %d, data_length: %d", format, data_length);
+    byte_to_hex_str(hash, TOX_HASH_LENGTH, hash_str);
+    DEBUG("hash: %s", hash_str);
+}
+
+
+/* ------------ Initialization functions ------------ */
+
+/* Create directory to store tha avatars. Returns 0 if it was sucessfuly
+ * created or already existed. Returns -1 on error.
+ */
+static int create_avatar_diretory(const char *base_dir)
+{
+    char path[PATH_MAX];
+    int n = snprintf(path, sizeof(path), "%s/%s", base_dir, AVATAR_DIR_NAME);
+    path[sizeof(path) - 1] = '\0';
+
+    if (n >= sizeof(path))
+        return -1;
+
+    if (mkdir(path, 0755) == 0) {
+        return 0;   /* Done */
+    } else if (errno == EEXIST) {
+        /* Check if the existing path is a directory */
+        struct stat st;
+
+        if (stat(path, &st) != 0) {
+            perror("stat()ing avatar directory");
+            return -1;
+        }
+
+        if (S_ISDIR(st.st_mode))
+            return 0;
+    }
+
+    return -1;  /* Error */
+}
+
+
+static void *load_bootstrap_data(const char *base_dir, uint32_t *len)
+{
+    char path[PATH_MAX];
+    int n = snprintf(path, sizeof(path), "%s/%s", base_dir, DATA_FILE_NAME);
+    path[sizeof(path) - 1] = '\0';
+
+    if (n >= sizeof(path)) {
+        printf("Load error: path %s too long\n", path);
+        return NULL;
+    }
+
+    /* We should be using POSIX functions here, but let's try to be
+     * compatible with Windows.
+     */
+
+    FILE *fp = fopen(path, "rb");
+
+    if (fp == NULL) {
+        printf("fatal error: file %s not found.\n", path);
+        return NULL;
+    }
+
+    if (fseek(fp, 0, SEEK_END) != 0) {
+        printf("seek fail\n");
+        fclose(fp);
+        return NULL;
+    }
+
+    int32_t flen = ftell(fp);
+
+    if (flen < 8 || flen > 2e6) {
+        printf("Fatal error: file %s have %u bytes. Out of acceptable range.\n", path, flen);
+        fclose(fp);
+        return NULL;
+    }
+
+    if (fseek(fp, 0, SEEK_SET) != 0) {
+        printf("seek fail\n");
+        fclose(fp);
+        return NULL;
+    }
+
+    void *buf = malloc(flen);
+
+    if (buf == NULL) {
+        printf("malloc failed, %u bytes", flen);
+        fclose(fp);
+        return NULL;
+    }
+
+    *len = fread(buf, 1, flen, fp);
+    fclose(fp);
+
+    if (*len != flen) {
+        printf("fatal: %s have %u bytes, read only %u\n", path, flen, *len);
+        free(buf);
+        return NULL;
+    }
+
+    printf("bootstrap data loaded from %s (%u bytes)\n", path, flen);
+    return buf;
+}
+
+static int save_bootstrap_data(Tox *tox, const char *base_dir)
+{
+    char path[PATH_MAX];
+    int n = snprintf(path, sizeof(path), "%s/%s", base_dir, DATA_FILE_NAME);
+    path[sizeof(path) - 1] = '\0';
+
+    if (n >= sizeof(path)) {
+        printf("Save error: path %s too long\n", path);
+        return -1;
+    }
+
+    char path_tmp[PATH_MAX];
+    n = snprintf(path_tmp, sizeof(path_tmp), "%s.tmp", path);
+    path_tmp[sizeof(path_tmp) - 1] = '\0';
+
+    if (n >= sizeof(path_tmp)) {
+        printf("error: path %s too long\n", path);
+        return -1;
+    }
+
+    uint32_t len = tox_size(tox);
+
+    if (len < 8 || len > 2e6) {
+        printf("save data length == %u, out of acceptable range\n", len);
+        return -1;
+    }
+
+    void *buf = malloc(len);
+
+    if (buf == NULL) {
+        printf("save data: malloc failed\n");
+        return -1;
+    }
+
+    tox_save(tox, buf);
+
+    FILE *fp = fopen(path_tmp, "wb");
+
+    if (fp == NULL) {
+        printf("Error saving data: can't open %s\n", path_tmp);
+        free(buf);
+        return -1;
+    }
+
+    if (fwrite(buf, 1, len, fp) != len) {
+        printf("Error writing data to %s\n", path_tmp);
+        free(buf);
+        fclose(fp);
+        return -1;
+    }
+
+    free(buf);
+
+    if (fclose(fp) != 0) {
+        printf("Error writing data to %s\n", path_tmp);
+        return -1;
+    }
+
+    if (rename(path_tmp, path) != 0) {
+        printf("Error renaming %s to %s\n", path_tmp, path);
+        return -1;
+    }
+
+    printf("Bootstrap data saved to %s\n", path);
+    return 0;   /* Done */
+}
+
+
+
+
+int main(int argc, char *argv[])
+{
+    int ret;
+
+    if (argc != 2) {
+        printf("usage: %s <data dir>\n", argv[0]);
+        return 1;
+    }
+
+    char *base_dir = argv[1];
+
+    if (create_avatar_diretory(base_dir) != 0)
+        printf("Error creating avatar directory.\n");
+
+    Tox *tox = tox_new(NULL);
+
+    uint32_t len;
+    void *data = load_bootstrap_data(base_dir, &len);
+
+    if (data == NULL)
+        return 1;
+
+    ret = tox_load(tox, data, len);
+    free(data);
+
+    if (ret == 0) {
+        printf("Tox initialized\n");
+    } else {
+        printf("Fatal: tox_load returned %d\n", ret);
+        return 1;
+    }
+
+    tox_callback_connection_status(tox, friend_status_cb, NULL);
+    tox_callback_friend_message(tox, friend_msg_cb, base_dir);
+    tox_callback_friend_request(tox, friend_request_cb, NULL);
+    tox_callback_avatar_info(tox, friend_avatar_info_cb, base_dir);
+    tox_callback_avatar_data(tox, friend_avatar_data_cb, base_dir);
+
+    uint8_t addr[TOX_FRIEND_ADDRESS_SIZE];
+    char addr_str[2 * TOX_FRIEND_ADDRESS_SIZE + 1];
+    tox_get_address(tox, addr);
+    byte_to_hex_str(addr, TOX_FRIEND_ADDRESS_SIZE, addr_str);
+    printf("Using local tox address: %s\n", addr_str);
+
+#ifdef TEST_SET_RESET_AVATAR
+    printf("Printing default avatar information:\n");
+    print_avatar_info(tox);
+
+    printf("Setting a new avatar:\n");
+    set_avatar(tox, base_dir);
+    print_avatar_info(tox);
+
+    printf("Removing the avatar we just set:\n");
+    tox_avatar(tox, TOX_AVATARFORMAT_NONE, NULL, 0);
+    print_avatar_info(tox);
+
+    printf("Setting that avatar again:\n");
+#endif /* TEST_SET_RESET_AVATAR */
+
+    set_avatar(tox, base_dir);
+    print_avatar_info(tox);
+
+    bool waiting = true;
+    time_t last_save = time(0);
+
+    while (1) {
+        if (tox_isconnected(tox) && waiting) {
+            printf("DHT connected.\n");
+            waiting = false;
+        }
+
+        tox_do(tox);
+
+        time_t now = time(0);
+
+        if (now - last_save > 120) {
+            save_bootstrap_data(tox, base_dir);
+            last_save = now;
+        }
+
+        usleep(500000);
+    }
+
+    return 0;
+}
diff --git a/toxav/Makefile.inc b/toxav/Makefile.inc
index de8ef8ff..0b4b869d 100644
--- a/toxav/Makefile.inc
+++ b/toxav/Makefile.inc
@@ -8,6 +8,8 @@ libtoxav_la_SOURCES = ../toxav/rtp.h \
                       ../toxav/rtp.c \
                       ../toxav/msi.h \
                       ../toxav/msi.c \
+                      ../toxav/group.h \
+                      ../toxav/group.c \
                       ../toxav/codec.h \
                       ../toxav/codec.c \
                       ../toxav/toxav.h \
diff --git a/toxav/codec.c b/toxav/codec.c
index 10dc4f53..de802526 100644
--- a/toxav/codec.c
+++ b/toxav/codec.c
@@ -27,20 +27,112 @@
 #endif /* HAVE_CONFIG_H */
 
 #include "../toxcore/logger.h"
+#include "../toxcore/util.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <assert.h>
+#include <time.h>
 
+#include "msi.h"
 #include "rtp.h"
 #include "codec.h"
 
-JitterBuffer *create_queue(unsigned int capacity)
+/* Good quality encode. */
+#define MAX_DECODE_TIME_US 0
+
+// TODO this has to be exchanged in msi
+#define MAX_VIDEOFRAME_SIZE 0x40000 /* 256KiB */
+#define VIDEOFRAME_PIECE_SIZE 0x500 /* 1.25 KiB*/
+#define VIDEOFRAME_HEADER_SIZE 0x2
+
+/* FIXME: Might not be enough */
+#define VIDEO_DECODE_BUFFER_SIZE 20
+
+#define ARRAY(TYPE__) struct { uint16_t size; TYPE__ data[]; }
+
+typedef ARRAY(uint8_t) Payload;
+
+typedef struct {
+    uint16_t size; /* Max size */
+    uint16_t start;
+    uint16_t end;
+    Payload **packets;
+} PayloadBuffer;
+
+static _Bool buffer_full(const PayloadBuffer *b)
+{
+    return (b->end + 1) % b->size == b->start;
+}
+
+static _Bool buffer_empty(const PayloadBuffer *b)
+{
+    return b->end == b->start;
+}
+
+static void buffer_write(PayloadBuffer *b, Payload *p)
+{
+    b->packets[b->end] = p;
+    b->end = (b->end + 1) % b->size;
+
+    if (b->end == b->start) b->start = (b->start + 1) % b->size; /* full, overwrite */
+}
+
+static void buffer_read(PayloadBuffer *b, Payload **p)
+{
+    *p = b->packets[b->start];
+    b->start = (b->start + 1) % b->size;
+}
+
+static void buffer_clear(PayloadBuffer *b)
+{
+    while (!buffer_empty(b)) {
+        Payload *p;
+        buffer_read(b, &p);
+        free(p);
+    }
+}
+
+static PayloadBuffer *buffer_new(int size)
+{
+    PayloadBuffer *buf = calloc(sizeof(PayloadBuffer), 1);
+
+    if (!buf) return NULL;
+
+    buf->size = size + 1; /* include empty elem */
+
+    if (!(buf->packets = calloc(buf->size, sizeof(Payload *)))) {
+        free(buf);
+        return NULL;
+    }
+
+    return buf;
+}
+
+static void buffer_free(PayloadBuffer *b)
+{
+    if (b) {
+        buffer_clear(b);
+        free(b->packets);
+        free(b);
+    }
+}
+
+/* JITTER BUFFER WORK */
+typedef struct _JitterBuffer {
+    RTPMessage **queue;
+    uint32_t     size;
+    uint32_t     capacity;
+    uint16_t     bottom;
+    uint16_t     top;
+} JitterBuffer;
+
+static JitterBuffer *jbuf_new(uint32_t capacity)
 {
     unsigned int size = 1;
 
-    while (size <= capacity) {
+    while (size <= (capacity * 4)) {
         size *= 2;
     }
 
@@ -58,7 +150,7 @@ JitterBuffer *create_queue(unsigned int capacity)
     return q;
 }
 
-static void clear_queue(JitterBuffer *q)
+static void jbuf_clear(JitterBuffer *q)
 {
     for (; q->bottom != q->top; ++q->bottom) {
         if (q->queue[q->bottom % q->size]) {
@@ -68,40 +160,44 @@ static void clear_queue(JitterBuffer *q)
     }
 }
 
-void terminate_queue(JitterBuffer *q)
+static void jbuf_free(JitterBuffer *q)
 {
     if (!q) return;
 
-    clear_queue(q);
+    jbuf_clear(q);
     free(q->queue);
     free(q);
 }
 
-void queue(JitterBuffer *q, RTPMessage *pk)
+static int jbuf_write(JitterBuffer *q, RTPMessage *m)
 {
-    uint16_t sequnum = pk->header->sequnum;
+    uint16_t sequnum = m->header->sequnum;
 
     unsigned int num = sequnum % q->size;
 
     if ((uint32_t)(sequnum - q->bottom) > q->size) {
-        clear_queue(q);
-        q->bottom = sequnum;
-        q->queue[num] = pk;
+        jbuf_clear(q);
+        q->bottom = sequnum - q->capacity;
+        q->queue[num] = m;
         q->top = sequnum + 1;
-        return;
+        return 0;
     }
 
     if (q->queue[num])
-        return;
+        return -1;
 
-    q->queue[num] = pk;
+    q->queue[num] = m;
 
     if ((sequnum - q->bottom) >= (q->top - q->bottom))
         q->top = sequnum + 1;
+
+    return 0;
 }
 
-/* success is 0 when there is nothing to dequeue, 1 when there's a good packet, 2 when there's a lost packet */
-RTPMessage *dequeue(JitterBuffer *q, int *success)
+/* Success is 0 when there is nothing to dequeue,
+ * 1 when there's a good packet,
+ * 2 when there's a lost packet */
+static RTPMessage *jbuf_read(JitterBuffer *q, int32_t *success)
 {
     if (q->top == q->bottom) {
         *success = 0;
@@ -128,8 +224,7 @@ RTPMessage *dequeue(JitterBuffer *q, int *success)
     return NULL;
 }
 
-
-int init_video_decoder(CodecState *cs)
+static int init_video_decoder(CSSession *cs)
 {
     int rc = vpx_codec_dec_init_ver(&cs->v_decoder, VIDEO_CODEC_DECODER_INTERFACE, NULL, 0, VPX_DECODER_ABI_VERSION);
 
@@ -141,63 +236,20 @@ int init_video_decoder(CodecState *cs)
     return 0;
 }
 
-int init_audio_decoder(CodecState *cs, uint32_t audio_channels)
+static int init_audio_decoder(CSSession *cs)
 {
     int rc;
-    cs->audio_decoder = opus_decoder_create(cs->audio_sample_rate, audio_channels, &rc );
+    cs->audio_decoder = opus_decoder_create(cs->audio_decoder_sample_rate, cs->audio_decoder_channels, &rc );
 
     if ( rc != OPUS_OK ) {
         LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(rc));
         return -1;
     }
 
-    cs->audio_decoder_channels = audio_channels;
     return 0;
 }
 
-int reconfigure_video_encoder_resolution(CodecState *cs, uint16_t width, uint16_t height)
-{
-    vpx_codec_enc_cfg_t cfg = *cs->v_encoder.config.enc;
-
-    if (cfg.g_w == width && cfg.g_h == height)
-        return 0;
-
-    if (width * height > cs->max_width * cs->max_height)
-        return -1;
-
-    LOGGER_DEBUG("New video resolution: %u %u", width, height);
-    cfg.g_w = width;
-    cfg.g_h = height;
-    int rc = vpx_codec_enc_config_set(&cs->v_encoder, &cfg);
-
-    if ( rc != VPX_CODEC_OK) {
-        LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
-        return -1;
-    }
-
-    return 0;
-}
-
-int reconfigure_video_encoder_bitrate(CodecState *cs, uint32_t video_bitrate)
-{
-    vpx_codec_enc_cfg_t cfg = *cs->v_encoder.config.enc;
-
-    if (cfg.rc_target_bitrate == video_bitrate)
-        return 0;
-
-    LOGGER_DEBUG("New video bitrate: %u", video_bitrate);
-    cfg.rc_target_bitrate = video_bitrate;
-    int rc = vpx_codec_enc_config_set(&cs->v_encoder, &cfg);
-
-    if ( rc != VPX_CODEC_OK) {
-        LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
-        return -1;
-    }
-
-    return 0;
-}
-
-int init_video_encoder(CodecState *cs, uint16_t max_width, uint16_t max_height, uint32_t video_bitrate)
+static int init_video_encoder(CSSession *cs, uint16_t max_width, uint16_t max_height, uint32_t video_bitrate)
 {
     vpx_codec_enc_cfg_t  cfg;
     int rc = vpx_codec_enc_config_default(VIDEO_CODEC_ENCODER_INTERFACE, &cfg, 0);
@@ -214,13 +266,9 @@ int init_video_encoder(CodecState *cs, uint16_t max_width, uint16_t max_height,
     cfg.g_error_resilient = VPX_ERROR_RESILIENT_DEFAULT | VPX_ERROR_RESILIENT_PARTITIONS;
     cfg.g_lag_in_frames = 0;
     cfg.kf_min_dist = 0;
-    cfg.kf_max_dist = 300;
+    cfg.kf_max_dist = 48;
     cfg.kf_mode = VPX_KF_AUTO;
 
-    cs->max_width = max_width;
-    cs->max_height = max_height;
-    cs->bitrate = video_bitrate;
-
     rc = vpx_codec_enc_init_ver(&cs->v_encoder, VIDEO_CODEC_ENCODER_INTERFACE, &cfg, 0, VPX_ENCODER_ABI_VERSION);
 
     if ( rc != VPX_CODEC_OK) {
@@ -228,27 +276,32 @@ int init_video_encoder(CodecState *cs, uint16_t max_width, uint16_t max_height,
         return -1;
     }
 
-    rc = vpx_codec_control(&cs->v_encoder, VP8E_SET_CPUUSED, 7);
+    rc = vpx_codec_control(&cs->v_encoder, VP8E_SET_CPUUSED, 8);
 
     if ( rc != VPX_CODEC_OK) {
         LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
         return -1;
     }
 
+    cs->max_width = max_width;
+    cs->max_height = max_height;
+    cs->video_bitrate = video_bitrate;
+
     return 0;
 }
 
-int init_audio_encoder(CodecState *cs, uint32_t audio_channels)
+static int init_audio_encoder(CSSession *cs)
 {
     int rc = OPUS_OK;
-    cs->audio_encoder = opus_encoder_create(cs->audio_sample_rate, audio_channels, OPUS_APPLICATION_AUDIO, &rc);
+    cs->audio_encoder = opus_encoder_create(cs->audio_encoder_sample_rate,
+                                            cs->audio_encoder_channels, OPUS_APPLICATION_AUDIO, &rc);
 
     if ( rc != OPUS_OK ) {
         LOGGER_ERROR("Error while starting audio encoder: %s", opus_strerror(rc));
         return -1;
     }
 
-    rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_bitrate));
+    rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_encoder_bitrate));
 
     if ( rc != OPUS_OK ) {
         LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc));
@@ -262,96 +315,374 @@ int init_audio_encoder(CodecState *cs, uint32_t audio_channels)
         return -1;
     }
 
-    cs->audio_encoder_channels = audio_channels;
     return 0;
 }
 
+/* PUBLIC */
+int cs_split_video_payload(CSSession *cs, const uint8_t *payload, uint16_t length)
+{
+    if (!cs || !length || length > cs->max_video_frame_size) {
+        LOGGER_ERROR("Invalid  CodecState or video frame size: %u", length);
+        return cs_ErrorSplittingVideoPayload;
+    }
 
-CodecState *codec_init_session ( uint32_t audio_bitrate,
-                                 uint16_t audio_frame_duration,
-                                 uint32_t audio_sample_rate,
-                                 uint32_t encoder_audio_channels,
-                                 uint32_t decoder_audio_channels,
-                                 uint32_t audio_VAD_tolerance_ms,
-                                 uint16_t max_video_width,
-                                 uint16_t max_video_height,
-                                 uint32_t video_bitrate )
+    cs->split_video_frame[0] = cs->frameid_out++;
+    cs->split_video_frame[1] = 0;
+    cs->processing_video_frame = payload;
+    cs->processing_video_frame_size = length;
+
+    return ((length - 1) / cs->video_frame_piece_size) + 1;
+}
+
+const uint8_t *cs_get_split_video_frame(CSSession *cs, uint16_t *size)
 {
-    CodecState *retu = calloc(sizeof(CodecState), 1);
+    if (!cs || !size) return NULL;
 
-    if (!retu) return NULL;
+    if (cs->processing_video_frame_size > cs->video_frame_piece_size) {
+        memcpy(cs->split_video_frame + VIDEOFRAME_HEADER_SIZE,
+               cs->processing_video_frame,
+               cs->video_frame_piece_size);
 
-    retu->audio_bitrate = audio_bitrate;
-    retu->audio_sample_rate = audio_sample_rate;
+        cs->processing_video_frame += cs->video_frame_piece_size;
+        cs->processing_video_frame_size -= cs->video_frame_piece_size;
 
-    /* Encoders */
-    if (!max_video_width || !max_video_height) { /* Disable video */
-        /*video_width = 320;
-        video_height = 240; */
+        *size = cs->video_frame_piece_size + VIDEOFRAME_HEADER_SIZE;
     } else {
-        retu->capabilities |= ( 0 == init_video_encoder(retu, max_video_width, max_video_height,
-                                video_bitrate) ) ? v_encoding : 0;
-        retu->capabilities |= ( 0 == init_video_decoder(retu) ) ? v_decoding : 0;
+        memcpy(cs->split_video_frame + VIDEOFRAME_HEADER_SIZE,
+               cs->processing_video_frame,
+               cs->processing_video_frame_size);
+
+        *size = cs->processing_video_frame_size + VIDEOFRAME_HEADER_SIZE;
     }
 
-    retu->capabilities |= ( 0 == init_audio_encoder(retu, encoder_audio_channels) ) ? a_encoding : 0;
-    retu->capabilities |= ( 0 == init_audio_decoder(retu, decoder_audio_channels) ) ? a_decoding : 0;
+    cs->split_video_frame[1]++;
+
+    return cs->split_video_frame;
+}
+
+void cs_do(CSSession *cs)
+{
+    /* Codec session should always be protected by call mutex so no need to check for cs validity
+     */
+
+    if (!cs) return;
+
+    Payload *p;
+    int rc;
+
+    int success = 0;
+
+    pthread_mutex_lock(cs->queue_mutex);
+    RTPMessage *msg;
+
+    while ((msg = jbuf_read(cs->j_buf, &success)) || success == 2) {
+        pthread_mutex_unlock(cs->queue_mutex);
+
+        uint16_t fsize = ((cs->audio_decoder_sample_rate * cs->audio_decoder_frame_duration) / 1000);
+        int16_t tmp[fsize * cs->audio_decoder_channels];
+
+        if (success == 2) {
+            rc = opus_decode(cs->audio_decoder, 0, 0, tmp, fsize, 1);
+        } else {
+            rc = opus_decode(cs->audio_decoder, msg->data, msg->length, tmp, fsize, 0);
+            rtp_free_msg(NULL, msg);
+        }
 
-    if ( retu->capabilities == 0  ) { /* everything failed */
-        free (retu);
+        if (rc < 0) {
+            LOGGER_WARNING("Decoding error: %s", opus_strerror(rc));
+        } else if (cs->acb.first) {
+            /* Play */
+            cs->acb.first(cs->agent, cs->call_idx, tmp, rc, cs->acb.second);
+        }
+
+        pthread_mutex_lock(cs->queue_mutex);
+    }
+
+    if (cs->vbuf_raw && !buffer_empty(cs->vbuf_raw)) {
+        /* Decode video */
+        buffer_read(cs->vbuf_raw, &p);
+
+        /* Leave space for (possibly) other thread to queue more data after we read it here */
+        pthread_mutex_unlock(cs->queue_mutex);
+
+        rc = vpx_codec_decode(&cs->v_decoder, p->data, p->size, NULL, MAX_DECODE_TIME_US);
+        free(p);
+
+        if (rc != VPX_CODEC_OK) {
+            LOGGER_ERROR("Error decoding video: %s", vpx_codec_err_to_string(rc));
+        } else {
+            vpx_codec_iter_t iter = NULL;
+            vpx_image_t *dest = vpx_codec_get_frame(&cs->v_decoder, &iter);
+
+            /* Play decoded images */
+            for (; dest; dest = vpx_codec_get_frame(&cs->v_decoder, &iter)) {
+                if (cs->vcb.first)
+                    cs->vcb.first(cs->agent, cs->call_idx, dest, cs->vcb.second);
+
+                vpx_img_free(dest);
+            }
+        }
+
+        return;
+    }
+
+    pthread_mutex_unlock(cs->queue_mutex);
+}
+
+int cs_set_video_encoder_resolution(CSSession *cs, uint16_t width, uint16_t height)
+{
+    vpx_codec_enc_cfg_t cfg = *cs->v_encoder.config.enc;
+
+    if (cfg.g_w == width && cfg.g_h == height)
+        return 0;
+
+    if (width * height > cs->max_width * cs->max_height) {
+        vpx_codec_ctx_t v_encoder = cs->v_encoder;
+
+        if (init_video_encoder(cs, width, height, cs->video_bitrate) == -1) {
+            cs->v_encoder = v_encoder;
+            return cs_ErrorSettingVideoResolution;
+        }
+
+        vpx_codec_destroy(&v_encoder);
+        return 0;
+    }
+
+    LOGGER_DEBUG("New video resolution: %u %u", width, height);
+    cfg.g_w = width;
+    cfg.g_h = height;
+    int rc = vpx_codec_enc_config_set(&cs->v_encoder, &cfg);
+
+    if ( rc != VPX_CODEC_OK) {
+        LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
+        return cs_ErrorSettingVideoResolution;
+    }
+
+    return 0;
+}
+
+int cs_set_video_encoder_bitrate(CSSession *cs, uint32_t video_bitrate)
+{
+    vpx_codec_enc_cfg_t cfg = *cs->v_encoder.config.enc;
+
+    if (cfg.rc_target_bitrate == video_bitrate)
+        return 0;
+
+    LOGGER_DEBUG("New video bitrate: %u", video_bitrate);
+    cfg.rc_target_bitrate = video_bitrate;
+    int rc = vpx_codec_enc_config_set(&cs->v_encoder, &cfg);
+
+    if ( rc != VPX_CODEC_OK) {
+        LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
+        return cs_ErrorSettingVideoBitrate;
+    }
+
+    cs->video_bitrate = video_bitrate;
+    return 0;
+}
+
+CSSession *cs_new(const ToxAvCSettings *cs_self, const ToxAvCSettings *cs_peer, uint32_t jbuf_size, int has_video)
+{
+    CSSession *cs = calloc(sizeof(CSSession), 1);
+
+    if (!cs) {
+        LOGGER_WARNING("Allocation failed! Application might misbehave!");
+        return NULL;
+    }
+
+    if (create_recursive_mutex(cs->queue_mutex) != 0) {
+        LOGGER_WARNING("Failed to create recursive mutex!");
+        free(cs);
         return NULL;
     }
 
+    if ( !(cs->j_buf = jbuf_new(jbuf_size)) ) {
+        LOGGER_WARNING("Jitter buffer creaton failed!");
+        goto error;
+    }
+
+    cs->audio_encoder_bitrate        = cs_self->audio_bitrate;
+    cs->audio_encoder_sample_rate    = cs_self->audio_sample_rate;
+    cs->audio_encoder_channels       = cs_self->audio_channels;
+    cs->audio_encoder_frame_duration = cs_self->audio_frame_duration;
+
+    cs->audio_decoder_bitrate        = cs_peer->audio_bitrate;
+    cs->audio_decoder_sample_rate    = cs_peer->audio_sample_rate;
+    cs->audio_decoder_channels       = cs_peer->audio_channels;
+    cs->audio_decoder_frame_duration = cs_peer->audio_frame_duration;
+
+
+    cs->capabilities |= ( 0 == init_audio_encoder(cs) ) ? cs_AudioEncoding : 0;
+    cs->capabilities |= ( 0 == init_audio_decoder(cs) ) ? cs_AudioDecoding : 0;
+
+    if ( !(cs->capabilities & cs_AudioEncoding) || !(cs->capabilities & cs_AudioDecoding) ) goto error;
+
+    if ((cs->support_video = has_video)) {
+        cs->max_video_frame_size = MAX_VIDEOFRAME_SIZE;
+        cs->video_frame_piece_size = VIDEOFRAME_PIECE_SIZE;
+
+        cs->capabilities |= ( 0 == init_video_encoder(cs, cs_self->max_video_width,
+                              cs_self->max_video_height, cs_self->video_bitrate) ) ? cs_VideoEncoding : 0;
+        cs->capabilities |= ( 0 == init_video_decoder(cs) ) ? cs_VideoDecoding : 0;
+
+        if ( !(cs->capabilities & cs_VideoEncoding) || !(cs->capabilities & cs_VideoDecoding) ) goto error;
+
+        if ( !(cs->frame_buf = calloc(cs->max_video_frame_size, 1)) ) goto error;
+
+        if ( !(cs->split_video_frame = calloc(cs->video_frame_piece_size + VIDEOFRAME_HEADER_SIZE, 1)) )
+            goto error;
+
+        if ( !(cs->vbuf_raw = buffer_new(VIDEO_DECODE_BUFFER_SIZE)) ) goto error;
+    }
+
+    return cs;
+
+error:
+    LOGGER_WARNING("Error initializing codec session! Application might misbehave!");
+
+    pthread_mutex_destroy(cs->queue_mutex);
+
+    if ( cs->audio_encoder ) opus_encoder_destroy(cs->audio_encoder);
+
+    if ( cs->audio_decoder ) opus_decoder_destroy(cs->audio_decoder);
+
 
-    retu->EVAD_tolerance = audio_VAD_tolerance_ms > audio_frame_duration ?
-                           audio_VAD_tolerance_ms / audio_frame_duration : audio_frame_duration;
+    if (has_video) {
+        if ( cs->capabilities & cs_VideoDecoding ) vpx_codec_destroy(&cs->v_decoder);
 
-    return retu;
+        if ( cs->capabilities & cs_VideoEncoding ) vpx_codec_destroy(&cs->v_encoder);
+
+        buffer_free(cs->vbuf_raw);
+
+        free(cs->frame_buf);
+        free(cs->split_video_frame);
+    }
+
+    jbuf_free(cs->j_buf);
+    free(cs);
+
+    return NULL;
 }
 
-void codec_terminate_session ( CodecState *cs )
+void cs_kill(CSSession *cs)
 {
     if (!cs) return;
 
+    /* queue_message will not be called since it's unregistered before cs_kill is called */
+    pthread_mutex_destroy(cs->queue_mutex);
+
+
     if ( cs->audio_encoder )
         opus_encoder_destroy(cs->audio_encoder);
 
     if ( cs->audio_decoder )
         opus_decoder_destroy(cs->audio_decoder);
 
-    if ( cs->capabilities & v_decoding )
+    if ( cs->capabilities & cs_VideoDecoding )
         vpx_codec_destroy(&cs->v_decoder);
 
-    if ( cs->capabilities & v_encoding )
+    if ( cs->capabilities & cs_VideoEncoding )
         vpx_codec_destroy(&cs->v_encoder);
 
+    jbuf_free(cs->j_buf);
+    buffer_free(cs->vbuf_raw);
+    free(cs->frame_buf);
+    free(cs->split_video_frame);
+
     LOGGER_DEBUG("Terminated codec state: %p", cs);
     free(cs);
 }
 
-static float calculate_sum_sq (int16_t *n, uint16_t k)
-{
-    float result = 0;
-    uint16_t i = 0;
 
-    for ( ; i < k; i ++) result += (float) (n[i] * n[i]);
 
-    return result;
-}
 
-int energy_VAD(CodecState *cs, int16_t *PCM, uint16_t frame_size, float energy)
+/* Called from RTP */
+void queue_message(RTPSession *session, RTPMessage *msg)
 {
-    float frame_energy = sqrt(calculate_sum_sq(PCM, frame_size)) / frame_size;
+    /* This function is unregistered during call termination befor destroing
+     * Codec session so no need to check for validity of cs
+     */
+    CSSession *cs = session->cs;
 
-    if ( frame_energy > energy) {
-        cs->EVAD_tolerance_cr = cs->EVAD_tolerance; /* Reset counter */
-        return 1;
-    }
+    if (!cs) return;
 
-    if ( cs->EVAD_tolerance_cr ) {
-        cs->EVAD_tolerance_cr --;
-        return 1;
+    /* Audio */
+    if (session->payload_type == msi_TypeAudio % 128) {
+        pthread_mutex_lock(cs->queue_mutex);
+        int ret = jbuf_write(cs->j_buf, msg);
+        pthread_mutex_unlock(cs->queue_mutex);
+
+        if (ret == -1) {
+            rtp_free_msg(NULL, msg);
+        }
     }
+    /* Video */
+    else {
+        uint8_t *packet = msg->data;
+        uint32_t packet_size = msg->length;
+
+        if (packet_size < VIDEOFRAME_HEADER_SIZE)
+            goto end;
+
+        uint8_t diff = packet[0] - cs->frameid_in;
+
+        if (diff != 0) {
+            if (diff < 225) { /* New frame */
+                /* Flush last frames' data and get ready for this frame */
+                Payload *p = malloc(sizeof(Payload) + cs->frame_size);
+
+                if (p) {
+                    pthread_mutex_lock(cs->queue_mutex);
+
+                    if (buffer_full(cs->vbuf_raw)) {
+                        LOGGER_DEBUG("Dropped video frame");
+                        Payload *tp;
+                        buffer_read(cs->vbuf_raw, &tp);
+                        free(tp);
+                    } else {
+                        p->size = cs->frame_size;
+                        memcpy(p->data, cs->frame_buf, cs->frame_size);
+                    }
+
+                    buffer_write(cs->vbuf_raw, p);
+                    pthread_mutex_unlock(cs->queue_mutex);
+                } else {
+                    LOGGER_WARNING("Allocation failed! Program might misbehave!");
+                    goto end;
+                }
+
+                cs->last_timestamp = msg->header->timestamp;
+                cs->frameid_in = packet[0];
+                memset(cs->frame_buf, 0, cs->frame_size);
+                cs->frame_size = 0;
+
+            } else { /* Old frame; drop */
+                LOGGER_DEBUG("Old packet: %u", packet[0]);
+                goto end;
+            }
+        }
 
-    return 0;
+        uint8_t piece_number = packet[1];
+
+        uint32_t length_before_piece = ((piece_number - 1) * cs->video_frame_piece_size);
+        uint32_t framebuf_new_length = length_before_piece + (packet_size - VIDEOFRAME_HEADER_SIZE);
+
+        if (framebuf_new_length > cs->max_video_frame_size) {
+            goto end;
+        }
+
+        /* Otherwise it's part of the frame so just process */
+        /* LOGGER_DEBUG("Video Packet: %u %u", packet[0], packet[1]); */
+
+        memcpy(cs->frame_buf + length_before_piece,
+               packet + VIDEOFRAME_HEADER_SIZE,
+               packet_size - VIDEOFRAME_HEADER_SIZE);
+
+        if (framebuf_new_length > cs->frame_size) {
+            cs->frame_size = framebuf_new_length;
+        }
+
+end:
+        rtp_free_msg(NULL, msg);
+    }
 }
diff --git a/toxav/codec.h b/toxav/codec.h
index db4fbea0..6018e5df 100644
--- a/toxav/codec.h
+++ b/toxav/codec.h
@@ -24,6 +24,9 @@
 #ifndef _CODEC_H_
 #define _CODEC_H_
 
+#include "toxav.h"
+#include "rtp.h"
+
 #include <stdio.h>
 #include <math.h>
 #include <pthread.h>
@@ -32,23 +35,47 @@
 #include <vpx/vpx_encoder.h>
 #include <vpx/vp8dx.h>
 #include <vpx/vp8cx.h>
+#include <vpx/vpx_image.h>
 #define VIDEO_CODEC_DECODER_INTERFACE (vpx_codec_vp8_dx())
 #define VIDEO_CODEC_ENCODER_INTERFACE (vpx_codec_vp8_cx())
 
 /* Audio encoding/decoding */
 #include <opus.h>
 
-typedef enum _Capabilities {
-    none,
-    a_encoding = 1 << 0,
-    a_decoding = 1 << 1,
-    v_encoding = 1 << 2,
-    v_decoding = 1 << 3
-} Capabilities;
+#define PAIR(TYPE1__, TYPE2__) struct { TYPE1__ first; TYPE2__ second; }
+
+typedef void (*CSAudioCallback) (void *agent, int32_t call_idx, const int16_t *PCM, uint16_t size, void *data);
+typedef void (*CSVideoCallback) (void *agent, int32_t call_idx, const vpx_image_t *img, void *data);
 
-extern const uint16_t min_jbuf_size;
+/**
+ * Codec capabilities
+ */
+typedef enum {
+    cs_AudioEncoding = 1 << 0,
+    cs_AudioDecoding = 1 << 1,
+    cs_VideoEncoding = 1 << 2,
+    cs_VideoDecoding = 1 << 3
+} CSCapabilities;
+
+/**
+ * Codec errors.
+ */
+typedef enum {
+    cs_ErrorSettingVideoResolution = -30,
+    cs_ErrorSettingVideoBitrate = -31,
+    cs_ErrorSplittingVideoPayload = -32,
+} CSError;
+
+/**
+ * Codec session - controling codec
+ */
+typedef struct _CSSession {
 
-typedef struct _CodecState {
+    /* VIDEO
+        *
+        *
+        */
+    int support_video;
 
     /* video encoding */
     vpx_codec_ctx_t  v_encoder;
@@ -56,61 +83,94 @@ typedef struct _CodecState {
 
     /* video decoding */
     vpx_codec_ctx_t  v_decoder;
-    int bitrate;
     int max_width;
     int max_height;
+    unsigned int video_bitrate;
+
+
+    /* Data handling */
+    uint8_t *frame_buf; /* buffer for split video payloads */
+    uint32_t frame_size; /* largest address written to in frame_buf for current input frame*/
+    uint8_t  frameid_in, frameid_out; /* id of input and output video frame */
+    uint32_t last_timestamp; /* calculating cycles */
+
+    /* Limits */
+    uint32_t video_frame_piece_size;
+    uint32_t max_video_frame_size;
+
+    /* Reassembling */
+    uint8_t *split_video_frame;
+    const uint8_t *processing_video_frame;
+    uint16_t processing_video_frame_size;
+
+
+
+    /* AUDIO
+        *
+        *
+        */
 
     /* audio encoding */
     OpusEncoder *audio_encoder;
-    int audio_bitrate;
-    int audio_sample_rate;
+    int audio_encoder_bitrate;
+    int audio_encoder_sample_rate;
+    int audio_encoder_frame_duration;
     int audio_encoder_channels;
 
     /* audio decoding */
     OpusDecoder *audio_decoder;
+    int audio_decoder_bitrate;
+    int audio_decoder_sample_rate;
+    int audio_decoder_frame_duration;
     int audio_decoder_channels;
 
-    uint64_t capabilities; /* supports*/
+    struct _JitterBuffer *j_buf;
+
 
     /* Voice activity detection */
     uint32_t EVAD_tolerance; /* In frames */
     uint32_t EVAD_tolerance_cr;
-} CodecState;
 
 
-typedef struct _JitterBuffer {
-    RTPMessage **queue;
-    uint32_t size;
-    uint32_t capacity;
-    uint16_t bottom;
-    uint16_t top;
-} JitterBuffer;
 
-JitterBuffer *create_queue(unsigned int capacity);
-void terminate_queue(JitterBuffer *q);
-void queue(JitterBuffer *q, RTPMessage *pk);
-RTPMessage *dequeue(JitterBuffer *q, int *success);
+    /* OTHER
+        *
+        *
+        */
+
+    uint64_t capabilities; /* supports*/
+
+    /* Callbacks */
+    PAIR(CSAudioCallback, void *) acb;
+    PAIR(CSVideoCallback, void *) vcb;
+
+    /* Buffering */
+    void *vbuf_raw; /* Un-decoded data */
+    pthread_mutex_t queue_mutex[1];
+
+    void *agent; /* Pointer to ToxAv */
+    int32_t call_idx;
+} CSSession;
 
+/* Make sure to be called BEFORE corresponding rtp_new */
+CSSession *cs_new(const ToxAvCSettings *cs_self, const ToxAvCSettings *cs_peer, uint32_t jbuf_size, int has_video);
+/* Make sure to be called AFTER corresponding rtp_kill */
+void cs_kill(CSSession *cs);
 
-CodecState *codec_init_session ( uint32_t audio_bitrate,
-                                 uint16_t audio_frame_duration,
-                                 uint32_t audio_sample_rate,
-                                 uint32_t encoder_audio_channels,
-                                 uint32_t decoder_audio_channels,
-                                 uint32_t audio_VAD_tolerance_ms,
-                                 uint16_t max_video_width,
-                                 uint16_t max_video_height,
-                                 uint32_t video_bitrate );
+int cs_split_video_payload(CSSession *cs, const uint8_t *payload, uint16_t length);
+const uint8_t *cs_get_split_video_frame(CSSession *cs, uint16_t *size);
+
+/**
+ * Call playback callbacks
+ */
+void cs_do(CSSession *cs);
 
-void codec_terminate_session(CodecState *cs);
 
-/* Reconfigure video encoder
-   return 0 on success.
-   return -1 on failure. */
-int reconfigure_video_encoder_resolution(CodecState *cs, uint16_t width, uint16_t height);
-int reconfigure_video_encoder_bitrate(CodecState *cs, uint32_t video_bitrate);
+/* Reconfigure video encoder; return 0 on success or -1 on failure. */
+int cs_set_video_encoder_resolution(CSSession *cs, uint16_t width, uint16_t height);
+int cs_set_video_encoder_bitrate(CSSession *cs, uint32_t video_bitrate);
 
-/* Calculate energy and return 1 if has voice, 0 if not */
-int energy_VAD(CodecState *cs, int16_t *PCM, uint16_t frame_size, float energy);
 
+/* Internal. Called from rtp_handle_message */
+void queue_message(RTPSession *session, RTPMessage *msg);
 #endif /* _CODEC_H_ */
diff --git a/toxav/group.c b/toxav/group.c
new file mode 100644
index 00000000..3c09878a
--- /dev/null
+++ b/toxav/group.c
@@ -0,0 +1,525 @@
+/**  groupav.h
+ *
+ *   Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *   This file is part of Tox.
+ *
+ *   Tox is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Tox is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "group.h"
+#include "../toxcore/logger.h"
+
+#define GROUP_JBUF_SIZE 6
+
+typedef struct {
+    uint16_t sequnum;
+    uint16_t length;
+    uint8_t data[];
+} Group_Audio_Packet;
+
+typedef struct {
+    Group_Audio_Packet **queue;
+    uint32_t size;
+    uint32_t capacity;
+    uint16_t bottom;
+    uint16_t top;
+} Group_JitterBuffer;
+
+static Group_JitterBuffer *create_queue(unsigned int capacity)
+{
+    unsigned int size = 1;
+
+    while (size <= capacity) {
+        size *= 2;
+    }
+
+    Group_JitterBuffer *q;
+
+    if ( !(q = calloc(sizeof(Group_JitterBuffer), 1)) ) return NULL;
+
+    if (!(q->queue = calloc(sizeof(Group_Audio_Packet *), size))) {
+        free(q);
+        return NULL;
+    }
+
+    q->size = size;
+    q->capacity = capacity;
+    return q;
+}
+
+static void clear_queue(Group_JitterBuffer *q)
+{
+    for (; q->bottom != q->top; ++q->bottom) {
+        if (q->queue[q->bottom % q->size]) {
+            free(q->queue[q->bottom % q->size]);
+            q->queue[q->bottom % q->size] = NULL;
+        }
+    }
+}
+
+static void terminate_queue(Group_JitterBuffer *q)
+{
+    if (!q) return;
+
+    clear_queue(q);
+    free(q->queue);
+    free(q);
+}
+
+/* Return 0 if packet was queued, -1 if it wasn't.
+ */
+static int queue(Group_JitterBuffer *q, Group_Audio_Packet *pk)
+{
+    uint16_t sequnum = pk->sequnum;
+
+    unsigned int num = sequnum % q->size;
+
+    if ((uint32_t)(sequnum - q->bottom) > q->size) {
+        clear_queue(q);
+        q->bottom = sequnum - q->capacity;
+        q->queue[num] = pk;
+        q->top = sequnum + 1;
+        return 0;
+    }
+
+    if (q->queue[num])
+        return -1;
+
+    q->queue[num] = pk;
+
+    if ((sequnum - q->bottom) >= (q->top - q->bottom))
+        q->top = sequnum + 1;
+
+    return 0;
+}
+
+/* success is 0 when there is nothing to dequeue, 1 when there's a good packet, 2 when there's a lost packet */
+static Group_Audio_Packet *dequeue(Group_JitterBuffer *q, int *success)
+{
+    if (q->top == q->bottom) {
+        *success = 0;
+        return NULL;
+    }
+
+    unsigned int num = q->bottom % q->size;
+
+    if (q->queue[num]) {
+        Group_Audio_Packet *ret = q->queue[num];
+        q->queue[num] = NULL;
+        ++q->bottom;
+        *success = 1;
+        return ret;
+    }
+
+    if ((uint32_t)(q->top - q->bottom) > q->capacity) {
+        ++q->bottom;
+        *success = 2;
+        return NULL;
+    }
+
+    *success = 0;
+    return NULL;
+}
+
+typedef struct {
+    Group_Chats *g_c;
+    OpusEncoder *audio_encoder;
+
+    unsigned int audio_channels, audio_sample_rate, audio_bitrate;
+
+    uint16_t audio_sequnum;
+
+    void (*audio_data)(Messenger *m, int groupnumber, int peernumber, const int16_t *pcm, unsigned int samples,
+                       uint8_t channels, unsigned int sample_rate, void *userdata);
+    void *userdata;
+} Group_AV;
+
+typedef struct {
+    Group_JitterBuffer *buffer;
+
+    OpusDecoder *audio_decoder;
+    int decoder_channels;
+    unsigned int last_packet_samples;
+} Group_Peer_AV;
+
+static void kill_group_av(Group_AV *group_av)
+{
+    if (group_av->audio_encoder) {
+        opus_encoder_destroy(group_av->audio_encoder);
+    }
+
+    free(group_av);
+}
+
+static int recreate_encoder(Group_AV *group_av)
+{
+    if (group_av->audio_encoder) {
+        opus_encoder_destroy(group_av->audio_encoder);
+        group_av->audio_encoder = NULL;
+    }
+
+    int rc = OPUS_OK;
+    group_av->audio_encoder = opus_encoder_create(group_av->audio_sample_rate, group_av->audio_channels,
+                              OPUS_APPLICATION_AUDIO, &rc);
+
+    if ( rc != OPUS_OK ) {
+        LOGGER_ERROR("Error while starting audio encoder: %s", opus_strerror(rc));
+        group_av->audio_encoder = NULL;
+        return -1;
+    }
+
+    rc = opus_encoder_ctl(group_av->audio_encoder, OPUS_SET_BITRATE(group_av->audio_bitrate));
+
+    if ( rc != OPUS_OK ) {
+        LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc));
+        opus_encoder_destroy(group_av->audio_encoder);
+        group_av->audio_encoder = NULL;
+        return -1;
+    }
+
+    rc = opus_encoder_ctl(group_av->audio_encoder, OPUS_SET_COMPLEXITY(10));
+
+    if ( rc != OPUS_OK ) {
+        LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc));
+        opus_encoder_destroy(group_av->audio_encoder);
+        group_av->audio_encoder = NULL;
+        return -1;
+    }
+
+    return 0;
+}
+
+static Group_AV *new_group_av(Group_Chats *g_c, void (*audio_callback)(Messenger *, int, int, const int16_t *,
+                              unsigned int, uint8_t, unsigned int, void *), void *userdata)
+{
+    if (!g_c)
+        return NULL;
+
+    Group_AV *group_av = calloc(1, sizeof(Group_AV));
+
+    if (!group_av)
+        return NULL;
+
+    group_av->g_c = g_c;
+
+    group_av->audio_data = audio_callback;
+    group_av->userdata = userdata;
+
+    return group_av;
+}
+
+static void group_av_peer_new(void *object, int groupnumber, int friendgroupnumber)
+{
+    Group_AV *group_av = object;
+    Group_Peer_AV *peer_av = calloc(1, sizeof(Group_Peer_AV));
+
+    if (!peer_av)
+        return;
+
+    peer_av->buffer = create_queue(GROUP_JBUF_SIZE);
+    group_peer_set_object(group_av->g_c, groupnumber, friendgroupnumber, peer_av);
+}
+
+static void group_av_peer_delete(void *object, int groupnumber, int friendgroupnumber, void *peer_object)
+{
+    Group_Peer_AV *peer_av = peer_object;
+
+    if (!peer_av)
+        return;
+
+    if (peer_av->audio_decoder)
+        opus_decoder_destroy(peer_av->audio_decoder);
+
+    terminate_queue(peer_av->buffer);
+    free(peer_object);
+}
+
+static void group_av_groupchat_delete(void *object, int groupnumber)
+{
+    if (object)
+        kill_group_av(object);
+}
+
+static int decode_audio_packet(Group_AV *group_av, Group_Peer_AV *peer_av, int groupnumber, int friendgroupnumber)
+{
+    if (!group_av || !peer_av)
+        return -1;
+
+    int success;
+    Group_Audio_Packet *pk = dequeue(peer_av->buffer, &success);
+
+    if (success == 0)
+        return -1;
+
+    int16_t *out_audio = NULL;
+    int out_audio_samples = 0;
+
+    unsigned int sample_rate = 48000;
+
+    if (success == 1) {
+        int channels = opus_packet_get_nb_channels(pk->data);
+
+        if (channels == OPUS_INVALID_PACKET) {
+            free(pk);
+            return -1;
+        }
+
+        if (channels != 1 && channels != 2) {
+            free(pk);
+            return -1;
+        }
+
+        if (channels != peer_av->decoder_channels) {
+            if (peer_av->audio_decoder) {
+                opus_decoder_destroy(peer_av->audio_decoder);
+                peer_av->audio_decoder = NULL;
+            }
+
+            int rc;
+            peer_av->audio_decoder = opus_decoder_create(sample_rate, channels, &rc);
+
+            if ( rc != OPUS_OK ) {
+                LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(rc));
+                free(pk);
+                return -1;
+            }
+
+            peer_av->decoder_channels = channels;
+        }
+
+        int num_samples = opus_decoder_get_nb_samples(peer_av->audio_decoder, pk->data, pk->length);
+
+        out_audio = malloc(num_samples * peer_av->decoder_channels * sizeof(int16_t));
+
+        if (!out_audio) {
+            free(pk);
+            return -1;
+        }
+
+        out_audio_samples = opus_decode(peer_av->audio_decoder, pk->data, pk->length, out_audio, num_samples, 0);
+        free(pk);
+
+        if (out_audio_samples <= 0)
+            return -1;
+
+        peer_av->last_packet_samples = out_audio_samples;
+    } else {
+        if (!peer_av->audio_decoder)
+            return -1;
+
+        if (!peer_av->last_packet_samples)
+            return -1;
+
+        out_audio = malloc(peer_av->last_packet_samples * peer_av->decoder_channels * sizeof(int16_t));
+
+        if (!out_audio) {
+            free(pk);
+            return -1;
+        }
+
+        out_audio_samples = opus_decode(peer_av->audio_decoder, NULL, 0, out_audio, peer_av->last_packet_samples, 1);
+
+        if (out_audio_samples <= 0)
+            return -1;
+
+    }
+
+    if (out_audio) {
+
+        if (group_av->audio_data)
+            group_av->audio_data(group_av->g_c->m, groupnumber, friendgroupnumber, out_audio, out_audio_samples,
+                                 peer_av->decoder_channels, sample_rate, group_av->userdata);
+
+        free(out_audio);
+        return 0;
+    }
+
+    return -1;
+}
+
+static int handle_group_audio_packet(void *object, int groupnumber, int friendgroupnumber, void *peer_object,
+                                     const uint8_t *packet, uint16_t length)
+{
+    if (!peer_object || !object || length <= sizeof(uint16_t)) {
+        return -1;
+    }
+
+    Group_Peer_AV *peer_av = peer_object;
+
+    Group_Audio_Packet *pk = calloc(1, sizeof(Group_Audio_Packet) + (length - sizeof(uint16_t)));
+
+    if (!pk) {
+        return -1;
+    }
+
+    uint16_t sequnum;
+    memcpy(&sequnum, packet, sizeof(sequnum));
+    pk->sequnum = ntohs(sequnum);
+    pk->length = length - sizeof(uint16_t);
+    memcpy(pk->data, packet + sizeof(uint16_t), length - sizeof(uint16_t));
+
+    if (queue(peer_av->buffer, pk) == -1) {
+        free(pk);
+        return -1;
+    }
+
+    while (decode_audio_packet(object, peer_av, groupnumber, friendgroupnumber) == 0);
+
+    return 0;
+}
+
+/* Convert groupchat to an A/V groupchat.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static int groupchat_enable_av(Group_Chats *g_c, int groupnumber, void (*audio_callback)(Messenger *, int, int,
+                               const int16_t *, unsigned int, uint8_t, unsigned int, void *), void *userdata)
+{
+    if (groupnumber == -1)
+        return -1;
+
+    Group_AV *group_av = new_group_av(g_c, audio_callback, userdata);
+
+    if (group_av == NULL)
+        return -1;
+
+    if (group_set_object(g_c, groupnumber, group_av) == -1
+            || callback_groupchat_peer_new(g_c, groupnumber, group_av_peer_new) == -1
+            || callback_groupchat_peer_delete(g_c, groupnumber, group_av_peer_delete) == -1
+            || callback_groupchat_delete(g_c, groupnumber, group_av_groupchat_delete) == -1) {
+        kill_group_av(group_av);
+        return -1;
+    }
+
+    group_lossy_packet_registerhandler(g_c, GROUP_AUDIO_PACKET_ID, &handle_group_audio_packet);
+    return 0;
+}
+
+/* Create a new toxav group.
+ *
+ * return group number on success.
+ * return -1 on failure.
+ */
+int add_av_groupchat(Group_Chats *g_c, void (*audio_callback)(Messenger *, int, int, const int16_t *, unsigned int,
+                     uint8_t, unsigned int, void *), void *userdata)
+{
+    int groupnumber = add_groupchat(g_c, GROUPCHAT_TYPE_AV);
+
+    if (groupnumber == -1) {
+        return -1;
+    }
+
+    if (groupchat_enable_av(g_c, groupnumber, audio_callback, userdata) == -1) {
+        del_groupchat(g_c, groupnumber);
+        return -1;
+    }
+
+    return groupnumber;
+}
+
+/* Join a AV group (you need to have been invited first.)
+ *
+ * returns group number on success
+ * returns -1 on failure.
+ */
+int join_av_groupchat(Group_Chats *g_c, 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)
+{
+    int groupnumber = join_groupchat(g_c, friendnumber, GROUPCHAT_TYPE_AV, data, length);
+
+    if (groupnumber == -1) {
+        return -1;
+    }
+
+    if (groupchat_enable_av(g_c, groupnumber, audio_callback, userdata) == -1) {
+        del_groupchat(g_c, groupnumber);
+        return -1;
+    }
+
+    return groupnumber;
+}
+
+/* Send an encoded audio packet to the group chat.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static int send_audio_packet(Group_Chats *g_c, int groupnumber, uint8_t *packet, uint16_t length)
+{
+    if (!length)
+        return -1;
+
+    Group_AV *group_av = group_get_object(g_c, groupnumber);
+    uint8_t data[1 + sizeof(uint16_t) + length];
+    data[0] = GROUP_AUDIO_PACKET_ID;
+
+    uint16_t sequnum = htons(group_av->audio_sequnum);
+    memcpy(data + 1, &sequnum, sizeof(sequnum));
+    memcpy(data + 1 + sizeof(sequnum), packet, length);
+
+    if (send_group_lossy_packet(g_c, groupnumber, data, sizeof(data)) == -1)
+        return -1;
+
+    ++group_av->audio_sequnum;
+    return 0;
+}
+
+/* Send audio to the group chat.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int group_send_audio(Group_Chats *g_c, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
+                     unsigned int sample_rate)
+{
+    Group_AV *group_av = group_get_object(g_c, groupnumber);
+
+    if (!group_av)
+        return -1;
+
+    if (channels != 1 && channels != 2)
+        return -1;
+
+    if (sample_rate != 8000 && sample_rate != 12000 && sample_rate != 16000 && sample_rate != 24000 && sample_rate != 48000)
+        return -1;
+
+    if (!group_av->audio_encoder || group_av->audio_channels != channels || group_av->audio_sample_rate != sample_rate) {
+        group_av->audio_channels = channels;
+        group_av->audio_sample_rate = sample_rate;
+
+        if (channels == 1) {
+            group_av->audio_bitrate = 32000; //TODO: add way of adjusting bitrate
+        } else {
+            group_av->audio_bitrate = 64000; //TODO: add way of adjusting bitrate
+        }
+
+        if (recreate_encoder(group_av) == -1)
+            return -1;
+    }
+
+    uint8_t encoded[1024];
+    int32_t size = opus_encode(group_av->audio_encoder, pcm, samples, encoded, sizeof(encoded));
+
+    if (size <= 0)
+        return -1;
+
+    return send_audio_packet(g_c, groupnumber, encoded, size);
+}
diff --git a/toxav/group.h b/toxav/group.h
new file mode 100644
index 00000000..3355a447
--- /dev/null
+++ b/toxav/group.h
@@ -0,0 +1,53 @@
+/**  groupav.c
+ *
+ *   Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *   This file is part of Tox.
+ *
+ *   Tox is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Tox is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Audio encoding/decoding */
+#include <opus.h>
+
+#include "../toxcore/group.h"
+
+#define GROUP_AUDIO_PACKET_ID 192
+
+/* Create a new toxav group.
+ *
+ * return group number on success.
+ * return -1 on failure.
+ */
+int add_av_groupchat(Group_Chats *g_c, void (*audio_callback)(Messenger *, 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.
+ */
+int join_av_groupchat(Group_Chats *g_c, 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);
+
+
+/* Send audio to the group chat.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int group_send_audio(Group_Chats *g_c, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
+                     unsigned int sample_rate);
+
diff --git a/toxav/msi.c b/toxav/msi.c
index 91742c35..dcb7b62a 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -97,11 +97,6 @@ GENERIC_HEADER ( Reason, MSIReasonStrType )
 GENERIC_HEADER ( CSettings, MSIRawCSettingsType )
 
 
-/**
- * @brief This is the message structure. It contains all of the headers and
- *        destination/source of the message stored in friend_id.
- *
- */
 typedef struct _MSIMessage {
 
     MSIHeaderRequest   request;
@@ -115,24 +110,19 @@ typedef struct _MSIMessage {
 } MSIMessage;
 
 
-inline__ void invoke_callback(MSISession *session, int32_t call_index, MSICallbackID id)
+static void invoke_callback(MSISession *s, int32_t c, MSICallbackID i)
 {
-    if ( session->callbacks[id].function ) {
-        LOGGER_DEBUG("Invoking callback function: %d", id);
-        session->callbacks[id].function ( session->agent_handler, call_index, session->callbacks[id].data );
+    if ( s->callbacks[i].first ) {
+        LOGGER_DEBUG("Invoking callback function: %d", i);
+
+        s->callbacks[i].first( s->agent_handler, c, s->callbacks[i].second );
     }
 }
 
 /**
- * @brief Parse raw 'data' received from socket into MSIMessage struct.
- *        Every message has to have end value of 'end_byte' or _undefined_ behavior
- *        occures. The best practice is to check the end of the message at the handle_packet.
- *
- * @param msg Container.
- * @param data The data.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
+ * Parse raw 'data' received from socket into MSIMessage struct.
+ * Every message has to have end value of 'end_byte' or _undefined_ behavior
+ * occures. The best practice is to check the end of the message at the handle_packet.
  */
 static int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
 {
@@ -211,12 +201,7 @@ static int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t lengt
 }
 
 /**
- * @brief Create the message.
- *
- * @param type Request or response.
- * @param type_id Type of request/response.
- * @return MSIMessage* Created message.
- * @retval NULL Error occurred.
+ * Create the message.
  */
 MSIMessage *msi_new_message ( MSIMessageType type, const uint8_t type_value )
 {
@@ -241,11 +226,7 @@ MSIMessage *msi_new_message ( MSIMessageType type, const uint8_t type_value )
 
 
 /**
- * @brief Parse data from handle_packet.
- *
- * @param data The data.
- * @return MSIMessage* Parsed message.
- * @retval NULL Error occurred.
+ * Parse data from handle_packet.
  */
 MSIMessage *parse_recv ( const uint8_t *data, uint16_t length )
 {
@@ -272,16 +253,13 @@ MSIMessage *parse_recv ( const uint8_t *data, uint16_t length )
 
 
 /**
- * @brief Speaks for it self.
- *
- * @param dest Container.
- * @param header_field Field.
- * @param header_value Field value.
- * @param value_len Length of field value.
- * @param length Pointer to container length.
- * @return uint8_t* Iterated container.
+ * Speaks for itself.
  */
-uint8_t *format_output ( uint8_t *dest, MSIHeaderID id, const void *value, uint8_t value_len, uint16_t *length )
+uint8_t *format_output ( uint8_t *dest,
+                         MSIHeaderID id,
+                         const void *value,
+                         uint8_t value_len,
+                         uint16_t *length )
 {
     if ( dest == NULL ) {
         LOGGER_ERROR("No destination space!");
@@ -307,11 +285,7 @@ uint8_t *format_output ( uint8_t *dest, MSIHeaderID id, const void *value, uint8
 
 
 /**
- * @brief Parse MSIMessage to send.
- *
- * @param msg The message.
- * @param dest Destination.
- * @return uint16_t Its final size.
+ * Parse MSIMessage to send.
  */
 uint16_t parse_send ( MSIMessage *msg, uint8_t *dest )
 {
@@ -452,119 +426,83 @@ void msi_msg_get_csettings ( MSIMessage *msg, MSICSettings *dest )
 }
 
 typedef struct _Timer {
-    void *(*func)(void *);
-    void *func_arg1;
-    int func_arg2;
+    void (*func)(struct _Timer *);
     uint64_t timeout;
-    int idx;
+    MSISession *session;
+    int call_idx;
+    int id;
 
 } Timer;
 
 typedef struct _TimerHandler {
     Timer **timers;
-    pthread_mutex_t mutex;
 
     uint32_t max_capacity;
     uint32_t size;
-    uint64_t resolution;
-
-    _Bool running;
-
 } TimerHandler;
 
-struct timer_function_args {
-    void *arg1;
-    int  arg2;
-};
 
-/**
- * @brief Allocate timer in array
- *
- * @param timers_container Handler
- * @param func Function to be executed
- * @param arg Its args
- * @param timeout Timeout in ms
- * @return int
- */
-static int timer_alloc ( TimerHandler *timers_container, void *(func)(void *), void *arg1, int arg2, uint32_t timeout)
+static int timer_alloc (MSISession *session , void (*func)(Timer *), int call_idx, uint32_t timeout)
 {
     static int timer_id;
-    pthread_mutex_lock(&timers_container->mutex);
+    TimerHandler *timer_handler = session->timer_handler;
 
     uint32_t i = 0;
 
-    for (; i < timers_container->max_capacity && timers_container->timers[i]; i ++);
+    for (; i < timer_handler->max_capacity && timer_handler->timers[i]; i ++);
 
-    if (i == timers_container->max_capacity) {
+    if (i == timer_handler->max_capacity) {
         LOGGER_WARNING("Maximum capacity reached!");
-        pthread_mutex_unlock(&timers_container->mutex);
         return -1;
     }
 
-    Timer *timer = timers_container->timers[i] = calloc(sizeof(Timer), 1);
+    Timer *timer = timer_handler->timers[i] = calloc(sizeof(Timer), 1);
 
     if (timer == NULL) {
         LOGGER_ERROR("Failed to allocate timer!");
-        pthread_mutex_unlock(&timers_container->mutex);
         return -1;
     }
 
-    timers_container->size ++;
+    timer_handler->size ++;
 
     timer->func = func;
-    timer->func_arg1 = arg1;
-    timer->func_arg2 = arg2;
+    timer->session = session;
+    timer->call_idx = call_idx;
     timer->timeout = timeout + current_time_monotonic(); /* In ms */
     ++timer_id;
-    timer->idx = timer_id;
+    timer->id = timer_id;
 
     /* reorder */
     if (i) {
         int64_t j = i - 1;
 
-        for (; j >= 0 && timeout < timers_container->timers[j]->timeout; j--) {
-            Timer *tmp = timers_container->timers[j];
-            timers_container->timers[j] = timer;
-            timers_container->timers[j + 1] = tmp;
+        for (; j >= 0 && timeout < timer_handler->timers[j]->timeout; j--) {
+            Timer *tmp = timer_handler->timers[j];
+            timer_handler->timers[j] = timer;
+            timer_handler->timers[j + 1] = tmp;
         }
     }
 
-    pthread_mutex_unlock(&timers_container->mutex);
-
-    LOGGER_DEBUG("Allocated timer index: %ull timeout: %ull, current size: %ull", i, timeout, timers_container->size);
-    return timer->idx;
+    LOGGER_DEBUG("Allocated timer index: %ull timeout: %ull, current size: %ull", i, timeout, timer_handler->size);
+    return timer->id;
 }
 
-/**
- * @brief Remove timer from array
- *
- * @param timers_container handler
- * @param idx timer id
- * @param lock_mutex (does the mutex need to be locked)
- * @return int
- */
-static int timer_release ( TimerHandler *timers_container, int idx , int lock_mutex)
+static int timer_release ( TimerHandler *timers_container, int id)
 {
-    if (lock_mutex)
-        pthread_mutex_lock(&timers_container->mutex);
-
     Timer **timed_events = timers_container->timers;
 
-    size_t i;
+    uint32_t i;
     int rc = -1;
 
     for (i = 0; i < timers_container->max_capacity; ++i) {
-        if (timed_events[i] && timed_events[i]->idx == idx) {
+        if (timed_events[i] && timed_events[i]->id == id) {
             rc = i;
             break;
         }
     }
 
     if (rc == -1) {
-        LOGGER_WARNING("No event with id: %d", idx);
-
-        if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
-
+        LOGGER_WARNING("No event with id: %d", id);
         return -1;
     }
 
@@ -581,132 +519,12 @@ static int timer_release ( TimerHandler *timers_container, int idx , int lock_mu
 
     timers_container->size--;
 
-    LOGGER_DEBUG("Popped id: %d, current size: %ull ", idx, timers_container->size);
-
-    if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
-
+    LOGGER_DEBUG("Popped id: %d, current size: %ull ", id, timers_container->size);
     return 0;
 }
 
 /**
- * @brief Main poll for timer execution
- *
- * @param arg ...
- * @return void*
- */
-static void *timer_poll( void *arg )
-{
-    TimerHandler *handler = arg;
-
-    while ( handler->running ) {
-
-        pthread_mutex_lock(&handler->mutex);
-
-        if ( handler->running ) {
-
-            uint64_t time = current_time_monotonic();
-
-            while ( handler->timers[0] && handler->timers[0]->timeout < time ) {
-                pthread_t tid;
-
-                struct timer_function_args *args = malloc(sizeof(struct timer_function_args));
-                args->arg1 = handler->timers[0]->func_arg1;
-                args->arg2 = handler->timers[0]->func_arg2;
-
-                if ( 0 != pthread_create(&tid, NULL, handler->timers[0]->func, args) ||
-                        0 != pthread_detach(tid) ) {
-                    LOGGER_ERROR("Failed to execute timer at: %d!", handler->timers[0]->timeout);
-                    free(args);
-                } else {
-                    LOGGER_DEBUG("Exectued timer assigned at: %d", handler->timers[0]->timeout);
-                }
-
-                timer_release(handler, handler->timers[0]->idx, 0);
-            }
-
-        }
-
-        pthread_mutex_unlock(&handler->mutex);
-
-        usleep(handler->resolution);
-    }
-
-    pthread_exit(NULL);
-}
-
-/**
- * @brief Start timer poll and return handler
- *
- * @param max_capacity capacity
- * @param resolution ...
- * @return TimerHandler*
- */
-static TimerHandler *timer_init_session (int max_capacity, int resolution)
-{
-    TimerHandler *handler = calloc(1, sizeof(TimerHandler));
-
-    if (handler == NULL) {
-        LOGGER_ERROR("Failed to allocate memory, program might misbehave!");
-        return NULL;
-    }
-
-    handler->timers = calloc(max_capacity, sizeof(Timer *));
-
-    if (handler->timers == NULL) {
-        LOGGER_ERROR("Failed to allocate %d timed events!", max_capacity);
-        free(handler);
-        return NULL;
-    }
-
-    handler->max_capacity = max_capacity;
-    handler->running = 1;
-    handler->resolution = resolution;
-
-    pthread_mutex_init(&handler->mutex, NULL);
-
-
-    pthread_t _tid;
-
-    if ( 0 != pthread_create(&_tid, NULL, timer_poll, handler) || 0 != pthread_detach(_tid) ) {
-        LOGGER_ERROR("Failed to start timer poll thread!");
-        free(handler->timers);
-        free(handler);
-        return NULL;
-    }
-
-    return handler;
-}
-
-/**
- * @brief Terminate timer session
- *
- * @param handler The timer handler
- * @return void
- */
-static void timer_terminate_session(TimerHandler *handler)
-{
-    pthread_mutex_lock(&handler->mutex);
-
-    handler->running = 0;
-
-    pthread_mutex_unlock(&handler->mutex);
-
-    size_t i = 0;
-
-    for (; i < handler->max_capacity; i ++)
-        free(handler->timers[i]);
-
-    free(handler->timers);
-
-    pthread_mutex_destroy( &handler->mutex );
-}
-
-/**
- * @brief Generate _random_ alphanumerical string.
- *
- * @param str Destination.
- * @param size Size of string.
- * @return void
+ * Generate _random_ alphanumerical string.
  */
 static void t_randomstr ( uint8_t *str, uint32_t size )
 {
@@ -727,7 +545,7 @@ static void t_randomstr ( uint8_t *str, uint32_t size )
     }
 }
 
-
+/* TODO: it would be nice to actually have some sane error codes */
 typedef enum {
     error_none,
     error_deadcall,      /* has call id but it's from old call */
@@ -743,12 +561,9 @@ typedef enum {
 
 
 /**
- * @brief Stringify error code.
- *
- * @param error_code The code.
- * @return const uint8_t* The string.
+ * Stringify error code.
  */
-static inline__ const uint8_t *stringify_error ( MSICallError error_code )
+static const uint8_t *stringify_error ( MSICallError error_code )
 {
     static const uint8_t *strings[] = {
         ( uint8_t *) "",
@@ -763,16 +578,6 @@ static inline__ const uint8_t *stringify_error ( MSICallError error_code )
     return strings[error_code];
 }
 
-/**
- * @brief Speaks for it self.
- *
- * @param session Control session.
- * @param msg The message.
- * @param to Where to.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
 static int send_message ( MSISession *session, MSICall *call, MSIMessage *msg, uint32_t to )
 {
     msi_msg_set_callid ( msg, call->id );
@@ -793,7 +598,7 @@ static int send_message ( MSISession *session, MSICall *call, MSIMessage *msg, u
     return -1;
 }
 
-inline__ int send_reponse ( MSISession *session, MSICall *call, MSIResponse response, uint32_t to )
+static int send_reponse ( MSISession *session, MSICall *call, MSIResponse response, uint32_t to )
 {
     MSIMessage *msg = msi_new_message ( TypeResponse, response );
     int ret = send_message ( session, call, msg, to );
@@ -801,14 +606,26 @@ inline__ int send_reponse ( MSISession *session, MSICall *call, MSIResponse resp
     return ret;
 }
 
+static int send_error ( MSISession *session, MSICall *call, MSICallError errid, uint32_t to )
+{
+    if (!call) {
+        LOGGER_WARNING("Cannot handle error on 'null' call");
+        return -1;
+    }
+
+    LOGGER_DEBUG("Sending error: %d on call: %s", errid, call->id);
+
+    MSIMessage *msg_error = msi_new_message ( TypeResponse, error );
+
+    msi_msg_set_reason ( msg_error, stringify_error(errid) );
+    send_message ( session, call, msg_error, to );
+    free ( msg_error );
+
+    return 0;
+}
+
 /**
- * @brief Determine 'bigger' call id
- *
- * @param first duh
- * @param second duh
- * @return int
- * @retval 0 it's first
- * @retval 1 it's second
+ * Determine 'bigger' call id
  */
 static int call_id_bigger( const uint8_t *first, const uint8_t *second)
 {
@@ -817,12 +634,7 @@ static int call_id_bigger( const uint8_t *first, const uint8_t *second)
 
 
 /**
- * @brief Speaks for it self.
- *
- * @param session Control session.
- * @param msg The message.
- * @param peer_id The peer.
- * @return -1, 0
+ * Set/change peer csettings
  */
 static int flush_peer_csettings ( MSICall *call, MSIMessage *msg, int peer_id )
 {
@@ -854,88 +666,9 @@ static int flush_peer_csettings ( MSICall *call, MSIMessage *msg, int peer_id )
     return -1;
 }
 
-static int terminate_call ( MSISession *session, MSICall *call );
-
-static void handle_remote_connection_change(Messenger *messenger, int friend_num, uint8_t status, void *session_p)
-{
-    (void)messenger;
-    MSISession *session = session_p;
-
-    switch ( status ) {
-        case 0: { /* Went offline */
-            int32_t j = 0;
-
-            for ( ; j < session->max_calls; j ++ ) {
-
-                if ( !session->calls[j] ) continue;
-
-                uint16_t i = 0;
-
-                for ( ; i < session->calls[j]->peer_count; i ++ )
-                    if ( session->calls[j]->peers[i] == (uint32_t)friend_num ) {
-                        invoke_callback(session, j, MSI_OnPeerTimeout);
-                        terminate_call(session, session->calls[j]);
-                        LOGGER_DEBUG("Remote: %d timed out!", friend_num);
-                        return; /* TODO: On group calls change behaviour */
-                    }
-            }
-        }
-        break;
-
-        default:
-            break;
-    }
-}
-
-static MSICall *find_call ( MSISession *session, uint8_t *call_id )
-{
-    if ( call_id == NULL ) return NULL;
-
-    int32_t i = 0;
-
-    for (; i < session->max_calls; i ++ )
-        if ( session->calls[i] && memcmp(session->calls[i]->id, call_id, sizeof(session->calls[i]->id)) == 0 ) {
-            return session->calls[i];
-        }
-
-    return NULL;
-}
-
-/**
- * @brief Sends error response to peer.
- *
- * @param session The session.
- * @param errid The id.
- * @param to Where to?
- * @return int
- * @retval -1/0 It's usually always success.
- */
-static int send_error ( MSISession *session, MSICall *call, MSICallError errid, uint32_t to )
-{
-    if (!call) {
-        LOGGER_WARNING("Cannot handle error on 'null' call");
-        return -1;
-    }
-
-    LOGGER_DEBUG("Sending error: %d on call: %s", errid, call->id);
-
-    MSIMessage *msg_error = msi_new_message ( TypeResponse, error );
-
-    msi_msg_set_reason ( msg_error, stringify_error(errid) );
-    send_message ( session, call, msg_error, to );
-    free ( msg_error );
-
-    return 0;
-}
-
-
 
 /**
- * @brief Add peer to peer list.
- *
- * @param call What call.
- * @param peer_id Its id.
- * @return void
+ * Add peer to peer list.
  */
 static void add_peer( MSICall *call, int peer_id )
 {
@@ -955,14 +688,20 @@ static void add_peer( MSICall *call, int peer_id )
 }
 
 
-/**
- * @brief Speaks for it self.
- *
- * @param session Control session.
- * @param peers Amount of peers. (Currently it only supports 1)
- * @param ringing_timeout Ringing timeout.
- * @return MSICall* The created call.
- */
+static MSICall *find_call ( MSISession *session, uint8_t *call_id )
+{
+    if ( call_id == NULL ) return NULL;
+
+    int32_t i = 0;
+
+    for (; i < session->max_calls; i ++ )
+        if ( session->calls[i] && memcmp(session->calls[i]->id, call_id, sizeof(session->calls[i]->id)) == 0 ) {
+            return session->calls[i];
+        }
+
+    return NULL;
+}
+
 static MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
 {
 
@@ -1008,21 +747,10 @@ static MSICall *init_call ( MSISession *session, int peers, int ringing_timeout
 
     call->ringing_tout_ms = ringing_timeout;
 
-    pthread_mutex_init ( &call->mutex, NULL );
-
     LOGGER_DEBUG("Started new call with index: %u", call_idx);
     return call;
 }
 
-
-/**
- * @brief Terminate the call.
- *
- * @param session Control session.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
 static int terminate_call ( MSISession *session, MSICall *call )
 {
     if ( !call ) {
@@ -1030,67 +758,71 @@ static int terminate_call ( MSISession *session, MSICall *call )
         return -1;
     }
 
-    LOGGER_DEBUG("Terminated call id: %d", call->call_idx);
     /* Check event loop and cancel timed events if there are any
-     * NOTE: This has to be done before possibly
-     * locking the mutex the second time
      */
-    timer_release ( session->timer_handler, call->request_timer_id, 1);
-    timer_release ( session->timer_handler, call->ringing_timer_id, 1);
-
-    /* Get a handle */
-    pthread_mutex_lock ( &call->mutex );
+    timer_release ( session->timer_handler, call->request_timer_id);
+    timer_release ( session->timer_handler, call->ringing_timer_id);
 
     session->calls[call->call_idx] = NULL;
 
-    free ( call->csettings_peer );
-    free ( call->peers);
-
-    /* Release handle */
-    pthread_mutex_unlock ( &call->mutex );
-
-    pthread_mutex_destroy ( &call->mutex );
+    LOGGER_DEBUG("Terminated call id: %d", call->call_idx);
 
+    free ( call->csettings_peer );
+    free ( call->peers );
     free ( call );
 
     return 0;
 }
 
+static void handle_remote_connection_change(Messenger *messenger, uint32_t friend_num, uint8_t status, void *session_p)
+{
+    (void)messenger;
+    MSISession *session = session_p;
+
+    switch ( status ) {
+        case 0: { /* Went offline */
+            int32_t j = 0;
+
+            for ( ; j < session->max_calls; j ++ ) {
+
+                if ( !session->calls[j] ) continue;
+
+                uint16_t i = 0;
+
+                for ( ; i < session->calls[j]->peer_count; i ++ )
+                    if ( session->calls[j]->peers[i] == (uint32_t)friend_num ) {
+                        invoke_callback(session, j, msi_OnPeerTimeout);
+                        terminate_call(session, session->calls[j]);
+                        LOGGER_DEBUG("Remote: %d timed out!", friend_num);
+                        return; /* TODO: On group calls change behaviour */
+                    }
+            }
+        }
+        break;
+
+        default:
+            break;
+    }
+}
 
 /**
- * @brief Function called at request timeout. If not called in thread it might cause trouble
- *
- * @param arg Control session
- * @return void*
+ * Function called at request timeout
  */
-static void *handle_timeout ( void *arg )
+static void handle_timeout ( Timer *timer )
 {
     /* TODO: Cancel might not arrive there; set up
      * timers on these cancels and terminate call on
      * their timeout
      */
-    struct timer_function_args *args = arg;
-    int call_index = args->arg2;
-    MSISession *session = args->arg1;
-    MSICall *call = session->calls[call_index];
+    MSICall *call = timer->session->calls[timer->call_idx];
+
 
     if (call) {
         LOGGER_DEBUG("[Call: %d] Request timed out!", call->call_idx);
 
-        invoke_callback(session, call_index, MSI_OnRequestTimeout);
-    }
-
-    if ( call && call->session ) {
-
-        /* TODO: Cancel all? */
-        /* uint16_t _it = 0;
-         *       for ( ; _it < _session->call->peer_count; _it++ ) */
-        msi_cancel ( call->session, call->call_idx, call->peers [0], "Request timed out" );
-        /*terminate_call(call->session, call);*/
+        invoke_callback(timer->session, timer->call_idx, msi_OnRequestTimeout);
+        msi_cancel(timer->session, timer->call_idx, call->peers [0], "Request timed out");
     }
-
-    free(arg);
-    pthread_exit(NULL);
 }
 
 
@@ -1099,18 +831,16 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
 {
     LOGGER_DEBUG("Session: %p Handling 'invite' on call: %d", session, call ? call->call_idx : -1);
 
-    pthread_mutex_lock(&session->mutex);
 
     if (!msg->csettings.exists) {/**/
         LOGGER_WARNING("Peer sent invalid codec settings!");
         send_error ( session, call, error_no_callid, msg->friend_id );
-        pthread_mutex_unlock(&session->mutex);
         return 0;
     }
 
     if ( call ) {
         if ( call->peers[0] == (uint32_t)msg->friend_id ) {
-            if (call->state == call_inviting) {
+            if (call->state == msi_CallInviting) {
                 /* The glare case. A calls B when at the same time
                  * B calls A. Who has advantage is set bey calculating
                  * 'bigger' Call id and then that call id is being used in
@@ -1127,41 +857,35 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
                     call = init_call ( session, 1, 0 );
 
                     if ( !call ) {
-                        pthread_mutex_unlock(&session->mutex);
                         LOGGER_ERROR("Starting call");
                         return 0;
                     }
 
                 } else {
-                    pthread_mutex_unlock(&session->mutex);
                     return 0; /* Wait for ringing from peer */
                 }
-            } else if (call->state == call_active) {
+            } else if (call->state == msi_CallActive) {
                 /* Request for media change; call callback and send starting response */
                 if (flush_peer_csettings(call, msg, 0) != 0) { /**/
                     LOGGER_WARNING("Peer sent invalid csetting!");
                     send_error ( session, call, error_no_callid, msg->friend_id );
-                    pthread_mutex_unlock(&session->mutex);
                     return 0;
                 }
 
-                LOGGER_DEBUG("Set new call type: %s", call->csettings_peer[0].call_type == type_audio ? "audio" : "video");
+                LOGGER_DEBUG("Set new call type: %s", call->csettings_peer[0].call_type == msi_TypeAudio ? "audio" : "video");
                 send_reponse(session, call, starting, msg->friend_id);
-                pthread_mutex_unlock(&session->mutex);
-                invoke_callback(session, call->call_idx, MSI_OnMediaChange);
+                invoke_callback(session, call->call_idx, msi_OnPeerCSChange);
                 return 1;
             }
         } else {
             send_error ( session, call, error_busy, msg->friend_id ); /* TODO: Ugh*/
             terminate_call(session, call);
-            pthread_mutex_unlock(&session->mutex);
             return 0;
         }
     } else {
         call = init_call ( session, 1, 0 );
 
         if ( !call ) {
-            pthread_mutex_unlock(&session->mutex);
             LOGGER_ERROR("Starting call");
             return 0;
         }
@@ -1170,22 +894,16 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
     if ( !msg->callid.exists ) {
         send_error ( session, call, error_no_callid, msg->friend_id );
         terminate_call(session, call);
-        pthread_mutex_unlock(&session->mutex);
         return 0;
     }
 
     memcpy ( call->id, msg->callid.value, sizeof(msg->callid.value) );
-    call->state = call_starting;
+    call->state = msi_CallStarting;
 
     add_peer( call, msg->friend_id);
-
     flush_peer_csettings ( call, msg, 0 );
-
     send_reponse(session, call, ringing, msg->friend_id);
-
-    pthread_mutex_unlock(&session->mutex);
-
-    invoke_callback(session, call->call_idx, MSI_OnInvite);
+    invoke_callback(session, call->call_idx, msi_OnInvite);
 
     return 1;
 }
@@ -1201,13 +919,8 @@ static int handle_recv_start ( MSISession *session, MSICall *call, MSIMessage *m
 
     LOGGER_DEBUG("Session: %p Handling 'start' on call: %d, friend id: %d", session, call->call_idx, msg->friend_id );
 
-    pthread_mutex_lock(&session->mutex);
-
-    call->state = call_active;
-
-    pthread_mutex_unlock(&session->mutex);
-
-    invoke_callback(session, call->call_idx, MSI_OnStart);
+    call->state = msi_CallActive;
+    invoke_callback(session, call->call_idx, msi_OnStart);
     return 1;
 }
 
@@ -1220,15 +933,11 @@ static int handle_recv_reject ( MSISession *session, MSICall *call, MSIMessage *
 
     LOGGER_DEBUG("Session: %p Handling 'reject' on call: %u", session, call->call_idx);
 
-    invoke_callback(session, call->call_idx, MSI_OnReject);
-
-    pthread_mutex_lock(&session->mutex);
+    invoke_callback(session, call->call_idx, msi_OnReject);
 
     send_reponse(session, call, ending, msg->friend_id);
     terminate_call(session, call);
 
-    pthread_mutex_unlock(&session->mutex);
-
     return 1;
 }
 
@@ -1243,14 +952,9 @@ static int handle_recv_cancel ( MSISession *session, MSICall *call, MSIMessage *
 
     LOGGER_DEBUG("Session: %p Handling 'cancel' on call: %u", session, call->call_idx);
 
-    invoke_callback(session, call->call_idx, MSI_OnCancel);
-
-    pthread_mutex_lock(&session->mutex);
-
+    invoke_callback(session, call->call_idx, msi_OnCancel);
     terminate_call ( session, call );
 
-    pthread_mutex_unlock(&session->mutex);
-
     return 1;
 }
 
@@ -1263,15 +967,10 @@ static int handle_recv_end ( MSISession *session, MSICall *call, MSIMessage *msg
 
     LOGGER_DEBUG("Session: %p Handling 'end' on call: %d", session, call->call_idx);
 
-    invoke_callback(session, call->call_idx, MSI_OnEnd);
-    pthread_mutex_lock(&session->mutex);
-
+    invoke_callback(session, call->call_idx, msi_OnEnd);
     send_reponse(session, call, ending, msg->friend_id);
     terminate_call ( session, call );
 
-    pthread_mutex_unlock(&session->mutex);
-
-
     return 1;
 }
 
@@ -1285,22 +984,16 @@ static int handle_recv_ringing ( MSISession *session, MSICall *call, MSIMessage
 
     (void)msg;
 
-    pthread_mutex_lock(&session->mutex);
-
     if ( call->ringing_timer_id ) {
         LOGGER_WARNING("Call already ringing");
-        pthread_mutex_unlock(&session->mutex);
         return 0;
     }
 
     LOGGER_DEBUG("Session: %p Handling 'ringing' on call: %d", session, call->call_idx );
 
-    call->ringing_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, call->call_idx,
-                                           call->ringing_tout_ms );
-
-    pthread_mutex_unlock(&session->mutex);
-
-    invoke_callback(session, call->call_idx, MSI_OnRinging);
+    call->ringing_timer_id = timer_alloc
+                             ( session, handle_timeout, call->call_idx, call->ringing_tout_ms );
+    invoke_callback(session, call->call_idx, msi_OnRinging);
     return 1;
 }
 static int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage *msg )
@@ -1310,19 +1003,16 @@ static int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage
         return 0;
     }
 
-    pthread_mutex_lock(&session->mutex);
-
-    if ( call->state == call_active ) { /* Change media */
+    if ( call->state == msi_CallActive ) { /* Change media */
 
         LOGGER_DEBUG("Session: %p Changing media on call: %d", session, call->call_idx );
-        pthread_mutex_unlock(&session->mutex);
 
-        invoke_callback(session, call->call_idx, MSI_OnMediaChange);
+        invoke_callback(session, call->call_idx, msi_OnSelfCSChange);
 
-    } else if ( call->state == call_inviting ) {
+    } else if ( call->state == msi_CallInviting ) {
         LOGGER_DEBUG("Session: %p Handling 'starting' on call: %d", session, call->call_idx );
 
-        call->state = call_active;
+        call->state = msi_CallActive;
 
         MSIMessage *msg_start = msi_new_message ( TypeRequest, start );
         send_message ( session, call, msg_start, msg->friend_id );
@@ -1332,15 +1022,11 @@ static int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage
         flush_peer_csettings ( call, msg, 0 );
 
         /* This is here in case of glare */
-        timer_release ( session->timer_handler, call->ringing_timer_id, 1 );
-
-        pthread_mutex_unlock(&session->mutex);
-
-        invoke_callback(session, call->call_idx, MSI_OnStarting);
+        timer_release(session->timer_handler, call->ringing_timer_id);
+        invoke_callback(session, call->call_idx, msi_OnStart);
     } else {
         LOGGER_ERROR("Invalid call state");
         terminate_call(session, call );
-        pthread_mutex_unlock(&session->mutex);
         return 0;
     }
 
@@ -1357,29 +1043,21 @@ static int handle_recv_ending ( MSISession *session, MSICall *call, MSIMessage *
 
     LOGGER_DEBUG("Session: %p Handling 'ending' on call: %d", session, call->call_idx );
 
-    invoke_callback(session, call->call_idx, MSI_OnEnding);
-
-    /* Terminate call */
-    pthread_mutex_lock(&session->mutex);
+    invoke_callback(session, call->call_idx, msi_OnEnd);
     terminate_call ( session, call );
-    pthread_mutex_unlock(&session->mutex);
 
     return 1;
 }
 static int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
-
     if ( !call ) {
         LOGGER_WARNING("Handling 'error' on non-existing call!");
-        pthread_mutex_unlock(&session->mutex);
         return -1;
     }
 
     LOGGER_DEBUG("Session: %p Handling 'error' on call: %d", session, call->call_idx );
 
-    invoke_callback(session, call->call_idx, MSI_OnEnding);
-
-    pthread_mutex_lock(&session->mutex);
+    invoke_callback(session, call->call_idx, msi_OnEnd);
 
     /* Handle error accordingly */
     if ( msg->reason.exists ) {
@@ -1388,14 +1066,11 @@ static int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *m
 
     terminate_call ( session, call );
 
-    pthread_mutex_unlock(&session->mutex);
-
     return 1;
 }
 
-
 /**
- * @brief BASIC call flow:
+ * BASIC call flow:
  *
  *    ALICE                    BOB
  *      | invite -->            |
@@ -1426,7 +1101,8 @@ static int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *m
  *
  *
  */
-static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t *data, uint16_t length, void *object )
+static void msi_handle_packet ( Messenger *messenger, uint32_t source, const uint8_t *data, uint16_t length,
+                                void *object )
 {
     LOGGER_DEBUG("Got msi message");
     /* Unused */
@@ -1436,7 +1112,7 @@ static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t
     MSIMessage *msg;
 
     if ( !length ) {
-        LOGGER_WARNING("Lenght param negative");
+        LOGGER_WARNING("Length param negative");
         return;
     }
 
@@ -1451,6 +1127,7 @@ static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t
 
     msg->friend_id = source;
 
+    pthread_mutex_lock(session->mutex);
 
     /* Find what call */
     MSICall *call = msg->callid.exists ? find_call(session, msg->callid.value ) : NULL;
@@ -1484,7 +1161,7 @@ static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t
     } else if ( msg->response.exists ) { /* Handle response */
 
         /* Got response so cancel timer */
-        if ( call ) timer_release ( session->timer_handler, call->request_timer_id, 1 );
+        if ( call ) timer_release(session->timer_handler, call->request_timer_id);
 
         switch (msg->response.value) {
             case ringing:
@@ -1509,42 +1186,29 @@ static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t
     }
 
     free ( msg );
+
+    pthread_mutex_unlock(session->mutex);
 }
 
 
-/**
- * @brief Callback setter.
- *
- * @param callback The callback.
- * @param id The id.
- * @return void
- */
+
+/********** User functions **********/
 void msi_register_callback ( MSISession *session, MSICallbackType callback, MSICallbackID id, void *userdata )
 {
-    session->callbacks[id].function = callback;
-    session->callbacks[id].data = userdata;
+    session->callbacks[id].first = callback;
+    session->callbacks[id].second = userdata;
 }
 
 
-/**
- * @brief Start the control session.
- *
- * @param messenger Tox* object.
- * @param max_calls Amount of calls possible
- * @return MSISession* The created session.
- * @retval NULL Error occurred.
- */
-MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls )
+MSISession *msi_new ( Messenger *messenger, int32_t max_calls )
 {
     if (messenger == NULL) {
         LOGGER_ERROR("Could not init session on empty messenger!");
         return NULL;
     }
 
-    TimerHandler *handler = timer_init_session(max_calls * 10, 10000);
-
-    if ( !max_calls || !handler ) {
-        LOGGER_WARNING("Invalid max call treshold or timer handler initialization failed!");
+    if ( !max_calls ) {
+        LOGGER_WARNING("Invalid max call treshold!");
         return NULL;
     }
 
@@ -1555,87 +1219,105 @@ MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls )
         return NULL;
     }
 
-    retu->messenger_handle = messenger;
-    retu->agent_handler = NULL;
-    retu->timer_handler = handler;
-
     if (!(retu->calls = calloc( sizeof (MSICall *), max_calls ))) {
         LOGGER_ERROR("Allocation failed! Program might misbehave!");
-        free(retu);
-        return NULL;
+        goto error;
     }
 
-    retu->max_calls = max_calls;
+    retu->timer_handler = calloc(1, sizeof(TimerHandler));
 
+    if (retu->timer_handler == NULL) {
+        LOGGER_ERROR("Allocation failed! Program might misbehave!");
+        goto error;
+    }
+
+    /* Allocate space for timers */
+    ((TimerHandler *)retu->timer_handler)->max_capacity = max_calls * 10;
+
+    if (!(((TimerHandler *)retu->timer_handler)->timers = calloc(max_calls * 10, sizeof(Timer *)))) {
+        LOGGER_ERROR("Allocation failed! Program might misbehave!");
+        goto error;
+    }
+
+    if (create_recursive_mutex(retu->mutex) != 0) {
+        LOGGER_ERROR("Failed to init mutex! Program might misbehave");
+        goto error;
+    }
+
+    retu->messenger_handle = messenger;
+    retu->agent_handler = NULL;
+    retu->max_calls = max_calls;
     retu->frequ = 10000; /* default value? */
     retu->call_timeout = 30000; /* default value? */
 
-
     m_callback_msi_packet(messenger, msi_handle_packet, retu );
 
     /* This is called when remote terminates session */
     m_callback_connectionstatus_internal_av(messenger, handle_remote_connection_change, retu);
 
-    pthread_mutex_init(&retu->mutex, NULL);
-
     LOGGER_DEBUG("New msi session: %p max calls: %u", retu, max_calls);
     return retu;
+
+error:
+
+    if (retu->timer_handler) {
+        free(((TimerHandler *)retu->timer_handler)->timers);
+        free(retu->timer_handler);
+    }
+
+    free(retu->calls);
+    free(retu);
+    return NULL;
 }
 
 
-/**
- * @brief Terminate control session.
- *
- * @param session The session
- * @return int
- */
-int msi_terminate_session ( MSISession *session )
+int msi_kill ( MSISession *session )
 {
     if (session == NULL) {
         LOGGER_ERROR("Tried to terminate non-existing session");
         return -1;
     }
 
-    pthread_mutex_lock(&session->mutex);
     m_callback_msi_packet((struct Messenger *) session->messenger_handle, NULL, NULL);
-    pthread_mutex_unlock(&session->mutex);
-
-    int _status = 0;
+    pthread_mutex_lock(session->mutex);
 
-    /* If have calls, cancel them */
+    /* Cancel active calls */
     int32_t idx = 0;
 
     for (; idx < session->max_calls; idx ++) if ( session->calls[idx] ) {
             /* Cancel all? */
             uint16_t _it = 0;
             /*for ( ; _it < session->calls[idx]->peer_count; _it++ )
-             * FIXME: will not work on multiple peers, must cancel call for all peers
-             */
-            msi_cancel ( session, idx, session->calls[idx]->peers [_it], "MSI session terminated!" );
+                * FIXME: will not work on multiple peers, must cancel call for all peers
+                */
+            MSICallState state = session->calls[idx]->state;
+
+            if (state == msi_CallInviting) {
+                msi_cancel( session, idx, session->calls[idx]->peers [_it], "MSI session terminated!" );
+            } else {
+                msi_stopcall(session, idx);
+            }
         }
 
-    timer_terminate_session(session->timer_handler);
+    free(((TimerHandler *)session->timer_handler)->timers);
+    free(session->timer_handler);
 
-    pthread_mutex_destroy(&session->mutex);
+    free ( session->calls );
+    pthread_mutex_unlock(session->mutex);
+    pthread_mutex_destroy(session->mutex);
 
     LOGGER_DEBUG("Terminated session: %p", session);
     free ( session );
-    return _status;
+    return 0;
 }
 
-
-/**
- * @brief Send invite request to friend_id.
- *
- * @param session Control session.
- * @param call_type Type of the call. Audio or Video(both audio and video)
- * @param rngsec Ringing timeout.
- * @param friend_id The friend.
- * @return int
- */
-int msi_invite ( MSISession *session, int32_t *call_index, MSICSettings csettings, uint32_t rngsec, uint32_t friend_id )
+int msi_invite ( MSISession *session,
+                 int32_t *call_index,
+                 const MSICSettings *csettings,
+                 uint32_t rngsec,
+                 uint32_t friend_id )
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
 
     LOGGER_DEBUG("Session: %p Inviting friend: %u", session, friend_id);
 
@@ -1645,17 +1327,17 @@ int msi_invite ( MSISession *session, int32_t *call_index, MSICSettings csetting
     for (; i < session->max_calls; i ++)
         if (session->calls[i] && session->calls[i]->peers[0] == friend_id) {
             LOGGER_ERROR("Already in a call with friend %d", friend_id);
-            pthread_mutex_unlock(&session->mutex);
-            return -1;
+            pthread_mutex_unlock(session->mutex);
+            return msi_ErrorAlreadyInCallWithPeer;
         }
 
 
     MSICall *call = init_call ( session, 1, rngsec ); /* Just one peer for now */
 
     if ( !call ) {
-        pthread_mutex_unlock(&session->mutex);
+        pthread_mutex_unlock(session->mutex);
         LOGGER_ERROR("Cannot handle more calls");
-        return -1;
+        return msi_ErrorReachedCallLimit;
     }
 
     *call_index = call->call_idx;
@@ -1664,50 +1346,40 @@ int msi_invite ( MSISession *session, int32_t *call_index, MSICSettings csetting
 
     add_peer ( call, friend_id );
 
-    call->csettings_local = csettings;
+    call->csettings_local = *csettings;
 
     MSIMessage *msg_invite = msi_new_message ( TypeRequest, invite );
 
-    msi_msg_set_csettings(msg_invite, &csettings);
+    msi_msg_set_csettings(msg_invite, csettings);
     send_message ( session, call, msg_invite, friend_id );
     free( msg_invite );
 
-    call->state = call_inviting;
+    call->state = msi_CallInviting;
 
-    call->request_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, call->call_idx, m_deftout );
+    call->request_timer_id = timer_alloc ( session, handle_timeout, call->call_idx, m_deftout );
 
     LOGGER_DEBUG("Invite sent");
 
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
 
     return 0;
 }
 
-
-/**
- * @brief Hangup active call.
- *
- * @param session Control session.
- * @param call_id To which call is this action handled.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
 int msi_hangup ( MSISession *session, int32_t call_index )
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
     LOGGER_DEBUG("Session: %p Hanging up call: %u", session, call_index);
 
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
     }
 
-    if ( session->calls[call_index]->state != call_active ) {
-        LOGGER_ERROR("No call with such index or call is not active!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+    if ( session->calls[call_index]->state != msi_CallActive ) {
+        LOGGER_ERROR("Call is not active!");
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorInvalidState;
     }
 
     MSIMessage *msg_end = msi_new_message ( TypeRequest, end );
@@ -1718,70 +1390,64 @@ int msi_hangup ( MSISession *session, int32_t call_index )
     for ( ; it < session->calls[call_index]->peer_count; it ++ )
         send_message ( session, session->calls[call_index], msg_end, session->calls[call_index]->peers[it] );
 
-    session->calls[call_index]->state = call_hanged_up;
+    session->calls[call_index]->state = msi_CallOver;
 
     free ( msg_end );
 
     session->calls[call_index]->request_timer_id =
-        timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
+        timer_alloc ( session, handle_timeout, call_index, m_deftout );
 
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
     return 0;
 }
 
-
-/**
- * @brief Answer active call request.
- *
- * @param session Control session.
- * @param call_id To which call is this action handled.
- * @param call_type Answer with Audio or Video(both).
- * @return int
- */
-int msi_answer ( MSISession *session, int32_t call_index, MSICSettings csettings )
+int msi_answer ( MSISession *session, int32_t call_index, const MSICSettings *csettings )
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
     LOGGER_DEBUG("Session: %p Answering call: %u", session, call_index);
 
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
+    }
+
+    if ( session->calls[call_index]->state != msi_CallStarting ) {
+        LOGGER_ERROR("Call is in invalid state!");
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorInvalidState;
     }
 
     MSIMessage *msg_starting = msi_new_message ( TypeResponse, starting );
 
-    session->calls[call_index]->csettings_local = csettings;
+    session->calls[call_index]->csettings_local = *csettings;
 
-    msi_msg_set_csettings(msg_starting, &csettings);
+    msi_msg_set_csettings(msg_starting, csettings);
 
     send_message ( session, session->calls[call_index], msg_starting, session->calls[call_index]->peers[0] );
     free ( msg_starting );
 
-    session->calls[call_index]->state = call_active;
+    session->calls[call_index]->state = msi_CallActive;
 
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
     return 0;
 }
 
-
-/**
- * @brief Cancel request.
- *
- * @param session Control session.
- * @param call_id To which call is this action handled.
- * @param reason Set optional reason header. Pass NULL if none.
- * @return int
- */
 int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const char *reason )
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
     LOGGER_DEBUG("Session: %p Canceling call: %u; reason: %s", session, call_index, reason ? reason : "Unknown");
 
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
+    }
+
+    if ( session->calls[call_index]->state != msi_CallInviting ) {
+        LOGGER_ERROR("Call is in invalid state: %u", session->calls[call_index]->state);
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorInvalidState;
     }
 
     MSIMessage *msg_cancel = msi_new_message ( TypeRequest, cancel );
@@ -1805,28 +1471,26 @@ int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const c
     free ( msg_cancel );
 
     terminate_call ( session, session->calls[call_index] );
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
 
     return 0;
 }
 
-
-/**
- * @brief Reject request.
- *
- * @param session Control session.
- * @param call_id To which call is this action handled.
- * @return int
- */
 int msi_reject ( MSISession *session, int32_t call_index, const char *reason )
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
     LOGGER_DEBUG("Session: %p Rejecting call: %u; reason: %s", session, call_index, reason ? reason : "Unknown");
 
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
+    }
+
+    if ( session->calls[call_index]->state != msi_CallStarting ) {
+        LOGGER_ERROR("Call is in invalid state!");
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorInvalidState;
     }
 
     MSIMessage *msg_reject = msi_new_message ( TypeRequest, reject );
@@ -1850,62 +1514,69 @@ int msi_reject ( MSISession *session, int32_t call_index, const char *reason )
                    session->calls[call_index]->peers[session->calls[call_index]->peer_count - 1] );
     free ( msg_reject );
 
-    session->calls[call_index]->state = call_hanged_up;
+    session->calls[call_index]->state = msi_CallOver;
     session->calls[call_index]->request_timer_id =
-        timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
+        timer_alloc ( session, handle_timeout, call_index, m_deftout );
 
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
     return 0;
 }
 
+int msi_stopcall ( MSISession *session, int32_t call_index )
+{
+    pthread_mutex_lock(session->mutex);
+    LOGGER_DEBUG("Session: %p Stopping call index: %u", session, call_index);
 
-/**
- * @brief Send invite request to friend_id.
- *
- * @param session Control session.
- * @param call_index Call index.
- * @param call_type Type of the call. Audio or Video(both audio and video)
- * @param rngsec Ringing timeout.
- * @param friend_id The friend.
- * @return int
- */
-int msi_change_csettings(MSISession *session, int32_t call_index, MSICSettings csettings)
+    if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
+    }
+
+    /* just terminate it */
+
+    terminate_call ( session, session->calls[call_index] );
+
+    pthread_mutex_unlock(session->mutex);
+    return 0;
+}
+
+int msi_change_csettings(MSISession *session, int32_t call_index, const MSICSettings *csettings)
 {
-    pthread_mutex_lock(&session->mutex);
+    pthread_mutex_lock(session->mutex);
 
     LOGGER_DEBUG("Changing media on call: %d", call_index);
 
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorNoCall;
     }
 
     MSICall *call = session->calls[call_index];
 
-    if ( call->state != call_active ) {
+    if ( call->state != msi_CallActive ) {
         LOGGER_ERROR("Call is not active!");
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
+        pthread_mutex_unlock(session->mutex);
+        return msi_ErrorInvalidState;
     }
 
     MSICSettings *local = &call->csettings_local;
 
     if (
-        local->call_type == csettings.call_type &&
-        local->video_bitrate == csettings.video_bitrate &&
-        local->max_video_width == csettings.max_video_width &&
-        local->max_video_height == csettings.max_video_height &&
-        local->audio_bitrate == csettings.audio_bitrate &&
-        local->audio_frame_duration == csettings.audio_frame_duration &&
-        local->audio_sample_rate == csettings.audio_sample_rate &&
-        local->audio_channels == csettings.audio_channels ) {
+        local->call_type == csettings->call_type &&
+        local->video_bitrate == csettings->video_bitrate &&
+        local->max_video_width == csettings->max_video_width &&
+        local->max_video_height == csettings->max_video_height &&
+        local->audio_bitrate == csettings->audio_bitrate &&
+        local->audio_frame_duration == csettings->audio_frame_duration &&
+        local->audio_sample_rate == csettings->audio_sample_rate &&
+        local->audio_channels == csettings->audio_channels ) {
         LOGGER_ERROR("Call is already set accordingly!");
-        pthread_mutex_unlock(&session->mutex);
+        pthread_mutex_unlock(session->mutex);
         return -1;
     }
 
-    *local = csettings;
+    *local = *csettings;
 
     MSIMessage *msg_invite = msi_new_message ( TypeRequest, invite );
 
@@ -1915,33 +1586,29 @@ int msi_change_csettings(MSISession *session, int32_t call_index, MSICSettings c
 
     LOGGER_DEBUG("Request for media change sent");
 
-    pthread_mutex_unlock(&session->mutex);
+    pthread_mutex_unlock(session->mutex);
 
     return 0;
 }
 
-
-/**
- * @brief Terminate the current call.
- *
- * @param session Control session.
- * @param call_id To which call is this action handled.
- * @return int
- */
-int msi_stopcall ( MSISession *session, int32_t call_index )
+void msi_do(MSISession *session)
 {
-    pthread_mutex_lock(&session->mutex);
-    LOGGER_DEBUG("Session: %p Stopping call index: %u", session, call_index);
+    pthread_mutex_lock(session->mutex);
 
-    if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
-    }
+    TimerHandler *timer = session->timer_handler;
 
-    /* just terminate it */
+    uint64_t time = current_time_monotonic();
 
-    terminate_call ( session, session->calls[call_index] );
+    while ( timer->timers[0] && timer->timers[0]->timeout < time ) {
+        LOGGER_DEBUG("Executing timer assigned at: %d", timer->timers[0]->timeout);
 
-    pthread_mutex_unlock(&session->mutex);
-    return 0;
+        int id = timer->timers[0]->id;
+        timer->timers[0]->func(timer->timers[0]);
+
+        /* In case function has released timer */
+        if (timer->timers[0] && timer->timers[0]->id == id)
+            timer_release(timer, id);
+    }
+
+    pthread_mutex_unlock(session->mutex);
 }
diff --git a/toxav/msi.h b/toxav/msi.h
index 64fa0881..660df05e 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -25,37 +25,37 @@
 #include <inttypes.h>
 #include <pthread.h>
 
+#include "codec.h"
 #include "../toxcore/Messenger.h"
 
 typedef uint8_t MSICallIDType[12];
 typedef uint8_t MSIReasonStrType[255];
 typedef void ( *MSICallbackType ) ( void *agent, int32_t call_idx, void *arg );
 
-
 /**
- * @brief Call type identifier. Also used as rtp callback prefix.
+ * Call type identifier. Also used as rtp callback prefix.
  */
 typedef enum {
-    type_audio = 192,
-    type_video
+    msi_TypeAudio = 192,
+    msi_TypeVideo
 } MSICallType;
 
 
 /**
- * @brief Call state identifiers.
+ * Call state identifiers.
  */
 typedef enum {
-    call_inviting, /* when sending call invite */
-    call_starting, /* when getting call invite */
-    call_active,
-    call_hold,
-    call_hanged_up
+    msi_CallInviting, /* when sending call invite */
+    msi_CallStarting, /* when getting call invite */
+    msi_CallActive,
+    msi_CallHold,
+    msi_CallOver
 
 } MSICallState;
 
 
 /**
- * @brief Encoding settings.
+ * Encoding settings.
  */
 typedef struct _MSICodecSettings {
     MSICallType call_type;
@@ -72,46 +72,41 @@ typedef struct _MSICodecSettings {
 
 
 /**
- * @brief Callbacks ids that handle the states
+ * Callbacks ids that handle the states
  */
 typedef enum {
-    /* Requests */
-    MSI_OnInvite,
-    MSI_OnStart,
-    MSI_OnCancel,
-    MSI_OnReject,
-    MSI_OnEnd,
-
-    /* Responses */
-    MSI_OnRinging,
-    MSI_OnStarting,
-    MSI_OnEnding,
-
-    /* Protocol */
-    MSI_OnRequestTimeout,
-    MSI_OnPeerTimeout,
-    MSI_OnMediaChange
+    msi_OnInvite, /* Incoming call */
+    msi_OnRinging, /* When peer is ready to accept/reject the call */
+    msi_OnStart, /* Call (RTP transmission) started */
+    msi_OnCancel, /* The side that initiated call canceled invite */
+    msi_OnReject, /* The side that was invited rejected the call */
+    msi_OnEnd, /* Call that was active ended */
+    msi_OnRequestTimeout, /* When the requested action didn't get response in specified time */
+    msi_OnPeerTimeout, /* Peer timed out; stop the call */
+    msi_OnPeerCSChange, /* Peer requested Csettings change */
+    msi_OnSelfCSChange /* Csettings change confirmation */
 } MSICallbackID;
 
 /**
- * @brief Callbacks container
+ * Errors
  */
-typedef struct _MSICallbackCont {
-    MSICallbackType function;
-    void *data;
-} MSICallbackCont;
+typedef enum {
+    msi_ErrorNoCall = -20, /* Trying to perform call action while not in a call */
+    msi_ErrorInvalidState = -21, /* Trying to perform call action while in invalid state*/
+    msi_ErrorAlreadyInCallWithPeer = -22, /* Trying to call peer when already in a call with peer */
+    msi_ErrorReachedCallLimit = -23, /* Cannot handle more calls */
+} MSIError;
 
 /**
- * @brief The call struct.
- *
+ * The call struct.
  */
 typedef struct _MSICall {                  /* Call info structure */
     struct _MSISession *session;           /* Session pointer */
 
     MSICallState        state;
 
-    MSICSettings    csettings_local;   /* Local call settings */
-    MSICSettings   *csettings_peer;    /* Peers call settings */
+    MSICSettings        csettings_local;   /* Local call settings */
+    MSICSettings       *csettings_peer;    /* Peers call settings */
 
     MSICallIDType       id;                /* Random value identifying the call */
 
@@ -120,8 +115,6 @@ typedef struct _MSICall {                  /* Call info structure */
     int                 request_timer_id;  /* Timer id for outgoing request/action */
     int                 ringing_timer_id;  /* Timer id for ringing timeout */
 
-
-    pthread_mutex_t     mutex;             /* */
     uint32_t           *peers;
     uint16_t            peer_count;
 
@@ -130,8 +123,7 @@ typedef struct _MSICall {                  /* Call info structure */
 
 
 /**
- * @brief Control session struct
- *
+ * Control session struct
  */
 typedef struct _MSISession {
 
@@ -143,125 +135,71 @@ typedef struct _MSISession {
     Messenger      *messenger_handle;
 
     uint32_t        frequ;
-    uint32_t        call_timeout; /* Time of the timeout for some action to end; 0 if infinite */
+    uint32_t        call_timeout;  /* Time of the timeout for some action to end; 0 if infinite */
 
-    pthread_mutex_t mutex;
+    pthread_mutex_t mutex[1];
 
     void           *timer_handler;
-    MSICallbackCont callbacks[11];     /* Callbacks used by this session */
+    PAIR(MSICallbackType, void *) callbacks[10];
 } MSISession;
 
 /**
- * @brief Callback setter.
- *
- * @param session The container.
- * @param callback The callback.
- * @param id The id.
- * @return void
+ * Start the control session.
  */
-void msi_register_callback(MSISession *session, MSICallbackType callback, MSICallbackID id, void *userdata);
-
+MSISession *msi_new ( Messenger *messenger, int32_t max_calls );
 
 /**
- * @brief Start the control session.
- *
- * @param messenger Tox* object.
- * @param max_calls Amount of calls possible
- * @return MSISession* The created session.
- * @retval NULL Error occurred.
+ * Terminate control session.
  */
-MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls );
-
+int msi_kill ( MSISession *session );
 
 /**
- * @brief Terminate control session.
- *
- * @param session The session
- * @return int
+ * Callback setter.
  */
-int msi_terminate_session ( MSISession *session );
-
+void msi_register_callback(MSISession *session, MSICallbackType callback, MSICallbackID id, void *userdata);
 
 /**
- * @brief Send invite request to friend_id.
- *
- * @param session Control session.
- * @param call_index Set to new call index.
- * @param call_type Type of the call. Audio or Video(both audio and video)
- * @param rngsec Ringing timeout.
- * @param friend_id The friend.
- * @return int
+ * Send invite request to friend_id.
  */
-int msi_invite ( MSISession *session, int32_t *call_index, MSICSettings csettings, uint32_t rngsec,
+int msi_invite ( MSISession *session,
+                 int32_t *call_index,
+                 const MSICSettings *csettings,
+                 uint32_t rngsec,
                  uint32_t friend_id );
 
-
 /**
- * @brief Hangup active call.
- *
- * @param session Control session.
- * @param call_index To which call is this action handled.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
+ * Hangup active call.
  */
 int msi_hangup ( MSISession *session, int32_t call_index );
 
-
 /**
- * @brief Answer active call request.
- *
- * @param session Control session.
- * @param call_index To which call is this action handled.
- * @param call_type Answer with Audio or Video(both).
- * @return int
+ * Answer active call request.
  */
-int msi_answer ( MSISession *session, int32_t call_index, MSICSettings csettings );
-
+int msi_answer ( MSISession *session, int32_t call_index, const MSICSettings *csettings );
 
 /**
- * @brief Cancel request.
- *
- * @param session Control session.
- * @param call_index To which call is this action handled.
- * @param peer To which peer.
- * @param reason Set optional reason header. Pass NULL if none.
- * @return int
+ * Cancel request.
  */
 int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const char *reason );
 
-
 /**
- * @brief Reject request.
- *
- * @param session Control session.
- * @param call_index To which call is this action handled.
- * @param reason Set optional reason header. Pass NULL if none.
- * @return int
+ * Reject incoming call.
  */
 int msi_reject ( MSISession *session, int32_t call_index, const char *reason );
 
-
 /**
- * @brief Send invite request to friend_id.
- *
- * @param session Control session.
- * @param call_index Call index.
- * @param call_type Type of the call. Audio or Video(both audio and video)
- * @param rngsec Ringing timeout.
- * @param friend_id The friend.
- * @return int
+ * Terminate the call.
  */
-int msi_change_csettings ( MSISession *session, int32_t call_index, MSICSettings csettings );
+int msi_stopcall ( MSISession *session, int32_t call_index );
 
+/**
+ * Change codec settings of the current call.
+ */
+int msi_change_csettings ( MSISession *session, int32_t call_index, const MSICSettings *csettings );
 
 /**
- * @brief Terminate the current call.
- *
- * @param session Control session.
- * @param call_index To which call is this action handled.
- * @return int
+ * Main msi loop
  */
-int msi_stopcall ( MSISession *session, int32_t call_index );
+void msi_do( MSISession *session );
 
 #endif /* __TOXMSI */
diff --git a/toxav/rtp.c b/toxav/rtp.c
index de6c9c41..63c2cdcb 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -28,7 +28,7 @@
 
 #include "rtp.h"
 #include <stdlib.h>
-void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg);
+void queue_message(RTPSession *_session, RTPMessage *_msg);
 
 #define size_32 4
 
@@ -47,15 +47,9 @@ void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg);
 #define GET_SETTING_PAYLOAD(_h) ((_h->marker_payloadt) & 0x7f)
 
 /**
- * @brief Checks if message came in late.
- *
- * @param session Control session.
- * @param msg The message.
- * @return int
- * @retval -1 The message came in order.
- * @retval 0 The message came late.
+ * Checks if message came in late.
  */
-inline__ int check_late_message (RTPSession *session, RTPMessage *msg)
+static int check_late_message (RTPSession *session, RTPMessage *msg)
 {
     /*
      * Check Sequence number. If this new msg has lesser number then the session->rsequnum
@@ -67,12 +61,7 @@ inline__ int check_late_message (RTPSession *session, RTPMessage *msg)
 
 
 /**
- * @brief Extracts header from payload.
- *
- * @param payload The payload.
- * @param length The size of payload.
- * @return RTPHeader* Extracted header.
- * @retval NULL Error occurred while extracting header.
+ * Extracts header from payload.
  */
 RTPHeader *extract_header ( const uint8_t *payload, int length )
 {
@@ -81,29 +70,30 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
         return NULL;
     }
 
-    RTPHeader *_retu = calloc(1, sizeof (RTPHeader));
+    RTPHeader *retu = calloc(1, sizeof (RTPHeader));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    bytes_to_U16(&_retu->sequnum, payload);
+    memcpy(&retu->sequnum, payload, sizeof(retu->sequnum));
+    retu->sequnum = ntohs(retu->sequnum);
 
-    const uint8_t *_it = payload + 2;
+    const uint8_t *it = payload + 2;
 
-    _retu->flags = *_it;
-    ++_it;
+    retu->flags = *it;
+    ++it;
 
     /* This indicates if the first 2 bits are valid.
      * Now it may happen that this is out of order but
      * it cuts down chances of parsing some invalid value
      */
 
-    if ( GET_FLAG_VERSION(_retu) != RTP_VERSION ) {
+    if ( GET_FLAG_VERSION(retu) != RTP_VERSION ) {
         /* Deallocate */
         LOGGER_WARNING("Invalid version!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
@@ -111,297 +101,276 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
      * Added a check for the size of the header little sooner so
      * I don't need to parse the other stuff if it's bad
      */
-    uint8_t _cc = GET_FLAG_CSRCC ( _retu );
-    int _length = 12 /* Minimum header len */ + ( _cc * 4 );
+    uint8_t cc = GET_FLAG_CSRCC ( retu );
+    int total = 12 /* Minimum header len */ + ( cc * 4 );
 
-    if ( length < _length ) {
+    if ( length < total ) {
         /* Deallocate */
         LOGGER_WARNING("Length invalid!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    memset(_retu->csrc, 0, 16 * sizeof (uint32_t));
+    memset(retu->csrc, 0, 16 * sizeof (uint32_t));
 
-    _retu->marker_payloadt = *_it;
-    ++_it;
-    _retu->length = _length;
+    retu->marker_payloadt = *it;
+    ++it;
+    retu->length = total;
 
 
-    bytes_to_U32(&_retu->timestamp, _it);
-    _it += 4;
-    bytes_to_U32(&_retu->ssrc, _it);
+    memcpy(&retu->timestamp, it, sizeof(retu->timestamp));
+    retu->timestamp = ntohl(retu->timestamp);
+    it += 4;
+    memcpy(&retu->ssrc, it, sizeof(retu->ssrc));
+    retu->ssrc = ntohl(retu->ssrc);
 
-    uint8_t _x;
+    uint8_t x;
 
-    for ( _x = 0; _x < _cc; _x++ ) {
-        _it += 4;
-        bytes_to_U32(&(_retu->csrc[_x]), _it);
+    for ( x = 0; x < cc; x++ ) {
+        it += 4;
+        memcpy(&retu->csrc[x], it, sizeof(retu->csrc[x]));
+        retu->csrc[x] = ntohl(retu->csrc[x]);
     }
 
-    return _retu;
+    return retu;
 }
 
 /**
- * @brief Extracts external header from payload. Must be called AFTER extract_header()!
- *
- * @param payload The ITERATED payload.
- * @param length The size of payload.
- * @return RTPExtHeader* Extracted extension header.
- * @retval NULL Error occurred while extracting extension header.
+ * Extracts external header from payload. Must be called AFTER extract_header()!
  */
 RTPExtHeader *extract_ext_header ( const uint8_t *payload, uint16_t length )
 {
-    const uint8_t *_it = payload;
+    const uint8_t *it = payload;
 
-    RTPExtHeader *_retu = calloc(1, sizeof (RTPExtHeader));
+    RTPExtHeader *retu = calloc(1, sizeof (RTPExtHeader));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    uint16_t _ext_length;
-    bytes_to_U16(&_ext_length, _it);
-    _it += 2;
+    uint16_t ext_length;
+    memcpy(&ext_length, it, sizeof(ext_length));
+    ext_length = ntohs(ext_length);
+    it += 2;
 
 
-    if ( length < ( _ext_length * sizeof(uint32_t) ) ) {
+    if ( length < ( ext_length * sizeof(uint32_t) ) ) {
         LOGGER_WARNING("Length invalid!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    _retu->length  = _ext_length;
-    bytes_to_U16(&_retu->type, _it);
-    _it += 2;
+    retu->length  = ext_length;
+    memcpy(&retu->type, it, sizeof(retu->type));
+    retu->type = ntohs(retu->type);
+    it += 2;
 
-    if ( !(_retu->table = calloc(_ext_length, sizeof (uint32_t))) ) {
+    if ( !(retu->table = calloc(ext_length, sizeof (uint32_t))) ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    uint16_t _x;
+    uint16_t x;
 
-    for ( _x = 0; _x < _ext_length; _x++ ) {
-        _it += 4;
-        bytes_to_U32(&(_retu->table[_x]), _it);
+    for ( x = 0; x < ext_length; x++ ) {
+        it += 4;
+        memcpy(&(retu->table[x]), it, sizeof(retu->table[x]));
+        retu->table[x] = ntohl(retu->table[x]);
     }
 
-    return _retu;
+    return retu;
 }
 
 /**
- * @brief Adds header to payload. Make sure _payload_ has enough space.
- *
- * @param header The header.
- * @param payload The payload.
- * @return uint8_t* Iterated position.
+ * Adds header to payload. Make sure _payload_ has enough space.
  */
 uint8_t *add_header ( RTPHeader *header, uint8_t *payload )
 {
-    uint8_t _cc = GET_FLAG_CSRCC ( header );
-
-    uint8_t *_it = payload;
+    uint8_t cc = GET_FLAG_CSRCC ( header );
+    uint8_t *it = payload;
+    uint16_t sequnum;
+    uint32_t timestamp;
+    uint32_t ssrc;
+    uint32_t csrc;
 
 
     /* Add sequence number first */
-    U16_to_bytes(_it, header->sequnum);
-    _it += 2;
+    sequnum = htons(header->sequnum);
+    memcpy(it, &sequnum, sizeof(sequnum));
+    it += 2;
 
-    *_it = header->flags;
-    ++_it;
-    *_it = header->marker_payloadt;
-    ++_it;
+    *it = header->flags;
+    ++it;
+    *it = header->marker_payloadt;
+    ++it;
 
 
-    U32_to_bytes( _it, header->timestamp);
-    _it += 4;
-    U32_to_bytes( _it, header->ssrc);
+    timestamp = htonl(header->timestamp);
+    memcpy(it, &timestamp, sizeof(timestamp));
+    it += 4;
+    ssrc = htonl(header->ssrc);
+    memcpy(it, &ssrc, sizeof(ssrc));
 
-    uint8_t _x;
+    uint8_t x;
 
-    for ( _x = 0; _x < _cc; _x++ ) {
-        _it += 4;
-        U32_to_bytes( _it, header->csrc[_x]);
+    for ( x = 0; x < cc; x++ ) {
+        it += 4;
+        csrc = htonl(header->csrc[x]);
+        memcpy(it, &csrc, sizeof(csrc));
     }
 
-    return _it + 4;
+    return it + 4;
 }
 
 /**
- * @brief Adds extension header to payload. Make sure _payload_ has enough space.
- *
- * @param header The header.
- * @param payload The payload.
- * @return uint8_t* Iterated position.
+ * Adds extension header to payload. Make sure _payload_ has enough space.
  */
 uint8_t *add_ext_header ( RTPExtHeader *header, uint8_t *payload )
 {
-    uint8_t *_it = payload;
-
-    U16_to_bytes(_it, header->length);
-    _it += 2;
-    U16_to_bytes(_it, header->type);
-    _it -= 2; /* Return to 0 position */
+    uint8_t *it = payload;
+    uint16_t length;
+    uint16_t type;
+    uint32_t entry;
+
+    length = htons(header->length);
+    memcpy(it, &length, sizeof(length));
+    it += 2;
+    type = htons(header->type);
+    memcpy(it, &type, sizeof(type));
+    it -= 2; /* Return to 0 position */
 
     if ( header->table ) {
-        uint16_t _x;
 
-        for ( _x = 0; _x < header->length; _x++ ) {
-            _it += 4;
-            U32_to_bytes(_it, header->table[_x]);
+        uint16_t x;
+
+        for ( x = 0; x < header->length; x++ ) {
+            it += 4;
+            entry = htonl(header->table[x]);
+            memcpy(it, &entry, sizeof(entry));
         }
     }
 
-    return _it + 4;
+    return it + 4;
 }
 
 /**
- * @brief Builds header from control session values.
- *
- * @param session Control session.
- * @return RTPHeader* Created header.
+ * Builds header from control session values.
  */
 RTPHeader *build_header ( RTPSession *session )
 {
-    RTPHeader *_retu = calloc ( 1, sizeof (RTPHeader) );
+    RTPHeader *retu = calloc ( 1, sizeof (RTPHeader) );
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    ADD_FLAG_VERSION ( _retu, session->version );
-    ADD_FLAG_PADDING ( _retu, session->padding );
-    ADD_FLAG_EXTENSION ( _retu, session->extension );
-    ADD_FLAG_CSRCC ( _retu, session->cc );
-    ADD_SETTING_MARKER ( _retu, session->marker );
-    ADD_SETTING_PAYLOAD ( _retu, session->payload_type );
+    ADD_FLAG_VERSION ( retu, session->version );
+    ADD_FLAG_PADDING ( retu, session->padding );
+    ADD_FLAG_EXTENSION ( retu, session->extension );
+    ADD_FLAG_CSRCC ( retu, session->cc );
+    ADD_SETTING_MARKER ( retu, session->marker );
+    ADD_SETTING_PAYLOAD ( retu, session->payload_type );
 
-    _retu->sequnum = session->sequnum;
-    _retu->timestamp = current_time_monotonic(); /* milliseconds */
-    _retu->ssrc = session->ssrc;
+    retu->sequnum = session->sequnum;
+    retu->timestamp = current_time_monotonic(); /* milliseconds */
+    retu->ssrc = session->ssrc;
 
     int i;
 
     for ( i = 0; i < session->cc; i++ )
-        _retu->csrc[i] = session->csrc[i];
+        retu->csrc[i] = session->csrc[i];
 
-    _retu->length = 12 /* Minimum header len */ + ( session->cc * size_32 );
+    retu->length = 12 /* Minimum header len */ + ( session->cc * size_32 );
 
-    return _retu;
+    return retu;
 }
 
 
 /**
- * @brief Parses data into RTPMessage struct. Stores headers separately from the payload data
- *        and so the length variable is set accordingly. _sequnum_ argument is
- *        passed by the handle_packet() since it's parsed already.
- *
- * @param session Control session.
- * @param sequnum Sequence number that's parsed from payload in handle_packet()
- * @param data Payload data.
- * @param length Payload size.
- * @return RTPMessage*
- * @retval NULL Error occurred.
+ * Parses data into RTPMessage struct. Stores headers separately from the payload data
+ * and so the length variable is set accordingly.
  */
 RTPMessage *msg_parse ( const uint8_t *data, int length )
 {
-    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
+    RTPMessage *retu = calloc(1, sizeof (RTPMessage));
 
-    _retu->header = extract_header ( data, length ); /* It allocates memory and all */
+    retu->header = extract_header ( data, length ); /* It allocates memory and all */
 
-    if ( !_retu->header ) {
+    if ( !retu->header ) {
         LOGGER_WARNING("Header failed to extract!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    uint16_t _from_pos = _retu->header->length;
-    _retu->length = length - _from_pos;
+    uint16_t from_pos = retu->header->length;
+    retu->length = length - from_pos;
 
 
 
-    if ( GET_FLAG_EXTENSION ( _retu->header ) ) {
-        _retu->ext_header = extract_ext_header ( data + _from_pos, length );
+    if ( GET_FLAG_EXTENSION ( retu->header ) ) {
+        retu->ext_header = extract_ext_header ( data + from_pos, length );
 
-        if ( _retu->ext_header ) {
-            _retu->length -= ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
-            _from_pos += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+        if ( retu->ext_header ) {
+            retu->length -= ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
+            from_pos += ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
         } else { /* Error */
             LOGGER_WARNING("Ext Header failed to extract!");
-            rtp_free_msg(NULL, _retu);
+            rtp_free_msg(NULL, retu);
             return NULL;
         }
     } else {
-        _retu->ext_header = NULL;
+        retu->ext_header = NULL;
     }
 
-    if ( length - _from_pos <= MAX_RTP_SIZE )
-        memcpy ( _retu->data, data + _from_pos, length - _from_pos );
+    if ( length - from_pos <= MAX_RTP_SIZE )
+        memcpy ( retu->data, data + from_pos, length - from_pos );
     else {
         LOGGER_WARNING("Invalid length!");
-        rtp_free_msg(NULL, _retu);
+        rtp_free_msg(NULL, retu);
         return NULL;
     }
 
-    _retu->next = NULL;
+    retu->next = NULL;
 
-    return _retu;
+    return retu;
 }
 
 /**
- * @brief Callback for networking core.
- *
- * @param object RTPSession object.
- * @param ip_port Where the message comes from.
- * @param data Message data.
- * @param length Message length.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
+ * Callback for networking core.
  */
-int rtp_handle_packet ( void *object, const uint8_t *data, uint32_t length )
+int rtp_handle_packet ( Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t length, void *object )
 {
-    RTPSession *_session = object;
-    RTPMessage *_msg;
+    RTPSession *session = object;
+    RTPMessage *msg;
 
-    if ( !_session || length < 13 ) { /* 12 is the minimum length for rtp + desc. byte */
+    if ( !session || length < 13 ) { /* 12 is the minimum length for rtp + desc. byte */
         LOGGER_WARNING("No session or invalid length of received buffer!");
         return -1;
     }
 
-    _msg = msg_parse ( data + 1, length - 1 );
+    msg = msg_parse ( data + 1, length - 1 );
 
-    if ( !_msg ) {
+    if ( !msg ) {
         LOGGER_WARNING("Could not parse message!");
         return -1;
     }
 
     /* Check if message came in late */
-    if ( check_late_message(_session, _msg) < 0 ) { /* Not late */
-        _session->rsequnum = _msg->header->sequnum;
-        _session->timestamp = _msg->header->timestamp;
+    if ( check_late_message(session, msg) < 0 ) { /* Not late */
+        session->rsequnum = msg->header->sequnum;
+        session->timestamp = msg->header->timestamp;
     }
 
-    toxav_handle_packet(_session, _msg);
+    queue_message(session, msg);
 
     return 0;
 }
 
-
-
 /**
- * @brief Stores headers and payload data in one container ( data )
- *        and the length is set accordingly. Returned message is used for sending _only_.
- *
- * @param session The control session.
- * @param data Payload data to send ( This is what you pass ).
- * @param length Size of the payload data.
- * @return RTPMessage* Created message.
- * @retval NULL Error occurred.
+ * Allocate message and store data there
  */
 RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t length )
 {
@@ -410,30 +379,30 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
         return NULL;
     }
 
-    uint8_t *_from_pos;
-    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
+    uint8_t *from_pos;
+    RTPMessage *retu = calloc(1, sizeof (RTPMessage));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    /* Sets header values and copies the extension header in _retu */
-    _retu->header = build_header ( session ); /* It allocates memory and all */
-    _retu->ext_header = session->ext_header;
+    /* Sets header values and copies the extension header in retu */
+    retu->header = build_header ( session ); /* It allocates memory and all */
+    retu->ext_header = session->ext_header;
 
 
-    uint32_t _total_length = length + _retu->header->length + 1;
+    uint32_t total_length = length + retu->header->length + 1;
 
-    _retu->data[0] = session->prefix;
+    retu->data[0] = session->prefix;
 
-    if ( _retu->ext_header ) {
-        _total_length += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+    if ( retu->ext_header ) {
+        total_length += ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
 
-        _from_pos = add_header ( _retu->header, _retu->data + 1 );
-        _from_pos = add_ext_header ( _retu->ext_header, _from_pos + 1 );
+        from_pos = add_header ( retu->header, retu->data + 1 );
+        from_pos = add_ext_header ( retu->ext_header, from_pos + 1 );
     } else {
-        _from_pos = add_header ( _retu->header, _retu->data + 1 );
+        from_pos = add_header ( retu->header, retu->data + 1 );
     }
 
     /*
@@ -441,41 +410,28 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
      * Of course if any
      */
 
-    /* Appends _data on to _retu->_data */
-    memcpy ( _from_pos, data, length );
+    /* Appends data on to retu->data */
+    memcpy ( from_pos, data, length );
 
-    _retu->length = _total_length;
+    retu->length = total_length;
 
-    _retu->next = NULL;
+    retu->next = NULL;
 
-    return _retu;
+    return retu;
 }
 
 
-/**
- * @brief Sends data to _RTPSession::dest
- *
- * @param session The session.
- * @param messenger Tox* object.
- * @param data The payload.
- * @param length Size of the payload.
- * @return int
- * @retval -1 On error.
- * @retval 0 On success.
- */
+
 int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *data, uint16_t length )
 {
     RTPMessage *msg = rtp_new_message (session, data, length);
 
-    if ( !msg ) {
-        LOGGER_WARNING("No session!");
-        return -1;
-    }
+    if ( !msg ) return -1;
 
     if ( -1 == send_custom_lossy_packet(messenger, session->dest, msg->data, msg->length) ) {
-        LOGGER_WARNING("Failed to send full packet! std error: %s", strerror(errno));
+        LOGGER_WARNING("Failed to send full packet (len: %d)! std error: %s", length, strerror(errno));
         rtp_free_msg ( session, msg );
-        return -1;
+        return rtp_ErrorSending;
     }
 
 
@@ -486,15 +442,6 @@ int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *dat
     return 0;
 }
 
-
-/**
- * @brief Speaks for it self.
- *
- * @param session The control session msg belongs to. You set it as NULL when freeing recved messages.
- *                Otherwise set it to session the message was created from.
- * @param msg The message.
- * @return void
- */
 void rtp_free_msg ( RTPSession *session, RTPMessage *msg )
 {
     if ( !session ) {
@@ -513,77 +460,57 @@ void rtp_free_msg ( RTPSession *session, RTPMessage *msg )
     free ( msg );
 }
 
-/**
- * @brief Must be called before calling any other rtp function. It's used
- *        to initialize RTP control session.
- *
- * @param payload_type Type of payload used to send. You can use values in toxmsi.h::MSICallType
- * @param messenger Tox* object.
- * @param friend_num Friend id.
- * @return RTPSession* Created control session.
- * @retval NULL Error occurred.
- */
-RTPSession *rtp_init_session ( int payload_type, Messenger *messenger, int friend_num )
+RTPSession *rtp_new ( int payload_type, Messenger *messenger, int friend_num )
 {
-    RTPSession *_retu = calloc(1, sizeof(RTPSession));
+    RTPSession *retu = calloc(1, sizeof(RTPSession));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, _retu)) {
+    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, retu)) {
         LOGGER_ERROR("Error setting custom register handler for rtp session");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
     LOGGER_DEBUG("Registered packet handler: pt: %d; fid: %d", payload_type, friend_num);
 
-    _retu->version   = RTP_VERSION;   /* It's always 2 */
-    _retu->padding   = 0;             /* If some additional data is needed about the packet */
-    _retu->extension = 0;           /* If extension to header is needed */
-    _retu->cc        = 1;           /* Amount of contributors */
-    _retu->csrc      = NULL;        /* Container */
-    _retu->ssrc      = random_int();
-    _retu->marker    = 0;
-    _retu->payload_type = payload_type % 128;
+    retu->version   = RTP_VERSION;   /* It's always 2 */
+    retu->padding   = 0;             /* If some additional data is needed about the packet */
+    retu->extension = 0;           /* If extension to header is needed */
+    retu->cc        = 1;           /* Amount of contributors */
+    retu->csrc      = NULL;        /* Container */
+    retu->ssrc      = random_int();
+    retu->marker    = 0;
+    retu->payload_type = payload_type % 128;
 
-    _retu->dest = friend_num;
+    retu->dest = friend_num;
 
-    _retu->rsequnum = _retu->sequnum = 0;
+    retu->rsequnum = retu->sequnum = 0;
 
-    _retu->ext_header = NULL; /* When needed allocate */
+    retu->ext_header = NULL; /* When needed allocate */
 
 
-    if ( !(_retu->csrc = calloc(1, sizeof (uint32_t))) ) {
+    if ( !(retu->csrc = calloc(1, sizeof (uint32_t))) ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    _retu->csrc[0] = _retu->ssrc; /* Set my ssrc to the list receive */
+    retu->csrc[0] = retu->ssrc; /* Set my ssrc to the list receive */
 
     /* Also set payload type as prefix */
-    _retu->prefix = payload_type;
+    retu->prefix = payload_type;
 
     /*
      *
      */
-    return _retu;
+    return retu;
 }
 
-
-/**
- * @brief Terminate the session.
- *
- * @param session The session.
- * @param messenger The messenger who owns the session
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
-void rtp_terminate_session ( RTPSession *session, Messenger *messenger )
+void rtp_kill ( RTPSession *session, Messenger *messenger )
 {
     if ( !session ) return;
 
diff --git a/toxav/rtp.h b/toxav/rtp.h
index d57c5ef7..c98840ac 100644
--- a/toxav/rtp.h
+++ b/toxav/rtp.h
@@ -24,21 +24,19 @@
 
 #define RTP_VERSION 2
 #include <inttypes.h>
-#include <pthread.h>
+// #include <pthread.h>
 
-#include "../toxcore/util.h"
-#include "../toxcore/network.h"
-#include "../toxcore/net_crypto.h"
 #include "../toxcore/Messenger.h"
 
 #define MAX_SEQU_NUM 65535
 #define MAX_RTP_SIZE 65535
 
+typedef enum {
+    rtp_ErrorSending = -40
+} RTPError;
 /**
- * @brief Standard rtp header
- *
+ * Standard rtp header
  */
-
 typedef struct _RTPHeader {
     uint8_t  flags;             /* Version(2),Padding(1), Ext(1), Cc(4) */
     uint8_t  marker_payloadt;   /* Marker(1), PlayLoad Type(7) */
@@ -50,10 +48,8 @@ typedef struct _RTPHeader {
 
 } RTPHeader;
 
-
 /**
- * @brief Standard rtp extension header.
- *
+ * Standard rtp extension header.
  */
 typedef struct _RTPExtHeader {
     uint16_t  type;          /* Extension profile */
@@ -62,10 +58,8 @@ typedef struct _RTPExtHeader {
 
 } RTPExtHeader;
 
-
 /**
- * @brief Standard rtp message.
- *
+ * Standard rtp message.
  */
 typedef struct _RTPMessage {
     RTPHeader    *header;
@@ -77,14 +71,8 @@ typedef struct _RTPMessage {
     struct _RTPMessage   *next;
 } RTPMessage;
 
-
 /**
- * @brief Our main session descriptor.
- *        It measures the session variables and controls
- *        the entire session. There are functions for manipulating
- *        the session so tend to use those instead of directly modifying
- *        session parameters.
- *
+ * RTP control session.
  */
 typedef struct _RTPSession {
     uint8_t         version;
@@ -109,88 +97,31 @@ typedef struct _RTPSession {
     uint8_t         prefix;
 
     int             dest;
-    int32_t         call_index;
-    struct _ToxAv *av;
-
-} RTPSession;
 
+    struct _CSSession *cs;
 
-/**
- * @brief Release all messages held by session.
- *
- * @param session The session.
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
-int rtp_release_session_recv ( RTPSession *session );
-
+} RTPSession;
 
 /**
- * @brief Call this to change queue limit
- *
- * @param session The session
- * @param limit new limit
- * @return void
+ * Must be called before calling any other rtp function.
  */
-void rtp_queue_adjust_limit ( RTPSession *session, uint64_t limit );
+RTPSession *rtp_new ( int payload_type, Messenger *messenger, int friend_num );
 
 /**
- * @brief Get's oldest message in the list.
- *
- * @param session Where the list is.
- * @return RTPMessage* The message. You need to call rtp_msg_free() to free it.
- * @retval NULL No messages in the list, or no list.
+ * Terminate the session.
  */
-RTPMessage *rtp_recv_msg ( RTPSession *session );
-
+void rtp_kill ( RTPSession *session, Messenger *messenger );
 
 /**
- * @brief Sends msg to _RTPSession::dest
- *
- * @param session The session.
- * @param msg The message
- * @param messenger Tox* object.
- * @return int
- * @retval -1 On error.
- * @retval 0 On success.
+ * Sends msg to _RTPSession::dest
  */
 int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *data, uint16_t length );
 
-
 /**
- * @brief Speaks for it self.
- *
- * @param session The control session msg belongs to. It can be NULL.
- * @param msg The message.
- * @return void
+ * Dealloc msg.
  */
 void rtp_free_msg ( RTPSession *session, RTPMessage *msg );
 
-/**
- * @brief Must be called before calling any other rtp function. It's used
- *        to initialize RTP control session.
- *
- * @param payload_type Type of payload used to send. You can use values in toxmsi.h::MSICallType
- * @param messenger Tox* object.
- * @param friend_num Friend id.
- * @return RTPSession* Created control session.
- * @retval NULL Error occurred.
- */
-RTPSession *rtp_init_session ( int payload_type, Messenger *messenger, int friend_num );
-
-
-/**
- * @brief Terminate the session.
- *
- * @param session The session.
- * @param messenger The messenger who owns the session
- * @return int
- * @retval -1 Error occurred.
- * @retval 0 Success.
- */
-void rtp_terminate_session ( RTPSession *session, Messenger *messenger );
-
 
 
 #endif /* __TOXRTP */
diff --git a/toxav/toxav.c b/toxav/toxav.c
index cd0ec70e..f8605fd5 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -23,15 +23,17 @@
 #include "config.h"
 #endif /* HAVE_CONFIG_H */
 
+#define __TOX_DEFINED__
+typedef struct Messenger Tox;
 
 #define _GNU_SOURCE /* implicit declaration warning */
 
-#include "rtp.h"
 #include "codec.h"
 #include "msi.h"
-#include "toxav.h"
+#include "group.h"
 
 #include "../toxcore/logger.h"
+#include "../toxcore/util.h"
 
 #include <assert.h>
 #include <stdlib.h>
@@ -39,134 +41,64 @@
 
 /* Assume 24 fps*/
 #define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
-#define MAX_DECODE_TIME_US 0
-
-#define MAX_VIDEOFRAME_SIZE 0x40000 /* 256KiB */
-#define VIDEOFRAME_PIECE_SIZE 0x500 /* 1.25 KiB*/
-#define VIDEOFRAME_HEADER_SIZE 0x2
-
-
-#define inline__ inline __attribute__((always_inline))
-
-/* call index invalid: true if invalid */
-#define cii(c_idx, session) (c_idx < 0 || c_idx >= session->max_calls)
 
+/* true if invalid call index */
+#define CALL_INVALID_INDEX(idx, max) (idx < 0 || idx >= max)
 
 const ToxAvCSettings av_DefaultSettings = {
-    TypeAudio,
+    av_TypeAudio,
 
     500,
     1280,
     720,
 
-    64000,
+    32000,
     20,
     48000,
     1
 };
 
-const uint32_t av_jbufdc = 3;
-const uint32_t av_VADd = 40;
-
-
+static const uint32_t jbuf_capacity = 6;
 static const uint8_t audio_index = 0, video_index = 1;
 
-typedef struct {
-    uint32_t size;
-    uint8_t data[0];
-} DECODE_PACKET;
-
-#define VIDEO_DECODE_QUEUE_SIZE 2
-#define AUDIO_DECODE_QUEUE_SIZE 16
-
-typedef struct _CallSpecific {
+typedef struct _ToxAvCall {
+    pthread_mutex_t mutex[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 */
-    CodecState *cs;/** Each call have its own encoders and decoders.
-                     * You can, but don't have to, reuse encoders for
-                     * multiple calls. If you choose to reuse encoders,
-                     * make sure to also reuse encoded payload for every call.
-                     * Decoders have to be unique for each call. FIXME: Now add refcounted encoders and
-                     * reuse them really.
-                     */
-    JitterBuffer *j_buf; /** Jitter buffer for audio */
-
-    uint32_t frame_limit; /* largest address written to in frame_buf for current input frame*/
-    uint8_t frame_id, frame_outid; /* id of input and output video frame */
-    void *frame_buf; /* buffer for split video payloads */
-
-    _Bool call_active;
-    pthread_mutex_t mutex;
-
-    /* used in the "decode on another thread" system */
-    volatile _Bool exit, decoding;
-    uint8_t video_decode_read, video_decode_write, audio_decode_read, audio_decode_write;
-    pthread_mutex_t decode_cond_mutex;
-    pthread_cond_t decode_cond;
-    DECODE_PACKET *volatile video_decode_queue[VIDEO_DECODE_QUEUE_SIZE];
-    DECODE_PACKET *volatile audio_decode_queue[AUDIO_DECODE_QUEUE_SIZE];
-} CallSpecific;
+    CSSession *cs;
+    _Bool active;
+} ToxAvCall;
 
 struct _ToxAv {
     Messenger *messenger;
     MSISession *msi_session; /** Main msi session */
-    CallSpecific *calls; /** Per-call params */
-
-    void (*audio_callback)(ToxAv *, int32_t, int16_t *, int, void *);
-    void (*video_callback)(ToxAv *, int32_t, vpx_image_t *, void *);
+    ToxAvCall *calls; /** Per-call params */
+    uint32_t max_calls;
 
-    void *audio_callback_userdata;
-    void *video_callback_userdata;
+    PAIR(ToxAvAudioCallback, void *) acb;
+    PAIR(ToxAvVideoCallback, void *) vcb;
 
-    uint32_t max_calls;
+    /* Decode time measure */
+    int32_t dectmsscount; /** Measure count */
+    int32_t dectmsstotal; /** Last cycle total */
+    int32_t avgdectms; /** Average decoding time in ms */
 };
 
-static void *toxav_decoding(void *arg);
-
-static MSICSettings msicsettings_cast (const ToxAvCSettings *from)
+static const MSICSettings *msicsettings_cast (const ToxAvCSettings *from)
 {
-    MSICSettings csettings;
-    csettings.call_type = from->call_type;
-
-    csettings.video_bitrate = from->video_bitrate;
-    csettings.max_video_width = from->max_video_width;
-    csettings.max_video_height = from->max_video_height;
-
-    csettings.audio_bitrate = from->audio_bitrate;
-    csettings.audio_frame_duration = from->audio_frame_duration;
-    csettings.audio_sample_rate = from->audio_sample_rate;
-    csettings.audio_channels = from->audio_channels;
-
-    return csettings;
+    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
+    return (const MSICSettings *) from;
 }
 
-static ToxAvCSettings toxavcsettings_cast (const MSICSettings *from)
+static const ToxAvCSettings *toxavcsettings_cast (const MSICSettings *from)
 {
-    ToxAvCSettings csettings;
-    csettings.call_type = from->call_type;
-
-    csettings.video_bitrate = from->video_bitrate;
-    csettings.max_video_width = from->max_video_width;
-    csettings.max_video_height = from->max_video_height;
-
-    csettings.audio_bitrate = from->audio_bitrate;
-    csettings.audio_frame_duration = from->audio_frame_duration;
-    csettings.audio_sample_rate = from->audio_sample_rate;
-    csettings.audio_channels = from->audio_channels;
+    assert(sizeof(MSICSettings) == sizeof(ToxAvCSettings));
+    return (const ToxAvCSettings *) from;
 
-    return csettings;
 }
 
-/**
- * @brief Start new A/V session. There can only be one session at the time. If you register more
- *        it will result in undefined behaviour.
- *
- * @param messenger The messenger handle.
- * @param userdata The agent handling A/V session (i.e. phone).
- * @param video_width Width of video frame.
- * @param video_height Height of video frame.
- * @return ToxAv*
- * @retval NULL On error.
- */
 ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
 {
     ToxAv *av = calloc ( sizeof(ToxAv), 1);
@@ -177,556 +109,371 @@ ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
     }
 
     av->messenger = (Messenger *)messenger;
-    av->msi_session = msi_init_session(av->messenger, max_calls);
+    av->msi_session = msi_new(av->messenger, max_calls);
     av->msi_session->agent_handler = av;
-    av->calls = calloc(sizeof(CallSpecific), max_calls);
+    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) != 0 ) {
+            LOGGER_WARNING("Failed to init call(%u) mutex!", i);
+            msi_kill(av->msi_session);
+
+            free(av->calls);
+            free(av);
+            return NULL;
+        }
+    }
+
     return av;
 }
 
-/**
- * @brief Remove A/V session.
- *
- * @param av Handler.
- * @return void
- */
 void toxav_kill ( ToxAv *av )
 {
     uint32_t i;
 
     for (i = 0; i < av->max_calls; i ++) {
         if ( av->calls[i].crtps[audio_index] )
-            rtp_terminate_session(av->calls[i].crtps[audio_index], av->msi_session->messenger_handle);
+            rtp_kill(av->calls[i].crtps[audio_index], av->msi_session->messenger_handle);
 
 
         if ( av->calls[i].crtps[video_index] )
-            rtp_terminate_session(av->calls[i].crtps[video_index], av->msi_session->messenger_handle);
+            rtp_kill(av->calls[i].crtps[video_index], av->msi_session->messenger_handle);
 
+        if ( av->calls[i].cs )
+            cs_kill(av->calls[i].cs);
 
-
-        if ( av->calls[i].j_buf ) terminate_queue(av->calls[i].j_buf);
-
-        if ( av->calls[i].cs ) codec_terminate_session(av->calls[i].cs);
+        pthread_mutex_destroy(av->calls[i].mutex);
     }
 
-    msi_terminate_session(av->msi_session);
+    msi_kill(av->msi_session);
 
     free(av->calls);
     free(av);
 }
 
-/**
- * @brief Register callback for call state.
- *
- * @param av Handler.
- * @param callback The callback
- * @param id One of the ToxAvCallbackID values
- * @return void
- */
-void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback callback, ToxAvCallbackID id, void *userdata )
+uint32_t toxav_do_interval(ToxAv *av)
 {
-    msi_register_callback(av->msi_session, (MSICallbackType)callback, (MSICallbackID) id, userdata);
+    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);
+
+        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);
+    }
+
+    return rc < av->avgdectms ? 0 : rc - av->avgdectms;
 }
 
-/**
- * @brief Register callback for recieving audio data
- *
- * @param callback The callback
- * @return void
- */
-void toxav_register_audio_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, int16_t *, int, void *),
-        void *user_data)
+void toxav_do(ToxAv *av)
 {
-    av->audio_callback = callback;
-    av->audio_callback_userdata = user_data;
+    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);
+
+        if (av->calls[i].active) {
+            pthread_mutex_lock(av->calls[i].mutex_do);
+            pthread_mutex_unlock(av->calls[i].mutex);
+            cs_do(av->calls[i].cs);
+            pthread_mutex_unlock(av->calls[i].mutex_do);
+        } else {
+            pthread_mutex_unlock(av->calls[i].mutex);
+        }
+    }
+
+    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;
+    }
 }
 
-/**
- * @brief Register callback for recieving video data
- *
- * @param callback The callback
- * @return void
- */
-void toxav_register_video_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, vpx_image_t *, void *),
-        void *user_data)
+void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata )
 {
-    av->video_callback = callback;
-    av->video_callback_userdata = user_data;
+    msi_register_callback(av->msi_session, (MSICallbackType)cb, (MSICallbackID) id, userdata);
 }
 
-/**
- * @brief Call user. Use its friend_id.
- *
- * @param av Handler.
- * @param user The user.
- * @param call_type Call type.
- * @param ringing_seconds Ringing timeout.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-int toxav_call (ToxAv *av, int32_t *call_index, int user, const ToxAvCSettings *csettings, int ringing_seconds )
+void toxav_register_audio_callback(ToxAv *av, ToxAvAudioCallback cb, void *userdata)
 {
-    return msi_invite(av->msi_session, call_index, msicsettings_cast(csettings), ringing_seconds * 1000, user);
+    av->acb.first = cb;
+    av->acb.second = userdata;
 }
 
-/**
- * @brief Hangup active call.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-int toxav_hangup ( ToxAv *av, int32_t call_index )
+void toxav_register_video_callback(ToxAv *av, ToxAvVideoCallback cb, void *userdata)
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
+    av->vcb.first = cb;
+    av->vcb.second = userdata;
+}
 
-    if ( av->msi_session->calls[call_index]->state != call_active ) {
-        return ErrorInvalidState;
-    }
+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);
 }
 
-/**
- * @brief Answer incomming call.
- *
- * @param av Handler.
- * @param call_type Answer with...
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_answer ( ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings )
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
-
-    if ( av->msi_session->calls[call_index]->state != call_starting ) {
-        return ErrorInvalidState;
-    }
-
     return msi_answer(av->msi_session, call_index, msicsettings_cast(csettings));
 }
 
-/**
- * @brief Reject incomming call.
- *
- * @param av Handler.
- * @param reason Optional reason. Set NULL if none.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_reject ( ToxAv *av, int32_t call_index, const char *reason )
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
-
-    if ( av->msi_session->calls[call_index]->state != call_starting ) {
-        return ErrorInvalidState;
-    }
-
     return msi_reject(av->msi_session, call_index, reason);
 }
 
-/**
- * @brief Cancel outgoing request.
- *
- * @param av Handler.
- * @param reason Optional reason.
- * @param peer_id peer friend_id
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reason )
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
-
-    if ( av->msi_session->calls[call_index]->state != call_inviting ) {
-        return ErrorInvalidState;
-    }
-
     return msi_cancel(av->msi_session, call_index, peer_id, reason);
 }
 
-/**
- * @brief Notify peer that we are changing call type
- *
- * @param av Handler.
- * @return int
- * @param call_type Change to...
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings)
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
-
     return msi_change_csettings(av->msi_session, call_index, msicsettings_cast(csettings));
 }
 
-/**
- * @brief Terminate transmission. Note that transmission will be terminated without informing remote peer.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_stop_call ( ToxAv *av, int32_t call_index )
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
-        return ErrorNoCall;
-    }
-
     return msi_stopcall(av->msi_session, call_index);
 }
 
-/**
- * @brief Must be call before any RTP transmission occurs.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, uint32_t jbuf_capacity, uint32_t VAD_treshold,
-                                 int support_video )
+int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, int support_video )
 {
-    if ( !av->msi_session || cii(call_index, av->msi_session) ||
-            !av->msi_session->calls[call_index] || !av->msi_session->calls[call_index]->csettings_peer ||
-            av->calls[call_index].call_active) {
+    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 ErrorInternal;
+        return av_ErrorNoCall;
     }
 
-    CallSpecific *call = &av->calls[call_index];
+    ToxAvCall *call = &av->calls[call_index];
+
+    pthread_mutex_lock(call->mutex);
+
+    if (call->active) {
+        pthread_mutex_unlock(call->mutex);
+        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);
+        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);
+        return av_ErrorInitializingCodecs;
+    }
+
+    call->cs->agent = av;
+    call->cs->call_idx = call_index;
+
+    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_init_session(type_audio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
 
+    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");
-        return ErrorInternal;
+        goto error;
     }
 
-    call->crtps[audio_index]->call_index = call_index;
-    call->crtps[audio_index]->av = av;
+    call->crtps[audio_index]->cs = call->cs;
 
     if ( support_video ) {
         call->crtps[video_index] =
-            rtp_init_session(type_video, av->messenger, av->msi_session->calls[call_index]->peers[0]);
+            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]->call_index = call_index;
-        call->crtps[video_index]->av = av;
-
-        call->frame_limit = 0;
-        call->frame_id = 0;
-        call->frame_outid = 0;
-
-        call->frame_buf = calloc(MAX_VIDEOFRAME_SIZE, 1);
-
-        if (!call->frame_buf) {
-            LOGGER_WARNING("Frame buffer allocation failed!");
-            goto error;
-        }
-
-    }
-
-    if ( !(call->j_buf = create_queue(jbuf_capacity)) ) {
-        LOGGER_WARNING("Jitter buffer creaton failed!");
-        goto error;
-    }
-
-    ToxAvCSettings csettings_peer = toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_peer[0]);
-    ToxAvCSettings csettings_local = toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_local);
-    LOGGER_DEBUG(
-        "Type: %u \n"
-        "Video bitrate: %u \n"
-        "Video height: %u \n"
-        "Video width: %u \n"
-        "Audio bitrate: %u \n"
-        "Audio framedur: %u \n"
-        "Audio sample rate: %u \n"
-        "Audio channels: %u \n",
-        csettings_peer.call_type,
-        csettings_peer.video_bitrate,
-        csettings_peer.max_video_height,
-        csettings_peer.max_video_width,
-        csettings_peer.audio_bitrate,
-        csettings_peer.audio_frame_duration,
-        csettings_peer.audio_sample_rate,
-        csettings_peer.audio_channels );
-
-    if ( (call->cs = codec_init_session(csettings_local.audio_bitrate,
-                                        csettings_local.audio_frame_duration,
-                                        csettings_local.audio_sample_rate,
-                                        csettings_local.audio_channels,
-                                        csettings_peer.audio_channels,
-                                        VAD_treshold,
-                                        csettings_local.max_video_width,
-                                        csettings_local.max_video_height,
-                                        csettings_local.video_bitrate) )) {
-
-        if ( pthread_mutex_init(&call->mutex, NULL) != 0 ) goto error;
-
-        //todo: add error checks
-        pthread_mutex_init(&call->decode_cond_mutex, NULL);
-        pthread_cond_init(&call->decode_cond, NULL);
-
-        void **arg = malloc(2 * sizeof(void *));
-        arg[0] = av;
-        arg[1] = call;
-
-        pthread_t temp;
-        pthread_attr_t attr;
-
-        pthread_attr_init(&attr);
-        pthread_attr_setstacksize(&attr, 1 << 18);
-        pthread_create(&temp, &attr, toxav_decoding, arg);
-        pthread_attr_destroy(&attr);
-
-
-        LOGGER_WARNING("Got here");
-        call->call_active = 1;
-
-        return ErrorNone;
+        call->crtps[video_index]->cs = call->cs;
     }
 
+    call->active = 1;
+    pthread_mutex_unlock(call->mutex);
+    return av_ErrorNone;
 error:
-    rtp_terminate_session(call->crtps[audio_index], av->messenger);
-    rtp_terminate_session(call->crtps[video_index], av->messenger);
-    free(call->frame_buf);
-    terminate_queue(call->j_buf);
-    codec_terminate_session(call->cs);
+    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);
 
-    return ErrorInternal;
+    pthread_mutex_unlock(call->mutex);
+    return av_ErrorCreatingRtpSessions;
 }
 
-/**
- * @brief Call this at the end of the transmission.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
 int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
 {
-    if (cii(call_index, av->msi_session)) {
+    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
         LOGGER_WARNING("Invalid call index: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorNoCall;
     }
 
-    CallSpecific *call = &av->calls[call_index];
+    ToxAvCall *call = &av->calls[call_index];
 
-    pthread_mutex_lock(&call->mutex);
+    pthread_mutex_lock(call->mutex);
 
-    if (!call->call_active) {
-        pthread_mutex_unlock(&call->mutex);
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex);
         LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorInvalidState;
     }
 
+    call->active = 0;
 
-    call->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_terminate_session(call->crtps[audio_index], av->messenger);
+    rtp_kill(call->crtps[audio_index], av->messenger);
     call->crtps[audio_index] = NULL;
-    rtp_terminate_session(call->crtps[video_index], av->messenger);
+    rtp_kill(call->crtps[video_index], av->messenger);
     call->crtps[video_index] = NULL;
-    terminate_queue(call->j_buf);
-    call->j_buf = NULL;
-
-    int i;
-    DECODE_PACKET *p;
-
-    call->exit = 1;
-    pthread_mutex_lock(&call->decode_cond_mutex);
-    pthread_cond_signal(&call->decode_cond);
-    pthread_cond_wait(&call->decode_cond, &call->decode_cond_mutex);
-    pthread_mutex_unlock(&call->decode_cond_mutex);
-    pthread_mutex_destroy(&call->decode_cond_mutex);
-    pthread_cond_destroy(&call->decode_cond);
-
-    for (i = 0; i != VIDEO_DECODE_QUEUE_SIZE; i++) {
-        p = call->video_decode_queue[i];
-        call->video_decode_queue[i] = NULL;
-
-        if (p) {
-            free(p);
-        }
-    }
-
-    for (i = 0; i != AUDIO_DECODE_QUEUE_SIZE; i++) {
-        p = call->audio_decode_queue[i];
-        call->audio_decode_queue[i] = NULL;
-
-        if (p) {
-            free(p);
-        }
-    }
-
-    codec_terminate_session(call->cs);
+    cs_kill(call->cs);
     call->cs = NULL;
 
-    pthread_mutex_unlock(&call->mutex);
-    pthread_mutex_destroy(&call->mutex);
+    pthread_mutex_destroy(call->mutex_encoding_audio);
+    pthread_mutex_destroy(call->mutex_encoding_video);
+    pthread_mutex_destroy(call->mutex_do);
 
-    memset(call, 0, sizeof(CallSpecific));
-    return ErrorNone;
-}
+    pthread_mutex_unlock(call->mutex);
 
+    return av_ErrorNone;
+}
 
-/**
- * @brief Send RTP payload.
- *
- * @param av Handler.
- * @param type Type of payload.
- * @param payload The payload.
- * @param length Size of it.
- * @return int
- * @retval 0 Success.
- * @retval -1 Failure.
- */
-static int toxav_send_rtp_payload(ToxAv *av, int32_t call_index, ToxAvCallType type, const uint8_t *payload,
+static int toxav_send_rtp_payload(ToxAv *av,
+                                  ToxAvCall *call,
+                                  ToxAvCallType type,
+                                  const uint8_t *payload,
                                   unsigned int length)
 {
-    CallSpecific *call = &av->calls[call_index];
-
-    if (call->crtps[type - TypeAudio]) {
+    if (call->crtps[type - av_TypeAudio]) {
 
-        if (type == TypeAudio) {
-            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, payload, length);
-        } else {
-            if (length == 0 || length > MAX_VIDEOFRAME_SIZE) {
-                LOGGER_ERROR("Invalid video frame size: %u\n", length);
-                return ErrorInternal;
-            }
-
-            /* number of pieces - 1*/
-            uint8_t numparts = (length - 1) / VIDEOFRAME_PIECE_SIZE;
+        /* Audio */
+        if (type == av_TypeAudio)
+            return rtp_send_msg(call->crtps[audio_index], av->messenger, payload, length);
 
-            uint8_t load[2 + VIDEOFRAME_PIECE_SIZE];
-            load[0] = call->frame_outid++;
-            load[1] = 0;
+        /* Video */
+        int parts = cs_split_video_payload(call->cs, payload, length);
 
-            int i;
+        if (parts < 0) return parts;
 
-            for (i = 0; i < numparts; i++) {
-                memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, VIDEOFRAME_PIECE_SIZE);
-                payload += VIDEOFRAME_PIECE_SIZE;
+        uint16_t part_size;
+        const uint8_t *iter;
 
-                if (rtp_send_msg(call->crtps[type - TypeAudio], av->messenger,
-                                 load, VIDEOFRAME_HEADER_SIZE + VIDEOFRAME_PIECE_SIZE) != 0) {
+        int i;
 
-                    return ErrorInternal;
-                }
-
-                load[1]++;
-            }
+        for (i = 0; i < parts; i++) {
+            iter = cs_get_split_video_frame(call->cs, &part_size);
 
-            /* remainder = length % VIDEOFRAME_PIECE_SIZE, VIDEOFRAME_PIECE_SIZE if = 0 */
-            length = ((length - 1) % VIDEOFRAME_PIECE_SIZE) + 1;
-            memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, length);
-
-            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, load, VIDEOFRAME_HEADER_SIZE + length);
+            if (rtp_send_msg(call->crtps[video_index], av->messenger, iter, part_size) < 0)
+                return av_ErrorSendingPayload;
         }
-    } else {
-        return ErrorNoRtpSession;
-    }
-}
-
-/**
- * @brief Encode and send video packet.
- *
- * @param av Handler.
- * @param input The packet.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size)
-{
-
-    if (cii(call_index, av->msi_session)) {
-        LOGGER_WARNING("Invalid call index: %d", call_index);
-        return ErrorNoCall;
-    }
-
-    CallSpecific *call = &av->calls[call_index];
-    pthread_mutex_lock(&call->mutex);
 
+        return av_ErrorNone;
 
-    if (!call->call_active) {
-        pthread_mutex_unlock(&call->mutex);
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
-    }
-
-    int rc = toxav_send_rtp_payload(av, call_index, TypeVideo, frame, frame_size);
-    pthread_mutex_unlock(&call->mutex);
-
-    return rc;
+    } else return av_ErrorNoRtpSession;
 }
 
-/**
- * @brief Encode video frame
- *
- * @param av Handler
- * @param dest Where to
- * @param dest_max Max size
- * @param input What to encode
- * @return int
- * @retval ToxAvError On error.
- * @retval >0 On success
- */
-int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
+int toxav_prepare_video_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input)
 {
-    if (cii(call_index, av->msi_session)) {
+    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
         LOGGER_WARNING("Invalid call index: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorNoCall;
     }
 
 
-    CallSpecific *call = &av->calls[call_index];
-    pthread_mutex_lock(&call->mutex);
+    ToxAvCall *call = &av->calls[call_index];
+    pthread_mutex_lock(call->mutex);
 
-    if (!call->call_active) {
-        pthread_mutex_unlock(&call->mutex);
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex);
         LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorInvalidState;
     }
 
-    if (reconfigure_video_encoder_resolution(call->cs, input->d_w, input->d_h) != 0) {
-        pthread_mutex_unlock(&call->mutex);
-        return ErrorInternal;
+    if (cs_set_video_encoder_resolution(call->cs, input->d_w, input->d_h) < 0) {
+        pthread_mutex_unlock(call->mutex);
+        return av_ErrorSettingVideoResolution;
     }
 
+    pthread_mutex_lock(call->mutex_encoding_video);
+    pthread_mutex_unlock(call->mutex);
+
     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);
-        return ErrorInternal;
+        pthread_mutex_unlock(call->mutex_encoding_video);
+        return av_ErrorEncodingVideo;
     }
 
     ++call->cs->frame_counter;
@@ -738,8 +485,8 @@ int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *dest, int
     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);
-                return ErrorPacketTooLarge;
+                pthread_mutex_unlock(call->mutex_encoding_video);
+                return av_ErrorPacketTooLarge;
             }
 
             memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
@@ -747,402 +494,198 @@ int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *dest, int
         }
     }
 
-    pthread_mutex_unlock(&call->mutex);
+    pthread_mutex_unlock(call->mutex_encoding_video);
     return copied;
 }
 
-/**
- * @brief Send audio frame.
- *
- * @param av Handler.
- * @param data The audio data encoded with toxav_prepare_audio_frame().
- * @param size Its size in number of bytes.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *data, unsigned int size)
+int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size)
 {
-    if (size > MAX_CRYPTO_DATA_SIZE)
-        return ErrorInternal;
 
-    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
+        return av_ErrorNoCall;
     }
 
-    CallSpecific *call = &av->calls[call_index];
-    pthread_mutex_lock(&call->mutex);
+    ToxAvCall *call = &av->calls[call_index];
+    pthread_mutex_lock(call->mutex);
 
 
-    if (!call->call_active) {
-        pthread_mutex_unlock(&call->mutex);
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex);
         LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorInvalidState;
     }
 
-    int rc = toxav_send_rtp_payload(av, call_index, TypeAudio, data, size);
-    pthread_mutex_unlock(&call->mutex);
+    int rc = toxav_send_rtp_payload(av, call, av_TypeVideo, frame, frame_size);
+    pthread_mutex_unlock(call->mutex);
 
     return rc;
 }
 
-/**
- * @brief Encode audio frame
- *
- * @param av Handler
- * @param dest dest
- * @param dest_max Max dest size
- * @param frame The frame
- * @param frame_size The frame size
- * @return int
- * @retval ToxAvError On error.
- * @retval >0 On success
- */
-int toxav_prepare_audio_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, const int16_t *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)
 {
-    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
-        LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+    if (CALL_INVALID_INDEX(call_index, av->msi_session->max_calls)) {
+        LOGGER_WARNING("Action on nonexisting call: %d", call_index);
+        return av_ErrorNoCall;
     }
 
-    CallSpecific *call = &av->calls[call_index];
-    pthread_mutex_lock(&call->mutex);
+    ToxAvCall *call = &av->calls[call_index];
+    pthread_mutex_lock(call->mutex);
 
-
-    if (!call->call_active) {
-        pthread_mutex_unlock(&call->mutex);
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex);
         LOGGER_WARNING("Action on inactive call: %d", call_index);
-        return ErrorNoCall;
+        return av_ErrorInvalidState;
     }
 
+    pthread_mutex_lock(call->mutex_encoding_audio);
+    pthread_mutex_unlock(call->mutex);
     int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
-    pthread_mutex_unlock(&call->mutex);
+    pthread_mutex_unlock(call->mutex_encoding_audio);
 
     if (rc < 0) {
         LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
-        return ErrorInternal;
+        return av_ErrorEncodingAudio;
     }
 
     return rc;
 }
 
-/**
- * @brief Get peer transmission type. It can either be audio or video.
- *
- * @param av Handler.
- * @param peer The peer
- * @return int
- * @retval ToxAvCallType On success.
- * @retval ToxAvError On error.
- */
+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);
+
+
+    if (!call->active) {
+        pthread_mutex_unlock(call->mutex);
+        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);
+    return rc;
+}
+
 int toxav_get_peer_csettings ( ToxAv *av, int32_t call_index, int peer, ToxAvCSettings *dest )
 {
-    if ( peer < 0 || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index]
-            || av->msi_session->calls[call_index]->peer_count <= peer )
-        return ErrorInternal;
+    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 ErrorNone;
+    *dest = *toxavcsettings_cast(&av->msi_session->calls[call_index]->csettings_peer[peer]);
+    return av_ErrorNone;
 }
 
-/**
- * @brief Get id of peer participating in conversation
- *
- * @param av Handler
- * @param peer peer index
- * @return int
- * @retval ToxAvError No peer id
- */
 int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
 {
-    if ( peer < 0 || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index]
+    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 ErrorInternal;
+        return av_ErrorNoCall;
 
     return av->msi_session->calls[call_index]->peers[peer];
 }
 
-/**
- * @brief Get id of peer participating in conversation
- *
- * @param av Handler
- * @param peer peer index
- * @return int
- * @retval ToxAvError No peer id
- */
 ToxAvCallState toxav_get_call_state(ToxAv *av, int32_t call_index)
 {
-    if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] )
-        return av_CallNonExistant;
+    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;
 
 }
 
-/**
- * @brief Is certain capability supported
- *
- * @param av Handler
- * @return int
- * @retval 1 Yes.
- * @retval 0 No.
- */
-inline__ int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability )
+int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCapabilities capability )
 {
-    return av->calls[call_index].cs ? av->calls[call_index].cs->capabilities & (Capabilities) capability : 0;
+    return av->calls[call_index].cs ? av->calls[call_index].cs->capabilities & (CSCapabilities) capability : 0;
     /* 0 is error here */
 }
 
-inline__ Tox *toxav_get_tox(ToxAv *av)
+Tox *toxav_get_tox(ToxAv *av)
 {
     return (Tox *)av->messenger;
 }
 
-int toxav_has_activity(ToxAv *av, int32_t call_index, int16_t *PCM, uint16_t frame_size, float ref_energy)
-{
-    if ( !av->calls[call_index].cs ) return ErrorInvalidCodecState;
-
-    return energy_VAD(av->calls[call_index].cs, PCM, frame_size, ref_energy);
-}
-
-
-static void decode_video(ToxAv *av, CallSpecific *call, DECODE_PACKET *p)
+int toxav_get_active_count(ToxAv *av)
 {
-    int32_t call_index = call - av->calls;
+    if (!av) return -1;
 
-    int rc = vpx_codec_decode(&call->cs->v_decoder, p->data, p->size, NULL, MAX_DECODE_TIME_US);
+    int rc = 0, i = 0;
 
-    if (rc != VPX_CODEC_OK) {
-        LOGGER_ERROR("Error decoding video: %s\n", vpx_codec_err_to_string(rc));
-    }
+    for (; i < av->max_calls; i++) {
+        pthread_mutex_lock(av->calls[i].mutex);
 
-    vpx_codec_iter_t iter = NULL;
-    vpx_image_t *img;
-    img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
+        if (av->calls[i].active) rc++;
 
-    if (img && av->video_callback) {
-        av->video_callback(av, call_index, img, av->video_callback_userdata);
-    } else {
-        LOGGER_WARNING("Video packet dropped due to missing callback or no image!");
+        pthread_mutex_unlock(av->calls[i].mutex);
     }
 
-    free(p);
+    return rc;
 }
 
-static void decode_audio(ToxAv *av, CallSpecific *call, DECODE_PACKET *p)
+/* 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)
 {
-    int32_t call_index = call - av->calls;
-
-    // ToxAvCSettings csettings;
-    // toxav_get_peer_csettings(av, call_index, 0, &csettings);
-
-    int frame_size = 10000; /* FIXME: not static?  */
-    int16_t dest[frame_size];
-
-    int dec_size = opus_decode(call->cs->audio_decoder, p->data, p->size, dest, frame_size, (p->size == 0));
-    free(p);
-
-    if (dec_size < 0) {
-        LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
-        return;
-    }
-
-    if ( av->audio_callback )
-        av->audio_callback(av, call_index, dest, dec_size, av->audio_callback_userdata);
-    else
-        LOGGER_WARNING("Audio packet dropped due to missing callback!");
+    Messenger *m = tox;
+    return add_av_groupchat(m->group_chat_object, audio_callback, userdata);
 }
 
-static void *toxav_decoding(void *arg)
+/* 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)
 {
-    void **pp = arg;
-    ToxAv *av = pp[0];
-    CallSpecific *call = pp[1];
-    free(pp);
-
-    while (1) {
-        DECODE_PACKET *p;
-        _Bool video = 0;
-
-        pthread_mutex_lock(&call->decode_cond_mutex);
-
-        if (call->exit) {
-            break;
-        }
-
-        uint8_t r;
-
-        /* first check for available packets, otherwise wait for condition*/
-        r = call->audio_decode_read;
-        p = call->audio_decode_queue[r];
-
-        if (!p) {
-            r = call->video_decode_read;
-            p = call->video_decode_queue[r];
-
-            if (!p) {
-                pthread_cond_wait(&call->decode_cond, &call->decode_cond_mutex);
-                r = call->audio_decode_read;
-                p = call->audio_decode_queue[r];
-
-                if (!p) {
-                    r = call->video_decode_read;
-                    p = call->video_decode_queue[r];
-                    video = 1;
-                }
-            } else {
-                video = 1;
-            }
-        }
-
-        if (video) {
-            if (p) {
-                call->video_decode_queue[r] = NULL;
-                call->video_decode_read = (r + 1) % VIDEO_DECODE_QUEUE_SIZE;
-            }
-        } else {
-            call->audio_decode_queue[r] = NULL;
-            call->audio_decode_read = (r + 1) % AUDIO_DECODE_QUEUE_SIZE;
-        }
-
-        pthread_mutex_unlock(&call->decode_cond_mutex);
-
-        if (p) {
-            if (video) {
-                decode_video(av, call, p);
-            } else {
-                decode_audio(av, call, p);
-            }
-        }
-    }
-
-    call->exit = 0;
-    pthread_cond_signal(&call->decode_cond);
-    pthread_mutex_unlock(&call->decode_cond_mutex);
-
-    return NULL;
+    Messenger *m = tox;
+    return join_av_groupchat(m->group_chat_object, friendnumber, data, length, audio_callback, userdata);
 }
 
-void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
+/* 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)
 {
-    ToxAv *av = _session->av;
-    int32_t call_index = _session->call_index;
-    CallSpecific *call = &av->calls[call_index];
-
-    if (!call->call_active) return;
-
-    if (_session->payload_type == type_audio % 128) {
-        queue(call->j_buf, _msg);
-
-        int success = 0;
-
-        while ((_msg = dequeue(call->j_buf, &success)) || success == 2) {
-            DECODE_PACKET *p;
-
-            if (success == 2) {
-                p = malloc(sizeof(DECODE_PACKET));
-
-                if (p) {
-                    p->size = 0;
-                }
-            } else {
-                p = malloc(sizeof(DECODE_PACKET) + _msg->length);
-
-                if (p) {
-                    p->size = _msg->length;
-                    memcpy(p->data, _msg->data, _msg->length);
-                }
-
-                rtp_free_msg(NULL, _msg);
-            }
-
-            if (p) {
-                /* do the decoding on another thread */
-                pthread_mutex_lock(&call->decode_cond_mutex);
-                uint8_t w = call->audio_decode_write;
-
-                if (call->audio_decode_queue[w] == NULL) {
-                    call->audio_decode_queue[w] = p;
-                    call->audio_decode_write = (w + 1) % AUDIO_DECODE_QUEUE_SIZE;
-                    pthread_cond_signal(&call->decode_cond);
-                } else {
-                    LOGGER_DEBUG("Dropped audio frame\n");
-                    free(p);
-                }
-
-                pthread_mutex_unlock(&call->decode_cond_mutex);
-            } else {
-                //malloc failed
-            }
-        }
-
-    } else {
-        uint8_t *packet = _msg->data;
-        int recved_size = _msg->length;
-
-        if (recved_size < VIDEOFRAME_HEADER_SIZE) {
-            goto end;
-        }
-
-        uint8_t i = packet[0] - call->frame_id;
-
-        if (i == 0) {
-            /* piece of current frame */
-        } else if (i > 0 && i < 128) {
-            /* recieved a piece of a frame ahead, flush current frame and start reading this new frame */
-            DECODE_PACKET *p = malloc(sizeof(DECODE_PACKET) + call->frame_limit);
-
-            if (p) {
-                p->size = call->frame_limit;
-                memcpy(p->data, call->frame_buf, call->frame_limit);
-
-                /* do the decoding on another thread */
-                pthread_mutex_lock(&call->decode_cond_mutex);
-                uint8_t w = call->video_decode_write;
-
-                if (call->video_decode_queue[w] == NULL) {
-                    call->video_decode_queue[w] = p;
-                    call->video_decode_write = (w + 1) % VIDEO_DECODE_QUEUE_SIZE;
-                    pthread_cond_signal(&call->decode_cond);
-                } else {
-                    LOGGER_DEBUG("Dropped video frame\n");
-                    free(p);
-                }
-
-                pthread_mutex_unlock(&call->decode_cond_mutex);
-            } else {
-                //malloc failed
-            }
-
-            call->frame_id = packet[0];
-            memset(call->frame_buf, 0, call->frame_limit);
-            call->frame_limit = 0;
-        } else {
-            /* old packet, dont read */
-            LOGGER_DEBUG("Old packet: %u\n", i);
-            goto end;
-        }
-
-        if (packet[1] > (MAX_VIDEOFRAME_SIZE - VIDEOFRAME_PIECE_SIZE + 1) /
-                VIDEOFRAME_PIECE_SIZE) { //TODO, fix this check? not sure
-            /* packet out of buffer range */
-            goto end;
-        }
-
-        LOGGER_DEBUG("Video Packet: %u %u\n", packet[0], packet[1]);
-        memcpy(call->frame_buf + packet[1] * VIDEOFRAME_PIECE_SIZE, packet + VIDEOFRAME_HEADER_SIZE,
-               recved_size - VIDEOFRAME_HEADER_SIZE);
-        uint32_t limit = packet[1] * VIDEOFRAME_PIECE_SIZE + recved_size - VIDEOFRAME_HEADER_SIZE;
-
-        if (limit > call->frame_limit) {
-            call->frame_limit = limit;
-            LOGGER_DEBUG("Limit: %u\n", call->frame_limit);
-        }
-
-end:
-        ;
-        rtp_free_msg(NULL, _msg);
-    }
+    Messenger *m = tox;
+    return group_send_audio(m->group_chat_object, groupnumber, pcm, samples, channels, sample_rate);
 }
+
diff --git a/toxav/toxav.h b/toxav/toxav.h
index e31c7aad..3696f961 100644
--- a/toxav/toxav.h
+++ b/toxav/toxav.h
@@ -28,11 +28,14 @@
 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 struct _ToxAv ToxAv;
+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__
@@ -43,82 +46,79 @@ typedef struct Tox Tox;
 
 
 /**
- * @brief Callbacks ids that handle the call states.
+ * Callbacks ids that handle the call states.
  */
 typedef enum {
-    /* Requests */
-    av_OnInvite,
-    av_OnStart,
-    av_OnCancel,
-    av_OnReject,
-    av_OnEnd,
-
-    /* Responses */
-    av_OnRinging,
-    av_OnStarting,
-    av_OnEnding,
-
-    /* Protocol */
-    av_OnRequestTimeout,
-    av_OnPeerTimeout,
-    av_OnMediaChange
+    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;
 
 
 /**
- * @brief Call type identifier.
+ * Call type identifier.
  */
 typedef enum {
-    TypeAudio = 192,
-    TypeVideo
+    av_TypeAudio = 192,
+    av_TypeVideo
 } ToxAvCallType;
 
 
 typedef enum {
-    av_CallNonExistant = -1,
+    av_CallNonExistent = -1,
     av_CallInviting, /* when sending call invite */
     av_CallStarting, /* when getting call invite */
     av_CallActive,
     av_CallHold,
-    av_CallHanged_up
+    av_CallHungUp
 } ToxAvCallState;
 
 /**
- * @brief Error indicators.
+ * Error indicators. Values under -20 are reserved for toxcore.
  */
 typedef enum {
-    ErrorNone = 0,
-    ErrorInternal = -1, /* Internal error */
-    ErrorAlreadyInCall = -2, /* Already has an active call */
-    ErrorNoCall = -3, /* Trying to perform call action while not in a call */
-    ErrorInvalidState = -4, /* Trying to perform call action while in invalid state*/
-    ErrorNoRtpSession = -5, /* Trying to perform rtp action on invalid session */
-    ErrorAudioPacketLost = -6, /* Indicating packet loss */
-    ErrorStartingAudioRtp = -7, /* Error in toxav_prepare_transmission() */
-    ErrorStartingVideoRtp = -8 , /* Error in toxav_prepare_transmission() */
-    ErrorTerminatingAudioRtp = -9, /* Returned in toxav_kill_transmission() */
-    ErrorTerminatingVideoRtp = -10, /* Returned in toxav_kill_transmission() */
-    ErrorPacketTooLarge = -11, /* Buffer exceeds size while encoding */
-    ErrorInvalidCodecState = -12, /* Codec state not initialized */
-
+    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;
 
 
 /**
- * @brief Locally supported capabilities.
+ * Locally supported capabilities.
  */
 typedef enum {
-    AudioEncoding = 1 << 0,
-    AudioDecoding = 1 << 1,
-    VideoEncoding = 1 << 2,
-    VideoDecoding = 1 << 3
+    av_AudioEncoding = 1 << 0,
+    av_AudioDecoding = 1 << 1,
+    av_VideoEncoding = 1 << 2,
+    av_VideoDecoding = 1 << 3
 } ToxAvCapabilities;
 
 
 /**
- * @brief Encoding settings.
+ * Encoding settings.
  */
-typedef struct _ToxAvCodecSettings {
+typedef struct _ToxAvCSettings {
     ToxAvCallType call_type;
 
     uint32_t video_bitrate; /* In kbits/s */
@@ -132,255 +132,195 @@ typedef struct _ToxAvCodecSettings {
 } ToxAvCSettings;
 
 extern const ToxAvCSettings av_DefaultSettings;
-extern const uint32_t av_jbufdc; /* Jitter buffer default capacity */
-extern const uint32_t av_VADd; /* VAD default treshold */
 
 /**
- * @brief Start new A/V session. There can only be one session at the time. If you register more
- *        it will result in undefined behaviour.
- *
- * @param messenger The messenger handle.
- * @param userdata The agent handling A/V session (i.e. phone).
- * @param video_width Width of video frame.
- * @param video_height Height of video frame.
- * @return ToxAv*
- * @retval NULL On error.
+ * Start new A/V session. There can only be one session at the time.
  */
 ToxAv *toxav_new(Tox *messenger, int32_t max_calls);
 
 /**
- * @brief Remove A/V session.
- *
- * @param av Handler.
- * @return void
+ * Remove A/V session.
  */
 void toxav_kill(ToxAv *av);
 
 /**
- * @brief Register callback for call state.
- *
- * @param av Handler.
- * @param callback The callback
- * @param id One of the ToxAvCallbackID values
- * @return void
+ * Returns the interval in milliseconds when the next toxav_do() should be called.
+ * If no call is active at the moment returns 200.
  */
-void toxav_register_callstate_callback (ToxAv *av, ToxAVCallback callback, ToxAvCallbackID id, void *userdata);
+uint32_t toxav_do_interval(ToxAv *av);
 
 /**
- * @brief Register callback for recieving audio data
- *
- * @param av Handler.
- * @param callback The callback
- * @return void
+ * Main loop for the session. Best called right after tox_do();
  */
-void toxav_register_audio_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, int16_t *, int, void *),
-        void *user_data);
+void toxav_do(ToxAv *av);
 
 /**
- * @brief Register callback for recieving video data
- *
- * @param av Handler.
- * @param callback The callback
- * @return void
+ * Register callback for call state.
  */
-void toxav_register_video_recv_callback (ToxAv *av, void (*callback)(ToxAv *, int32_t, vpx_image_t *, void *),
-        void *user_data);
+void toxav_register_callstate_callback (ToxAv *av, ToxAVCallback cb, ToxAvCallbackID id, void *userdata);
 
 /**
- * @brief Call user. Use its friend_id.
- *
- * @param av Handler.
- * @param user The user.
- * @param call_type Call type.
- * @param ringing_seconds Ringing timeout.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Register callback for audio data.
  */
-int toxav_call(ToxAv *av, int32_t *call_index, int user, const ToxAvCSettings *csettings, int ringing_seconds);
+void toxav_register_audio_callback (ToxAv *av, ToxAvAudioCallback cb, void *userdata);
 
 /**
- * @brief Hangup active call.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * 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);
 
 /**
- * @brief Answer incomming call.
- *
- * @param av Handler.
- * @param call_type Answer with...
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Answer incoming call. Pass the csettings that you will use.
  */
 int toxav_answer(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings );
 
 /**
- * @brief Reject incomming call.
- *
- * @param av Handler.
- * @param reason Optional reason. Set NULL if none.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Reject incoming call.
  */
 int toxav_reject(ToxAv *av, int32_t call_index, const char *reason);
 
 /**
- * @brief Cancel outgoing request.
- *
- * @param av Handler.
- * @param reason Optional reason.
- * @param peer_id peer friend_id
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Cancel outgoing request.
  */
 int toxav_cancel(ToxAv *av, int32_t call_index, int peer_id, const char *reason);
 
 /**
- * @brief Notify peer that we are changing call settings
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Notify peer that we are changing codec settings.
  */
 int toxav_change_settings(ToxAv *av, int32_t call_index, const ToxAvCSettings *csettings);
 
 /**
- * @brief Terminate transmission. Note that transmission will be terminated without informing remote peer.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * 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);
 
 /**
- * @brief Must be call before any RTP transmission occurs.
- *
- * @param av Handler.
- * @param support_video Is video supported ? 1 : 0
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * 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, uint32_t jbuf_size, uint32_t VAD_treshold,
-                               int support_video);
+int toxav_prepare_transmission(ToxAv *av, int32_t call_index, int support_video);
 
 /**
- * @brief Call this at the end of the transmission.
- *
- * @param av Handler.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Clears transmission data. Call this at the end of the transmission.
  */
 int toxav_kill_transmission(ToxAv *av, int32_t call_index);
 
 /**
- * @brief Encode and send video packet.
- *
- * @param av Handler.
- * @param frame The encoded frame.
- * @param frame_size The size of the encoded frame.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Encode video frame.
  */
-int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int frame_size);
+int toxav_prepare_video_frame ( ToxAv *av,
+                                int32_t call_index,
+                                uint8_t *dest,
+                                int dest_max,
+                                vpx_image_t *input);
 
 /**
- * @brief Send audio frame.
- *
- * @param av Handler.
- * @param data The audio data encoded with toxav_prepare_audio_frame().
- * @param size Its size in number of bytes.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
+ * Send encoded video packet.
  */
-int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *frame, unsigned int size);
+int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, uint32_t frame_size);
 
 /**
- * @brief Encode video frame
- *
- * @param av Handler
- * @param dest Where to
- * @param dest_max Max size
- * @param input What to encode
- * @return int
- * @retval ToxAvError On error.
- * @retval >0 On success
+ * Encode audio frame.
  */
-int toxav_prepare_video_frame ( ToxAv *av, int32_t call_index, uint8_t *dest, int dest_max, vpx_image_t *input );
+int toxav_prepare_audio_frame ( ToxAv *av,
+                                int32_t call_index,
+                                uint8_t *dest,
+                                int dest_max,
+                                const int16_t *frame,
+                                int frame_size);
 
 /**
- * @brief Encode audio frame
- *
- * @param av Handler
- * @param dest dest
- * @param dest_max Max dest size
- * @param frame The frame
- * @param frame_size The frame size
- * @return int
- * @retval ToxAvError On error.
- * @retval >0 On success
- */
-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);
 
 /**
- * @brief Get peer transmission type. It can either be audio or video.
- *
- * @param av Handler.
- * @param peer The peer
- * @return int
- * @retval ToxAvCallType On success.
- * @retval ToxAvError On error.
+ * 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 );
 
 /**
- * @brief Get id of peer participating in conversation
- *
- * @param av Handler
- * @param peer peer index
- * @return int
- * @retval ToxAvError No peer id
+ * Get friend id of peer participating in conversation.
  */
 int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer );
 
 /**
- * @brief Get current call state
- *
- * @param av Handler
- * @param call_index What call
- * @return int
- * @retval ToxAvCallState State id
+ * Get current call state.
  */
 ToxAvCallState toxav_get_call_state ( ToxAv *av, int32_t call_index );
+
 /**
- * @brief Is certain capability supported
- *
- * @param av Handler
- * @return int
- * @retval 1 Yes.
- * @retval 0 No.
+ * 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);
 
-Tox *toxav_get_tox(ToxAv *av);
+/* 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);
 
-int toxav_has_activity ( ToxAv *av, int32_t call_index, int16_t *PCM, uint16_t frame_size, float ref_energy );
+/* 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
 }
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 6bd23081..2d3d6ffe 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -65,11 +65,6 @@
 /* Number of get node requests to send to quickly find close nodes. */
 #define MAX_BOOTSTRAP_TIMES 10
 
-Client_data *DHT_get_close_list(DHT *dht)
-{
-    return dht->close_clientlist;
-}
-
 /* Compares client_id1 and client_id2 with client_id.
  *
  *  return 0 if both are same distance.
@@ -169,12 +164,17 @@ void to_net_family(IP *ip)
         ip->family = TOX_AF_INET6;
 }
 
-void to_host_family(IP *ip)
+int to_host_family(IP *ip)
 {
-    if (ip->family == TOX_AF_INET)
+    if (ip->family == TOX_AF_INET) {
         ip->family = AF_INET;
-    else if (ip->family == TOX_AF_INET6)
+        return 0;
+    } else if (ip->family == TOX_AF_INET6) {
         ip->family = AF_INET6;
+        return 0;
+    } else {
+        return -1;
+    }
 }
 
 /* Pack number of nodes into data of maxlength length.
@@ -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 {
@@ -318,7 +318,7 @@ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed
  *
  *  return True(1) or False(0)
  */
-static int client_or_ip_port_in_list(Client_data *list, uint32_t length, const uint8_t *client_id, IP_Port ip_port)
+static int client_or_ip_port_in_list(Client_data *list, uint16_t length, const uint8_t *client_id, IP_Port ip_port)
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
@@ -330,9 +330,9 @@ static int client_or_ip_port_in_list(Client_data *list, uint32_t length, const u
             if (ip_port.ip.family == AF_INET) {
 
                 LOGGER_SCOPE( if (!ipport_equal(&list[i].assoc4.ip_port, &ip_port)) {
-                LOGGER_INFO("coipil[%u]: switching ipv4 from %s:%u to %s:%u", i,
-                            ip_ntoa(&list[i].assoc4.ip_port.ip), ntohs(list[i].assoc4.ip_port.port),
-                            ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
+                LOGGER_TRACE("coipil[%u]: switching ipv4 from %s:%u to %s:%u", i,
+                             ip_ntoa(&list[i].assoc4.ip_port.ip), ntohs(list[i].assoc4.ip_port.port),
+                             ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
                 }
                             );
 
@@ -344,9 +344,9 @@ static int client_or_ip_port_in_list(Client_data *list, uint32_t length, const u
             } else if (ip_port.ip.family == AF_INET6) {
 
                 LOGGER_SCOPE( if (!ipport_equal(&list[i].assoc4.ip_port, &ip_port)) {
-                LOGGER_INFO("coipil[%u]: switching ipv6 from %s:%u to %s:%u", i,
-                            ip_ntoa(&list[i].assoc6.ip_port.ip), ntohs(list[i].assoc6.ip_port.port),
-                            ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
+                LOGGER_TRACE("coipil[%u]: switching ipv6 from %s:%u to %s:%u", i,
+                             ip_ntoa(&list[i].assoc6.ip_port.ip), ntohs(list[i].assoc6.ip_port.port),
+                             ip_ntoa(&ip_port.ip), ntohs(ip_port.port));
                 }
                             );
 
@@ -397,12 +397,12 @@ static int client_or_ip_port_in_list(Client_data *list, uint32_t length, const u
  *  return 1 if true.
  *  return 0 if false.
  */
-static int client_in_nodelist(const Node_format *list, uint32_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)) {
@@ -605,6 +605,63 @@ int get_close_nodes(const DHT *dht, const uint8_t *client_id, Node_format *nodes
 #endif
 }
 
+static uint8_t cmp_public_key[crypto_box_PUBLICKEYBYTES];
+static int cmp_dht_entry(const void *a, const void *b)
+{
+    Client_data entry1, entry2;
+    memcpy(&entry1, a, sizeof(Client_data));
+    memcpy(&entry2, b, sizeof(Client_data));
+    int t1 = is_timeout(entry1.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry1.assoc6.timestamp, BAD_NODE_TIMEOUT);
+    int t2 = is_timeout(entry2.assoc4.timestamp, BAD_NODE_TIMEOUT) && is_timeout(entry2.assoc6.timestamp, BAD_NODE_TIMEOUT);
+
+    if (t1 && t2)
+        return 0;
+
+    if (t1)
+        return -1;
+
+    if (t2)
+        return 1;
+
+    t1 = hardening_correct(&entry1.assoc4.hardening) != HARDENING_ALL_OK
+         && hardening_correct(&entry1.assoc6.hardening) != HARDENING_ALL_OK;
+    t2 = hardening_correct(&entry2.assoc4.hardening) != HARDENING_ALL_OK
+         && hardening_correct(&entry2.assoc6.hardening) != HARDENING_ALL_OK;
+
+    if (t1 != t2) {
+        if (t1)
+            return -1;
+
+        if (t2)
+            return 1;
+    }
+
+    int close = id_closest(cmp_public_key, entry1.client_id, entry2.client_id);
+
+    if (close == 1)
+        return 1;
+
+    if (close == 2)
+        return -1;
+
+    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
@@ -619,48 +676,20 @@ int get_close_nodes(const DHT *dht, const uint8_t *client_id, Node_format *nodes
  *
  *  returns True(1) when the item was stored, False(0) otherwise */
 static int replace_all(   Client_data    *list,
-                          uint32_t        length,
+                          uint16_t        length,
                           const uint8_t  *client_id,
                           IP_Port         ip_port,
                           const uint8_t  *comp_client_id )
 {
     if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6))
-        return 1;
-
-    uint32_t i, replace = ~0, bad = ~0, possibly_bad = ~0, good = ~0;
-
-    for (i = 0; i < length; ++i) {
-
-        Client_data *client = &list[i];
+        return 0;
 
-        if (is_timeout(client->assoc4.timestamp, BAD_NODE_TIMEOUT) &&
-                is_timeout(client->assoc6.timestamp, BAD_NODE_TIMEOUT)) {
-            // "bad" node
-            bad = i;
-            break;
-        } else if (hardening_correct(&client->assoc4.hardening) != HARDENING_ALL_OK &&
-                   hardening_correct(&client->assoc6.hardening) != HARDENING_ALL_OK) {
-            // "possibly bad" node
-            if (possibly_bad == (uint32_t)~0 ||
-                    id_closest(comp_client_id, list[possibly_bad].client_id, list[i].client_id) == 1)
-                possibly_bad = i;
-        } else {
-            // "good" node
-            if (good == (uint32_t)~0 ||
-                    id_closest(comp_client_id, list[good].client_id, list[i].client_id) == 1)
-                good = i;
-        }
-    }
+    memcpy(cmp_public_key, comp_client_id, crypto_box_PUBLICKEYBYTES);
+    qsort(list, length, sizeof(Client_data), cmp_dht_entry);
 
-    if (bad != (uint32_t)~0)
-        replace = bad;
-    else if (possibly_bad != (uint32_t)~0)
-        replace = possibly_bad;
-    else if (good != (uint32_t)~0 && id_closest(comp_client_id, list[good].client_id, client_id) == 2)
-        replace = good;
+    Client_data *client = &list[0];
 
-    if (replace != (uint32_t)~0) {
-        Client_data *client = &list[replace];
+    if (store_node_ok(client, client_id, comp_client_id)) {
         IPPTsPng *ipptp_write = NULL;
         IPPTsPng *ipptp_clear = NULL;
 
@@ -689,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.
  *
@@ -713,14 +765,41 @@ int addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *client_id)
     } else
         used++;
 
+    DHT_Friend *friend_foundip = 0;
+
     for (i = 0; i < dht->num_friends; ++i) {
         if (!client_or_ip_port_in_list(dht->friends_list[i].client_list,
                                        MAX_FRIEND_CLIENTS, client_id, ip_port)) {
             if (replace_all(dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS,
-                            client_id, ip_port, dht->friends_list[i].client_id))
+                            client_id, ip_port, dht->friends_list[i].client_id)) {
+
+                DHT_Friend *friend = &dht->friends_list[i];
+
+                if (memcmp(client_id, friend->client_id, CLIENT_ID_SIZE) == 0) {
+                    friend_foundip = friend;
+                }
+
                 used++;
-        } else
+            }
+        } else {
+            DHT_Friend *friend = &dht->friends_list[i];
+
+            if (memcmp(client_id, friend->client_id, CLIENT_ID_SIZE) == 0) {
+                friend_foundip = friend;
+            }
+
             used++;
+        }
+    }
+
+    if (friend_foundip) {
+        uint32_t j;
+
+        for (j = 0; j < friend_foundip->lock_count; ++j) {
+            if (friend_foundip->callbacks[j].ip_callback)
+                friend_foundip->callbacks[j].ip_callback(friend_foundip->callbacks[j].data, friend_foundip->callbacks[j].number,
+                        ip_port);
+        }
     }
 
 #ifdef ENABLE_ASSOC_DHT
@@ -806,8 +885,6 @@ end:
     return 0;
 }
 
-#define NODES_ENCRYPTED_MESSAGE_LENGTH (crypto_box_NONCEBYTES + sizeof(uint64_t) + sizeof(Node_format) + sizeof(Node_format) + crypto_box_MACBYTES)
-
 /* Send a getnodes request.
    sendback_node is the node that it will send back the response to (set to NULL to disable this) */
 static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t *client_id,
@@ -820,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));
 
@@ -874,7 +951,7 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
     if (id_equal(public_key, dht->self_public_key))
         return -1;
 
-    if (length > NODES_ENCRYPTED_MESSAGE_LENGTH || length == 0)
+    if (length != sizeof(uint64_t))
         return -1;
 
     size_t Node_format_size = sizeof(Node_format);
@@ -916,38 +993,31 @@ static int sendnodes_ipv6(const DHT *dht, IP_Port ip_port, const uint8_t *public
     return sendpacket(dht->net, ip_port, data, 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + len);
 }
 
-static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
-    uint32_t cmp_len = 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + CLIENT_ID_SIZE + crypto_box_MACBYTES;
-
-    if (length <= cmp_len)
+    if (length != (1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + CLIENT_ID_SIZE + sizeof(uint64_t) + crypto_box_MACBYTES))
         return 1;
 
-    if (length > cmp_len + NODES_ENCRYPTED_MESSAGE_LENGTH)
-        return 1;
-
-    uint16_t sendback_data_length = length - cmp_len;
-
     DHT *dht = object;
 
     /* Check if packet is from ourself. */
     if (id_equal(packet + 1, dht->self_public_key))
         return 1;
 
-    uint8_t plain[CLIENT_ID_SIZE + sendback_data_length];
+    uint8_t plain[CLIENT_ID_SIZE + sizeof(uint64_t)];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
 
     DHT_get_shared_key_recv(dht, shared_key, packet + 1);
     int len = decrypt_data_symmetric( shared_key,
                                       packet + 1 + CLIENT_ID_SIZE,
                                       packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                                      CLIENT_ID_SIZE + sendback_data_length + crypto_box_MACBYTES,
+                                      CLIENT_ID_SIZE + sizeof(uint64_t) + crypto_box_MACBYTES,
                                       plain );
 
-    if (len != CLIENT_ID_SIZE + sendback_data_length)
+    if (len != CLIENT_ID_SIZE + sizeof(uint64_t))
         return 1;
 
-    sendnodes_ipv6(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE, sendback_data_length, shared_key);
+    sendnodes_ipv6(dht, source, packet + 1, plain, plain + CLIENT_ID_SIZE, sizeof(uint64_t), shared_key);
 
     add_to_ping(dht->ping, packet + 1, source);
 
@@ -971,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;
@@ -981,7 +1051,7 @@ static uint8_t sent_getnode_to_node(DHT *dht, const uint8_t *client_id, IP_Port
 static int send_hardening_getnode_res(const DHT *dht, const Node_format *sendto, const uint8_t *queried_client_id,
                                       const uint8_t *nodes_data, uint16_t nodes_data_length);
 
-static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *packet, uint32_t length,
+static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *packet, uint16_t length,
                                  Node_format *plain_nodes, uint16_t size_plain_nodes, uint32_t *num_nodes_out)
 {
     DHT *dht = object;
@@ -1043,7 +1113,7 @@ static int handle_sendnodes_core(void *object, IP_Port source, const uint8_t *pa
     return 0;
 }
 
-static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_sendnodes_ipv6(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     DHT *dht = object;
     Node_format plain_nodes[MAX_SENT_NODES];
@@ -1058,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);
         }
     }
 
@@ -1094,23 +1165,54 @@ static void get_bunchnodes(DHT *dht, Client_data *list, uint16_t length, uint16_
     }
 }
 */
-int DHT_addfriend(DHT *dht, const uint8_t *client_id)
+int DHT_addfriend(DHT *dht, const uint8_t *client_id, void (*ip_callback)(void *data, int32_t number, IP_Port),
+                  void *data, int32_t number, uint16_t *lock_count)
 {
-    if (friend_number(dht, client_id) != -1) /* Is friend already in DHT? */
-        return 1;
+    int friend_num = friend_number(dht, client_id);
+
+    uint16_t lock_num;
+
+    if (friend_num != -1) { /* Is friend already in DHT? */
+        DHT_Friend *friend = &dht->friends_list[friend_num];
+
+        if (friend->lock_count == DHT_FRIEND_MAX_LOCKS)
+            return -1;
+
+        lock_num = friend->lock_count;
+        ++friend->lock_count;
+        friend->callbacks[lock_num].ip_callback = ip_callback;
+        friend->callbacks[lock_num].data = data;
+        friend->callbacks[lock_num].number = number;
+
+        if (lock_count)
+            *lock_count = lock_num + 1;
+
+        return 0;
+    }
 
     DHT_Friend *temp;
     temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends + 1));
 
     if (temp == NULL)
-        return 1;
+        return -1;
 
     dht->friends_list = temp;
-    memset(&dht->friends_list[dht->num_friends], 0, sizeof(DHT_Friend));
-    memcpy(dht->friends_list[dht->num_friends].client_id, client_id, CLIENT_ID_SIZE);
+    DHT_Friend *friend = &dht->friends_list[dht->num_friends];
+    memset(friend, 0, sizeof(DHT_Friend));
+    memcpy(friend->client_id, client_id, CLIENT_ID_SIZE);
 
-    dht->friends_list[dht->num_friends].nat.NATping_id = random_64b();
+    friend->nat.NATping_id = random_64b();
     ++dht->num_friends;
+
+    lock_num = friend->lock_count;
+    ++friend->lock_count;
+    friend->callbacks[lock_num].ip_callback = ip_callback;
+    friend->callbacks[lock_num].data = data;
+    friend->callbacks[lock_num].number = number;
+
+    if (lock_count)
+        *lock_count = lock_num + 1;
+
 #ifdef ENABLE_ASSOC_DHT
 
     if (dht->assoc) {
@@ -1148,39 +1250,48 @@ int DHT_addfriend(DHT *dht, const uint8_t *client_id)
     return 0;
 }
 
-int DHT_delfriend(DHT *dht, const uint8_t *client_id)
+int DHT_delfriend(DHT *dht, const uint8_t *client_id, uint16_t lock_count)
 {
-    uint32_t i;
-    DHT_Friend *temp;
+    int friend_num = friend_number(dht, client_id);
 
-    for (i = 0; i < dht->num_friends; ++i) {
-        /* Equal */
-        if (id_equal(dht->friends_list[i].client_id, client_id)) {
-            --dht->num_friends;
+    if (friend_num == -1) {
+        return -1;
+    }
 
-            if (dht->num_friends != i) {
-                memcpy( &dht->friends_list[i],
-                        &dht->friends_list[dht->num_friends],
-                        sizeof(DHT_Friend) );
-            }
+    DHT_Friend *friend = &dht->friends_list[friend_num];
+    --friend->lock_count;
 
-            if (dht->num_friends == 0) {
-                free(dht->friends_list);
-                dht->friends_list = NULL;
-                return 0;
-            }
+    if (friend->lock_count && lock_count) { /* DHT friend is still in use.*/
+        --lock_count;
+        friend->callbacks[lock_count].ip_callback = NULL;
+        friend->callbacks[lock_count].data = NULL;
+        friend->callbacks[lock_count].number = 0;
+        return 0;
+    }
 
-            temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
+    DHT_Friend *temp;
 
-            if (temp == NULL)
-                return 1;
+    --dht->num_friends;
 
-            dht->friends_list = temp;
-            return 0;
-        }
+    if (dht->num_friends != friend_num) {
+        memcpy( &dht->friends_list[friend_num],
+                &dht->friends_list[dht->num_friends],
+                sizeof(DHT_Friend) );
     }
 
-    return 1;
+    if (dht->num_friends == 0) {
+        free(dht->friends_list);
+        dht->friends_list = NULL;
+        return 0;
+    }
+
+    temp = realloc(dht->friends_list, sizeof(DHT_Friend) * (dht->num_friends));
+
+    if (temp == NULL)
+        return -1;
+
+    dht->friends_list = temp;
+    return 0;
 }
 
 /* TODO: Optimize this. */
@@ -1356,7 +1467,7 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
  *
  *  return -1 if failure.
  */
-int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint32_t length)
+int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint16_t length)
 {
     uint32_t i;
 
@@ -1451,7 +1562,7 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n
  *  return ip for friend.
  *  return number of nodes the packet was sent to. (Only works if more than (MAX_FRIEND_CLIENTS / 4).
  */
-int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint32_t length)
+int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length)
 {
     int num = friend_number(dht, friend_id);
 
@@ -1506,7 +1617,7 @@ int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *pack
  *
  *  return number of nodes the packet was sent to.
  */
-static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint32_t length)
+static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length)
 {
     int num = friend_number(dht, friend_id);
 
@@ -1552,26 +1663,6 @@ static int routeone_tofriend(DHT *dht, const uint8_t *friend_id, const uint8_t *
     return 0;
 }
 
-/* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist.
- * ip_portlist must be at least MAX_FRIEND_CLIENTS big.
- *
- *  return number of ips returned.
- *  return 0 if we are connected to friend or if no ips were found.
- *  return -1 if no such friend.
- */
-int friend_ips(const DHT *dht, IP_Port *ip_portlist, const uint8_t *friend_id)
-{
-    uint32_t i;
-
-    for (i = 0; i < dht->num_friends; ++i) {
-        /* Equal */
-        if (id_equal(dht->friends_list[i].client_id, friend_id))
-            return friend_iplist(dht, ip_portlist, i);
-    }
-
-    return -1;
-}
-
 /*----------------------------------------------------------------------------------*/
 /*---------------------BEGINNING OF NAT PUNCHING FUNCTIONS--------------------------*/
 
@@ -1604,7 +1695,7 @@ static int send_NATping(DHT *dht, const uint8_t *public_key, uint64_t ping_id, u
 
 /* Handle a received ping request for. */
 static int handle_NATping(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                          uint32_t length)
+                          uint16_t length)
 {
     if (length != sizeof(uint64_t) + 1)
         return 1;
@@ -1794,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)
@@ -1824,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)
@@ -1861,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)) {
@@ -1884,7 +1975,7 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num)
 
 /* Handle a received hardening packet */
 static int handle_hardening(void *object, IP_Port source, const uint8_t *source_pubkey, const uint8_t *packet,
-                            uint32_t length)
+                            uint16_t length)
 {
     DHT *dht = object;
 
@@ -1899,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;
@@ -1999,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;
 
@@ -2011,82 +2102,6 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num)
     return count;
 }
 
-/* Put a random node from list of list_size in node. LAN_ok is 1 if LAN ips are ok, 0 if we don't want them. */
-static int random_node_fromlist(Client_data *list, uint16_t list_size, Node_format *node, uint8_t LAN_ok)
-{
-    uint32_t i;
-    uint32_t num_nodes = 0;
-    Client_data *client_list[list_size * 2];
-    IPPTsPng    *assoc_list[list_size * 2];
-
-    for (i = 0; i < list_size; i++) {
-        /* If node is not dead. */
-        Client_data *client = &list[i];
-        IPPTsPng *assoc;
-        uint32_t a;
-
-        for (a = 0, assoc = &client->assoc6; a < 2; a++, assoc = &client->assoc4) {
-            /* If node is good. */
-            if (!is_timeout(assoc->timestamp, BAD_NODE_TIMEOUT)) {
-                if (!LAN_ok) {
-                    if (LAN_ip(assoc->ip_port.ip) == 0)
-                        continue;
-                }
-
-                client_list[num_nodes] = client;
-                assoc_list[num_nodes] = assoc;
-                ++num_nodes;
-            }
-        }
-    }
-
-    if (num_nodes == 0)
-        return -1;
-
-    uint32_t rand_node = rand() % num_nodes;
-    node->ip_port = assoc_list[rand_node]->ip_port;
-    memcpy(node->client_id, client_list[rand_node]->client_id, CLIENT_ID_SIZE);
-    return 0;
-}
-
-/* Put up to max_num random nodes in nodes.
- *
- * return the number of nodes.
- *
- * NOTE:this is used to pick nodes for paths.
- *
- * TODO: remove the LAN stuff from this.
- */
-uint16_t random_nodes_path(const DHT *dht, Node_format *nodes, uint16_t max_num)
-{
-    if (max_num == 0)
-        return 0;
-
-    if (dht->num_friends == 0)
-        return 0;
-
-    uint16_t count = 0;
-    uint16_t list_size = 0;
-    uint32_t i;
-
-    for (i = 0; i < max_num; ++i) {
-        Client_data *list = NULL;
-        uint16_t rand_num = rand() % (dht->num_friends);
-        list = dht->friends_list[rand_num].client_list;
-        list_size = MAX_FRIEND_CLIENTS;
-
-        uint8_t LAN_ok = 1;
-
-        if (count != 0 && LAN_ip(nodes[0].ip_port.ip) != 0)
-            LAN_ok = 0;
-
-        if (random_node_fromlist(list, list_size, &nodes[count], LAN_ok) == 0)
-            ++count;
-    }
-
-    return count;
-}
-
 void do_hardening(DHT *dht)
 {
     uint32_t i;
@@ -2114,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();
                 }
             }
@@ -2145,7 +2160,7 @@ void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_c
     dht->cryptopackethandlers[byte].object = object;
 }
 
-static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int cryptopacket_handle(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     DHT *dht = object;
 
@@ -2221,7 +2236,7 @@ DHT *new_DHT(Networking_Core *net)
     for (i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) {
         uint8_t random_key_bytes[CLIENT_ID_SIZE];
         randombytes(random_key_bytes, sizeof(random_key_bytes));
-        DHT_addfriend(dht, random_key_bytes);
+        DHT_addfriend(dht, random_key_bytes, 0, 0, 0, 0);
     }
 
     return dht;
@@ -2229,6 +2244,12 @@ DHT *new_DHT(Networking_Core *net)
 
 void do_DHT(DHT *dht)
 {
+    // Load friends/clients if first call to do_DHT
+    if (dht->has_loaded_friends_clients == 0) {
+        dht->has_loaded_friends_clients = 1;
+        DHT_connect_after_load(dht);
+    }
+
     unix_time_update();
 
     if (dht->last_run == unix_time()) {
@@ -2254,7 +2275,6 @@ void kill_DHT(DHT *dht)
     kill_Assoc(dht->assoc);
 #endif
     networking_registerhandler(dht->net, NET_PACKET_GET_NODES, NULL, NULL);
-    networking_registerhandler(dht->net, NET_PACKET_SEND_NODES, NULL, NULL);
     networking_registerhandler(dht->net, NET_PACKET_SEND_NODES_IPV6, NULL, NULL);
     cryptopacket_registerhandler(dht, CRYPTO_PACKET_NAT_PING, NULL, NULL);
     cryptopacket_registerhandler(dht, CRYPTO_PACKET_HARDENING, NULL, NULL);
@@ -2262,6 +2282,8 @@ void kill_DHT(DHT *dht)
     ping_array_free_all(&dht->dht_harden_ping_array);
     kill_ping(dht->ping);
     free(dht->friends_list);
+    free(dht->loaded_friends_list);
+    free(dht->loaded_clients_list);
     free(dht);
 }
 
@@ -2333,10 +2355,73 @@ void DHT_save(DHT *dht, uint8_t *data)
     }
 }
 
+static void DHT_bootstrap_loaded_clients(DHT *dht)
+{
+    if (!dht->loaded_clients_list)
+        return;
+
+    uint32_t i;
+
+    Client_data *client_list = dht->loaded_clients_list;
+    uint32_t client_count = dht->loaded_num_clients;
+
+    for (i = 0; i < client_count; ++i) {
+        if (client_list[i].assoc4.timestamp != 0)
+            DHT_bootstrap(dht, client_list[i].assoc4.ip_port, client_list[i].client_id);
+
+        if (client_list[i].assoc6.timestamp != 0)
+            DHT_bootstrap(dht, client_list[i].assoc6.ip_port, client_list[i].client_id);
+    }
+}
+
+static void getnodes_of_loaded_friend_clients(DHT *dht)
+{
+    if (!dht->loaded_friends_list)
+        return;
+
+    uint32_t i, j;
+
+    DHT_Friend *friend_list = dht->loaded_friends_list;
+    uint32_t friend_count = dht->loaded_num_friends;
+
+    for (i = 0; i < friend_count; ++i) {
+        for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
+            Client_data *client = &friend_list[i].client_list[j];
+
+            if (client->assoc4.timestamp != 0)
+                getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id, NULL);
+
+            if (client->assoc6.timestamp != 0)
+                getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id, NULL);
+        }
+    }
+}
+
+/* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set */
+int DHT_connect_after_load(DHT *dht)
+{
+    if (dht == NULL)
+        return -1;
+
+    getnodes_of_loaded_friend_clients(dht);
+    DHT_bootstrap_loaded_clients(dht);
+
+    // Loaded lists were allocd, free them
+    free(dht->loaded_friends_list);
+    dht->loaded_friends_list = NULL;
+    dht->loaded_num_friends = 0;
+
+    free(dht->loaded_clients_list);
+    dht->loaded_clients_list = NULL;
+    dht->loaded_num_clients = 0;
+
+    return 0;
+}
+
 static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
 {
     DHT *dht = outer;
-    uint32_t num, i, j;
+    uint32_t num, i;
 
     switch (type) {
         case DHT_STATE_TYPE_FRIENDS_ASSOC46:
@@ -2347,18 +2432,16 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
                 DHT_Friend *friend_list = (DHT_Friend *)data;
                 num = length / sizeof(DHT_Friend);
 
-                for (i = 0; i < num; ++i) {
+                free(dht->loaded_friends_list);
+                // Copy to loaded_friends_list
+                dht->loaded_friends_list = calloc(num, sizeof(DHT_Friend));
 
-                    for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                        Client_data *client = &friend_list[i].client_list[j];
+                for (i = 0; i < num; i++)
+                    memcpy(&(dht->loaded_friends_list[i]), &(friend_list[i]), sizeof(DHT_Friend));
 
-                        if (client->assoc4.timestamp != 0)
-                            getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id, NULL);
+                dht->loaded_num_friends = num;
 
-                        if (client->assoc6.timestamp != 0)
-                            getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id, NULL);
-                    }
-                }
+                dht->has_loaded_friends_clients = 1;
             } /* localize declarations */
 
             break;
@@ -2371,13 +2454,16 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
                 num = length / sizeof(Client_data);
                 Client_data *client_list = (Client_data *)data;
 
-                for (i = 0; i < num; ++i) {
-                    if (client_list[i].assoc4.timestamp != 0)
-                        DHT_bootstrap(dht, client_list[i].assoc4.ip_port, client_list[i].client_id);
+                free(dht->loaded_clients_list);
+                // Copy to loaded_clients_list
+                dht->loaded_clients_list = calloc(num, sizeof(Client_data));
 
-                    if (client_list[i].assoc6.timestamp != 0)
-                        DHT_bootstrap(dht, client_list[i].assoc6.ip_port, client_list[i].client_id);
-                }
+                for (i = 0; i < num; i++)
+                    memcpy(&(dht->loaded_clients_list[i]), &(client_list[i]), sizeof(Client_data));
+
+                dht->loaded_num_clients = num;
+
+                dht->has_loaded_friends_clients = 1;
             } /* localize declarations */
 
             break;
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index 563ae08c..318a6002 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -65,7 +65,9 @@
 
 /* Functions to transfer ips safely across wire. */
 void to_net_family(IP *ip);
-void to_host_family(IP *ip);
+
+/* return 0 on success, -1 on failure. */
+int to_host_family(IP *ip);
 
 typedef struct {
     IP_Port     ip_port;
@@ -122,6 +124,8 @@ typedef struct {
     uint64_t    NATping_timestamp;
 } NAT;
 
+#define DHT_FRIEND_MAX_LOCKS 32
+
 typedef struct {
     uint8_t     client_id[CLIENT_ID_SIZE];
     Client_data client_list[MAX_FRIEND_CLIENTS];
@@ -133,11 +137,18 @@ typedef struct {
 
     /* Symetric NAT hole punching stuff. */
     NAT         nat;
+
+    uint16_t lock_count;
+    struct {
+        void (*ip_callback)(void *, int32_t, IP_Port);
+        void *data;
+        int32_t number;
+    } callbacks[DHT_FRIEND_MAX_LOCKS];
+
 } DHT_Friend;
 
-typedef struct __attribute__ ((__packed__))
-{
-    uint8_t     client_id[CLIENT_ID_SIZE];
+typedef struct {
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     IP_Port     ip_port;
 }
 Node_format;
@@ -177,7 +188,7 @@ typedef struct {
 /*----------------------------------------------------------------------------------*/
 
 typedef int (*cryptopacket_handler_callback)(void *object, IP_Port ip_port, const uint8_t *source_pubkey,
-        const uint8_t *data, uint32_t len);
+        const uint8_t *data, uint16_t len);
 
 typedef struct {
     cryptopacket_handler_callback function;
@@ -200,6 +211,14 @@ typedef struct {
     DHT_Friend    *friends_list;
     uint16_t       num_friends;
 
+    // Used after loading of file (tox_load), but no longer needed after connect (tox_connect)
+    // Unsure if friends_list and num_friends could just be used instead?
+    int has_loaded_friends_clients; // Whether or not we have loaded on the first do_DHT
+    DHT_Friend    *loaded_friends_list;
+    uint32_t       loaded_num_friends;
+    Client_data   *loaded_clients_list;
+    uint32_t       loaded_num_clients;
+
     Shared_Keys shared_keys_recv;
     Shared_Keys shared_keys_sent;
 
@@ -238,18 +257,25 @@ void DHT_getnodes(DHT *dht, const IP_Port *from_ipp, const uint8_t *from_id, con
 /* Add a new friend to the friends list.
  * client_id must be CLIENT_ID_SIZE bytes long.
  *
+ * ip_callback is the callback of a function that will be called when the ip address
+ * is found along with arguments data and number.
+ *
+ * lock_count will be set to a non zero number that must be passed to DHT_delfriend()
+ * to properly remove the callback.
+ *
  *  return 0 if success.
- *  return 1 if failure (friends list is full).
+ *  return -1 if failure (friends list is full).
  */
-int DHT_addfriend(DHT *dht, const uint8_t *client_id);
+int DHT_addfriend(DHT *dht, const uint8_t *client_id, void (*ip_callback)(void *data, int32_t number, IP_Port),
+                  void *data, int32_t number, uint16_t *lock_count);
 
 /* Delete a friend from the friends list.
  * client_id must be CLIENT_ID_SIZE bytes long.
  *
  *  return 0 if success.
- *  return 1 if failure (client_id not in friends list).
+ *  return -1 if failure (client_id not in friends list).
  */
-int DHT_delfriend(DHT *dht, const uint8_t *client_id);
+int DHT_delfriend(DHT *dht, const uint8_t *client_id, uint16_t lock_count);
 
 /* Get ip of friend.
  *  client_id must be CLIENT_ID_SIZE bytes long.
@@ -300,14 +326,6 @@ int get_close_nodes(const DHT *dht, const uint8_t *client_id, Node_format *nodes
  */
 uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num);
 
-/* Put up to max_num random nodes in nodes.
- *
- * return the number of nodes.
- *
- * NOTE:this is used to pick nodes for paths.
- */
-uint16_t random_nodes_path(const DHT *dht, Node_format *nodes, uint16_t max_num);
-
 /* Run this function at least a couple times per second (It's the main loop). */
 void do_DHT(DHT *dht);
 
@@ -332,6 +350,12 @@ void DHT_bootstrap(DHT *dht, IP_Port ip_port, const uint8_t *public_key);
 int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enabled,
                                uint16_t port, const uint8_t *public_key);
 
+/* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set.
+ *
+ * returns 0 if successful
+ * returns -1 otherwise
+ */
+int DHT_connect_after_load(DHT *dht);
 
 /* ROUTING FUNCTIONS */
 
@@ -339,28 +363,18 @@ int DHT_bootstrap_from_address(DHT *dht, const char *address, uint8_t ipv6enable
  *
  *  return -1 if failure.
  */
-int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint32_t length);
+int route_packet(const DHT *dht, const uint8_t *client_id, const uint8_t *packet, uint16_t length);
 
 /* Send the following packet to everyone who tells us they are connected to friend_id.
  *
  *  return number of nodes it sent the packet to.
  */
-int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint32_t length);
+int route_tofriend(const DHT *dht, const uint8_t *friend_id, const uint8_t *packet, uint16_t length);
 
 /* Function to handle crypto packets.
  */
 void cryptopacket_registerhandler(DHT *dht, uint8_t byte, cryptopacket_handler_callback cb, void *object);
 
-/* NAT PUNCHING FUNCTIONS */
-
-/* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist.
- * ip_portlist must be at least MAX_FRIEND_CLIENTS big.
- *
- *  returns number of ips returned.
- *  returns -1 if no such friend.
- */
-int friend_ips(const DHT *dht, IP_Port *ip_portlist, const uint8_t *friend_id);
-
 /* SAVE/LOAD functions */
 
 /* Get the size of the DHT (for saving). */
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index 3c05fe8d..bc020d87 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -28,6 +28,13 @@
 #include "LAN_discovery.h"
 #include "util.h"
 
+/* Used for get_broadcast(). */
+#ifdef __linux
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <linux/netdevice.h>
+#endif
+
 #define MAX_INTERFACES 16
 
 
@@ -86,6 +93,10 @@ static void fetch_broadcast_info(uint16_t port)
             pAdapter = pAdapter->Next;
         }
     }
+
+    if (pAdapterInfo) {
+        free(pAdapterInfo);
+    }
 }
 
 #elif defined(__linux__)
@@ -141,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++;
     }
@@ -269,7 +285,7 @@ int LAN_ip(IP ip)
     return -1;
 }
 
-static int handle_LANdiscovery(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_LANdiscovery(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     DHT *dht = object;
 
diff --git a/toxcore/LAN_discovery.h b/toxcore/LAN_discovery.h
index fcb094e4..5dffc3ad 100644
--- a/toxcore/LAN_discovery.h
+++ b/toxcore/LAN_discovery.h
@@ -28,13 +28,6 @@
 
 #include "DHT.h"
 
-/* Used for get_broadcast(). */
-#ifdef __linux
-#include <sys/ioctl.h>
-#include <arpa/inet.h>
-#include <linux/netdevice.h>
-#endif
-
 /* Interval in seconds between LAN discovery packet sending. */
 #define LAN_DISCOVERY_INTERVAL 10
 
diff --git a/toxcore/Makefile.inc b/toxcore/Makefile.inc
index 8e39f96e..9fd1f94a 100644
--- a/toxcore/Makefile.inc
+++ b/toxcore/Makefile.inc
@@ -19,6 +19,8 @@ libtoxcore_la_SOURCES = ../toxcore/DHT.h \
                         ../toxcore/friend_requests.c \
                         ../toxcore/LAN_discovery.h \
                         ../toxcore/LAN_discovery.c \
+                        ../toxcore/friend_connection.h \
+                        ../toxcore/friend_connection.c \
                         ../toxcore/Messenger.h \
                         ../toxcore/Messenger.c \
                         ../toxcore/ping.h \
@@ -27,8 +29,8 @@ libtoxcore_la_SOURCES = ../toxcore/DHT.h \
                         ../toxcore/tox.c \
                         ../toxcore/util.h \
                         ../toxcore/util.c \
-                        ../toxcore/group_chats.h \
-                        ../toxcore/group_chats.c \
+                        ../toxcore/group.h \
+                        ../toxcore/group.c \
                         ../toxcore/assoc.h \
                         ../toxcore/assoc.c \
                         ../toxcore/onion.h \
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index eff845cf..a9d5e6a1 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -36,18 +36,21 @@
 #include "util.h"
 
 
-#define MIN(a,b) (((a)<(b))?(a):(b))
-
-
 static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status);
 static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
-                                uint32_t length);
-static int clear_receipts(Messenger *m, int32_t friendnumber);
+                                uint32_t length, uint8_t congestion_control);
+static int send_avatar_data_control(const Messenger *m, const uint32_t friendnumber, uint8_t op);
 
 // friend_not_valid determines if the friendnumber passed is valid in the Messenger object
 static uint8_t friend_not_valid(const Messenger *m, int32_t friendnumber)
 {
-    return (unsigned int)friendnumber >= m->numfriends;
+    if ((unsigned int)friendnumber < m->numfriends) {
+        if (m->friendlist[friendnumber].status != 0) {
+            return 0;
+        }
+    }
+
+    return 1;
 }
 
 static int add_online_friend(Messenger *m, int32_t friendnumber)
@@ -92,37 +95,45 @@ 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);
-        return 0;
-    }
+    memcpy(real_pk, m->friendlist[friendnumber].real_pk, crypto_box_PUBLICKEYBYTES);
+    return 0;
+}
 
-    return -1;
+/*  return friend connection id on success.
+ *  return -1 if failure.
+ */
+int getfriendcon_id(const Messenger *m, int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    return m->friendlist[friendnumber].friendcon_id;
 }
+
 /* TODO: Another checksum algorithm might be better.
  *
  *  return a uint16_t that represents the checksum of address of length len.
@@ -140,7 +151,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.
  */
@@ -153,19 +164,71 @@ void getaddress(const Messenger *m, uint8_t *address)
     memcpy(address + crypto_box_PUBLICKEYBYTES + sizeof(nospam), &checksum, sizeof(checksum));
 }
 
-/* callback for recv TCP relay nodes. */
-static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key)
+static int send_online_packet(Messenger *m, int32_t friendnumber)
 {
-    Messenger *m = object;
+    if (friend_not_valid(m, friendnumber))
+        return 0;
 
-    if (friend_not_valid(m, number))
-        return -1;
+    uint8_t packet = PACKET_ID_ONLINE;
+    return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                             m->friendlist[friendnumber].friendcon_id), &packet, sizeof(packet), 0) != -1;
+}
 
-    if (m->friendlist[number].crypt_connection_id != -1) {
-        return add_tcp_relay_peer(m->net_crypto, m->friendlist[number].crypt_connection_id, ip_port, public_key);
-    } else {
-        return add_tcp_relay(m->net_crypto, ip_port, public_key);
+static int send_offine_packet(Messenger *m, int friendcon_id)
+{
+    uint8_t packet = PACKET_ID_OFFLINE;
+    return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), &packet,
+                             sizeof(packet), 0) != -1;
+}
+
+static int handle_status(void *object, int i, uint8_t status);
+static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len);
+static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length);
+
+static 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_NOMEM;
+
+    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_length = 0;
+            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;
+            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_NOMEM;
 }
 
 /*
@@ -179,7 +242,6 @@ static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_por
  *  return FAERR_NOMESSAGE if no message (message length must be >= 1 byte).
  *  return FAERR_OWNKEY if user's own key.
  *  return FAERR_ALREADYSENT if friend request already sent or already a friend.
- *  return FAERR_UNKNOWN for unknown error.
  *  return FAERR_BADCHECKSUM if bad checksum in address.
  *  return FAERR_SETNEWNOSPAM if the friend was already there but the nospam was different.
  *  (the nospam for that friend was set to the new one).
@@ -190,10 +252,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));
@@ -205,10 +267,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)
@@ -224,143 +286,32 @@ 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));
-
-    int32_t onion_friendnum = onion_addfriend(m->onion_c, client_id);
-
-    if (onion_friendnum == -1)
-        return FAERR_UNKNOWN;
-
-    uint32_t i;
+    int32_t ret = init_new_friend(m, real_pk, FRIEND_ADDED);
 
-    for (i = 0; i <= m->numfriends; ++i)  {
-        if (m->friendlist[i].status == NOFRIEND) {
-            m->friendlist[i].onion_friendnum = onion_friendnum;
-            m->friendlist[i].status = FRIEND_ADDED;
-            m->friendlist[i].crypt_connection_id = -1;
-            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].is_typing = 0;
-            memcpy(m->friendlist[i].info, data, length);
-            m->friendlist[i].info_size = length;
-            m->friendlist[i].message_id = 0;
-            memcpy(&(m->friendlist[i].friendrequest_nospam), address + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
-            recv_tcp_relay_handler(m->onion_c, onion_friendnum, &tcp_relay_node_callback, m, i);
-
-            if (m->numfriends == i)
-                ++m->numfriends;
-
-            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));
 
-int32_t m_addfriend_norequest(Messenger *m, const uint8_t *client_id)
-{
-    if (getfriend_id(m, client_id) != -1)
-        return -1;
-
-    if (!public_key_valid(client_id))
-        return -1;
-
-    /* Resize the friend list if necessary. */
-    if (realloc_friendlist(m, m->numfriends + 1) != 0)
-        return -1;
-
-    if (id_equal(client_id, m->net_crypto->self_public_key))
-        return -1;
-
-    memset(&(m->friendlist[m->numfriends]), 0, sizeof(Friend));
-
-    int32_t onion_friendnum = onion_addfriend(m->onion_c, client_id);
-
-    if (onion_friendnum == -1)
-        return -1;
-
-    uint32_t i;
-
-    for (i = 0; i <= m->numfriends; ++i) {
-        if (m->friendlist[i].status == NOFRIEND) {
-            m->friendlist[i].onion_friendnum = onion_friendnum;
-            m->friendlist[i].status = FRIEND_CONFIRMED;
-            m->friendlist[i].crypt_connection_id = -1;
-            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].is_typing = 0;
-            m->friendlist[i].message_id = 0;
-            recv_tcp_relay_handler(m->onion_c, onion_friendnum, &tcp_relay_node_callback, m, i);
-
-            if (m->numfriends == i)
-                ++m->numfriends;
-
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-/* Remove a friend.
- *
- *  return 0 if success.
- *  return -1 if failure.
- */
-int m_delfriend(Messenger *m, int32_t friendnumber)
-{
-    if (friend_not_valid(m, friendnumber))
-        return -1;
-
-    if (m->friendlist[friendnumber].status == FRIEND_ONLINE)
-        remove_online_friend(m, friendnumber);
-
-    onion_delfriend(m->onion_c, m->friendlist[friendnumber].onion_friendnum);
-    crypto_kill(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id);
-    free(m->friendlist[friendnumber].statusmessage);
-    clear_receipts(m, friendnumber);
-    remove_request_received(&(m->fr), m->friendlist[friendnumber].client_id);
-    memset(&(m->friendlist[friendnumber]), 0, sizeof(Friend));
-    uint32_t i;
-
-    for (i = m->numfriends; i != 0; --i) {
-        if (m->friendlist[i - 1].status != NOFRIEND)
-            break;
-    }
-
-    m->numfriends = i;
-
-    if (realloc_friendlist(m, m->numfriends) != 0)
-        return FAERR_NOMEM;
-
-    return 0;
+    return ret;
 }
 
-int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber)
+int32_t m_addfriend_norequest(Messenger *m, const uint8_t *real_pk)
 {
-    if (friend_not_valid(m, friendnumber))
-        return -1;
+    if (getfriend_id(m, real_pk) != -1)
+        return FAERR_ALREADYSENT;
 
-    return m->friendlist[friendnumber].status == FRIEND_ONLINE;
-}
+    if (!public_key_valid(real_pk))
+        return FAERR_BADCHECKSUM;
 
-int m_friend_exists(const Messenger *m, int32_t friendnumber)
-{
-    if (friend_not_valid(m, friendnumber))
-        return 0;
+    if (id_equal(real_pk, m->net_crypto->self_public_key))
+        return FAERR_OWNKEY;
 
-    return m->friendlist[friendnumber].status > NOFRIEND;
+    return init_new_friend(m, real_pk, FRIEND_CONFIRMED);
 }
 
 static int clear_receipts(Messenger *m, int32_t friendnumber)
@@ -415,7 +366,7 @@ static int do_receipts(Messenger *m, int32_t friendnumber)
     while (receipts) {
         struct Receipts *temp_r = receipts->next;
 
-        if (cryptpacket_received(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, receipts->packet_num) == -1)
+        if (cryptpacket_received(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id), receipts->packet_num) == -1)
             break;
 
         if (m->read_receipt)
@@ -432,6 +383,74 @@ static int do_receipts(Messenger *m, int32_t friendnumber)
     return 0;
 }
 
+/* Remove a friend.
+ *
+ *  return 0 if success.
+ *  return -1 if failure.
+ */
+int m_delfriend(Messenger *m, int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    if (m->friendlist[friendnumber].status == FRIEND_ONLINE)
+        remove_online_friend(m, friendnumber);
+
+    free(m->friendlist[friendnumber].avatar_recv_data);
+    clear_receipts(m, friendnumber);
+    remove_request_received(&(m->fr), m->friendlist[friendnumber].real_pk);
+    friend_connection_callbacks(m->fr_c, m->friendlist[friendnumber].friendcon_id, MESSENGER_CALLBACK_INDEX, 0, 0, 0, 0, 0);
+    kill_friend_connection(m->fr_c, m->friendlist[friendnumber].friendcon_id);
+
+    if (friend_con_connected(m->fr_c, m->friendlist[friendnumber].friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
+        send_offine_packet(m, m->friendlist[friendnumber].friendcon_id);
+    }
+
+    memset(&(m->friendlist[friendnumber]), 0, sizeof(Friend));
+    uint32_t i;
+
+    for (i = m->numfriends; i != 0; --i) {
+        if (m->friendlist[i - 1].status != NOFRIEND)
+            break;
+    }
+
+    m->numfriends = i;
+
+    if (realloc_friendlist(m, m->numfriends) != 0)
+        return FAERR_NOMEM;
+
+    return 0;
+}
+
+int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    if (m->friendlist[friendnumber].status == FRIEND_ONLINE) {
+        uint8_t direct_connected = 0;
+        crypto_connection_status(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                                 m->friendlist[friendnumber].friendcon_id), &direct_connected);
+
+        if (direct_connected) {
+            return CONNECTION_UDP;
+        } else {
+            return CONNECTION_TCP;
+        }
+    } else {
+        return CONNECTION_NONE;
+    }
+}
+
+int m_friend_exists(const Messenger *m, int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return 0;
+
+    return 1;
+}
+
+
 static uint32_t send_message_generic(Messenger *m, int32_t friendnumber, const uint8_t *message, uint32_t length,
                                      uint8_t packet_id)
 {
@@ -447,8 +466,7 @@ static uint32_t send_message_generic(Messenger *m, int32_t friendnumber, const u
     if (length != 0)
         memcpy(packet + 1, message, length);
 
-    int64_t packet_num = write_cryptpacket(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, packet,
-                                           length + 1);
+    int64_t packet_num = write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id), packet, length + 1, 0);
 
     if (packet_num == -1)
         return 0;
@@ -488,10 +506,10 @@ uint32_t m_sendaction(Messenger *m, int32_t friendnumber, const uint8_t *action,
  */
 static int m_sendname(const Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length)
 {
-    if (length > MAX_NAME_LENGTH || length == 0)
+    if (length > MAX_NAME_LENGTH)
         return 0;
 
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_NICKNAME, name, length);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_NICKNAME, name, length, 0);
 }
 
 /* Set the name and name_length of a friend.
@@ -522,20 +540,21 @@ int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint1
  */
 int setname(Messenger *m, const uint8_t *name, uint16_t length)
 {
-    if (length > MAX_NAME_LENGTH || length == 0)
+    if (length > MAX_NAME_LENGTH)
         return -1;
 
-    memcpy(m->name, name, length);
+    if (m->name_length == length && (length == 0 || memcmp(name, m->name, length) == 0))
+        return 0;
+
+    if (length)
+        memcpy(m->name, name, length);
+
     m->name_length = length;
     uint32_t i;
 
     for (i = 0; i < m->numfriends; ++i)
         m->friendlist[i].name_sent = 0;
 
-    for (i = 0; i < m->numchats; i++)
-        if (m->chats[i] != NULL)
-            set_nick(m->chats[i], name, length); /* TODO: remove this (group nicks should not be tied to the global one) */
-
     return 0;
 }
 
@@ -588,7 +607,12 @@ int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length)
     if (length > MAX_STATUSMESSAGE_LENGTH)
         return -1;
 
-    memcpy(m->statusmessage, status, length);
+    if (m->statusmessage_length == length && (length == 0 || memcmp(m->statusmessage, status, length) == 0))
+        return 0;
+
+    if (length)
+        memcpy(m->statusmessage, status, length);
+
     m->statusmessage_length = length;
 
     uint32_t i;
@@ -601,9 +625,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;
@@ -614,6 +640,149 @@ int m_set_userstatus(Messenger *m, uint8_t status)
     return 0;
 }
 
+int m_unset_avatar(Messenger *m)
+{
+    if (m->avatar_data != NULL)
+        free(m->avatar_data);
+
+    m->avatar_data = NULL;
+    m->avatar_data_length = 0;
+    m->avatar_format = AVATAR_FORMAT_NONE;
+    memset(m->avatar_hash, 0, AVATAR_HASH_LENGTH);
+
+    uint32_t i;
+
+    for (i = 0; i < m->numfriends; ++i)
+        m->friendlist[i].avatar_info_sent = 0;
+
+    return 0;
+}
+
+int m_set_avatar(Messenger *m, uint8_t format, const uint8_t *data, uint32_t length)
+{
+    if (format == AVATAR_FORMAT_NONE) {
+        m_unset_avatar(m);
+        return 0;
+    }
+
+    if (length > AVATAR_MAX_DATA_LENGTH || length == 0)
+        return -1;
+
+    if (data == NULL)
+        return -1;
+
+    uint8_t *tmp = realloc(m->avatar_data, length);
+
+    if (tmp == NULL)
+        return -1;
+
+    m->avatar_format = format;
+    m->avatar_data = tmp;
+    m->avatar_data_length = length;
+    memcpy(m->avatar_data, data, length);
+
+    m_avatar_hash(m->avatar_hash, m->avatar_data, m->avatar_data_length);
+
+    uint32_t i;
+
+    for (i = 0; i < m->numfriends; ++i)
+        m->friendlist[i].avatar_info_sent = 0;
+
+    return 0;
+}
+
+int m_get_self_avatar(const Messenger *m, uint8_t *format, uint8_t *buf, uint32_t *length, uint32_t maxlen,
+                      uint8_t *hash)
+{
+    if (format)
+        *format = m->avatar_format;
+
+    if (length)
+        *length = m->avatar_data_length;
+
+    if (hash)
+        memcpy(hash, m->avatar_hash, AVATAR_HASH_LENGTH);
+
+    if (buf != NULL && maxlen > 0) {
+        if (m->avatar_data_length <= maxlen)
+            memcpy(buf, m->avatar_data, m->avatar_data_length);
+        else
+            return -1;
+    }
+
+    return 0;
+}
+
+int m_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen)
+{
+    if (hash == NULL)
+        return -1;
+
+    return crypto_hash_sha256(hash, data, datalen);
+}
+
+int m_avatar_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen)
+{
+    return m_hash(hash, data, datalen);
+}
+
+int m_request_avatar_info(const Messenger *m, const int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_AVATAR_INFO_REQ, 0, 0, 0))
+        return 0;
+    else
+        return -1;
+}
+
+int m_send_avatar_info(const Messenger *m, const int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    uint8_t data[sizeof(uint8_t) + AVATAR_HASH_LENGTH];
+    data[0] = m->avatar_format;
+    memcpy(data + 1, m->avatar_hash, AVATAR_HASH_LENGTH);
+
+    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_AVATAR_INFO, data, sizeof(data), 0))
+        return 0;
+    else
+        return -1;
+}
+
+int m_request_avatar_data(const Messenger *m, const int32_t friendnumber)
+{
+    if (friend_not_valid(m, friendnumber))
+        return -1;
+
+    AVATAR_RECEIVEDATA *avrd = m->friendlist[friendnumber].avatar_recv_data;
+
+    if (avrd == NULL) {
+        avrd = calloc(sizeof(AVATAR_RECEIVEDATA), 1);
+
+        if (avrd == NULL)
+            return -1;
+
+        avrd->started = 0;
+        m->friendlist[friendnumber].avatar_recv_data = avrd;
+    }
+
+    if (avrd->started) {
+        LOGGER_DEBUG("Resetting already started data request. "
+                     "friendnumber == %u", friendnumber);
+    }
+
+    avrd->started = 0;
+    avrd->bytes_received = 0;
+    avrd->total_length = 0;
+    avrd->format = AVATAR_FORMAT_NONE;
+
+    return send_avatar_data_control(m, friendnumber, AVATAR_DATACONTROL_REQ);
+}
+
+
 /* return the size of friendnumber's user status.
  * Guaranteed to be at most MAX_STATUSMESSAGE_LENGTH.
  */
@@ -648,12 +817,10 @@ int m_get_self_statusmessage_size(const Messenger *m)
     return m->statusmessage_length;
 }
 
-int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf, uint32_t maxlen)
+int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf)
 {
-    int msglen = MIN(maxlen, m->statusmessage_length);
-    memcpy(buf, m->statusmessage, msglen);
-    memset(buf + msglen, 0, maxlen - msglen);
-    return msglen;
+    memcpy(buf, m->statusmessage, m->statusmessage_length);
+    return m->statusmessage_length;
 }
 
 uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber)
@@ -686,20 +853,22 @@ 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;
 
     return 0;
 }
 
-uint8_t m_get_istyping(const Messenger *m, int32_t friendnumber)
+int m_get_istyping(const Messenger *m, int32_t friendnumber)
 {
     if (friend_not_valid(m, friendnumber))
         return -1;
@@ -709,28 +878,18 @@ uint8_t m_get_istyping(const Messenger *m, int32_t friendnumber)
 
 static int send_statusmessage(const Messenger *m, int32_t friendnumber, const uint8_t *status, uint16_t length)
 {
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_STATUSMESSAGE, status, length);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_STATUSMESSAGE, status, length, 0);
 }
 
 static int send_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status)
 {
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_USERSTATUS, &status, sizeof(status));
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_USERSTATUS, &status, sizeof(status), 0);
 }
 
 static int send_user_istyping(const Messenger *m, int32_t friendnumber, uint8_t is_typing)
 {
     uint8_t typing = is_typing;
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_TYPING, &typing, sizeof(typing));
-}
-
-static int send_ping(const Messenger *m, int32_t friendnumber)
-{
-    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_ALIVE, 0, 0);
-
-    if (ret == 1)
-        m->friendlist[friendnumber].ping_lastsent = unix_time();
-
-    return ret;
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_TYPING, &typing, sizeof(typing), 0);
 }
 
 static int send_relays(const Messenger *m, int32_t friendnumber)
@@ -742,7 +901,7 @@ static int send_relays(const Messenger *m, int32_t friendnumber)
     n = copy_connected_tcp_relays(m->net_crypto, nodes, MAX_SHARED_RELAYS);
     length = pack_nodes(data, sizeof(data), nodes, n);
 
-    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_SHARE_RELAYS, data, length);
+    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_SHARE_RELAYS, data, length, 0);
 
     if (ret == 1)
         m->friendlist[friendnumber].share_relays_lastsent = unix_time();
@@ -757,10 +916,12 @@ static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, co
     if (friend_not_valid(m, friendnumber))
         return -1;
 
-    uint8_t *newstatus = calloc(length + 1, 1);
-    memcpy(newstatus, status, length);
-    free(m->friendlist[friendnumber].statusmessage);
-    m->friendlist[friendnumber].statusmessage = newstatus;
+    if (length > MAX_STATUSMESSAGE_LENGTH)
+        return -1;
+
+    if (length)
+        memcpy(m->friendlist[friendnumber].statusmessage, status, length);
+
     m->friendlist[friendnumber].statusmessage_length = length;
     return 0;
 }
@@ -775,75 +936,106 @@ static void set_friend_typing(const Messenger *m, int32_t friendnumber, uint8_t
     m->friendlist[friendnumber].is_typing = is_typing;
 }
 
-/* static void (*friend_request)(uint8_t *, uint8_t *, uint16_t); */
 /* Set the function that will be executed when a friend request is received. */
-void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, uint16_t,
+void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, size_t,
                               void *), void *userdata)
 {
-    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, uint16_t, void *) = (void *)function;
+    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, size_t, void *) = (void *)function;
     callback_friendrequest(&(m->fr), handle_friendrequest, m, userdata);
 }
 
 /* Set the function that will be executed when a message from a friend is received. */
-void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                               void *userdata)
 {
     m->friend_message = function;
     m->friend_message_userdata = userdata;
 }
 
-void m_callback_action(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_action(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                        void *userdata)
 {
     m->friend_action = function;
     m->friend_action_userdata = userdata;
 }
 
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                            void *userdata)
 {
     m->friend_namechange = function;
     m->friend_namechange_userdata = userdata;
 }
 
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                               void *userdata)
 {
     m->friend_statusmessagechange = function;
     m->friend_statuschange_userdata = userdata;
 }
 
-void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *), void *userdata)
+void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *), void *userdata)
 {
     m->friend_userstatuschange = function;
     m->friend_userstatuschange_userdata = userdata;
 }
 
-void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, int32_t, uint8_t, void *), void *userdata)
+void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, _Bool, void *), void *userdata)
 {
     m->friend_typingchange = function;
     m->friend_typingchange_userdata = userdata;
 }
 
-void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, int32_t, uint32_t, void *), void *userdata)
+void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *), void *userdata)
 {
     m->read_receipt = function;
     m->read_receipt_userdata = userdata;
 }
 
-void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *), void *userdata)
+void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
+                                 void *userdata)
 {
     m->friend_connectionstatuschange = function;
     m->friend_connectionstatuschange_userdata = userdata;
 }
 
-void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *),
+void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
         void *userdata)
 {
     m->friend_connectionstatuschange_internal = function;
     m->friend_connectionstatuschange_internal_userdata = userdata;
 }
 
+void m_callback_avatar_info(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t *, void *),
+                            void *userdata)
+{
+    m->avatar_info_recv = function;
+    m->avatar_info_recv_userdata = userdata;
+}
+
+void m_callback_avatar_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t *, uint8_t *,
+                            uint32_t, void *), void *userdata)
+{
+    m->avatar_data_recv = function;
+    m->avatar_data_recv_userdata = userdata;
+}
+
+static void check_friend_tcp_udp(Messenger *m, int32_t friendnumber)
+{
+    int last_connection_udp_tcp = m->friendlist[friendnumber].last_connection_udp_tcp;
+
+    int ret = m_get_friend_connectionstatus(m, friendnumber);
+
+    if (ret == -1)
+        return;
+
+    if (last_connection_udp_tcp != ret) {
+        if (m->friend_connectionstatuschange)
+            m->friend_connectionstatuschange(m, friendnumber, ret, m->friend_connectionstatuschange_userdata);
+    }
+
+    m->friendlist[friendnumber].last_connection_udp_tcp = ret;
+}
+
 static void break_files(const Messenger *m, int32_t friendnumber);
 static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, uint8_t status)
 {
@@ -853,8 +1045,6 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
     const uint8_t was_online = m->friendlist[friendnumber].status == FRIEND_ONLINE;
     const uint8_t is_online = status == FRIEND_ONLINE;
 
-    onion_set_friend_online(m->onion_c, m->friendlist[friendnumber].onion_friendnum, is_online);
-
     if (is_online != was_online) {
         if (was_online) {
             break_files(m, friendnumber);
@@ -866,8 +1056,7 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
 
         m->friendlist[friendnumber].status = status;
 
-        if (m->friend_connectionstatuschange)
-            m->friend_connectionstatuschange(m, friendnumber, is_online, m->friend_connectionstatuschange_userdata);
+        check_friend_tcp_udp(m, friendnumber);
 
         if (m->friend_connectionstatuschange_internal)
             m->friend_connectionstatuschange_internal(m, friendnumber, is_online,
@@ -882,7 +1071,7 @@ void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status)
 }
 
 static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
-                                uint32_t length)
+                                uint32_t length, uint8_t congestion_control)
 {
     if (friend_not_valid(m, friendnumber))
         return 0;
@@ -896,463 +1085,31 @@ static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_
     if (length != 0)
         memcpy(packet + 1, data, length);
 
-    return write_cryptpacket(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, packet, length + 1) != -1;
+    return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                             m->friendlist[friendnumber].friendcon_id), packet, length + 1, congestion_control) != -1;
 }
 
 /**********GROUP CHATS************/
 
-/* return 1 if the groupnumber is not valid.
- * return 0 if the groupnumber is valid.
- */
-static uint8_t groupnumber_not_valid(const Messenger *m, int groupnumber)
-{
-    if ((unsigned int)groupnumber >= m->numchats)
-        return 1;
-
-    if (m->chats == NULL)
-        return 1;
-
-    if (m->chats[groupnumber] == NULL)
-        return 1;
-
-    return 0;
-}
-
-
-/* returns valid ip port of connected friend on success
- * returns zeroed out IP_Port on failure
- */
-static IP_Port get_friend_ipport(const Messenger *m, int32_t friendnumber)
-{
-    IP_Port zero;
-    memset(&zero, 0, sizeof(zero));
-
-    if (friend_not_valid(m, friendnumber))
-        return zero;
-
-    int crypt_id = m->friendlist[friendnumber].crypt_connection_id;
-
-    uint8_t direct_connected;
-
-    if (crypto_connection_status(m->net_crypto, crypt_id, &direct_connected) != CRYPTO_CONN_ESTABLISHED)
-        return zero;
-
-    if (direct_connected == 0)
-        return zero;
-
-    return m->net_crypto->crypto_connections[crypt_id].ip_port;
-}
-
-/* returns the group number of the chat with public key group_public_key.
- * returns -1 on failure.
- */
-static int group_num(const Messenger *m, const uint8_t *group_public_key)
-{
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; ++i) {
-        if (m->chats[i] != NULL)
-            if (id_equal(m->chats[i]->self_public_key, group_public_key))
-                return i;
-    }
-
-    return -1;
-}
 
 /* Set the callback for group invites.
  *
- *  Function(Messenger *m, int32_t friendnumber, uint8_t *group_public_key, void *userdata)
+ *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length)
  */
-void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, void *),
-                             void *userdata)
+void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t))
 {
     m->group_invite = function;
-    m->group_invite_userdata = userdata;
-}
-
-/* Set the callback for group messages.
- *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void m_callback_group_message(Messenger *m, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t, void *),
-                              void *userdata)
-{
-    m->group_message = function;
-    m->group_message_userdata = userdata;
-}
-
-/* Set the callback for group actions.
- *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void m_callback_group_action(Messenger *m, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t, void *),
-                             void *userdata)
-{
-    m->group_action = function;
-    m->group_action_userdata = userdata;
-}
-
-/* Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, void *userdata)
- */
-void m_callback_group_namelistchange(Messenger *m, void (*function)(Messenger *m, int, int, uint8_t, void *),
-                                     void *userdata)
-{
-    m->group_namelistchange = function;
-    m->group_namelistchange_userdata = userdata;
-}
-
-static int get_chat_num(const Messenger *m, const Group_Chat *chat)
-{
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; ++i) { //TODO: remove this
-        if (m->chats[i] == chat)
-            return i;
-    }
-
-    return -1;
-}
-
-static void group_message_function(Group_Chat *chat, int peer_number, const uint8_t *message, uint16_t length,
-                                   void *userdata)
-{
-    Messenger *m = userdata;
-    int i = get_chat_num(m, chat);
-
-    if (i == -1)
-        return;
-
-    uint8_t message_terminated[length + 1];
-    memcpy(message_terminated, message, length);
-    message_terminated[length] = 0; /* Force NULL terminator */
-
-    if (m->group_message)
-        (*m->group_message)(m, i, peer_number, message_terminated, length, m->group_message_userdata);
-}
-
-static void group_action_function(Group_Chat *chat, int peer_number, const uint8_t *action, uint16_t length,
-                                  void *userdata)
-{
-    Messenger *m = userdata;
-    int i = get_chat_num(m, chat);
-
-    if (i == -1)
-        return;
-
-    uint8_t action_terminated[length + 1];
-    memcpy(action_terminated, action, length);
-    action_terminated[length] = 0; /* Force NULL terminator */
-
-    if (m->group_action)
-        (*m->group_action)(m, i, peer_number, action_terminated, length, m->group_action_userdata);
-}
-
-static void group_namelistchange_function(Group_Chat *chat, int peer, uint8_t change, void *userdata)
-{
-    Messenger *m = userdata;
-    int i = get_chat_num(m, chat);
-
-    if (i == -1)
-        return;
-
-    if (m->group_namelistchange)
-        (*m->group_namelistchange)(m, i, peer, change, m->group_namelistchange_userdata);
-}
-
-
-/* Creates a new groupchat and puts it in the chats array.
- *
- * return group number on success.
- * return -1 on failure.
- */
-int add_groupchat(Messenger *m)
-{
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; ++i) {
-        if (m->chats[i] == NULL) {
-            Group_Chat *newchat = new_groupchat(m->net);
-
-            if (newchat == NULL)
-                return -1;
-
-            callback_groupmessage(newchat, &group_message_function, m);
-            callback_groupaction(newchat, &group_action_function, m);
-            callback_namelistchange(newchat, &group_namelistchange_function, m);
-            /* TODO: remove this (group nicks should not be tied to the global one) */
-            set_nick(newchat, m->name, m->name_length);
-            m->chats[i] = newchat;
-            return i;
-        }
-    }
-
-    Group_Chat **temp;
-    temp = realloc(m->chats, sizeof(Group_Chat *) * (m->numchats + 1));
-
-    if (temp == NULL)
-        return -1;
-
-    m->chats = temp;
-    temp[m->numchats] = new_groupchat(m->net);
-
-    if (temp[m->numchats] == NULL)
-        return -1;
-
-    callback_groupmessage(temp[m->numchats], &group_message_function, m);
-    callback_groupaction(temp[m->numchats], &group_action_function, m);
-    callback_namelistchange(temp[m->numchats], &group_namelistchange_function, m);
-    /* TODO: remove this (group nicks should not be tied to the global one) */
-    set_nick(temp[m->numchats], m->name, m->name_length);
-    ++m->numchats;
-    return (m->numchats - 1);
-}
-
-/* Delete a groupchat from the chats array.
- *
- * return 0 on success.
- * return -1 if failure.
- */
-int del_groupchat(Messenger *m, int groupnumber)
-{
-    if ((unsigned int)groupnumber >= m->numchats)
-        return -1;
-
-    if (m->chats == NULL)
-        return -1;
-
-    if (m->chats[groupnumber] == NULL)
-        return -1;
-
-    kill_groupchat(m->chats[groupnumber]);
-    m->chats[groupnumber] = NULL;
-
-    uint32_t i;
-
-    for (i = m->numchats; i != 0; --i) {
-        if (m->chats[i - 1] != NULL)
-            break;
-    }
-
-    m->numchats = i;
-
-    if (i == 0) {
-        free(m->chats);
-        m->chats = NULL;
-    } else {
-        Group_Chat **temp = realloc(m->chats, sizeof(Group_Chat *) * i);
-
-        if (temp != NULL)
-            m->chats = temp;
-    }
-
-    return 0;
-}
-
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least MAX_NICK_BYTES long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int m_group_peername(const Messenger *m, int groupnumber, int peernumber, uint8_t *name)
-{
-    if ((unsigned int)groupnumber >= m->numchats)
-        return -1;
-
-    if (m->chats == NULL)
-        return -1;
-
-    if (m->chats[groupnumber] == NULL)
-        return -1;
-
-    return group_peername(m->chats[groupnumber], peernumber, name);
-}
-
-/* Store the fact that we invited a specific friend.
- */
-static void group_store_friendinvite(Messenger *m, int32_t friendnumber, int groupnumber)
-{
-    /* Add 1 to the groupchat number because 0 (default value in invited_groups) is a valid groupchat number */
-    m->friendlist[friendnumber].invited_groups[m->friendlist[friendnumber].invited_groups_num % MAX_INVITED_GROUPS] =
-        groupnumber + 1;
-    ++m->friendlist[friendnumber].invited_groups_num;
-}
-
-/* return 1 if that friend was invited to the group
- * return 0 if the friend was not or error.
- */
-static uint8_t group_invited(const Messenger *m, int32_t friendnumber, int groupnumber)
-{
-
-    uint32_t i;
-    uint16_t num = MAX_INVITED_GROUPS;
-
-    if (MAX_INVITED_GROUPS > m->friendlist[friendnumber].invited_groups_num)
-        num = m->friendlist[friendnumber].invited_groups_num;
-
-    for (i = 0; i < num; ++i) {
-        if (m->friendlist[friendnumber].invited_groups[i] == groupnumber + 1) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
- */
-int invite_friend(Messenger *m, int32_t friendnumber, int groupnumber)
-{
-    if (friend_not_valid(m, friendnumber) || (unsigned int)groupnumber >= m->numchats)
-        return -1;
-
-    if (m->chats == NULL)
-        return -1;
-
-    if (m->friendlist[friendnumber].status == NOFRIEND || m->chats[groupnumber] == NULL)
-        return -1;
-
-    group_store_friendinvite(m, friendnumber, groupnumber);
-
-    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_GROUPCHAT, m->chats[groupnumber]->self_public_key,
-                             crypto_box_PUBLICKEYBYTES) == 0)
-        return -1;
-
-    return 0;
 }
 
 
-/* Join a group (you need to have been invited first.)
+/* Send a group invite packet.
  *
- * returns group number on success
- * returns -1 on failure.
- */
-int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_group_public_key)
-{
-    if (friend_not_valid(m, friendnumber))
-        return -1;
-
-    uint8_t data[crypto_box_PUBLICKEYBYTES * 2];
-    int groupnum = add_groupchat(m);
-
-    if (groupnum == -1)
-        return -1;
-
-    IP_Port friend_ip = get_friend_ipport(m, friendnumber);
-
-    if (friend_ip.ip.family == 0) {
-        del_groupchat(m, groupnum);
-        return -1;
-    }
-
-    id_copy(data, friend_group_public_key);
-    id_copy(data + crypto_box_PUBLICKEYBYTES, m->chats[groupnum]->self_public_key);
-
-    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_JOIN_GROUPCHAT, data, sizeof(data))) {
-        chat_bootstrap_nonlazy(m->chats[groupnum], get_friend_ipport(m, friendnumber),
-                               friend_group_public_key); //TODO: check if ip returned is zero?
-        return groupnum;
-    }
-
-    del_groupchat(m, groupnum);
-    return -1;
-}
-
-
-/* send a group message
- * return 0 on success
- * return -1 on failure
- */
-int group_message_send(const Messenger *m, int groupnumber, const uint8_t *message, uint32_t length)
-{
-    if (groupnumber_not_valid(m, groupnumber))
-        return -1;
-
-    if (group_sendmessage(m->chats[groupnumber], message, length) > 0)
-        return 0;
-
-    return -1;
-}
-
-/* send a group action
- * return 0 on success
- * return -1 on failure
- */
-int group_action_send(const Messenger *m, int groupnumber, const uint8_t *action, uint32_t length)
-{
-    if (groupnumber_not_valid(m, groupnumber))
-        return -1;
-
-    if (group_sendaction(m->chats[groupnumber], action, length) > 0)
-        return 0;
-
-    return -1;
-}
-
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
- */
-int group_number_peers(const Messenger *m, int groupnumber)
-{
-    if (groupnumber_not_valid(m, groupnumber))
-        return -1;
-
-    return group_numpeers(m->chats[groupnumber]);
-}
-
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
- *
- * Copies the lengths of the names to lengths[length]
- *
- * returns the number of peers on success.
- *
- * return -1 on failure.
+ *  return 1 on success
+ *  return 0 on failure
  */
-int group_names(const Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
-                uint16_t length)
+int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length)
 {
-    if (groupnumber_not_valid(m, groupnumber))
-        return -1;
-
-    return group_client_names(m->chats[groupnumber], names, lengths, length);
-}
-
-static int handle_group(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
-{
-    Messenger *m = object;
-
-    if (length < crypto_box_PUBLICKEYBYTES + 1) {
-        return 1;
-    }
-
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; ++i) {
-        if (m->chats[i] == NULL)
-            continue;
-
-        if (id_equal(packet + 1, m->chats[i]->self_public_key))
-            return handle_groupchatpacket(m->chats[i], source, packet, length);
-    }
-
-    return 1;
-}
-
-static void do_allgroupchats(Messenger *m)
-{
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; ++i) {
-        if (m->chats[i] != NULL)
-            do_groupchat(m->chats[i]);
-    }
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_INVITE_GROUPCHAT, data, length, 0);
 }
 
 /****************FILE SENDING*****************/
@@ -1360,9 +1117,10 @@ static void do_allgroupchats(Messenger *m)
 
 /* Set the callback for file send requests.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
  */
-void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint64_t, const uint8_t *,
+void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint64_t,
+                               const uint8_t *,
                                uint16_t, void *), void *userdata)
 {
     m->file_sendrequest = function;
@@ -1371,10 +1129,10 @@ void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int3
 
 /* Set the callback for file control requests.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
  *
  */
-void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t,
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t, uint8_t,
                            const uint8_t *, uint16_t, void *), void *userdata)
 {
     m->file_filecontrol = function;
@@ -1383,10 +1141,11 @@ void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t,
 
 /* Set the callback for file data.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
  *
  */
-void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
+void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, const uint8_t *,
+                        uint16_t length,
                         void *), void *userdata)
 {
     m->file_filedata = function;
@@ -1415,7 +1174,7 @@ int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t filenumbe
     memcpy(packet + 1, &filesize, sizeof(filesize));
     memcpy(packet + 1 + sizeof(filesize), filename, filename_length);
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_SENDREQUEST, packet,
-                                1 + sizeof(filesize) + filename_length);
+                                1 + sizeof(filesize) + filename_length, 0);
 }
 
 /* Send a file send request.
@@ -1493,7 +1252,7 @@ int file_control(const Messenger *m, int32_t friendnumber, uint8_t send_receive,
         memcpy(packet + 3, data, length);
     }
 
-    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_CONTROL, packet, length + 3)) {
+    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_CONTROL, packet, length + 3, 0)) {
         if (send_receive == 1)
             switch (message_id) {
                 case FILECONTROL_ACCEPT:
@@ -1555,15 +1314,16 @@ int file_data(const Messenger *m, int32_t friendnumber, uint8_t filenumber, cons
     if (m->friendlist[friendnumber].file_sending[filenumber].status != FILESTATUS_TRANSFERRING)
         return -1;
 
-    /* Prevent file sending from filling up the entire buffer preventing messages from being sent. */
-    if (crypto_num_free_sendqueue_slots(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id) < MIN_SLOTS_FREE)
+    /* Prevent file sending from filling up the entire buffer preventing messages from being sent. TODO: remove */
+    if (crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                                        m->friendlist[friendnumber].friendcon_id)) < MIN_SLOTS_FREE)
         return -1;
 
     uint8_t packet[MAX_CRYPTO_DATA_SIZE];
     packet[0] = filenumber;
     memcpy(packet + 1, data, length);
 
-    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_DATA, packet, length + 1)) {
+    if (write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_DATA, packet, length + 1, 1)) {
         m->friendlist[friendnumber].file_sending[filenumber].transferred += length;
         return 0;
     }
@@ -1706,7 +1466,7 @@ static int handle_filecontrol(const Messenger *m, int32_t friendnumber, uint8_t
  *
  *  Function(Messenger *m, int friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *),
                            void *userdata)
 {
     m->msi_packet = function;
@@ -1720,7 +1480,7 @@ void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t,
  */
 int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length)
 {
-    return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length);
+    return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length, 0);
 }
 
 static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
@@ -1732,13 +1492,15 @@ static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_
 
     if (m->friendlist[friend_num].lossy_packethandlers[packet[0] % PACKET_ID_LOSSY_RANGE_SIZE].function)
         return m->friendlist[friend_num].lossy_packethandlers[packet[0] % PACKET_ID_LOSSY_RANGE_SIZE].function(
-                   m->friendlist[friend_num].lossy_packethandlers[packet[0] % PACKET_ID_LOSSY_RANGE_SIZE].object, packet, length);
+                   m, friend_num, packet, length, m->friendlist[friend_num].lossy_packethandlers[packet[0] %
+                           PACKET_ID_LOSSY_RANGE_SIZE].object);
 
     return 1;
 }
 
 int custom_lossy_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-                                        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object)
+                                        int (*packet_handler_callback)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object),
+                                        void *object)
 {
     if (friend_not_valid(m, friendnumber))
         return -1;
@@ -1762,10 +1524,8 @@ int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uin
     if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
         return -1;
 
-    if (m->friendlist[friendnumber].crypt_connection_id == -1)
-        return -1;
-
-    return send_lossy_cryptpacket(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, data, length);
+    return send_lossy_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                                  m->friendlist[friendnumber].friendcon_id), data, length);
 }
 
 static int handle_custom_lossless_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
@@ -1783,13 +1543,15 @@ static int handle_custom_lossless_packet(void *object, int friend_num, const uin
 
     if (m->friendlist[friend_num].lossless_packethandlers[packet[0] % PACKET_ID_LOSSLESS_RANGE_SIZE].function)
         return m->friendlist[friend_num].lossless_packethandlers[packet[0] % PACKET_ID_LOSSLESS_RANGE_SIZE].function(
-                   m->friendlist[friend_num].lossless_packethandlers[packet[0] % PACKET_ID_LOSSLESS_RANGE_SIZE].object, packet, length);
+                   m, friend_num, packet, length, m->friendlist[friend_num].lossless_packethandlers[packet[0] %
+                           PACKET_ID_LOSSLESS_RANGE_SIZE].object);
 
     return 1;
 }
 
 int custom_lossless_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object)
+        int (*packet_handler_callback)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object),
+        void *object)
 {
     if (friend_not_valid(m, friendnumber))
         return -1;
@@ -1811,21 +1573,32 @@ int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const
     if (friend_not_valid(m, friendnumber))
         return -1;
 
-    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
+    if (length == 0)
+        return -1;
+
+    if (data[0] < PACKET_ID_LOSSLESS_RANGE_START)
         return -1;
 
-    if (m->friendlist[friendnumber].crypt_connection_id == -1)
+    if (data[0] >= (PACKET_ID_LOSSLESS_RANGE_START + PACKET_ID_LOSSLESS_RANGE_SIZE))
+        return -1;
+
+    if (m->friendlist[friendnumber].status != FRIEND_ONLINE)
         return -1;
 
-    return write_cryptpacket(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, data, length) != -1;
+    if (write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
+                          m->friendlist[friendnumber].friendcon_id), data, length, 1) == -1) {
+        return -1;
+    } else {
+        return 0;
+    }
 }
 
 /* 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;
@@ -1840,31 +1613,6 @@ static void LANdiscovery(Messenger *m)
     }
 }
 
-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_new_connections(void *object, New_Connection *n_c)
-{
-    Messenger *m = object;
-    int friend_id = getfriend_id(m, n_c->public_key);
-
-    if (friend_id != -1) {
-        if (m->friendlist[friend_id].crypt_connection_id != -1)
-            return -1;
-
-        int id = accept_crypto_connection(m->net_crypto, n_c);
-        connection_status_handler(m->net_crypto, id, &handle_status, m, friend_id);
-        connection_data_handler(m->net_crypto, id, &handle_packet, m, friend_id);
-        connection_lossy_data_handler(m->net_crypto, id, &handle_custom_lossy_packet, m, friend_id);
-        m->friendlist[friend_id].crypt_connection_id = id;
-        set_friend_status(m, friend_id, FRIEND_CONFIRMED);
-        return 0;
-    }
-
-    return -1;
-}
-
-
 /* Run this at startup. */
 Messenger *new_messenger(Messenger_Options *options)
 {
@@ -1882,6 +1630,9 @@ Messenger *new_messenger(Messenger_Options *options)
         m->net = new_networking(ip, TOX_PORT_DEFAULT);
     }
 
+    m->avatar_format = AVATAR_FORMAT_NONE;
+    m->avatar_data = NULL;
+
     if (m->net == NULL) {
         free(m);
         return NULL;
@@ -1895,11 +1646,7 @@ Messenger *new_messenger(Messenger_Options *options)
         return NULL;
     }
 
-    if (options->proxy_enabled) {
-        m->net_crypto = new_net_crypto(m->dht, &options->proxy_info);
-    } else {
-        m->net_crypto = new_net_crypto(m->dht, 0);
-    }
+    m->net_crypto = new_net_crypto(m->dht, &options->proxy_info);
 
     if (m->net_crypto == NULL) {
         kill_networking(m->net);
@@ -1908,13 +1655,13 @@ Messenger *new_messenger(Messenger_Options *options)
         return NULL;
     }
 
-    new_connection_handler(m->net_crypto, &handle_new_connections, m);
-
     m->onion = new_onion(m->dht);
     m->onion_a = new_onion_announce(m->dht);
     m->onion_c =  new_onion_client(m->net_crypto);
+    m->fr_c = new_friend_connections(m->onion_c);
 
     if (!(m->onion && m->onion_a && m->onion_c)) {
+        kill_friend_connections(m->fr_c);
         kill_onion(m->onion);
         kill_onion_announce(m->onion_a);
         kill_onion_client(m->onion_c);
@@ -1926,27 +1673,23 @@ Messenger *new_messenger(Messenger_Options *options)
     }
 
     m->options = *options;
-    friendreq_init(&(m->fr), m->onion_c);
+    friendreq_init(&(m->fr), m->fr_c);
     LANdiscovery_init(m->dht);
     set_nospam(&(m->fr), random_int());
     set_filter_function(&(m->fr), &friend_already_added, m);
 
-    networking_registerhandler(m->net, NET_PACKET_GROUP_CHATS, &handle_group, m);
-
     return m;
 }
 
 /* Run this before closing shop. */
 void kill_messenger(Messenger *m)
 {
-    /* FIXME TODO: ideally cleanupMessenger will mirror initMessenger.
-     * This requires the other modules to expose cleanup functions.
-     */
-    uint32_t i, numchats = m->numchats;
+    if (!m)
+        return;
 
-    for (i = 0; i < numchats; ++i)
-        del_groupchat(m, i);
+    uint32_t i;
 
+    kill_friend_connections(m->fr_c);
     kill_onion(m->onion);
     kill_onion_announce(m->onion_a);
     kill_onion_client(m->onion_c);
@@ -1955,10 +1698,11 @@ void kill_messenger(Messenger *m)
     kill_networking(m->net);
 
     for (i = 0; i < m->numfriends; ++i) {
+        free(m->friendlist[i].avatar_recv_data);
         clear_receipts(m, i);
-        free(m->friendlist[i].statusmessage);
     }
 
+    free(m->avatar_data);
     free(m->friendlist);
     free(m);
 }
@@ -1974,7 +1718,7 @@ static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t)
 
     if (f->friendrequest_lastsent + f->friendrequest_timeout < t) {
         set_friend_status(m, i, FRIEND_ADDED);
-        /* Double the default timeout everytime if friendrequest is assumed
+        /* Double the default timeout every time if friendrequest is assumed
          * to have been sent unsuccessfully.
          */
         f->friendrequest_timeout *= 2;
@@ -1987,44 +1731,332 @@ static int handle_status(void *object, int i, uint8_t status)
     Messenger *m = object;
 
     if (status) { /* Went online. */
-        set_friend_status(m, i, FRIEND_ONLINE);
+        send_online_packet(m, i);
         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. */
-        m->friendlist[i].crypt_connection_id = -1;
-
         if (m->friendlist[i].status == FRIEND_ONLINE) {
             set_friend_status(m, i, FRIEND_CONFIRMED);
         }
+
+        /* Clear avatar transfer state */
+        if (m->friendlist[i].avatar_recv_data) {
+            free(m->friendlist[i].avatar_recv_data);
+            m->friendlist[i].avatar_recv_data = NULL;
+        }
+    }
+
+    return 0;
+}
+
+
+/* Sends an avatar data control packet to the peer. Usually to return status
+ * values or request data.
+ */
+static int send_avatar_data_control(const Messenger *m, const uint32_t friendnumber,
+                                    uint8_t op)
+{
+    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_AVATAR_DATA_CONTROL,
+                                   &op, sizeof(op), 0);
+    LOGGER_DEBUG("friendnumber = %u, op = %u, ret = %d",
+                 friendnumber, op, ret);
+    return ret ? 0 : -1;
+}
+
+
+static int handle_avatar_data_control(Messenger *m, uint32_t friendnumber,
+                                      uint8_t *data, uint32_t data_length)
+{
+    if (data_length != 1) {
+        LOGGER_DEBUG("Error: PACKET_ID_AVATAR_DATA_CONTROL with bad "
+                     "data_length = %u, friendnumber = %u",
+                     data_length, friendnumber);
+        send_avatar_data_control(m, friendnumber, AVATAR_DATACONTROL_ERROR);
+        return -1;  /* Error */
+    }
+
+    LOGGER_DEBUG("friendnumber = %u, op = %u", friendnumber, data[0]);
+
+    switch (data[0]) {
+        case AVATAR_DATACONTROL_REQ: {
+
+            /* Check data transfer limits for this friend */
+            AVATAR_SENDDATA *const avsd = &(m->friendlist[friendnumber].avatar_send_data);
+
+            if (avsd->bytes_sent >= AVATAR_DATA_TRANSFER_LIMIT) {
+                /* User reached data limit. Check timeout */
+                uint64_t now = unix_time();
+
+                if (avsd->last_reset > 0
+                        && (avsd->last_reset + AVATAR_DATA_TRANSFER_TIMEOUT < now)) {
+                    avsd->bytes_sent = 0;
+                    avsd->last_reset = now;
+                } else {
+                    /* Friend still rate-limitted. Send an error and stops. */
+                    LOGGER_DEBUG("Avatar data transfer limit reached. "
+                                 "friendnumber = %u", friendnumber);
+                    send_avatar_data_control(m, friendnumber, AVATAR_DATACONTROL_ERROR);
+                    return 0;
+                }
+            }
+
+            /* Start the transmission with a DATA_START message. Format:
+             *  uint8_t format
+             *  uint8_t hash[AVATAR_HASH_LENGTH]
+             *  uint32_t total_length
+             */
+            LOGGER_DEBUG("Sending start msg to friend number %u. "
+                         "m->avatar_format = %u, m->avatar_data_length = %u",
+                         friendnumber, m->avatar_format, m->avatar_data_length);
+            uint8_t start_data[1 + AVATAR_HASH_LENGTH + sizeof(uint32_t)];
+            uint32_t avatar_len = htonl(m->avatar_data_length);
+
+            start_data[0] = m->avatar_format;
+            memcpy(start_data + 1, m->avatar_hash, AVATAR_HASH_LENGTH);
+            memcpy(start_data + 1 + AVATAR_HASH_LENGTH, &avatar_len, sizeof(uint32_t));
+
+            avsd->bytes_sent += sizeof(start_data);  /* For rate limit */
+
+            int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_AVATAR_DATA_START,
+                                           start_data, sizeof(start_data), 0);
+
+            if (!ret) {
+                /* Something went wrong, try to signal the error so the friend
+                 * can clear up the state. */
+                send_avatar_data_control(m, friendnumber, AVATAR_DATACONTROL_ERROR);
+                return 0;
+            }
+
+            /* User have no avatar data, nothing more to do. */
+            if (m->avatar_format == AVATAR_FORMAT_NONE)
+                return 0;
+
+            /* Send the actual avatar data. */
+            uint32_t offset = 0;
+
+            while (offset < m->avatar_data_length) {
+                uint32_t chunk_len = m->avatar_data_length - offset;
+
+                if (chunk_len > AVATAR_DATA_MAX_CHUNK_SIZE)
+                    chunk_len = AVATAR_DATA_MAX_CHUNK_SIZE;
+
+                uint8_t chunk[AVATAR_DATA_MAX_CHUNK_SIZE];
+                memcpy(chunk, m->avatar_data + offset, chunk_len);
+                offset += chunk_len;
+                avsd->bytes_sent += chunk_len;  /* For rate limit */
+
+                int ret = write_cryptpacket_id(m, friendnumber,
+                                               PACKET_ID_AVATAR_DATA_PUSH,
+                                               chunk, chunk_len, 0);
+
+                if (!ret) {
+                    LOGGER_DEBUG("write_cryptpacket_id failed. ret = %d, "
+                                 "friendnumber = %u, offset = %u",
+                                 ret, friendnumber, offset);
+                    send_avatar_data_control(m, friendnumber, AVATAR_DATACONTROL_ERROR);
+                    return -1;
+                }
+            }
+
+            return 0;
+        }
+
+        case AVATAR_DATACONTROL_ERROR: {
+            if (m->friendlist[friendnumber].avatar_recv_data) {
+                /* We were receiving the data, sender detected an error
+                  (eg. changing avatar) and asked us to stop. */
+                free(m->friendlist[friendnumber].avatar_recv_data);
+                m->friendlist[friendnumber].avatar_recv_data = NULL;
+            }
+
+            return 0;
+        }
+    }
+
+    return -1;
+}
+
+
+static int handle_avatar_data_start(Messenger *m, uint32_t friendnumber,
+                                    uint8_t *data, uint32_t data_length)
+{
+    LOGGER_DEBUG("data_length = %u, friendnumber = %u", data_length, friendnumber);
+
+    if (data_length != 1 + AVATAR_HASH_LENGTH + sizeof(uint32_t)) {
+        LOGGER_DEBUG("Invalid msg length = %u, friendnumber = %u",
+                     data_length, friendnumber);
+        return -1;
+    }
+
+    AVATAR_RECEIVEDATA *avrd = m->friendlist[friendnumber].avatar_recv_data;
+
+    if (avrd == NULL) {
+        LOGGER_DEBUG("Received an unrequested DATA_START, friendnumber = %u",
+                     friendnumber);
+        return -1;
+    }
+
+    if (avrd->started) {
+        /* Already receiving data from this friend. Must be an error
+         * or an malicious request, because we zeroed the started bit
+         * when we requested the data. */
+        LOGGER_DEBUG("Received an unrequested duplicated DATA_START, "
+                     "friendnumber = %u", friendnumber);
+        return -1;
+    }
+
+    /* Copy data from message to our control structure */
+    avrd->started = 1;
+    avrd->format = data[0];
+    memcpy(avrd->hash, data + 1, AVATAR_HASH_LENGTH);
+    uint32_t tmp_len;
+    memcpy(&tmp_len, data + 1 + AVATAR_HASH_LENGTH, sizeof(uint32_t));
+    avrd->total_length = ntohl(tmp_len);
+    avrd->bytes_received = 0;
+
+    LOGGER_DEBUG("friendnumber = %u, avrd->format = %u, "
+                 "avrd->total_length = %u, avrd->bytes_received = %u",
+                 friendnumber, avrd->format, avrd->total_length,
+                 avrd->bytes_received);
+
+    if (avrd->total_length > AVATAR_MAX_DATA_LENGTH) {
+        /* Invalid data length. Stops. */
+        LOGGER_DEBUG("Error: total_length > MAX_AVATAR_DATA_LENGTH, "
+                     "friendnumber = %u", friendnumber);
+        free(avrd);
+        avrd = NULL;
+        m->friendlist[friendnumber].avatar_recv_data = NULL;
+        return 0;
+    }
+
+    if (avrd->format == AVATAR_FORMAT_NONE || avrd->total_length == 0) {
+        /* No real data to receive. Run callback function and finish. */
+        LOGGER_DEBUG("format == NONE, friendnumber = %u", friendnumber);
+
+        if (m->avatar_data_recv) {
+            memset(avrd->hash, 0, AVATAR_HASH_LENGTH);
+            (m->avatar_data_recv)(m, friendnumber, avrd->format, avrd->hash,
+                                  NULL, 0, m->avatar_data_recv_userdata);
+        }
+
+        free(avrd);
+        avrd = NULL;
+        m->friendlist[friendnumber].avatar_recv_data = NULL;
+        return 0;
+    }
+
+    /* Waits for more data to be received */
+    return 0;
+}
+
+
+static int handle_avatar_data_push(Messenger *m, uint32_t friendnumber,
+                                   uint8_t *data, uint32_t data_length)
+{
+    LOGGER_DEBUG("friendnumber = %u, data_length = %u", friendnumber, data_length);
+
+    AVATAR_RECEIVEDATA *avrd = m->friendlist[friendnumber].avatar_recv_data;
+
+    if (avrd == NULL) {
+        /* No active transfer. It must be an error or a malicious request,
+         * because we set the avatar_recv_data on the first DATA_START. */
+        LOGGER_DEBUG("Error: avrd == NULL, friendnumber = %u", friendnumber);
+        return -1;  /* Error */
+    }
+
+    if (avrd->started == 0) {
+        /* Receiving data for a non-started request. Must be an error
+         * or an malicious request. */
+        LOGGER_DEBUG("Received an data push for a yet non started data "
+                     "request. friendnumber = %u", friendnumber);
+        return -1;  /* Error */
+    }
+
+    uint32_t new_length = avrd->bytes_received + data_length;
+
+    if (new_length > avrd->total_length
+            || new_length >= AVATAR_MAX_DATA_LENGTH) {
+        /* Invalid data length due to error or malice. Stops. */
+        LOGGER_DEBUG("Invalid data length. friendnumber = %u, "
+                     "new_length = %u, avrd->total_length = %u",
+                     friendnumber, new_length,  avrd->total_length);
+        free(avrd);
+        m->friendlist[friendnumber].avatar_recv_data = NULL;
+        return 0;
+    }
+
+    memcpy(avrd->data + avrd->bytes_received, data, data_length);
+    avrd->bytes_received += data_length;
+
+    if (avrd->bytes_received == avrd->total_length) {
+        LOGGER_DEBUG("All data received. friendnumber = %u", friendnumber);
+
+        /* All data was received. Check if the hashes match. It the
+         * requester's responsability to do this. The sender may have done
+         * anything with its avatar data between the DATA_START and now.
+         */
+        uint8_t cur_hash[AVATAR_HASH_LENGTH];
+        m_avatar_hash(cur_hash, avrd->data, avrd->bytes_received);
+
+        if (memcmp(cur_hash, avrd->hash, AVATAR_HASH_LENGTH) == 0) {
+            /* Avatar successfuly received! */
+            if (m->avatar_data_recv) {
+                (m->avatar_data_recv)(m, friendnumber, avrd->format, cur_hash,
+                                      avrd->data, avrd->bytes_received, m->avatar_data_recv_userdata);
+            }
+        } else {
+            LOGGER_DEBUG("Avatar hash error. friendnumber = %u", friendnumber);
+        }
+
+        free(avrd);
+        m->friendlist[friendnumber].avatar_recv_data = NULL;
+        return 0;
     }
 
+    /* Waits for more data to be received */
     return 0;
 }
 
+
+
 static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
 {
     if (len == 0)
         return -1;
 
     Messenger *m = object;
-    uint64_t temp_time = unix_time();
     uint8_t packet_id = temp[0];
     uint8_t *data = temp + 1;
     uint32_t data_length = len - 1;
 
-    if (m->friendlist[i].status != FRIEND_ONLINE)
-        return -1;
+    if (m->friendlist[i].status != FRIEND_ONLINE) {
+        if (packet_id == PACKET_ID_ONLINE && len == 1) {
+            set_friend_status(m, i, FRIEND_ONLINE);
+            send_online_packet(m, i);
+        } else if (packet_id == PACKET_ID_NICKNAME || packet_id == PACKET_ID_STATUSMESSAGE
+                   || packet_id == PACKET_ID_USERSTATUS) {
+            /* Some backward compatibility, TODO: remove. */
+            set_friend_status(m, i, FRIEND_ONLINE);
+            send_online_packet(m, i);
+        } else {
+            return -1;
+        }
+    }
 
     switch (packet_id) {
-        case PACKET_ID_ALIVE: {
-            m->friendlist[i].ping_lastrecv = temp_time;
-            break;
+        case PACKET_ID_OFFLINE: {
+            if (data_length != 0)
+                break;
+
+            set_friend_status(m, i, FRIEND_CONFIRMED);
         }
 
         case PACKET_ID_NICKNAME: {
-            if (data_length > MAX_NAME_LENGTH || data_length == 0)
+            if (data_length > MAX_NAME_LENGTH)
                 break;
 
             /* Make sure the NULL terminator is present. */
@@ -2043,7 +2075,7 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         }
 
         case PACKET_ID_STATUSMESSAGE: {
-            if (data_length == 0 || data_length > MAX_STATUSMESSAGE_LENGTH)
+            if (data_length > MAX_STATUSMESSAGE_LENGTH)
                 break;
 
             /* Make sure the NULL terminator is present. */
@@ -2079,7 +2111,7 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
             if (data_length != 1)
                 break;
 
-            uint8_t typing = data[0];
+            _Bool typing = !!data[0];
 
             set_friend_typing(m, i, typing);
 
@@ -2090,6 +2122,8 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         }
 
         case PACKET_ID_MESSAGE: {
+            const uint8_t *message_id = data;
+
             if (data_length == 0)
                 break;
 
@@ -2108,6 +2142,8 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
         }
 
         case PACKET_ID_ACTION: {
+            const uint8_t *message_id = data;
+
             if (data_length == 0)
                 break;
 
@@ -2126,31 +2162,49 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
             break;
         }
 
-        case PACKET_ID_INVITE_GROUPCHAT: {
-            if (data_length != crypto_box_PUBLICKEYBYTES)
-                break;
+        case PACKET_ID_AVATAR_INFO_REQ: {
+            /* Send our avatar information */
+            m_send_avatar_info(m, i);
+            break;
+        }
 
-            if (m->group_invite)
-                (*m->group_invite)(m, i, data, m->group_invite_userdata);
+        case PACKET_ID_AVATAR_INFO: {
+            if (m->avatar_info_recv) {
+                /*
+                 * A malicious user may send an incomplete avatar info message.
+                 * Check if it have the correct size for the format:
+                 * [1 uint8_t: avatar format] [32 uint8_t: hash]
+                 */
+                if (data_length == AVATAR_HASH_LENGTH + 1) {
+                    (m->avatar_info_recv)(m, i, data[0], data + 1, m->avatar_info_recv_userdata);
+                }
+            }
 
             break;
         }
 
-        case PACKET_ID_JOIN_GROUPCHAT: {
-            if (data_length != crypto_box_PUBLICKEYBYTES * 2)
-                break;
+        case PACKET_ID_AVATAR_DATA_CONTROL: {
+            handle_avatar_data_control(m, i, data, data_length);
+            break;
+        }
 
-            int groupnum = group_num(m, data);
+        case PACKET_ID_AVATAR_DATA_START: {
+            handle_avatar_data_start(m, i, data, data_length);
+            break;
+        }
 
-            if (groupnum == -1)
-                break;
+        case PACKET_ID_AVATAR_DATA_PUSH: {
+            handle_avatar_data_push(m, i, data, data_length);
+            break;
+        }
 
-            if (!group_invited(m, i, groupnum))
+        case PACKET_ID_INVITE_GROUPCHAT: {
+            if (data_length == 0)
                 break;
 
-            group_newpeer(m->chats[groupnum], data + crypto_box_PUBLICKEYBYTES);
-            /* This is just there to speedup joining. */
-            chat_bootstrap(m->chats[groupnum], get_friend_ipport(m, i), data + crypto_box_PUBLICKEYBYTES);
+            if (m->group_invite)
+                (*m->group_invite)(m, i, data, data_length);
+
             break;
         }
 
@@ -2233,7 +2287,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;
@@ -2248,27 +2302,6 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
     return 0;
 }
 
-static int friend_new_connection(Messenger *m, int32_t friendnumber, const uint8_t *real_public_key)
-{
-    if (friend_not_valid(m, friendnumber))
-        return -1;
-
-    if (m->friendlist[friendnumber].crypt_connection_id != -1) {
-        return -1;
-    }
-
-    int id = new_crypto_connection(m->net_crypto, real_public_key);
-
-    if (id == -1)
-        return -1;
-
-    m->friendlist[friendnumber].crypt_connection_id = id;
-    connection_status_handler(m->net_crypto, id, &handle_status, m, friendnumber);
-    connection_data_handler(m->net_crypto, id, &handle_packet, m, friendnumber);
-    connection_lossy_data_handler(m->net_crypto, id, &handle_custom_lossy_packet, m, friendnumber);
-    return 0;
-}
-
 /* TODO: Make this function not suck. */
 void do_friends(Messenger *m)
 {
@@ -2277,9 +2310,9 @@ void do_friends(Messenger *m)
 
     for (i = 0; i < m->numfriends; ++i) {
         if (m->friendlist[i].status == FRIEND_ADDED) {
-            int fr = send_friendrequest(m->onion_c, m->friendlist[i].client_id, m->friendlist[i].friendrequest_nospam,
-                                        m->friendlist[i].info,
-                                        m->friendlist[i].info_size);
+            int fr = send_friend_request_packet(m->fr_c, m->friendlist[i].friendcon_id, m->friendlist[i].friendrequest_nospam,
+                                                m->friendlist[i].info,
+                                                m->friendlist[i].info_size);
 
             if (fr >= 0) {
                 set_friend_status(m, i, FRIEND_REQUESTED);
@@ -2295,32 +2328,6 @@ void do_friends(Messenger *m)
                  */
                 check_friend_request_timed_out(m, i, temp_time);
             }
-
-            friend_new_connection(m, i, m->friendlist[i].client_id);
-        }
-
-        if (m->friendlist[i].crypt_connection_id != -1) {
-            uint8_t dht_public_key1[crypto_box_PUBLICKEYBYTES];
-            uint64_t timestamp1 = onion_getfriend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key1);
-            uint8_t dht_public_key2[crypto_box_PUBLICKEYBYTES];
-            uint64_t timestamp2 = get_connection_dht_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key2);
-
-            if (timestamp1 > timestamp2) {
-                set_connection_dht_public_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key1, timestamp1);
-            } else if (timestamp1 < timestamp2) {
-                onion_set_friend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key2, timestamp2);
-            }
-
-            uint8_t direct_connected;
-            unsigned int status = crypto_connection_status(m->net_crypto, m->friendlist[i].crypt_connection_id, &direct_connected);
-
-            if (direct_connected == 0 || status == CRYPTO_CONN_COOKIE_REQUESTING) {
-                IP_Port friendip;
-
-                if (onion_getfriendip(m->onion_c, m->friendlist[i].onion_friendnum, &friendip) == 1) {
-                    set_direct_ip_port(m->net_crypto, m->friendlist[i].crypt_connection_id, friendip);
-                }
-            }
         }
 
         if (m->friendlist[i].status == FRIEND_ONLINE) { /* friend is online. */
@@ -2339,26 +2346,21 @@ void do_friends(Messenger *m)
                     m->friendlist[i].userstatus_sent = 1;
             }
 
+            if (m->friendlist[i].avatar_info_sent == 0) {
+                if (m_send_avatar_info(m, i) == 0)
+                    m->friendlist[i].avatar_info_sent = 1;
+            }
+
             if (m->friendlist[i].user_istyping_sent == 0) {
                 if (send_user_istyping(m, i, m->friendlist[i].user_istyping))
                     m->friendlist[i].user_istyping_sent = 1;
             }
 
-            if (m->friendlist[i].ping_lastsent + FRIEND_PING_INTERVAL < temp_time) {
-                send_ping(m, i);
-            }
-
-            if (m->friendlist[i].ping_lastrecv + FRIEND_CONNECTION_TIMEOUT < temp_time) {
-                /* If we stopped receiving ping packets, kill it. */
-                crypto_kill(m->net_crypto, m->friendlist[i].crypt_connection_id);
-                m->friendlist[i].crypt_connection_id = -1;
-                set_friend_status(m, i, FRIEND_CONFIRMED);
-            }
-
             if (m->friendlist[i].share_relays_lastsent + FRIEND_SHARE_RELAYS_INTERVAL < temp_time) {
                 send_relays(m, i);
             }
 
+            check_friend_tcp_udp(m, i);
             do_receipts(m, i);
         }
     }
@@ -2370,15 +2372,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
@@ -2392,7 +2394,7 @@ static char *ID2String(const uint8_t *client_id)
  *
  * returns time (in ms) before the next do_messenger() needs to be run on success.
  */
-uint32_t messenger_run_interval(Messenger *m)
+uint32_t messenger_run_interval(const Messenger *m)
 {
     uint32_t crypto_interval = crypto_run_interval(m->net_crypto);
 
@@ -2406,6 +2408,17 @@ uint32_t messenger_run_interval(Messenger *m)
 /* The main loop that needs to be run at least 20 times per second. */
 void do_messenger(Messenger *m)
 {
+    // Add the TCP relays, but only if this is the first time calling do_messenger
+    if (m->has_added_relays == 0) {
+        m->has_added_relays = 1;
+
+        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].public_key);
+        }
+    }
+
     unix_time_update();
 
     if (!m->options.udp_disabled) {
@@ -2415,8 +2428,8 @@ void do_messenger(Messenger *m)
 
     do_net_crypto(m->net_crypto);
     do_onion_client(m->onion_c);
+    do_friend_connections(m->fr_c);
     do_friends(m);
-    do_allgroupchats(m);
     LANdiscovery(m);
 
 #ifdef LOGGING
@@ -2427,16 +2440,6 @@ void do_messenger(Messenger *m)
         Assoc_status(m->dht->assoc);
 #endif
 
-        if (m->numchats > 0) {
-            size_t c;
-
-            for (c = 0; c < m->numchats; c++) {
-                if (m->chats[c])
-                    Assoc_status(m->chats[c]->assoc);
-            }
-        }
-
-
         lastdump = unix_time();
         uint32_t client, last_pinged;
 
@@ -2452,9 +2455,9 @@ void do_messenger(Messenger *m)
                     if (last_pinged > 999)
                         last_pinged = 999;
 
-                    LOGGER_INFO("C[%2u] %s:%u [%3u] %s",
-                                client, ip_ntoa(&assoc->ip_port.ip), ntohs(assoc->ip_port.port),
-                                last_pinged, ID2String(cptr->client_id));
+                    LOGGER_TRACE("C[%2u] %s:%u [%3u] %s",
+                                 client, ip_ntoa(&assoc->ip_port.ip), ntohs(assoc->ip_port.port),
+                                 last_pinged, ID2String(cptr->client_id));
                 }
         }
 
@@ -2474,7 +2477,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;
                 }
@@ -2485,7 +2488,7 @@ void do_messenger(Messenger *m)
                 dht2m[m2dht[friend]] = friend;
 
         if (m->numfriends != m->dht->num_friends) {
-            LOGGER_INFO("Friend num in DHT %u != friend num in msger %u\n", m->dht->num_friends, m->numfriends);
+            LOGGER_TRACE("Friend num in DHT %u != friend num in msger %u\n", m->dht->num_friends, m->numfriends);
         }
 
         uint32_t ping_lastrecv;
@@ -2506,11 +2509,11 @@ void do_messenger(Messenger *m)
                 if (ping_lastrecv > 999)
                     ping_lastrecv = 999;
 
-                LOGGER_INFO("F[%2u:%2u] <%s> %02i [%03u] %s",
-                            dht2m[friend], friend, msgfptr->name, msgfptr->crypt_connection_id,
-                            ping_lastrecv, ID2String(msgfptr->client_id));
+                LOGGER_TRACE("F[%2u:%2u] <%s> [%03u] %s",
+                             dht2m[friend], friend, msgfptr->name,
+                             ping_lastrecv, ID2String(msgfptr->real_pk));
             } else {
-                LOGGER_INFO("F[--:%2u] %s", friend, ID2String(dhtfptr->client_id));
+                LOGGER_TRACE("F[--:%2u] %s", friend, ID2String(dhtfptr->client_id));
             }
 
             for (client = 0; client < MAX_FRIEND_CLIENTS; client++) {
@@ -2525,10 +2528,10 @@ void do_messenger(Messenger *m)
                         if (last_pinged > 999)
                             last_pinged = 999;
 
-                        LOGGER_INFO("F[%2u] => C[%2u] %s:%u [%3u] %s",
-                                    friend, client, ip_ntoa(&assoc->ip_port.ip),
-                                    ntohs(assoc->ip_port.port), last_pinged,
-                                    ID2String(cptr->client_id));
+                        LOGGER_TRACE("F[%2u] => C[%2u] %s:%u [%3u] %s",
+                                     friend, client, ip_ntoa(&assoc->ip_port.ip),
+                                     ntohs(assoc->ip_port.port), last_pinged,
+                                     ID2String(cptr->client_id));
                     }
             }
         }
@@ -2552,11 +2555,10 @@ void do_messenger(Messenger *m)
 #define MESSENGER_STATE_TYPE_PATH_NODE     11
 
 #define SAVED_FRIEND_REQUEST_SIZE 1024
-#define NUM_SAVED_TCP_RELAYS 8
 #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];
@@ -2583,7 +2585,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) {
@@ -2629,7 +2631,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;
@@ -2644,7 +2646,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));
@@ -2673,14 +2675,13 @@ uint32_t messenger_size(const Messenger *m)
 
 static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
 {
-    uint32_t *data32 = (uint32_t *)data;
-    data32[0] = len;
-    data32[1] = (MESSENGER_STATE_COOKIE_TYPE << 16) | type;
-    data += sizeof(uint32_t) * 2;
+    host_to_lendian32(data, len);
+    data += sizeof(uint32_t);
+    host_to_lendian32(data, (host_tolendian16(MESSENGER_STATE_COOKIE_TYPE) << 16) | host_tolendian16(type));
+    data += sizeof(uint32_t);
     return data;
 }
 
-
 /* Save the messenger in data of size Messenger_size(). */
 void messenger_save(const Messenger *m, uint8_t *data)
 {
@@ -2780,7 +2781,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
             break;
 
         case MESSENGER_STATE_TYPE_NAME:
-            if ((length > 0) && (length < MAX_NAME_LENGTH)) {
+            if ((length > 0) && (length <= MAX_NAME_LENGTH)) {
                 setname(m, data, length);
             }
 
@@ -2801,18 +2802,12 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
             break;
 
         case MESSENGER_STATE_TYPE_TCP_RELAY: {
-            Node_format relays[NUM_SAVED_TCP_RELAYS];
-
-            if (length != sizeof(relays)) {
+            if (length != sizeof(m->loaded_relays)) {
                 return -1;
             }
 
-            memcpy(relays, data, length);
-            uint32_t i;
-
-            for (i = 0; i < NUM_SAVED_TCP_RELAYS; ++i) {
-                add_tcp_relay(m->net_crypto, relays[i].ip_port, relays[i].client_id);
-            }
+            memcpy(m->loaded_relays, data, length);
+            m->has_added_relays = 0;
 
             break;
         }
@@ -2828,7 +2823,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_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;
@@ -2892,7 +2887,7 @@ uint32_t get_num_online_friends(const Messenger *m)
  * Otherwise, returns the number of elements copied.
  * If the array was too small, the contents
  * of out_list will be truncated to list_size. */
-uint32_t copy_friendlist(Messenger const *m, int32_t *out_list, uint32_t list_size)
+uint32_t copy_friendlist(Messenger const *m, uint32_t *out_list, uint32_t list_size)
 {
     if (!out_list)
         return 0;
@@ -2917,84 +2912,3 @@ uint32_t copy_friendlist(Messenger const *m, int32_t *out_list, uint32_t list_si
 
     return ret;
 }
-
-/* Allocate and return a list of valid friend id's. List must be freed by the
- * caller.
- *
- * retun 0 if success.
- * return -1 if failure.
- */
-int get_friendlist(const Messenger *m, int32_t **out_list, uint32_t *out_list_length)
-{
-    uint32_t i;
-
-    *out_list_length = 0;
-
-    if (m->numfriends == 0) {
-        *out_list = NULL;
-        return 0;
-    }
-
-    *out_list = malloc(m->numfriends * sizeof(int32_t));
-
-    if (*out_list == NULL) {
-        return -1;
-    }
-
-    for (i = 0; i < m->numfriends; i++) {
-        if (m->friendlist[i].status > 0) {
-            (*out_list)[i] = i;
-            (*out_list_length)++;
-        }
-    }
-
-    return 0;
-}
-
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t count_chatlist(const Messenger *m)
-{
-    uint32_t ret = 0;
-    uint32_t i;
-
-    for (i = 0; i < m->numchats; i++) {
-        if (m->chats[i]) {
-            ret++;
-        }
-    }
-
-    return ret;
-}
-
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t copy_chatlist(const Messenger *m, int *out_list, uint32_t list_size)
-{
-    if (!out_list)
-        return 0;
-
-    if (m->numchats == 0) {
-        return 0;
-    }
-
-    uint32_t i;
-    uint32_t ret = 0;
-
-    for (i = 0; i < m->numchats; i++) {
-        if (ret >= list_size) {
-            break; /* Abandon ship */
-        }
-
-        if (m->chats[i]) {
-            out_list[ret] = i;
-            ret++;
-        }
-    }
-
-    return ret;
-}
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index c9f3cf88..0a613c0b 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -26,38 +26,43 @@
 #ifndef MESSENGER_H
 #define MESSENGER_H
 
-#include "net_crypto.h"
-#include "DHT.h"
 #include "friend_requests.h"
 #include "LAN_discovery.h"
-#include "group_chats.h"
-#include "onion_client.h"
+#include "friend_connection.h"
 
 #define MAX_NAME_LENGTH 128
 /* TODO: this must depend on other variable. */
 #define MAX_STATUSMESSAGE_LENGTH 1007
+#define AVATAR_MAX_DATA_LENGTH 16384
+#define AVATAR_HASH_LENGTH crypto_hash_sha256_BYTES
+
 
 #define FRIEND_ADDRESS_SIZE (crypto_box_PUBLICKEYBYTES + sizeof(uint32_t) + sizeof(uint16_t))
 
-/* NOTE: Packet ids below 16 must never be used. */
-#define PACKET_ID_ALIVE 16
+/* NOTE: Packet ids below 17 must never be used. */
 #define PACKET_ID_SHARE_RELAYS 17
+#define PACKET_ID_ONLINE 24
+#define PACKET_ID_OFFLINE 25
 #define PACKET_ID_NICKNAME 48
 #define PACKET_ID_STATUSMESSAGE 49
 #define PACKET_ID_USERSTATUS 50
 #define PACKET_ID_TYPING 51
+#define PACKET_ID_AVATAR_INFO_REQ 52
+#define PACKET_ID_AVATAR_INFO 53
+#define PACKET_ID_AVATAR_DATA_CONTROL 54
+#define PACKET_ID_AVATAR_DATA_START 55
+#define PACKET_ID_AVATAR_DATA_PUSH 56
 #define PACKET_ID_MESSAGE 64
 #define PACKET_ID_ACTION 65
 #define PACKET_ID_MSI 69
 #define PACKET_ID_FILE_SENDREQUEST 80
 #define PACKET_ID_FILE_CONTROL 81
 #define PACKET_ID_FILE_DATA 82
-#define PACKET_ID_INVITE_GROUPCHAT 144
-#define PACKET_ID_JOIN_GROUPCHAT 145
-#define PACKET_ID_ACCEPT_GROUPCHAT 146
-
-/* Max number of groups we can invite someone at the same time to. */
-#define MAX_INVITED_GROUPS 64
+#define PACKET_ID_INVITE_GROUPCHAT 96
+#define PACKET_ID_ONLINE_PACKET 97
+#define PACKET_ID_DIRECT_GROUPCHAT 98
+#define PACKET_ID_MESSAGE_GROUPCHAT 99
+#define PACKET_ID_LOSSY_GROUPCHAT 199
 
 /* Max number of tcp relays sent to friends */
 #define MAX_SHARED_RELAYS 16
@@ -69,7 +74,6 @@
 typedef struct {
     uint8_t ipv6enabled;
     uint8_t udp_disabled;
-    uint8_t proxy_enabled;
     TCP_Proxy_Info proxy_info;
 } Messenger_Options;
 
@@ -97,7 +101,6 @@ enum {
     FAERR_NOMESSAGE = -2,
     FAERR_OWNKEY = -3,
     FAERR_ALREADYSENT = -4,
-    FAERR_UNKNOWN = -5,
     FAERR_BADCHECKSUM = -6,
     FAERR_SETNEWNOSPAM = -7,
     FAERR_NOMEM = -8
@@ -106,16 +109,23 @@ enum {
 /* Default start timeout in seconds between friend requests. */
 #define FRIENDREQUEST_TIMEOUT 5;
 
-/* Interval between the sending of ping packets. */
-#define FRIEND_PING_INTERVAL 5
-
 /* Interval between the sending of tcp relay information */
 #define FRIEND_SHARE_RELAYS_INTERVAL (5 * 60)
 
-/* If no packets are received from friend in this time interval, kill the connection. */
-#define FRIEND_CONNECTION_TIMEOUT (FRIEND_PING_INTERVAL * 3)
+/* Must be < MAX_CRYPTO_DATA_SIZE */
+#define AVATAR_DATA_MAX_CHUNK_SIZE (MAX_CRYPTO_DATA_SIZE-1)
+
+/* Per-friend data limit for avatar data requests */
+#define AVATAR_DATA_TRANSFER_LIMIT  (10*AVATAR_MAX_DATA_LENGTH)
+#define AVATAR_DATA_TRANSFER_TIMEOUT    (60) /* 164kB every 60 seconds is not a lot */
 
 
+enum {
+    CONNECTION_NONE,
+    CONNECTION_TCP,
+    CONNECTION_UDP
+};
+
 /* USERSTATUS -
  * Represents userstatuses someone can have.
  */
@@ -128,6 +138,42 @@ typedef enum {
 }
 USERSTATUS;
 
+/* AVATAR_FORMAT -
+ * Data formats for user avatar images
+ */
+typedef enum {
+    AVATAR_FORMAT_NONE = 0,
+    AVATAR_FORMAT_PNG
+}
+AVATAR_FORMAT;
+
+/* AVATAR_DATACONTROL
+ * To control avatar data requests (PACKET_ID_AVATAR_DATA_CONTROL)
+ */
+typedef enum {
+    AVATAR_DATACONTROL_REQ,
+    AVATAR_DATACONTROL_ERROR
+}
+AVATAR_DATACONTROL;
+
+typedef struct {
+    uint8_t started;
+    AVATAR_FORMAT format;
+    uint8_t hash[AVATAR_HASH_LENGTH];
+    uint32_t total_length;
+    uint32_t bytes_received;
+    uint8_t data[AVATAR_MAX_DATA_LENGTH];
+}
+AVATAR_RECEIVEDATA;
+
+typedef struct {
+    /* Fields only used to limit the network usage from a given friend */
+    uint32_t bytes_sent;    /* Total bytes send to this user */
+    uint64_t last_reset;    /* Time the data counter was last reset */
+}
+AVATAR_SENDDATA;
+
+
 struct File_Transfers {
     uint64_t size;
     uint64_t transferred;
@@ -153,10 +199,12 @@ enum {
     FILECONTROL_RESUME_BROKEN
 };
 
+typedef struct Messenger Messenger;
+
 typedef struct {
-    uint8_t client_id[CLIENT_ID_SIZE];
-    uint32_t onion_friendnum;
-    int crypt_connection_id;
+    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    int friendcon_id;
+
     uint64_t friendrequest_lastsent; // Time at which the last friend request was sent.
     uint32_t friendrequest_timeout; // The timeout between successful friendrequest sending attempts.
     uint8_t status; // 0 if no friend, 1 if added, 2 if friend request sent, 3 if confirmed friend, 4 if online.
@@ -164,32 +212,34 @@ typedef struct {
     uint8_t name[MAX_NAME_LENGTH];
     uint16_t name_length;
     uint8_t name_sent; // 0 if we didn't send our name to this friend 1 if we have.
-    uint8_t *statusmessage;
+    uint8_t statusmessage[MAX_STATUSMESSAGE_LENGTH];
     uint16_t statusmessage_length;
     uint8_t statusmessage_sent;
     USERSTATUS userstatus;
     uint8_t userstatus_sent;
+    uint8_t avatar_info_sent;
     uint8_t user_istyping;
     uint8_t user_istyping_sent;
     uint8_t is_typing;
     uint16_t info_size; // Length of the info.
     uint32_t message_id; // a semi-unique id used in read receipts.
     uint32_t friendrequest_nospam; // The nospam number used in the friend request.
-    uint64_t ping_lastrecv;
-    uint64_t ping_lastsent;
+    uint64_t ping_lastrecv;//TODO remove
     uint64_t share_relays_lastsent;
+    uint8_t last_connection_udp_tcp;
     struct File_Transfers file_sending[MAX_CONCURRENT_FILE_PIPES];
     struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES];
-    int invited_groups[MAX_INVITED_GROUPS];
-    uint16_t invited_groups_num;
+
+    AVATAR_SENDDATA avatar_send_data;
+    AVATAR_RECEIVEDATA *avatar_recv_data;    // We are receiving avatar data from this friend.
 
     struct {
-        int (*function)(void *object, const uint8_t *data, uint32_t len);
+        int (*function)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object);
         void *object;
     } lossy_packethandlers[PACKET_ID_LOSSY_RANGE_SIZE];
 
     struct {
-        int (*function)(void *object, const uint8_t *data, uint32_t len);
+        int (*function)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object);
         void *object;
     } lossless_packethandlers[PACKET_ID_LOSSLESS_RANGE_SIZE];
 
@@ -198,7 +248,7 @@ typedef struct {
 } Friend;
 
 
-typedef struct Messenger {
+struct Messenger {
 
     Networking_Core *net;
     Net_Crypto *net_crypto;
@@ -208,6 +258,8 @@ typedef struct Messenger {
     Onion_Announce *onion_a;
     Onion_Client *onion_c;
 
+    Friend_Connections *fr_c;
+
     Friend_Requests fr;
     uint8_t name[MAX_NAME_LENGTH];
     uint16_t name_length;
@@ -217,60 +269,65 @@ typedef struct Messenger {
 
     USERSTATUS userstatus;
 
+    AVATAR_FORMAT avatar_format;
+    uint8_t *avatar_data;
+    uint32_t avatar_data_length;
+    uint8_t avatar_hash[AVATAR_HASH_LENGTH];
+
     Friend *friendlist;
     uint32_t numfriends;
 
     uint32_t numonline_friends;
 
-    Group_Chat **chats;
-    uint32_t numchats;
-
     uint64_t last_LANdiscovery;
 
-    void (*friend_message)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
+#define NUM_SAVED_TCP_RELAYS 8
+    uint8_t has_added_relays; // If the first connection has occurred in do_messenger
+    Node_format loaded_relays[NUM_SAVED_TCP_RELAYS]; // Relays loaded from config
+
+    void (*friend_message)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
     void *friend_message_userdata;
-    void (*friend_action)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
+    void (*friend_action)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
     void *friend_action_userdata;
-    void (*friend_namechange)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
+    void (*friend_namechange)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
     void *friend_namechange_userdata;
-    void (*friend_statusmessagechange)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
+    void (*friend_statusmessagechange)(struct Messenger *m, uint32_t, const uint8_t *, size_t, void *);
     void *friend_statusmessagechange_userdata;
-    void (*friend_userstatuschange)(struct Messenger *m, int32_t, uint8_t, void *);
+    void (*friend_userstatuschange)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_userstatuschange_userdata;
-    void (*friend_typingchange)(struct Messenger *m, int32_t, uint8_t, void *);
+    void (*friend_typingchange)(struct Messenger *m, uint32_t, _Bool, void *);
     void *friend_typingchange_userdata;
-    void (*read_receipt)(struct Messenger *m, int32_t, uint32_t, void *);
+    void (*read_receipt)(struct Messenger *m, uint32_t, uint32_t, void *);
     void *read_receipt_userdata;
-    void (*friend_statuschange)(struct Messenger *m, int32_t, uint8_t, void *);
+    void (*friend_statuschange)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_statuschange_userdata;
-    void (*friend_connectionstatuschange)(struct Messenger *m, int32_t, uint8_t, void *);
+    void (*friend_connectionstatuschange)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_connectionstatuschange_userdata;
-    void (*friend_connectionstatuschange_internal)(struct Messenger *m, int32_t, uint8_t, void *);
+    void (*friend_connectionstatuschange_internal)(struct Messenger *m, uint32_t, uint8_t, void *);
     void *friend_connectionstatuschange_internal_userdata;
+    void *avatar_info_recv_userdata;
+    void (*avatar_info_recv)(struct Messenger *m, uint32_t, uint8_t, uint8_t *, void *);
+    void *avatar_data_recv_userdata;
+    void (*avatar_data_recv)(struct Messenger *m, uint32_t, uint8_t, uint8_t *, uint8_t *, uint32_t, void *);
 
-    void (*group_invite)(struct Messenger *m, int32_t, const uint8_t *, void *);
-    void *group_invite_userdata;
-    void (*group_message)(struct Messenger *m, int, int, const uint8_t *, uint16_t, void *);
-    void *group_message_userdata;
-    void (*group_action)(struct Messenger *m, int, int, const uint8_t *, uint16_t, void *);
-    void *group_action_userdata;
-    void (*group_namelistchange)(struct Messenger *m, int, int, uint8_t, void *);
-    void *group_namelistchange_userdata;
+    void *group_chat_object; /* Set by new_groupchats()*/
+    void (*group_invite)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t);
+    void (*group_message)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t);
 
-    void (*file_sendrequest)(struct Messenger *m, int32_t, uint8_t, uint64_t, const uint8_t *, uint16_t, void *);
+    void (*file_sendrequest)(struct Messenger *m, uint32_t, uint8_t, uint64_t, const uint8_t *, uint16_t, void *);
     void *file_sendrequest_userdata;
-    void (*file_filecontrol)(struct Messenger *m, int32_t, uint8_t, uint8_t, uint8_t, const uint8_t *, uint16_t, void *);
+    void (*file_filecontrol)(struct Messenger *m, uint32_t, uint8_t, uint8_t, uint8_t, const uint8_t *, uint16_t, void *);
     void *file_filecontrol_userdata;
-    void (*file_filedata)(struct Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length, void *);
+    void (*file_filedata)(struct Messenger *m, uint32_t, uint8_t, const uint8_t *, uint16_t length, void *);
     void *file_filedata_userdata;
 
-    void (*msi_packet)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
+    void (*msi_packet)(struct Messenger *m, uint32_t, const uint8_t *, uint16_t, void *);
     void *msi_packet_userdata;
 
     Messenger_Options options;
-} Messenger;
+};
 
-/* 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.
  */
@@ -286,7 +343,6 @@ void getaddress(const Messenger *m, uint8_t *address);
  *  return -2 if no message (message length must be >= 1 byte).
  *  return -3 if user's own key.
  *  return -4 if friend request already sent or already a friend.
- *  return -5 for unknown error.
  *  return -6 if bad checksum in address.
  *  return -7 if the friend was already there but the nospam was different.
  *  (the nospam for that friend was set to the new one).
@@ -297,22 +353,30 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u
 
 /* Add a friend without sending a friendrequest.
  *  return the friend number if success.
- *  return -1 if failure.
+ *  return -3 if user's own key.
+ *  return -4 if friend request already sent or already a friend.
+ *  return -6 if bad checksum in address.
+ *  return -8 if increasing the friend list size fails.
  */
-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.
+ */
+int getfriendcon_id(const Messenger *m, int32_t friendnumber);
 
 /* Remove a friend.
  *
@@ -323,8 +387,9 @@ int m_delfriend(Messenger *m, int32_t friendnumber);
 
 /* Checks friend's connecting status.
  *
- *  return 1 if friend is connected to us (Online).
- *  return 0 if friend is not connected to us (Offline).
+ *  return CONNECTION_UDP (2) if friend is directly connected to us (Online UDP).
+ *  return CONNECTION_TCP (1) if friend is connected to us (Online TCP).
+ *  return CONNECTION_NONE (0) if friend is not connected to us (Offline).
  *  return -1 on failure.
  */
 int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber);
@@ -423,7 +488,7 @@ int m_get_self_statusmessage_size(const Messenger *m);
  * retruns -1 on failure.
  */
 int m_copy_statusmessage(const Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
-int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf, uint32_t maxlen);
+int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf);
 
 /*  return one of USERSTATUS values.
  *  Values unknown to your application should be represented as USERSTATUS_NONE.
@@ -433,6 +498,114 @@ int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf, uint32_t maxlen)
 uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber);
 uint8_t m_get_self_userstatus(const Messenger *m);
 
+
+/* Set the user avatar image data.
+ * This should be made before connecting, so we will not announce that the user have no avatar
+ * before setting and announcing a new one, forcing the peers to re-download it.
+ *
+ * Notice that the library treats the image as raw data and does not interpret it by any way.
+ *
+ * Arguments:
+ *  format - Avatar image format or NONE for user with no avatar (see AVATAR_FORMAT);
+ *  data - pointer to the avatar data (may be NULL it the format is NONE);
+ *  length - length of image data. Must be <= MAX_AVATAR_DATA_LENGTH.
+ *
+ * returns 0 on success
+ * returns -1 on failure.
+ */
+int m_set_avatar(Messenger *m, uint8_t format, const uint8_t *data, uint32_t length);
+
+/* Unsets the user avatar.
+
+   returns 0 on success (currently always returns 0) */
+int m_unset_avatar(Messenger *m);
+
+/* Get avatar data from the current user.
+ * Copies the current user avatar data to the destination buffer and sets the image format
+ * accordingly.
+ *
+ * If the avatar format is NONE, the buffer 'buf' isleft uninitialized, 'hash' is zeroed, and
+ * 'length' is set to zero.
+ *
+ * If any of the pointers format, buf, length, and hash are NULL, that particular field will be ignored.
+ *
+ * Arguments:
+ *   format - destination pointer to the avatar image format (see AVATAR_FORMAT);
+ *   buf - destination buffer to the image data. Must have at least 'maxlen' bytes;
+ *   length - destination pointer to the image data length;
+ *   maxlen - length of the destination buffer 'buf';
+ *   hash - destination pointer to the avatar hash (it must be exactly AVATAR_HASH_LENGTH bytes long).
+ *
+ * returns 0 on success;
+ * returns -1 on failure.
+ *
+ */
+int m_get_self_avatar(const Messenger *m, uint8_t *format, uint8_t *buf, uint32_t *length, uint32_t maxlen,
+                      uint8_t *hash);
+
+/* Generates a cryptographic hash of the given data.
+ * This function may be used by clients for any purpose, but is provided primarily for
+ * validating cached avatars.
+ * This function is a wrapper to internal message-digest functions.
+ *
+ * Arguments:
+ *  hash - destination buffer for the hash data, it must be exactly crypto_hash_sha256_BYTES bytes long.
+ *  data - data to be hashed;
+ *  datalen - length of the data;
+ *
+ * returns 0 on success
+ * returns -1 on failure.
+ */
+int m_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen);
+
+/* Generates a cryptographic hash of the given avatar data.
+ * This function is a wrapper to m_hash and specifically provided
+ * to generate hashes from user avatars that may be memcmp()ed with the values returned by the
+ * other avatar functions. It is specially important to validate cached avatars.
+ *
+ * Arguments:
+ *  hash - destination buffer for the hash data, it must be exactly AVATAR_HASH_LENGTH bytes long.
+ *  data - avatar image data;
+ *  datalen - length of the avatar image data; it must be <= MAX_AVATAR_DATA_LENGTH.
+ *
+ * returns 0 on success
+ * returns -1 on failure.
+ */
+int m_avatar_hash(uint8_t *hash, const uint8_t *data, const uint32_t datalen);
+
+/* Request avatar information from a friend.
+ * Asks a friend to provide their avatar information (image format and hash). The friend may
+ * or may not answer this request and, if answered, the information will be provided through
+ * the callback 'avatar_info'.
+ *
+ * returns 0 on success
+ * returns -1 on failure.
+ */
+int m_request_avatar_info(const Messenger *m, const int32_t friendnumber);
+
+/* Send an unrequested avatar information to a friend.
+ * Sends our avatar format and hash to a friend; he/she can use this information to validate
+ * an avatar from the cache and may (or not) reply with an avatar data request.
+ *
+ * Notice: it is NOT necessary to send these notification after changing the avatar or
+ * connecting. The library already does this.
+ *
+ * returns 0 on success
+ * returns -1 on failure.
+ */
+int m_send_avatar_info(const Messenger *m, const int32_t friendnumber);
+
+
+/* Request the avatar data from a friend.
+ * Ask a friend to send their avatar data. The friend may or may not answer this request and,
+ * if answered, the information will be provided in callback 'avatar_data'.
+ *
+ * returns 0 on sucess
+ * returns -1 on failure.
+ */
+int m_request_avatar_data(const Messenger *m, const int32_t friendnumber);
+
+
 /* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
  * returns -1 on error.
  */
@@ -451,53 +624,53 @@ int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing);
  * returns 0 if friend is not typing.
  * returns 1 if friend is typing.
  */
-uint8_t m_get_istyping(const Messenger *m, int32_t friendnumber);
+int m_get_istyping(const Messenger *m, int32_t friendnumber);
 
 /* Set the function that will be executed when a friend request is received.
- *  Function format is function(uint8_t * public_key, uint8_t * data, uint16_t length)
+ *  Function format is function(uint8_t * public_key, uint8_t * data, size_t length)
  */
-void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, uint16_t,
+void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const uint8_t *, const uint8_t *, size_t,
                               void *), void *userdata);
 
 /* Set the function that will be executed when a message from a friend is received.
- *  Function format is: function(int32_t friendnumber, uint8_t * message, uint32_t length)
+ *  Function format is: function(uint32_t friendnumber, uint8_t * message, uint32_t length)
  */
-void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                               void *userdata);
 
 /* Set the function that will be executed when an action from a friend is received.
- *  Function format is: function(int32_t friendnumber, uint8_t * action, uint32_t length)
+ *  Function format is: function(uint32_t friendnumber, uint8_t * action, uint32_t length)
  */
-void m_callback_action(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_action(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                        void *userdata);
 
 /* Set the callback for name changes.
- *  Function(int32_t friendnumber, uint8_t *newname, uint16_t length)
+ *  Function(uint32_t friendnumber, uint8_t *newname, size_t length)
  *  You are not responsible for freeing newname.
  */
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                            void *userdata);
 
 /* Set the callback for status message changes.
- *  Function(int32_t friendnumber, uint8_t *newstatus, uint16_t length)
+ *  Function(uint32_t friendnumber, uint8_t *newstatus, size_t length)
  *
  *  You are not responsible for freeing newstatus
  */
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, size_t, void *),
                               void *userdata);
 
 /* Set the callback for status type changes.
- *  Function(int32_t friendnumber, USERSTATUS kind)
+ *  Function(uint32_t friendnumber, USERSTATUS kind)
  */
-void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *), void *userdata);
+void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *), void *userdata);
 
 /* Set the callback for typing changes.
- *  Function(int32_t friendnumber, uint8_t is_typing)
+ *  Function(uint32_t friendnumber, uint8_t is_typing)
  */
-void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, int32_t, uint8_t, void *), void *userdata);
+void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, uint32_t, _Bool, void *), void *userdata);
 
 /* Set the callback for read receipts.
- *  Function(int32_t friendnumber, uint32_t receipt)
+ *  Function(uint32_t friendnumber, uint32_t receipt)
  *
  *  If you are keeping a record of returns from m_sendmessage,
  *  receipt might be one of those values, meaning the message
@@ -505,10 +678,10 @@ void m_callback_typingchange(Messenger *m, void(*function)(Messenger *m, int32_t
  *  Since core doesn't track ids for you, receipt may not correspond to any message.
  *  In that case, you should discard it.
  */
-void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, int32_t, uint32_t, void *), void *userdata);
+void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, uint32_t, uint32_t, void *), void *userdata);
 
 /* Set the callback for connection status changes.
- *  function(int32_t friendnumber, uint8_t status)
+ *  function(uint32_t friendnumber, uint8_t status)
  *
  *  Status:
  *    0 -- friend went offline after being previously online.
@@ -518,132 +691,96 @@ void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, int32_
  *  being previously online" part.
  *  It's assumed that when adding friends, their connection status is offline.
  */
-void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *),
+void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
                                  void *userdata);
 /* Same as previous but for internal A/V core usage only */
-void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, void *),
+void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, void *),
         void *userdata);
 
-/**********GROUP CHATS************/
 
-/* Set the callback for group invites.
+/* Set the callback function for avatar information.
+ * This callback will be called when avatar information are received from friends. These events
+ * can arrive at anytime, but are usually received uppon connection and in reply of avatar
+ * information requests.
  *
- *  Function(Messenger *m, int32_t friendnumber, uint8_t *group_public_key, void *userdata)
- */
-void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, void *),
-                             void *userdata);
-
-/* Set the callback for group messages.
+ * Function format is:
+ *  function(Tox *tox, uint32_t friendnumber, uint8_t format, uint8_t *hash, void *userdata)
  *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void m_callback_group_message(Messenger *m, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t, void *),
-                              void *userdata);
-
-/* Set the callback for group actions.
+ * where 'format' is the avatar image format (see AVATAR_FORMAT) and 'hash' is the hash of
+ * the avatar data for caching purposes and it is exactly AVATAR_HASH_LENGTH long. If the
+ * image format is NONE, the hash is zeroed.
  *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
  */
-void m_callback_group_action(Messenger *m, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t, void *),
-                             void *userdata);
+void m_callback_avatar_info(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t *, void *),
+                            void *userdata);
 
-/* Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, void *userdata)
- */
-void m_callback_group_namelistchange(Messenger *m, void (*function)(Messenger *m, int, int, uint8_t, void *),
-                                     void *userdata);
 
-/* Creates a new groupchat and puts it in the chats array.
+/* Set the callback function for avatar data.
+ * This callback will be called when the complete avatar data was correctly received from a
+ * friend. This only happens in reply of a avatar data request (see tox_request_avatar_data);
  *
- * return group number on success.
- * return -1 on failure.
- */
-int add_groupchat(Messenger *m);
-
-/* Delete a groupchat from the chats array.
+ * Function format is:
+ *  function(Tox *tox, uint32_t friendnumber, uint8_t format, uint8_t *hash, uint8_t *data, uint32_t datalen, void *userdata)
  *
- * return 0 on success.
- * return -1 if failure.
- */
-int del_groupchat(Messenger *m, int groupnumber);
-
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least MAX_NICK_BYTES long.
+ * where 'format' is the avatar image format (see AVATAR_FORMAT); 'hash' is the
+ * locally-calculated cryptographic hash of the avatar data and it is exactly
+ * AVATAR_HASH_LENGTH long; 'data' is the avatar image data and 'datalen' is the length
+ * of such data.
  *
- * return length of name if success
- * return -1 if failure
- */
-int m_group_peername(const Messenger *m, int groupnumber, int peernumber, uint8_t *name);
-
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
- */
-int invite_friend(Messenger *m, int32_t friendnumber, int groupnumber);
-
-/* Join a group (you need to have been invited first.)
+ * If format is NONE, 'data' is NULL, 'datalen' is zero, and the hash is zeroed. The hash is
+ * always validated locally with the function tox_avatar_hash and ensured to match the image
+ * data, so this value can be safely used to compare with cached avatars.
  *
- * returns group number on success
- * returns -1 on failure.
+ * WARNING: users MUST treat all avatar image data received from another peer as untrusted and
+ * potentially malicious. The library only ensures that the data which arrived is the same the
+ * other user sent, and does not interpret or validate any image data.
  */
-int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_group_public_key);
+void m_callback_avatar_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t *, uint8_t *,
+                            uint32_t, void *), void *userdata);
 
-/* send a group message
- * return 0 on success
- * return -1 on failure
- */
-int group_message_send(const Messenger *m, int groupnumber, const uint8_t *message, uint32_t length);
 
-/* send a group action
- * return 0 on success
- * return -1 on failure
- */
-int group_action_send(const Messenger *m, int groupnumber, const uint8_t *action, uint32_t length);
 
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
- */
-int group_number_peers(const Messenger *m, int groupnumber);
+/**********GROUP CHATS************/
 
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
- *
- * Copies the lengths of the names to lengths[length]
+/* Set the callback for group invites.
  *
- * returns the number of peers on success.
+ *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length)
+ */
+void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t));
+
+/* Send a group invite packet.
  *
- * return -1 on failure.
+ *  return 1 on success
+ *  return 0 on failure
  */
-int group_names(const Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
-                uint16_t length);
+int send_group_invite_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length);
 
 /****************FILE SENDING*****************/
 
 
 /* Set the callback for file send requests.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
  */
-void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint64_t, const uint8_t *,
+void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint64_t,
+                               const uint8_t *,
                                uint16_t, void *), void *userdata);
 
 /* Set the callback for file control requests.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
  *
  */
-void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t,
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, uint8_t, uint8_t,
                            const uint8_t *, uint16_t, void *), void *userdata);
 
 /* Set the callback for file data.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Tox *tox, uint32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
  *
  */
-void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
+void callback_file_data(Messenger *m, void (*function)(Messenger *m, uint32_t, uint8_t, const uint8_t *,
+                        uint16_t length,
                         void *), void *userdata);
 
 /* Send a file send request.
@@ -691,9 +828,9 @@ uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t fi
 
 /* Set the callback for msi packets.
  *
- *  Function(Messenger *m, int32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
+ *  Function(Messenger *m, uint32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
  */
-void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, uint32_t, const uint8_t *, uint16_t, void *),
                            void *userdata);
 
 /* Send an msi packet.
@@ -711,7 +848,8 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
  * return 0 on success.
  */
 int custom_lossy_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-                                        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object);
+                                        int (*packet_handler_callback)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object),
+                                        void *object);
 
 /* High level function to send custom lossy packets.
  *
@@ -729,7 +867,8 @@ int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uin
  * return 0 on success.
  */
 int custom_lossless_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object);
+        int (*packet_handler_callback)(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint32_t len, void *object),
+        void *object);
 
 /* High level function to send custom lossless packets.
  *
@@ -758,7 +897,7 @@ void do_messenger(Messenger *m);
  *
  * returns time (in ms) before the next do_messenger() needs to be run on success.
  */
-uint32_t messenger_run_interval(Messenger *m);
+uint32_t messenger_run_interval(const Messenger *m);
 
 /* SAVING AND LOADING FUNCTIONS: */
 
@@ -784,26 +923,6 @@ uint32_t get_num_online_friends(const Messenger *m);
  * Otherwise, returns the number of elements copied.
  * If the array was too small, the contents
  * of out_list will be truncated to list_size. */
-uint32_t copy_friendlist(const Messenger *m, int32_t *out_list, uint32_t list_size);
-
-/* Allocate and return a list of valid friend id's. List must be freed by the
- * caller.
- *
- * retun 0 if success.
- * return -1 if failure.
- */
-int get_friendlist(const Messenger *m, int **out_list, uint32_t *out_list_length);
-
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t count_chatlist(const Messenger *m);
-
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t copy_chatlist(const Messenger *m, int *out_list, uint32_t list_size);
+uint32_t copy_friendlist(const Messenger *m, uint32_t *out_list, uint32_t list_size);
 
 #endif
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index f7b208e0..eaa248bf 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -37,10 +37,12 @@
  */
 static int connect_sock_to(sock_t sock, IP_Port ip_port, TCP_Proxy_Info *proxy_info)
 {
-    if (proxy_info)
+    if (proxy_info->proxy_type != TCP_PROXY_NONE) {
         ip_port = proxy_info->ip_port;
+    }
 
     struct sockaddr_storage addr = {0};
+
     size_t addrsize;
 
     if (ip_port.ip.family == AF_INET) {
@@ -66,8 +68,68 @@ static int connect_sock_to(sock_t sock, IP_Port ip_port, TCP_Proxy_Info *proxy_i
     return 1;
 }
 
+/* return 1 on success.
+ * return 0 on failure.
+ */
+static int proxy_http_generate_connection_request(TCP_Client_Connection *TCP_conn)
+{
+    char one[] = "CONNECT ";
+    char two[] = " HTTP/1.1\nHost: ";
+    char three[] = "\r\n\r\n";
+
+    char ip[INET6_ADDRSTRLEN];
+
+    if (!ip_parse_addr(&TCP_conn->ip_port.ip, ip, sizeof(ip))) {
+        return 0;
+    }
 
-static void socks5_generate_handshake(TCP_Client_Connection *TCP_conn)
+    const uint16_t port = ntohs(TCP_conn->ip_port.port);
+    const int written = snprintf((char *)TCP_conn->last_packet, MAX_PACKET_SIZE, "%s%s:%hu%s%s:%hu%s", one, ip, port, two,
+                                 ip, port, three);
+
+    if (written < 0) {
+        return 0;
+    }
+
+    TCP_conn->last_packet_length = written;
+    TCP_conn->last_packet_sent = 0;
+
+    return 1;
+}
+
+/* return 1 on success.
+ * return 0 if no data received.
+ * return -1 on failure (connection refused).
+ */
+static int proxy_http_read_connection_response(TCP_Client_Connection *TCP_conn)
+{
+    char success[] = "200";
+    uint8_t data[16]; // draining works the best if the length is a power of 2
+
+    int ret = read_TCP_packet(TCP_conn->sock, data, sizeof(data) - 1);
+
+    if (ret == -1) {
+        return 0;
+    }
+
+    data[sizeof(data) - 1] = 0;
+
+    if (strstr((char *)data, success)) {
+        // drain all data
+        unsigned int data_left = TCP_socket_data_recv_buffer(TCP_conn->sock);
+
+        if (data_left) {
+            uint8_t temp_data[data_left];
+            read_TCP_packet(TCP_conn->sock, temp_data, data_left);
+        }
+
+        return 1;
+    }
+
+    return -1;
+}
+
+static void proxy_socks5_generate_handshake(TCP_Client_Connection *TCP_conn)
 {
     TCP_conn->last_packet[0] = 5; /* SOCKSv5 */
     TCP_conn->last_packet[1] = 1; /* number of authentication methods supported */
@@ -95,7 +157,7 @@ static int socks5_read_handshake_response(TCP_Client_Connection *TCP_conn)
     return -1;
 }
 
-static void socks5_generate_connection_request(TCP_Client_Connection *TCP_conn)
+static void proxy_socks5_generate_connection_request(TCP_Client_Connection *TCP_conn)
 {
     TCP_conn->last_packet[0] = 5; /* SOCKSv5 */
     TCP_conn->last_packet[1] = 1; /* command code: establish a TCP/IP stream connection */
@@ -125,7 +187,7 @@ static void socks5_generate_connection_request(TCP_Client_Connection *TCP_conn)
  * return 0 if no data received.
  * return -1 on failure (connection refused).
  */
-static int socks5_read_connection_response(TCP_Client_Connection *TCP_conn)
+static int proxy_socks5_read_connection_response(TCP_Client_Connection *TCP_conn)
 {
     if (TCP_conn->ip_port.ip.family == AF_INET) {
         uint8_t data[4 + sizeof(IP4) + sizeof(uint16_t)];
@@ -322,7 +384,7 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
 
         increment_nonce(con->sent_nonce);
 
-        if (len == sizeof(packet)) {
+        if ((unsigned int)len == sizeof(packet)) {
             return 1;
         }
 
@@ -546,8 +608,16 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
 
     uint8_t family = ip_port.ip.family;
 
-    if (proxy_info)
+    TCP_Proxy_Info default_proxyinfo;
+
+    if (proxy_info == NULL) {
+        default_proxyinfo.proxy_type = TCP_PROXY_NONE;
+        proxy_info = &default_proxyinfo;
+    }
+
+    if (proxy_info->proxy_type != TCP_PROXY_NONE) {
         family = proxy_info->ip_port.ip.family;
+    }
 
     sock_t sock = socket(family, SOCK_STREAM, IPPROTO_TCP);
 
@@ -577,19 +647,29 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
     memcpy(temp->self_public_key, self_public_key, crypto_box_PUBLICKEYBYTES);
     encrypt_precompute(temp->public_key, self_secret_key, temp->shared_key);
     temp->ip_port = ip_port;
+    temp->proxy_info = *proxy_info;
 
-    if (proxy_info) {
-        temp->status = TCP_CLIENT_PROXY_CONNECTING;
-        temp->proxy_info = *proxy_info;
-        socks5_generate_handshake(temp);
-    } else {
-        temp->status = TCP_CLIENT_CONNECTING;
+    switch (proxy_info->proxy_type) {
+        case TCP_PROXY_HTTP:
+            temp->status = TCP_CLIENT_PROXY_HTTP_CONNECTING;
+            proxy_http_generate_connection_request(temp);
+            break;
 
-        if (generate_handshake(temp) == -1) {
-            kill_sock(sock);
-            free(temp);
-            return NULL;
-        }
+        case TCP_PROXY_SOCKS5:
+            temp->status = TCP_CLIENT_PROXY_SOCKS5_CONNECTING;
+            proxy_socks5_generate_handshake(temp);
+            break;
+
+        case TCP_PROXY_NONE:
+            temp->status = TCP_CLIENT_CONNECTING;
+
+            if (generate_handshake(temp) == -1) {
+                kill_sock(sock);
+                free(temp);
+                return NULL;
+            }
+
+            break;
     }
 
     temp->kill_at = unix_time() + TCP_CONNECTION_TIMEOUT;
@@ -783,7 +863,23 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
         return;
     }
 
-    if (TCP_connection->status == TCP_CLIENT_PROXY_CONNECTING) {
+    if (TCP_connection->status == TCP_CLIENT_PROXY_HTTP_CONNECTING) {
+        if (send_pending_data(TCP_connection) == 0) {
+            int ret = proxy_http_read_connection_response(TCP_connection);
+
+            if (ret == -1) {
+                TCP_connection->kill_at = 0;
+                TCP_connection->status = TCP_CLIENT_DISCONNECTED;
+            }
+
+            if (ret == 1) {
+                generate_handshake(TCP_connection);
+                TCP_connection->status = TCP_CLIENT_CONNECTING;
+            }
+        }
+    }
+
+    if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_CONNECTING) {
         if (send_pending_data(TCP_connection) == 0) {
             int ret = socks5_read_handshake_response(TCP_connection);
 
@@ -793,15 +889,15 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
             }
 
             if (ret == 1) {
-                socks5_generate_connection_request(TCP_connection);
-                TCP_connection->status = TCP_CLIENT_PROXY_UNCONFIRMED;
+                proxy_socks5_generate_connection_request(TCP_connection);
+                TCP_connection->status = TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED;
             }
         }
     }
 
-    if (TCP_connection->status == TCP_CLIENT_PROXY_UNCONFIRMED) {
+    if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED) {
         if (send_pending_data(TCP_connection) == 0) {
-            int ret = socks5_read_connection_response(TCP_connection);
+            int ret = proxy_socks5_read_connection_response(TCP_connection);
 
             if (ret == -1) {
                 TCP_connection->kill_at = 0;
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index 83cb48ba..e37a4ee0 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -29,14 +29,22 @@
 
 #define TCP_CONNECTION_TIMEOUT 10
 
-typedef struct  {
+typedef enum {
+    TCP_PROXY_NONE,
+    TCP_PROXY_HTTP,
+    TCP_PROXY_SOCKS5
+} TCP_PROXY_TYPE;
+
+typedef struct {
     IP_Port ip_port;
+    uint8_t proxy_type; // a value from TCP_PROXY_TYPE
 } TCP_Proxy_Info;
 
 enum {
     TCP_CLIENT_NO_STATUS,
-    TCP_CLIENT_PROXY_CONNECTING,
-    TCP_CLIENT_PROXY_UNCONFIRMED,
+    TCP_CLIENT_PROXY_HTTP_CONNECTING,
+    TCP_CLIENT_PROXY_SOCKS5_CONNECTING,
+    TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED,
     TCP_CLIENT_CONNECTING,
     TCP_CLIENT_UNCONFIRMED,
     TCP_CLIENT_CONFIRMED,
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index b1f7e04b..e1c1c85c 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -178,14 +178,10 @@ static int del_accepted(TCP_Server *TCP_server, int index)
     return 0;
 }
 
-/* Read the next two bytes in TCP stream then convert them to
- * length (host byte order).
- *
- * return length on success
- * return 0 if nothing has been read from socket.
- * return ~0 on failure.
+/* return the amount of data in the tcp recv buffer.
+ * return 0 on failure.
  */
-uint16_t read_TCP_length(sock_t sock)
+unsigned int TCP_socket_data_recv_buffer(sock_t sock)
 {
 #if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
     unsigned long count = 0;
@@ -195,7 +191,21 @@ uint16_t read_TCP_length(sock_t sock)
     ioctl(sock, FIONREAD, &count);
 #endif
 
-    if ((unsigned int)count >= sizeof(uint16_t)) {
+    return count;
+}
+
+/* Read the next two bytes in TCP stream then convert them to
+ * length (host byte order).
+ *
+ * return length on success
+ * return 0 if nothing has been read from socket.
+ * return ~0 on failure.
+ */
+uint16_t read_TCP_length(sock_t sock)
+{
+    unsigned int count = TCP_socket_data_recv_buffer(sock);
+
+    if (count >= sizeof(uint16_t)) {
         uint16_t length;
         int len = recv(sock, (uint8_t *)&length, sizeof(uint16_t), MSG_NOSIGNAL);
 
@@ -223,13 +233,7 @@ uint16_t read_TCP_length(sock_t sock)
  */
 int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length)
 {
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-    unsigned long count = 0;
-    ioctlsocket(sock, FIONREAD, &count);
-#else
-    int count = 0;
-    ioctl(sock, FIONREAD, &count);
-#endif
+    unsigned int count = TCP_socket_data_recv_buffer(sock);
 
     if (count >= length) {
         int len = recv(sock, data, length, MSG_NOSIGNAL);
@@ -415,7 +419,7 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
 
         increment_nonce(con->sent_nonce);
 
-        if (len == sizeof(packet)) {
+        if ((unsigned int)len == sizeof(packet)) {
             return 1;
         }
 
@@ -805,8 +809,10 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint
                     return -1;
 
                 IP_Port source;
+                source.port = 0;  // dummy initialise
                 source.ip.family = TCP_ONION_FAMILY;
                 source.ip.ip6.uint32[0] = con_id;
+                source.ip.ip6.uint32[1] = 0;
                 source.ip.ip6.uint64[1] = con->identifier;
                 onion_send_1(TCP_server->onion, data + 1 + crypto_box_NONCEBYTES, length - (1 + crypto_box_NONCEBYTES), source,
                              data + 1);
@@ -1328,5 +1334,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/TCP_server.h b/toxcore/TCP_server.h
index 81507acb..727c4b4e 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -35,7 +35,7 @@
 #define MSG_NOSIGNAL 0
 #endif
 
-#define MAX_INCOMMING_CONNECTIONS 32
+#define MAX_INCOMMING_CONNECTIONS 256
 
 #define TCP_MAX_BACKLOG MAX_INCOMMING_CONNECTIONS
 
@@ -154,6 +154,11 @@ void do_TCP_server(TCP_Server *TCP_server);
  */
 void kill_TCP_server(TCP_Server *TCP_server);
 
+/* return the amount of data in the tcp recv buffer.
+ * return 0 on failure.
+ */
+unsigned int TCP_socket_data_recv_buffer(sock_t sock);
+
 /* Read the next two bytes in TCP stream then convert them to
  * length (host byte order).
  *
diff --git a/toxcore/assoc.c b/toxcore/assoc.c
index 4d837aa3..3dbeba51 100644
--- a/toxcore/assoc.c
+++ b/toxcore/assoc.c
@@ -831,8 +831,20 @@ Assoc *new_Assoc(size_t bits, size_t entries, const uint8_t *public_id)
     /* allocation: preferably few blobs */
     size_t bckt, cix;
     Client_entry *clients = malloc(sizeof(*clients) * assoc->candidates_bucket_count * assoc->candidates_bucket_size);
+
+    if (!clients) {
+        free(assoc);
+        return NULL;
+    }
+
     candidates_bucket *lists = malloc(sizeof(*lists) * assoc->candidates_bucket_count);
 
+    if (!lists) {
+        free(assoc);
+        free(clients);
+        return NULL;
+    }
+
     for (bckt = 0; bckt < assoc->candidates_bucket_count; bckt++) {
         candidates_bucket *list = &lists[bckt];
 
@@ -984,11 +996,11 @@ static char *idpart2str(uint8_t *id, size_t len)
 void Assoc_status(const Assoc *assoc)
 {
     if (!assoc) {
-        LOGGER_INFO("Assoc status: no assoc");
+        LOGGER_TRACE("Assoc status: no assoc");
         return;
     }
 
-    LOGGER_INFO("[b:p] hash => [id...] used, seen, heard");
+    LOGGER_TRACE("[b:p] hash => [id...] used, seen, heard");
 
     size_t bid, cid, total = 0;
 
@@ -1001,20 +1013,20 @@ void Assoc_status(const Assoc *assoc)
             if (entry->hash) {
                 total++;
 
-                LOGGER_INFO("[%3i:%3i] %08x => [%s...] %i, %i(%c), %i(%c)\n",
-                            (int)bid, (int)cid, entry->hash, idpart2str(entry->client.client_id, 8),
-                            entry->used_at ? (int)(unix_time() - entry->used_at) : 0,
-                            entry->seen_at ? (int)(unix_time() - entry->seen_at) : 0,
-                            entry->seen_at ? (entry->seen_family == AF_INET ? '4' : (entry->seen_family == AF_INET6 ? '6' : '?')) : '?',
-                            entry->heard_at ? (int)(unix_time() - entry->heard_at) : 0,
-                            entry->heard_at ? (entry->heard_family == AF_INET ? '4' : (entry->heard_family == AF_INET6 ? '6' : '?')) : '?');
+                LOGGER_TRACE("[%3i:%3i] %08x => [%s...] %i, %i(%c), %i(%c)\n",
+                             (int)bid, (int)cid, entry->hash, idpart2str(entry->client.client_id, 8),
+                             entry->used_at ? (int)(unix_time() - entry->used_at) : 0,
+                             entry->seen_at ? (int)(unix_time() - entry->seen_at) : 0,
+                             entry->seen_at ? (entry->seen_family == AF_INET ? '4' : (entry->seen_family == AF_INET6 ? '6' : '?')) : '?',
+                             entry->heard_at ? (int)(unix_time() - entry->heard_at) : 0,
+                             entry->heard_at ? (entry->heard_family == AF_INET ? '4' : (entry->heard_family == AF_INET6 ? '6' : '?')) : '?');
             }
         }
     }
 
     if (total) {
-        LOGGER_INFO("Total: %i entries, table usage %i%%.\n", (int)total,
-                    (int)(total * 100 / (assoc->candidates_bucket_count * assoc->candidates_bucket_size)));
+        LOGGER_TRACE("Total: %i entries, table usage %i%%.\n", (int)total,
+                     (int)(total * 100 / (assoc->candidates_bucket_count * assoc->candidates_bucket_size)));
     }
 }
 
diff --git a/toxcore/crypto_core.c b/toxcore/crypto_core.c
index 1799b600..5c99a378 100644
--- a/toxcore/crypto_core.c
+++ b/toxcore/crypto_core.c
@@ -33,7 +33,7 @@
 /* Use this instead of memcmp; not vulnerable to timing attacks.
    returns 0 if both mem locations of length are equal,
    return -1 if they are not. */
-int crypto_cmp(const uint8_t *mem1, const uint8_t *mem2, uint32_t length)
+int crypto_cmp(const uint8_t *mem1, const uint8_t *mem2, size_t length)
 {
     if (length == 16) {
         return crypto_verify_16(mem1, mem2);
@@ -41,7 +41,8 @@ int crypto_cmp(const uint8_t *mem1, const uint8_t *mem2, uint32_t length)
         return crypto_verify_32(mem1, mem2);
     }
 
-    unsigned int i, check = 0;
+    unsigned int check = 0;
+    size_t i;
 
     for (i = 0; i < length; ++i) {
         check |= mem1[i] ^ mem2[i];
@@ -210,7 +211,7 @@ void new_nonce(uint8_t *nonce)
 
 /* Create a request to peer.
  * send_public_key and send_secret_key are the pub/secret keys of the sender.
- * recv_public_key is public key of reciever.
+ * recv_public_key is public key of receiver.
  * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
  * Data represents the data we send with the request with length being the length of the data.
  * request_id is the id of the request (32 = friend request, 254 = ping request).
diff --git a/toxcore/crypto_core.h b/toxcore/crypto_core.h
index 7362d49e..decc7fb9 100644
--- a/toxcore/crypto_core.h
+++ b/toxcore/crypto_core.h
@@ -43,7 +43,7 @@
 /* Use this instead of memcmp; not vulnerable to timing attacks.
    returns 0 if both mem locations of length are equal,
    return -1 if they are not. */
-int crypto_cmp(const uint8_t *mem1, const uint8_t *mem2, uint32_t length);
+int crypto_cmp(const uint8_t *mem1, const uint8_t *mem2, size_t length);
 
 /*  return a random number.
  *
@@ -122,14 +122,12 @@ 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_DHTPK         156
 #define CRYPTO_PACKET_NAT_PING      254 /* NAT ping crypto packet ID. */
-#define CRYPTO_PACKET_GROUP_CHAT_GET_NODES      48 /* Group chat get Nodes packet */
-#define CRYPTO_PACKET_GROUP_CHAT_SEND_NODES     49 /* Group chat send Nodes packet */
-#define CRYPTO_PACKET_GROUP_CHAT_BROADCAST      50 /* Group chat broadcast packet */
 
 /* Create a request to peer.
  * send_public_key and send_secret_key are the pub/secret keys of the sender.
- * recv_public_key is public key of reciever.
+ * recv_public_key is public key of receiver.
  * packet must be an array of MAX_CRYPTO_REQUEST_SIZE big.
  * Data represents the data we send with the request with length being the length of the data.
  * request_id is the id of the request (32 = friend request, 254 = ping request).
diff --git a/toxcore/friend_connection.c b/toxcore/friend_connection.c
new file mode 100644
index 00000000..588f0d6a
--- /dev/null
+++ b/toxcore/friend_connection.c
@@ -0,0 +1,688 @@
+/* friend_connection.c
+ *
+ * Connection to friends.
+ *
+ *  Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "friend_connection.h"
+#include "util.h"
+
+/* return 1 if the friendcon_id is not valid.
+ * return 0 if the friendcon_id is valid.
+ */
+static uint8_t friendconn_id_not_valid(const Friend_Connections *fr_c, int friendcon_id)
+{
+    if ((unsigned int)friendcon_id >= fr_c->num_cons)
+        return 1;
+
+    if (fr_c->conns == NULL)
+        return 1;
+
+    if (fr_c->conns[friendcon_id].status == FRIENDCONN_STATUS_NONE)
+        return 1;
+
+    return 0;
+}
+
+
+/* Set the size of the friend connections list to num.
+ *
+ *  return -1 if realloc fails.
+ *  return 0 if it succeeds.
+ */
+static int realloc_friendconns(Friend_Connections *fr_c, uint32_t num)
+{
+    if (num == 0) {
+        free(fr_c->conns);
+        fr_c->conns = NULL;
+        return 0;
+    }
+
+    Friend_Conn *newgroup_cons = realloc(fr_c->conns, num * sizeof(Friend_Conn));
+
+    if (newgroup_cons == NULL)
+        return -1;
+
+    fr_c->conns = newgroup_cons;
+    return 0;
+}
+
+/* Create a new empty friend connection.
+ *
+ * return -1 on failure.
+ * return friendcon_id on success.
+ */
+static int create_friend_conn(Friend_Connections *fr_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < fr_c->num_cons; ++i) {
+        if (fr_c->conns[i].status == FRIENDCONN_STATUS_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    if (realloc_friendconns(fr_c, fr_c->num_cons + 1) == 0) {
+        id = fr_c->num_cons;
+        ++fr_c->num_cons;
+        memset(&(fr_c->conns[id]), 0, sizeof(Friend_Conn));
+    }
+
+    return id;
+}
+
+/* Wipe a friend connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_friend_conn(Friend_Connections *fr_c, int friendcon_id)
+{
+    if (friendconn_id_not_valid(fr_c, friendcon_id))
+        return -1;
+
+    uint32_t i;
+    memset(&(fr_c->conns[friendcon_id]), 0 , sizeof(Friend_Conn));
+
+    for (i = fr_c->num_cons; i != 0; --i) {
+        if (fr_c->conns[i - 1].status != FRIENDCONN_STATUS_NONE)
+            break;
+    }
+
+    if (fr_c->num_cons != i) {
+        fr_c->num_cons = i;
+        realloc_friendconns(fr_c, fr_c->num_cons);
+    }
+
+    return 0;
+}
+
+static Friend_Conn *get_conn(const Friend_Connections *fr_c, int friendcon_id)
+{
+    if (friendconn_id_not_valid(fr_c, friendcon_id))
+        return 0;
+
+    return &fr_c->conns[friendcon_id];
+}
+
+/* return friendcon_id corresponding to the real public key on success.
+ * return -1 on failure.
+ */
+int getfriend_conn_id_pk(Friend_Connections *fr_c, const uint8_t *real_pk)
+{
+    uint32_t i;
+
+    for (i = 0; i < fr_c->num_cons; ++i) {
+        Friend_Conn *friend_con = get_conn(fr_c, i);
+
+        if (friend_con) {
+            if (memcmp(friend_con->real_public_key, real_pk, crypto_box_PUBLICKEYBYTES) == 0)
+                return i;
+        }
+    }
+
+    return -1;
+}
+
+/* callback for recv TCP relay nodes. */
+static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key)
+{
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (!friend_con)
+        return -1;
+
+    if (friend_con->crypt_connection_id != -1) {
+        return add_tcp_relay_peer(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port, public_key);
+    } else {
+        return add_tcp_relay(fr_c->net_crypto, ip_port, public_key);
+    }
+}
+
+static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id);
+/* Callback for DHT ip_port changes. */
+static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
+{
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (!friend_con)
+        return;
+
+    if (friend_con->crypt_connection_id == -1) {
+        friend_new_connection(fr_c, number);
+    }
+
+    set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port);
+    friend_con->dht_ip_port = ip_port;
+    friend_con->dht_ip_port_lastrecv = unix_time();
+}
+
+/* Callback for dht public key changes. */
+static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key)
+{
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (!friend_con)
+        return;
+
+    friend_con->dht_ping_lastrecv = unix_time();
+
+    if (memcmp(friend_con->dht_temp_pk, dht_public_key, crypto_box_PUBLICKEYBYTES) == 0)
+        return;
+
+    if (friend_con->dht_lock) {
+        if (DHT_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock) != 0) {
+            printf("a. Could not delete dht peer. Please report this.\n");
+            return;
+        }
+
+        friend_con->dht_lock = 0;
+    }
+
+    DHT_addfriend(fr_c->dht, dht_public_key, dht_ip_callback, object, number, &friend_con->dht_lock);
+
+    if (friend_con->crypt_connection_id == -1) {
+        friend_new_connection(fr_c, number);
+    }
+
+    set_connection_dht_public_key(fr_c->net_crypto, friend_con->crypt_connection_id, dht_public_key);
+    onion_set_friend_DHT_pubkey(fr_c->onion_c, friend_con->onion_friendnum, dht_public_key);
+
+    memcpy(friend_con->dht_temp_pk, dht_public_key, crypto_box_PUBLICKEYBYTES);
+}
+
+static int handle_status(void *object, int number, uint8_t status)
+{
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (!friend_con)
+        return -1;
+
+    if (status) {  /* Went online. */
+        friend_con->status = FRIENDCONN_STATUS_CONNECTED;
+        friend_con->ping_lastrecv = unix_time();
+        onion_set_friend_online(fr_c->onion_c, friend_con->onion_friendnum, status);
+    } else {  /* Went offline. */
+        friend_con->status = FRIENDCONN_STATUS_CONNECTING;
+        friend_con->crypt_connection_id = -1;
+        friend_con->dht_ping_lastrecv = unix_time();
+        onion_set_friend_online(fr_c->onion_c, friend_con->onion_friendnum, status);
+    }
+
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
+        if (friend_con->callbacks[i].status_callback)
+            friend_con->callbacks[i].status_callback(friend_con->callbacks[i].status_callback_object,
+                    friend_con->callbacks[i].status_callback_id, status);
+    }
+
+    return 0;
+}
+
+static int handle_packet(void *object, int number, uint8_t *data, uint16_t length)
+{
+    if (length == 0)
+        return -1;
+
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (data[0] == PACKET_ID_FRIEND_REQUESTS) {
+        if (fr_c->fr_request_callback)
+            fr_c->fr_request_callback(fr_c->fr_request_object, friend_con->real_public_key, data, length);
+
+        return 0;
+    }
+
+    if (!friend_con)
+        return -1;
+
+    if (data[0] == PACKET_ID_ALIVE) {
+        friend_con->ping_lastrecv = unix_time();
+        return 0;
+    }
+
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
+        if (friend_con->callbacks[i].data_callback)
+            friend_con->callbacks[i].data_callback(friend_con->callbacks[i].data_callback_object,
+                                                   friend_con->callbacks[i].data_callback_id, data, length);
+
+        friend_con = get_conn(fr_c, number);
+
+        if (!friend_con)
+            return -1;
+    }
+
+    return 0;
+}
+
+static int handle_lossy_packet(void *object, int number, const uint8_t *data, uint16_t length)
+{
+    if (length == 0)
+        return -1;
+
+    Friend_Connections *fr_c = object;
+    Friend_Conn *friend_con = get_conn(fr_c, number);
+
+    if (!friend_con)
+        return -1;
+
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {
+        if (friend_con->callbacks[i].lossy_data_callback)
+            friend_con->callbacks[i].lossy_data_callback(friend_con->callbacks[i].lossy_data_callback_object,
+                    friend_con->callbacks[i].lossy_data_callback_id, data, length);
+
+        friend_con = get_conn(fr_c, number);
+
+        if (!friend_con)
+            return -1;
+    }
+
+    return 0;
+}
+
+static int handle_new_connections(void *object, New_Connection *n_c)
+{
+    Friend_Connections *fr_c = object;
+    int friendcon_id = getfriend_conn_id_pk(fr_c, n_c->public_key);
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (friend_con) {
+
+        if (friend_con->crypt_connection_id != -1)
+            return -1;
+
+        int id = accept_crypto_connection(fr_c->net_crypto, n_c);
+        connection_status_handler(fr_c->net_crypto, id, &handle_status, fr_c, friendcon_id);
+        connection_data_handler(fr_c->net_crypto, id, &handle_packet, fr_c, friendcon_id);
+        connection_lossy_data_handler(fr_c->net_crypto, id, &handle_lossy_packet, fr_c, friendcon_id);
+        friend_con->crypt_connection_id = id;
+
+        if (n_c->source.ip.family != AF_INET && n_c->source.ip.family != AF_INET6) {
+            set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port);
+        } else {
+            friend_con->dht_ip_port = n_c->source;
+            friend_con->dht_ip_port_lastrecv = unix_time();
+        }
+
+        dht_pk_callback(fr_c, friendcon_id, n_c->dht_public_key);
+
+        nc_dht_pk_callback(fr_c->net_crypto, id, &dht_pk_callback, fr_c, friendcon_id);
+        return 0;
+    }
+
+    return -1;
+}
+
+static int friend_new_connection(Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    if (friend_con->crypt_connection_id != -1) {
+        return -1;
+    }
+
+    int id = new_crypto_connection(fr_c->net_crypto, friend_con->real_public_key);
+
+    if (id == -1)
+        return -1;
+
+    friend_con->crypt_connection_id = id;
+    connection_status_handler(fr_c->net_crypto, id, &handle_status, fr_c, friendcon_id);
+    connection_data_handler(fr_c->net_crypto, id, &handle_packet, fr_c, friendcon_id);
+    connection_lossy_data_handler(fr_c->net_crypto, id, &handle_lossy_packet, fr_c, friendcon_id);
+    nc_dht_pk_callback(fr_c->net_crypto, id, &dht_pk_callback, fr_c, friendcon_id);
+
+    return 0;
+}
+
+static int send_ping(const Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    uint8_t ping = PACKET_ID_ALIVE;
+    int64_t ret = write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, &ping, sizeof(ping), 0);
+
+    if (ret != -1) {
+        friend_con->ping_lastsent = unix_time();
+        return 0;
+    }
+
+    return -1;
+}
+
+/* Increases lock_count for the connection with friendcon_id by 1.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int friend_connection_lock(Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    ++friend_con->lock_count;
+    return 0;
+}
+
+/* return FRIENDCONN_STATUS_CONNECTED if the friend is connected.
+ * return FRIENDCONN_STATUS_CONNECTING if the friend isn't connected.
+ * return FRIENDCONN_STATUS_NONE on failure.
+ */
+unsigned int friend_con_connected(Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return 0;
+
+    return friend_con->status;
+}
+
+/* Copy public keys associated to friendcon_id.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int get_friendcon_public_keys(uint8_t *real_pk, uint8_t *dht_temp_pk, Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    if (real_pk)
+        memcpy(real_pk, friend_con->real_public_key, crypto_box_PUBLICKEYBYTES);
+
+    if (dht_temp_pk)
+        memcpy(dht_temp_pk, friend_con->dht_temp_pk, crypto_box_PUBLICKEYBYTES);
+
+    return 0;
+}
+
+/* Set temp dht key for connection.
+ */
+void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk)
+{
+    dht_pk_callback(fr_c, friendcon_id, dht_temp_pk);
+}
+
+/* Set the callbacks for the friend connection.
+ * index is the index (0 to (MAX_FRIEND_CONNECTION_CALLBACKS - 1)) we want the callback to set in the array.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int friend_connection_callbacks(Friend_Connections *fr_c, int friendcon_id, unsigned int index,
+                                int (*status_callback)(void *object, int id, uint8_t status), int (*data_callback)(void *object, int id, uint8_t *data,
+                                        uint16_t length), int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
+                                int number)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    if (index >= MAX_FRIEND_CONNECTION_CALLBACKS)
+        return -1;
+
+    friend_con->callbacks[index].status_callback = status_callback;
+    friend_con->callbacks[index].data_callback = data_callback;
+    friend_con->callbacks[index].lossy_data_callback = lossy_data_callback;
+
+    friend_con->callbacks[index].status_callback_object =
+        friend_con->callbacks[index].data_callback_object =
+            friend_con->callbacks[index].lossy_data_callback_object = object;
+
+    friend_con->callbacks[index].status_callback_id =
+        friend_con->callbacks[index].data_callback_id =
+            friend_con->callbacks[index].lossy_data_callback_id = number;
+    return 0;
+}
+
+/* return the crypt_connection_id for the connection.
+ *
+ * return crypt_connection_id on success.
+ * return -1 on failure.
+ */
+int friend_connection_crypt_connection_id(Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    return friend_con->crypt_connection_id;
+}
+
+/* Create a new friend connection.
+ * If one to that real public key already exists, increase lock count and return it.
+ *
+ * return -1 on failure.
+ * return connection id on success.
+ */
+int new_friend_connection(Friend_Connections *fr_c, const uint8_t *real_public_key)
+{
+    int friendcon_id = getfriend_conn_id_pk(fr_c, real_public_key);
+
+    if (friendcon_id != -1) {
+        ++fr_c->conns[friendcon_id].lock_count;
+        return friendcon_id;
+    }
+
+    friendcon_id = create_friend_conn(fr_c);
+
+    if (friendcon_id == -1)
+        return -1;
+
+    int32_t onion_friendnum = onion_addfriend(fr_c->onion_c, real_public_key);
+
+    if (onion_friendnum == -1)
+        return -1;
+
+    Friend_Conn *friend_con = &fr_c->conns[friendcon_id];
+
+    friend_con->crypt_connection_id = -1;
+    friend_con->status = FRIENDCONN_STATUS_CONNECTING;
+    memcpy(friend_con->real_public_key, real_public_key, crypto_box_PUBLICKEYBYTES);
+    friend_con->onion_friendnum = onion_friendnum;
+
+    recv_tcp_relay_handler(fr_c->onion_c, onion_friendnum, &tcp_relay_node_callback, fr_c, friendcon_id);
+    onion_dht_pk_callback(fr_c->onion_c, onion_friendnum, &dht_pk_callback, fr_c, friendcon_id);
+
+    return friendcon_id;
+}
+
+/* Kill a friend connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int kill_friend_connection(Friend_Connections *fr_c, int friendcon_id)
+{
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    if (friend_con->lock_count) {
+        --friend_con->lock_count;
+        return 0;
+    }
+
+    onion_delfriend(fr_c->onion_c, friend_con->onion_friendnum);
+    crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id);
+
+    if (friend_con->dht_lock) {
+        DHT_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock);
+    }
+
+    return wipe_friend_conn(fr_c, friendcon_id);
+}
+
+
+/* Set friend request callback.
+ *
+ * This function will be called every time a friend request packet is received.
+ */
+void set_friend_request_callback(Friend_Connections *fr_c, int (*fr_request_callback)(void *, const uint8_t *,
+                                 const uint8_t *, uint16_t), void *object)
+{
+    fr_c->fr_request_callback = fr_request_callback;
+    fr_c->fr_request_object = object;
+    oniondata_registerhandler(fr_c->onion_c, CRYPTO_PACKET_FRIEND_REQ, fr_request_callback, object);
+}
+
+/* Send a Friend request packet.
+ *
+ *  return -1 if failure.
+ *  return  0 if it sent the friend request directly to the friend.
+ *  return the number of peers it was routed through if it did not send it directly.
+ */
+int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint32_t nospam_num, const uint8_t *data,
+                               uint16_t length)
+{
+    if (1 + sizeof(nospam_num) + length > ONION_CLIENT_MAX_DATA_SIZE || length == 0)
+        return -1;
+
+    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);
+
+    if (!friend_con)
+        return -1;
+
+    uint8_t packet[1 + sizeof(nospam_num) + length];
+    memcpy(packet + 1, &nospam_num, sizeof(nospam_num));
+    memcpy(packet + 1 + sizeof(nospam_num), data, length);
+
+    if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) {
+        packet[0] = PACKET_ID_FRIEND_REQUESTS;
+        return write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, packet, sizeof(packet), 0) != -1;
+    } else {
+        packet[0] = CRYPTO_PACKET_FRIEND_REQ;
+        int num = send_onion_data(fr_c->onion_c, friend_con->onion_friendnum, packet, sizeof(packet));
+
+        if (num <= 0)
+            return -1;
+
+        return num;
+    }
+}
+
+/* Create new friend_connections instance. */
+Friend_Connections *new_friend_connections(Onion_Client *onion_c)
+{
+    if (!onion_c)
+        return NULL;
+
+    Friend_Connections *temp = calloc(1, sizeof(Friend_Connections));
+
+    if (temp == NULL)
+        return NULL;
+
+    temp->dht = onion_c->dht;
+    temp->net_crypto = onion_c->c;
+    temp->onion_c = onion_c;
+
+    new_connection_handler(temp->net_crypto, &handle_new_connections, temp);
+
+    return temp;
+}
+
+/* main friend_connections loop. */
+void do_friend_connections(Friend_Connections *fr_c)
+{
+    uint32_t i;
+    uint64_t temp_time = unix_time();
+
+    for (i = 0; i < fr_c->num_cons; ++i) {
+        Friend_Conn *friend_con = get_conn(fr_c, i);
+
+        if (friend_con) {
+            if (friend_con->status == FRIENDCONN_STATUS_CONNECTING) {
+                if (friend_con->dht_ping_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) {
+                    if (friend_con->dht_lock) {
+                        DHT_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock);
+                        friend_con->dht_lock = 0;
+                    }
+                }
+
+                if (friend_con->dht_ip_port_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) {
+                    friend_con->dht_ip_port.ip.family = 0;
+                }
+
+                if (friend_con->dht_lock) {
+                    if (friend_new_connection(fr_c, i) == 0) {
+                        set_connection_dht_public_key(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_temp_pk);
+                        set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port);
+                    }
+                }
+
+            } else if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) {
+                if (friend_con->ping_lastsent + FRIEND_PING_INTERVAL < temp_time) {
+                    send_ping(fr_c, i);
+                }
+
+                if (friend_con->ping_lastrecv + FRIEND_CONNECTION_TIMEOUT < temp_time) {
+                    /* If we stopped receiving ping packets, kill it. */
+                    crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id);
+                    friend_con->crypt_connection_id = -1;
+                    handle_status(fr_c, i, 0); /* Going offline. */
+                }
+            }
+        }
+    }
+}
+
+/* Free everything related with friend_connections. */
+void kill_friend_connections(Friend_Connections *fr_c)
+{
+    if (!fr_c)
+        return;
+
+    uint32_t i;
+
+    for (i = 0; i < fr_c->num_cons; ++i) {
+        kill_friend_connection(fr_c, i);
+    }
+
+    free(fr_c);
+}
diff --git a/toxcore/friend_connection.h b/toxcore/friend_connection.h
new file mode 100644
index 00000000..b814eb0c
--- /dev/null
+++ b/toxcore/friend_connection.h
@@ -0,0 +1,188 @@
+/* friend_connection.h
+ *
+ * Connection to friends.
+ *
+ *  Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef FRIEND_CONNECTION_H
+#define FRIEND_CONNECTION_H
+
+#include "net_crypto.h"
+#include "DHT.h"
+#include "LAN_discovery.h"
+#include "onion_client.h"
+
+
+#define MAX_FRIEND_CONNECTION_CALLBACKS 2
+#define MESSENGER_CALLBACK_INDEX 0
+#define GROUPCHAT_CALLBACK_INDEX 1
+
+#define PACKET_ID_ALIVE 16
+#define PACKET_ID_FRIEND_REQUESTS 18
+
+/* Interval between the sending of ping packets. */
+#define FRIEND_PING_INTERVAL 7
+
+/* If no packets are received from friend in this time interval, kill the connection. */
+#define FRIEND_CONNECTION_TIMEOUT (FRIEND_PING_INTERVAL * 3)
+
+/* Time before friend is removed from the DHT after last hearing about him. */
+#define FRIEND_DHT_TIMEOUT BAD_NODE_TIMEOUT
+
+
+enum {
+    FRIENDCONN_STATUS_NONE,
+    FRIENDCONN_STATUS_CONNECTING,
+    FRIENDCONN_STATUS_CONNECTED
+};
+
+typedef struct {
+    uint8_t status;
+
+    uint8_t real_public_key[crypto_box_PUBLICKEYBYTES];
+    uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+    uint16_t dht_lock;
+    IP_Port dht_ip_port;
+    uint64_t dht_ping_lastrecv, dht_ip_port_lastrecv;
+
+    int onion_friendnum;
+    int crypt_connection_id;
+
+    uint64_t ping_lastrecv, ping_lastsent;
+
+    struct {
+        int (*status_callback)(void *object, int id, uint8_t status);
+        void *status_callback_object;
+        int status_callback_id;
+
+        int (*data_callback)(void *object, int id, uint8_t *data, uint16_t length);
+        void *data_callback_object;
+        int data_callback_id;
+
+        int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
+        void *lossy_data_callback_object;
+        int lossy_data_callback_id;
+    } callbacks[MAX_FRIEND_CONNECTION_CALLBACKS];
+
+    uint16_t lock_count;
+} Friend_Conn;
+
+
+typedef struct {
+    Net_Crypto *net_crypto;
+    DHT *dht;
+    Onion_Client *onion_c;
+
+    Friend_Conn *conns;
+    uint32_t num_cons;
+
+    int (*fr_request_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint16_t len);
+    void *fr_request_object;
+} Friend_Connections;
+
+/* return friendcon_id corresponding to the real public key on success.
+ * return -1 on failure.
+ */
+int getfriend_conn_id_pk(Friend_Connections *fr_c, const uint8_t *real_pk);
+
+/* Increases lock_count for the connection with friendcon_id by 1.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int friend_connection_lock(Friend_Connections *fr_c, int friendcon_id);
+
+/* return FRIENDCONN_STATUS_CONNECTED if the friend is connected.
+ * return FRIENDCONN_STATUS_CONNECTING if the friend isn't connected.
+ * return FRIENDCONN_STATUS_NONE on failure.
+ */
+unsigned int friend_con_connected(Friend_Connections *fr_c, int friendcon_id);
+
+/* Copy public keys associated to friendcon_id.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int get_friendcon_public_keys(uint8_t *real_pk, uint8_t *dht_temp_pk, Friend_Connections *fr_c, int friendcon_id);
+
+/* Set temp dht key for connection.
+ */
+void set_dht_temp_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_temp_pk);
+
+/* Set the callbacks for the friend connection.
+ * index is the index (0 to (MAX_FRIEND_CONNECTION_CALLBACKS - 1)) we want the callback to set in the array.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int friend_connection_callbacks(Friend_Connections *fr_c, int friendcon_id, unsigned int index,
+                                int (*status_callback)(void *object, int id, uint8_t status), int (*data_callback)(void *object, int id, uint8_t *data,
+                                        uint16_t length), int (*lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
+                                int number);
+
+/* return the crypt_connection_id for the connection.
+ *
+ * return crypt_connection_id on success.
+ * return -1 on failure.
+ */
+int friend_connection_crypt_connection_id(Friend_Connections *fr_c, int friendcon_id);
+
+/* Create a new friend connection.
+ * If one to that real public key already exists, increase lock count and return it.
+ *
+ * return -1 on failure.
+ * return connection id on success.
+ */
+int new_friend_connection(Friend_Connections *fr_c, const uint8_t *real_public_key);
+
+/* Kill a friend connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int kill_friend_connection(Friend_Connections *fr_c, int friendcon_id);
+
+/* Send a Friend request packet.
+ *
+ *  return -1 if failure.
+ *  return  0 if it sent the friend request directly to the friend.
+ *  return the number of peers it was routed through if it did not send it directly.
+ */
+int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint32_t nospam_num, const uint8_t *data,
+                               uint16_t length);
+
+/* Set friend request callback.
+ *
+ * This function will be called every time a friend request is received.
+ */
+void set_friend_request_callback(Friend_Connections *fr_c, int (*fr_request_callback)(void *, const uint8_t *,
+                                 const uint8_t *, uint16_t), void *object);
+
+/* Create new friend_connections instance. */
+Friend_Connections *new_friend_connections(Onion_Client *onion_c);
+
+/* main friend_connections loop. */
+void do_friend_connections(Friend_Connections *fr_c);
+
+/* Free everything related with friend_connections. */
+void kill_friend_connections(Friend_Connections *fr_c);
+
+#endif
diff --git a/toxcore/friend_requests.c b/toxcore/friend_requests.c
index a662b629..dae1694a 100644
--- a/toxcore/friend_requests.c
+++ b/toxcore/friend_requests.c
@@ -28,37 +28,6 @@
 #include "friend_requests.h"
 #include "util.h"
 
-/* Try to send a friend request to peer with public_key.
- * data is the data in the request and length is the length.
- *
- *  return -1 if failure.
- *  return  0 if it sent the friend request directly to the friend.
- *  return the number of peers it was routed through if it did not send it directly.
- */
-int send_friendrequest(const Onion_Client *onion_c, const uint8_t *public_key, uint32_t nospam_num, const uint8_t *data,
-                       uint32_t length)
-{
-    if (1 + sizeof(nospam_num) + length > ONION_CLIENT_MAX_DATA_SIZE || length == 0)
-        return -1;
-
-    uint8_t temp[1 + sizeof(nospam_num) + length];
-    temp[0] = CRYPTO_PACKET_FRIEND_REQ;
-    memcpy(temp + 1, &nospam_num, sizeof(nospam_num));
-    memcpy(temp + 1 + sizeof(nospam_num), data, length);
-
-    int friend_num = onion_friend_num(onion_c, public_key);
-
-    if (friend_num == -1)
-        return -1;
-
-    int num = send_onion_data(onion_c, friend_num, temp, sizeof(temp));
-
-    if (num <= 0)
-        return -1;
-
-    return num;
-}
-
 
 /* Set and get the nospam variable used to prevent one type of friend request spam. */
 void set_nospam(Friend_Requests *fr, uint32_t num)
@@ -73,7 +42,7 @@ uint32_t get_nospam(const Friend_Requests *fr)
 
 
 /* Set the function that will be executed when a friend request is received. */
-void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, uint16_t,
+void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, size_t,
                             void *), void *object, void *userdata)
 {
     fr->handle_friendrequest = function;
@@ -89,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;
 }
 
@@ -103,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;
         }
@@ -134,7 +103,7 @@ int remove_request_received(Friend_Requests *fr, const uint8_t *client_id)
 }
 
 
-static int friendreq_handlepacket(void *object, const uint8_t *source_pubkey, const uint8_t *packet, uint32_t length)
+static int friendreq_handlepacket(void *object, const uint8_t *source_pubkey, const uint8_t *packet, uint16_t length)
 {
     Friend_Requests *fr = object;
 
@@ -169,7 +138,7 @@ static int friendreq_handlepacket(void *object, const uint8_t *source_pubkey, co
     return 0;
 }
 
-void friendreq_init(Friend_Requests *fr, Onion_Client *onion_c)
+void friendreq_init(Friend_Requests *fr, Friend_Connections *fr_c)
 {
-    oniondata_registerhandler(onion_c, CRYPTO_PACKET_FRIEND_REQ, &friendreq_handlepacket, fr);
+    set_friend_request_callback(fr_c, &friendreq_handlepacket, fr);
 }
diff --git a/toxcore/friend_requests.h b/toxcore/friend_requests.h
index c3e31f36..ae21f7dc 100644
--- a/toxcore/friend_requests.h
+++ b/toxcore/friend_requests.h
@@ -24,13 +24,13 @@
 #ifndef FRIEND_REQUESTS_H
 #define FRIEND_REQUESTS_H
 
-#include "onion_client.h"
+#include "friend_connection.h"
 
 #define MAX_FRIEND_REQUEST_DATA_SIZE (ONION_CLIENT_MAX_DATA_SIZE - (1 + sizeof(uint32_t)))
 
 typedef struct {
     uint32_t nospam;
-    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, uint16_t, void *);
+    void (*handle_friendrequest)(void *, const uint8_t *, const uint8_t *, size_t, void *);
     uint8_t handle_friendrequest_isset;
     void *handle_friendrequest_object;
     void *handle_friendrequest_userdata;
@@ -47,27 +47,21 @@ typedef struct {
     uint16_t received_requests_index;
 } Friend_Requests;
 
-/* Try to send a friendrequest to peer with public_key.
- * data is the data in the request and length is the length.
- * Maximum length of data is MAX_FRIEND_REQUEST_DATA_SIZE.
- */
-int send_friendrequest(const Onion_Client *onion_c, const uint8_t *public_key, uint32_t nospam_num, const uint8_t *data,
-                       uint32_t length);
 /* Set and get the nospam variable used to prevent one type of friend request spam. */
 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)
+ *  Function format is function(uint8_t * public_key, uint8_t * data, size_t length, void * userdata)
  */
-void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, uint16_t,
+void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const uint8_t *, const uint8_t *, size_t,
                             void *), void *object, void *userdata);
 
 /* Set the function used to check if a friend request should be displayed to the user or not.
@@ -77,7 +71,7 @@ void callback_friendrequest(Friend_Requests *fr, void (*function)(void *, const
 void set_filter_function(Friend_Requests *fr, int (*function)(const uint8_t *, void *), void *userdata);
 
 /* Sets up friendreq packet handlers. */
-void friendreq_init(Friend_Requests *fr, Onion_Client *onion_c);
+void friendreq_init(Friend_Requests *fr, Friend_Connections *fr_c);
 
 
 #endif
diff --git a/toxcore/group.c b/toxcore/group.c
new file mode 100644
index 00000000..c688ccff
--- /dev/null
+++ b/toxcore/group.c
@@ -0,0 +1,2322 @@
+/* group.c
+ *
+ * Slightly better groupchats implementation.
+ *
+ *  Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "group.h"
+#include "util.h"
+
+/* return 1 if the groupnumber is not valid.
+ * return 0 if the groupnumber is valid.
+ */
+static uint8_t groupnumber_not_valid(const Group_Chats *g_c, int groupnumber)
+{
+    if ((unsigned int)groupnumber >= g_c->num_chats)
+        return 1;
+
+    if (g_c->chats == NULL)
+        return 1;
+
+    if (g_c->chats[groupnumber].status == GROUPCHAT_STATUS_NONE)
+        return 1;
+
+    return 0;
+}
+
+
+/* Set the size of the groupchat list to num.
+ *
+ *  return -1 if realloc fails.
+ *  return 0 if it succeeds.
+ */
+static int realloc_groupchats(Group_Chats *g_c, uint32_t num)
+{
+    if (num == 0) {
+        free(g_c->chats);
+        g_c->chats = NULL;
+        return 0;
+    }
+
+    Group_c *newgroup_chats = realloc(g_c->chats, num * sizeof(Group_c));
+
+    if (newgroup_chats == NULL)
+        return -1;
+
+    g_c->chats = newgroup_chats;
+    return 0;
+}
+
+
+/* Create a new empty groupchat connection.
+ *
+ * return -1 on failure.
+ * return groupnumber on success.
+ */
+static int create_group_chat(Group_Chats *g_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        if (g_c->chats[i].status == GROUPCHAT_STATUS_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    if (realloc_groupchats(g_c, g_c->num_chats + 1) == 0) {
+        id = g_c->num_chats;
+        ++g_c->num_chats;
+        memset(&(g_c->chats[id]), 0, sizeof(Group_c));
+    }
+
+    return id;
+}
+
+
+/* Wipe a groupchat.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_group_chat(Group_Chats *g_c, int groupnumber)
+{
+    if (groupnumber_not_valid(g_c, groupnumber))
+        return -1;
+
+    uint32_t i;
+    memset(&(g_c->chats[groupnumber]), 0 , sizeof(Group_c));
+
+    for (i = g_c->num_chats; i != 0; --i) {
+        if (g_c->chats[i - 1].status != GROUPCHAT_STATUS_NONE)
+            break;
+    }
+
+    if (g_c->num_chats != i) {
+        g_c->num_chats = i;
+        realloc_groupchats(g_c, g_c->num_chats);
+    }
+
+    return 0;
+}
+
+static Group_c *get_group_c(const Group_Chats *g_c, int groupnumber)
+{
+    if (groupnumber_not_valid(g_c, groupnumber))
+        return 0;
+
+    return &g_c->chats[groupnumber];
+}
+
+/*
+ * check if peer with real_pk is in peer array.
+ *
+ * return peer index if peer is in chat.
+ * return -1 if peer is not in chat.
+ *
+ * TODO: make this more efficient.
+ */
+
+static int peer_in_chat(const Group_c *chat, const uint8_t *real_pk)
+{
+    uint32_t i;
+
+    for (i = 0; i < chat->numpeers; ++i)
+        if (id_equal(chat->group[i].real_pk, real_pk))
+            return i;
+
+    return -1;
+}
+
+/*
+ * check if group with identifier is in group array.
+ *
+ * return group number if peer is in list.
+ * return -1 if group is not in list.
+ *
+ * TODO: make this more efficient and maybe use constant time comparisons?
+ */
+static int get_group_num(const Group_Chats *g_c, const uint8_t *identifier)
+{
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_chats; ++i)
+        if (memcmp(g_c->chats[i].identifier, identifier, GROUP_IDENTIFIER_LENGTH) == 0)
+            return i;
+
+    return -1;
+}
+
+/*
+ * check if peer with peer_number is in peer array.
+ *
+ * return peer number if peer is in chat.
+ * return -1 if peer is not in chat.
+ *
+ * TODO: make this more efficient.
+ */
+static int get_peer_index(Group_c *g, uint16_t peer_number)
+{
+    uint32_t i;
+
+    for (i = 0; i < g->numpeers; ++i)
+        if (g->group[i].peer_number == peer_number)
+            return i;
+
+    return -1;
+}
+
+
+static uint64_t calculate_comp_value(const uint8_t *pk1, const uint8_t *pk2)
+{
+    uint64_t cmp1 = 0, cmp2 = 0;
+
+    unsigned int i;
+
+    for (i = 0; i < sizeof(uint64_t); ++i) {
+        cmp1 = (cmp1 << 8) + (uint64_t)pk1[i];
+        cmp2 = (cmp2 << 8) + (uint64_t)pk2[i];
+    }
+
+    return (cmp1 - cmp2);
+}
+
+enum {
+    GROUPCHAT_CLOSEST_NONE,
+    GROUPCHAT_CLOSEST_ADDED,
+    GROUPCHAT_CLOSEST_REMOVED
+};
+
+static int friend_in_close(Group_c *g, int friendcon_id);
+static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnumber, uint8_t closest, uint8_t lock);
+
+static int add_to_closest(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if (memcmp(g->real_pk, real_pk, crypto_box_PUBLICKEYBYTES) == 0)
+        return -1;
+
+    unsigned int i;
+    unsigned int index = DESIRED_CLOSE_CONNECTIONS;
+
+    for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
+        if (g->closest_peers[i].entry && memcmp(real_pk, g->closest_peers[i].real_pk, crypto_box_PUBLICKEYBYTES) == 0) {
+            return 0;
+        }
+    }
+
+    for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
+        if (g->closest_peers[i].entry == 0) {
+            index = i;
+            break;
+        }
+    }
+
+    if (index == DESIRED_CLOSE_CONNECTIONS) {
+        uint64_t comp_val = calculate_comp_value(g->real_pk, real_pk);
+        uint64_t comp_d = 0;
+
+        for (i = 0; i < (DESIRED_CLOSE_CONNECTIONS / 2); ++i) {
+            uint64_t comp;
+            comp = calculate_comp_value(g->real_pk, g->closest_peers[i].real_pk);
+
+            if (comp > comp_val && comp > comp_d) {
+                index = i;
+                comp_d = comp;
+            }
+        }
+
+        comp_val = calculate_comp_value(real_pk, g->real_pk);
+
+        for (i = (DESIRED_CLOSE_CONNECTIONS / 2); i < DESIRED_CLOSE_CONNECTIONS; ++i) {
+            uint64_t comp = calculate_comp_value(g->closest_peers[i].real_pk, g->real_pk);
+
+            if (comp > comp_val && comp > comp_d) {
+                index = i;
+                comp_d = comp;
+            }
+        }
+    }
+
+    if (index == DESIRED_CLOSE_CONNECTIONS) {
+        return -1;
+    }
+
+    uint8_t old_real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t old_temp_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t old = 0;
+
+    if (g->closest_peers[index].entry) {
+        memcpy(old_real_pk, g->closest_peers[index].real_pk, crypto_box_PUBLICKEYBYTES);
+        memcpy(old_temp_pk, g->closest_peers[index].temp_pk, crypto_box_PUBLICKEYBYTES);
+        old = 1;
+    }
+
+    g->closest_peers[index].entry = 1;
+    memcpy(g->closest_peers[index].real_pk, real_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(g->closest_peers[index].temp_pk, temp_pk, crypto_box_PUBLICKEYBYTES);
+
+    if (old) {
+        add_to_closest(g_c, groupnumber, old_real_pk, old_temp_pk);
+    }
+
+    if (!g->changed)
+        g->changed = GROUPCHAT_CLOSEST_ADDED;
+
+    return 0;
+}
+
+static unsigned int pk_in_closest_peers(Group_c *g, uint8_t *real_pk)
+{
+    unsigned int i;
+
+    for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
+        if (!g->closest_peers[i].entry)
+            continue;
+
+        if (memcmp(g->closest_peers[i].real_pk, real_pk, crypto_box_PUBLICKEYBYTES) == 0)
+            return 1;
+
+    }
+
+    return 0;
+}
+
+static int send_packet_online(Friend_Connections *fr_c, int friendcon_id, uint16_t group_num, uint8_t *identifier);
+
+static int connect_to_closest(Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if (!g->changed)
+        return 0;
+
+    unsigned int i;
+
+    if (g->changed == GROUPCHAT_CLOSEST_REMOVED) {
+        for (i = 0; i < g->numpeers; ++i) {
+            add_to_closest(g_c, groupnumber, g->group[i].real_pk, g->group[i].temp_pk);
+        }
+    }
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+            continue;
+
+        if (!g->close[i].closest)
+            continue;
+
+        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[i].number);
+
+        if (!pk_in_closest_peers(g, real_pk)) {
+            g->close[i].type = GROUPCHAT_CLOSE_NONE;
+            kill_friend_connection(g_c->fr_c, g->close[i].number);
+        }
+    }
+
+    for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) {
+        if (!g->closest_peers[i].entry)
+            continue;
+
+        int friendcon_id = getfriend_conn_id_pk(g_c->fr_c, g->closest_peers[i].real_pk);
+
+        uint8_t lock = 1;
+
+        if (friendcon_id == -1) {
+            friendcon_id = new_friend_connection(g_c->fr_c, g->closest_peers[i].real_pk);
+            lock = 0;
+
+            if (friendcon_id == -1) {
+                continue;
+            }
+
+            set_dht_temp_pk(g_c->fr_c, friendcon_id, g->closest_peers[i].temp_pk);
+        }
+
+        add_conn_to_groupchat(g_c, friendcon_id, groupnumber, 1, lock);
+
+        if (friend_con_connected(g_c->fr_c, friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
+            send_packet_online(g_c->fr_c, friendcon_id, groupnumber, g->identifier);
+        }
+    }
+
+    g->changed = GROUPCHAT_CLOSEST_NONE;
+
+    return 0;
+}
+
+/*
+ * Add a peer to the group chat.
+ *
+ * return peer_index if success or peer already in chat.
+ * return -1 if error.
+ */
+static int addpeer(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk,
+                   uint16_t peer_number)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    //TODO
+    int peer_index = peer_in_chat(g, real_pk);
+
+    if (peer_index != -1) {
+        id_copy(g->group[peer_index].temp_pk, temp_pk);
+
+        if (g->group[peer_index].peer_number != peer_number)
+            return -1;
+
+        return peer_index;
+    }
+
+    peer_index = get_peer_index(g, peer_number);
+
+    if (peer_index != -1)
+        return -1;
+
+    Group_Peer *temp;
+    temp = realloc(g->group, sizeof(Group_Peer) * (g->numpeers + 1));
+
+    if (temp == NULL)
+        return -1;
+
+    memset(&(temp[g->numpeers]), 0, sizeof(Group_Peer));
+    g->group = temp;
+
+    id_copy(g->group[g->numpeers].real_pk, real_pk);
+    id_copy(g->group[g->numpeers].temp_pk, temp_pk);
+    g->group[g->numpeers].peer_number = peer_number;
+
+    g->group[g->numpeers].last_recv = unix_time();
+    ++g->numpeers;
+
+    add_to_closest(g_c, groupnumber, real_pk, temp_pk);
+
+    if (g_c->peer_namelistchange)
+        g_c->peer_namelistchange(g_c->m, groupnumber, g->numpeers - 1, CHAT_CHANGE_PEER_ADD,
+                                 g_c->group_namelistchange_userdata);
+
+    if (g->peer_on_join)
+        g->peer_on_join(g->object, groupnumber, g->numpeers - 1);
+
+    return (g->numpeers - 1);
+}
+
+static int remove_close_conn(Group_Chats *g_c, int groupnumber, int friendcon_id)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint32_t i;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+            continue;
+
+        if (g->close[i].number == (unsigned int)friendcon_id) {
+            g->close[i].type = GROUPCHAT_CLOSE_NONE;
+            kill_friend_connection(g_c->fr_c, friendcon_id);
+            return 0;
+        }
+    }
+
+    return -1;
+}
+
+
+/*
+ * Delete a peer from the group chat.
+ *
+ * return 0 if success
+ * return -1 if error.
+ */
+static int delpeer(Group_Chats *g_c, int groupnumber, int peer_index)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint32_t i;
+
+    for (i = 0; i < DESIRED_CLOSE_CONNECTIONS; ++i) { /* If peer is in closest_peers list, remove it. */
+        if (g->closest_peers[i].entry && id_equal(g->closest_peers[i].real_pk, g->group[peer_index].real_pk)) {
+            g->closest_peers[i].entry = 0;
+            g->changed = GROUPCHAT_CLOSEST_REMOVED;
+            break;
+        }
+    }
+
+    int friendcon_id = getfriend_conn_id_pk(g_c->fr_c, g->group[peer_index].real_pk);
+
+    if (friendcon_id != -1) {
+        remove_close_conn(g_c, groupnumber, friendcon_id);
+    }
+
+    Group_Peer *temp;
+    --g->numpeers;
+
+    void *peer_object = g->group[peer_index].object;
+
+    if (g->numpeers == 0) {
+        free(g->group);
+        g->group = NULL;
+    } else {
+        if (g->numpeers != (uint32_t)peer_index)
+            memcpy(&g->group[peer_index], &g->group[g->numpeers], sizeof(Group_Peer));
+
+        temp = realloc(g->group, sizeof(Group_Peer) * (g->numpeers));
+
+        if (temp == NULL)
+            return -1;
+
+        g->group = temp;
+    }
+
+    if (g_c->peer_namelistchange)
+        g_c->peer_namelistchange(g_c->m, groupnumber, peer_index, CHAT_CHANGE_PEER_DEL, g_c->group_namelistchange_userdata);
+
+    if (g->peer_on_leave)
+        g->peer_on_leave(g->object, groupnumber, peer_index, peer_object);
+
+    return 0;
+}
+
+static int setnick(Group_Chats *g_c, int groupnumber, int peer_index, const uint8_t *nick, uint16_t nick_len)
+{
+    if (nick_len > MAX_NAME_LENGTH)
+        return -1;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    /* same name as already stored? */
+    if (g->group[peer_index].nick_len == nick_len)
+        if (nick_len == 0 || !memcmp(g->group[peer_index].nick, nick, nick_len))
+            return 0;
+
+    if (nick_len)
+        memcpy(g->group[peer_index].nick, nick, nick_len);
+
+    g->group[peer_index].nick_len = nick_len;
+
+    if (g_c->peer_namelistchange)
+        g_c->peer_namelistchange(g_c->m, groupnumber, peer_index, CHAT_CHANGE_PEER_NAME, g_c->group_namelistchange_userdata);
+
+    return 0;
+}
+
+static int settitle(Group_Chats *g_c, int groupnumber, int peer_index, const uint8_t *title, uint8_t title_len)
+{
+    if (title_len > MAX_NAME_LENGTH || title_len == 0)
+        return -1;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    /* same as already set? */
+    if (g->title_len == title_len && !memcmp(g->title, title, title_len))
+        return 0;
+
+    memcpy(g->title, title, title_len);
+    g->title_len = title_len;
+
+    if (g_c->title_callback)
+        g_c->title_callback(g_c->m, groupnumber, peer_index, title, title_len, g_c->title_callback_userdata);
+
+    return 0;
+}
+
+static void set_conns_type_close(Group_Chats *g_c, int groupnumber, int friendcon_id, uint8_t type)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return;
+
+    uint32_t i;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+            continue;
+
+        if (g->close[i].number != (unsigned int)friendcon_id)
+            continue;
+
+        if (type == GROUPCHAT_CLOSE_ONLINE) {
+            send_packet_online(g_c->fr_c, friendcon_id, groupnumber, g->identifier);
+        } else {
+            g->close[i].type = type;
+        }
+    }
+}
+/* Set the type for all close connections with friendcon_id */
+static void set_conns_status_groups(Group_Chats *g_c, int friendcon_id, uint8_t type)
+{
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        set_conns_type_close(g_c, i, friendcon_id, type);
+    }
+}
+
+static int handle_status(void *object, int friendcon_id, uint8_t status)
+{
+    Group_Chats *g_c = object;
+
+    if (status) { /* Went online */
+        set_conns_status_groups(g_c, friendcon_id, GROUPCHAT_CLOSE_ONLINE);
+    } else { /* Went offline */
+        set_conns_status_groups(g_c, friendcon_id, GROUPCHAT_CLOSE_CONNECTION);
+        //TODO remove timedout connections?
+    }
+
+    return 0;
+}
+
+static int handle_packet(void *object, int friendcon_id, uint8_t *data, uint16_t length);
+static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length);
+
+/* Add friend to group chat.
+ *
+ * return close index on success
+ * return -1 on failure.
+ */
+static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnumber, uint8_t closest, uint8_t lock)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint16_t i, ind = MAX_GROUP_CONNECTIONS;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE) {
+            ind = i;
+            continue;
+        }
+
+        if (g->close[i].number == (uint32_t)friendcon_id) {
+            g->close[i].closest = closest;
+            return i; /* Already in list. */
+        }
+    }
+
+    if (ind == MAX_GROUP_CONNECTIONS)
+        return -1;
+
+    if (lock)
+        friend_connection_lock(g_c->fr_c, friendcon_id);
+
+    g->close[ind].type = GROUPCHAT_CLOSE_CONNECTION;
+    g->close[ind].number = friendcon_id;
+    g->close[ind].closest = closest;
+    //TODO
+    friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &handle_status, &handle_packet,
+                                &handle_lossy, g_c, friendcon_id);
+
+    return ind;
+}
+
+/* Creates a new groupchat and puts it in the chats array.
+ *
+ * type is one of GROUPCHAT_TYPE_*
+ *
+ * return group number on success.
+ * return -1 on failure.
+ */
+int add_groupchat(Group_Chats *g_c, uint8_t type)
+{
+    int groupnumber = create_group_chat(g_c);
+
+    if (groupnumber == -1)
+        return -1;
+
+    Group_c *g = &g_c->chats[groupnumber];
+
+    g->status = GROUPCHAT_STATUS_CONNECTED;
+    g->number_joined = -1;
+    new_symmetric_key(g->identifier + 1);
+    g->identifier[0] = type;
+    g->peer_number = 0; /* Founder is peer 0. */
+    memcpy(g->real_pk, g_c->m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
+    int peer_index = addpeer(g_c, groupnumber, g->real_pk, g_c->m->dht->self_public_key, 0);
+
+    if (peer_index == -1) {
+        return -1;
+    }
+
+    setnick(g_c, groupnumber, peer_index, g_c->m->name, g_c->m->name_length);
+
+    return groupnumber;
+}
+
+static int group_kill_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num);
+/* Delete a groupchat from the chats array.
+ *
+ * return 0 on success.
+ * return -1 if failure.
+ */
+int del_groupchat(Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    group_kill_peer_send(g_c, groupnumber, g->peer_number);
+
+    unsigned int i;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+            continue;
+
+        g->close[i].type = GROUPCHAT_CLOSE_NONE;
+        kill_friend_connection(g_c->fr_c, g->close[i].number);
+    }
+
+    for (i = 0; i < g->numpeers; ++i) {
+        if (g->peer_on_leave)
+            g->peer_on_leave(g->object, groupnumber, i, g->group[i].object);
+    }
+
+    free(g->group);
+
+    if (g->group_on_delete)
+        g->group_on_delete(g->object, groupnumber);
+
+    return wipe_group_chat(g_c, groupnumber);
+}
+
+/* Copy the public key of peernumber who is in groupnumber to pk.
+ * pk must be crypto_box_PUBLICKEYBYTES long.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int group_peer_pubkey(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *pk)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if ((uint32_t)peernumber >= g->numpeers)
+        return -1;
+
+    memcpy(pk, g->group[peernumber].real_pk, crypto_box_PUBLICKEYBYTES);
+    return 0;
+}
+
+/* Copy the name of peernumber who is in groupnumber to name.
+ * name must be at least MAX_NAME_LENGTH long.
+ *
+ * return length of name if success
+ * return -1 if failure
+ */
+int group_peername(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *name)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if ((uint32_t)peernumber >= g->numpeers)
+        return -1;
+
+    if (g->group[peernumber].nick_len == 0) {
+        memcpy(name, "Tox User", 8);
+        return 8;
+    }
+
+    memcpy(name, g->group[peernumber].nick, g->group[peernumber].nick_len);
+    return g->group[peernumber].nick_len;
+}
+
+/* List all the peers in the group chat.
+ *
+ * Copies the names of the peers to the name[length][MAX_NAME_LENGTH] array.
+ *
+ * Copies the lengths of the names to lengths[length]
+ *
+ * returns the number of peers on success.
+ *
+ * return -1 on failure.
+ */
+int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
+                uint16_t length)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    unsigned int i;
+
+    for (i = 0; i < g->numpeers && i < length; ++i) {
+        lengths[i] = group_peername(g_c, groupnumber, i, names[i]);
+    }
+
+    return i;
+}
+
+/* Return the number of peers in the group chat on success.
+ * return -1 on failure
+ */
+int group_number_peers(const Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    return g->numpeers;
+}
+
+/* return 1 if the peernumber corresponds to ours.
+ * return 0 on failure.
+ */
+unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, int peernumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return 0;
+
+    if (g->status != GROUPCHAT_STATUS_CONNECTED)
+        return 0;
+
+    if ((uint32_t)peernumber >= g->numpeers)
+        return 0;
+
+    return g->peer_number == g->group[peernumber].peer_number;
+}
+
+/* return the type of groupchat (GROUPCHAT_TYPE_) that groupnumber is.
+ *
+ * return -1 on failure.
+ * return type on success.
+ */
+int group_get_type(const Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    return g->identifier[0];
+}
+
+/* Send a group packet to friendcon_id.
+ *
+ *  return 1 on success
+ *  return 0 on failure
+ */
+static unsigned int send_packet_group_peer(Friend_Connections *fr_c, int friendcon_id, uint8_t packet_id,
+        uint16_t group_num, const uint8_t *data, uint16_t length)
+{
+    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE)
+        return 0;
+
+    group_num = htons(group_num);
+    uint8_t packet[1 + sizeof(uint16_t) + length];
+    packet[0] = packet_id;
+    memcpy(packet + 1, &group_num, sizeof(uint16_t));
+    memcpy(packet + 1 + sizeof(uint16_t), data, length);
+    return write_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
+                             sizeof(packet), 0) != -1;
+}
+
+/* Send a group lossy packet to friendcon_id.
+ *
+ *  return 1 on success
+ *  return 0 on failure
+ */
+static unsigned int send_lossy_group_peer(Friend_Connections *fr_c, int friendcon_id, uint8_t packet_id,
+        uint16_t group_num, const uint8_t *data, uint16_t length)
+{
+    if (1 + sizeof(uint16_t) + length > MAX_CRYPTO_DATA_SIZE)
+        return 0;
+
+    group_num = htons(group_num);
+    uint8_t packet[1 + sizeof(uint16_t) + length];
+    packet[0] = packet_id;
+    memcpy(packet + 1, &group_num, sizeof(uint16_t));
+    memcpy(packet + 1 + sizeof(uint16_t), data, length);
+    return send_lossy_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
+                                  sizeof(packet)) != -1;
+}
+
+#define INVITE_PACKET_SIZE (1 + sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH)
+#define INVITE_ID 0
+
+#define INVITE_RESPONSE_PACKET_SIZE (1 + sizeof(uint16_t) * 2 + GROUP_IDENTIFIER_LENGTH)
+#define INVITE_RESPONSE_ID 1
+
+/* invite friendnumber to groupnumber
+ * return 0 on success
+ * return -1 on failure
+ */
+int invite_friend(Group_Chats *g_c, int32_t friendnumber, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint8_t invite[INVITE_PACKET_SIZE];
+    invite[0] = INVITE_ID;
+    uint16_t groupchat_num = htons((uint16_t)groupnumber);
+    memcpy(invite + 1, &groupchat_num, sizeof(groupchat_num));
+    memcpy(invite + 1 + sizeof(groupchat_num), g->identifier, GROUP_IDENTIFIER_LENGTH);
+
+    if (send_group_invite_packet(g_c->m, friendnumber, invite, sizeof(invite))) {
+        return 0;
+    } else {
+        wipe_group_chat(g_c, groupnumber);
+        return -1;
+    }
+}
+
+static unsigned int send_peer_query(Group_Chats *g_c, int friendcon_id, uint16_t group_num);
+
+/* Join a group (you need to have been invited first.)
+ *
+ * expected_type is the groupchat type we expect the chat we are joining is.
+ *
+ * returns group number on success
+ * returns -1 on failure.
+ */
+int join_groupchat(Group_Chats *g_c, int32_t friendnumber, uint8_t expected_type, const uint8_t *data, uint16_t length)
+{
+    if (length != sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH)
+        return -1;
+
+    if (data[sizeof(uint16_t)] != expected_type)
+        return -1;
+
+    int friendcon_id = getfriendcon_id(g_c->m, friendnumber);
+
+    if (friendcon_id == -1)
+        return -1;
+
+    if (get_group_num(g_c, data + sizeof(uint16_t)) != -1)
+        return -1;
+
+    int groupnumber = create_group_chat(g_c);
+
+    if (groupnumber == -1)
+        return -1;
+
+    Group_c *g = &g_c->chats[groupnumber];
+
+    uint16_t group_num = htons(groupnumber);
+    g->status = GROUPCHAT_STATUS_VALID;
+    g->number_joined = -1;
+    memcpy(g->real_pk, g_c->m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
+
+    uint8_t response[INVITE_RESPONSE_PACKET_SIZE];
+    response[0] = INVITE_RESPONSE_ID;
+    memcpy(response + 1, &group_num, sizeof(uint16_t));
+    memcpy(response + 1 + sizeof(uint16_t), data, sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH);
+
+    if (send_group_invite_packet(g_c->m, friendnumber, response, sizeof(response))) {
+        uint16_t other_groupnum;
+        memcpy(&other_groupnum, data, sizeof(other_groupnum));
+        other_groupnum = ntohs(other_groupnum);
+        memcpy(g->identifier, data + sizeof(uint16_t), GROUP_IDENTIFIER_LENGTH);
+        int close_index = add_conn_to_groupchat(g_c, friendcon_id, groupnumber, 0, 1);
+
+        if (close_index != -1) {
+            g->close[close_index].group_number = other_groupnum;
+            g->close[close_index].type = GROUPCHAT_CLOSE_ONLINE;
+            g->number_joined = friendcon_id;
+        }
+
+        send_peer_query(g_c, friendcon_id, other_groupnum);
+        return groupnumber;
+    } else {
+        g->status = GROUPCHAT_STATUS_NONE;
+        return -1;
+    }
+}
+
+/* Set the callback for group invites.
+ *
+ *  Function(Group_Chats *g_c, int32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
+ *
+ *  data of length is what needs to be passed to join_groupchat().
+ */
+void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *,
+                             uint16_t, void *), void *userdata)
+{
+    g_c->invite_callback = function;
+    g_c->invite_callback_userdata = userdata;
+}
+
+/* Set the callback for group messages.
+ *
+ *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ */
+void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
+                              void *), void *userdata)
+{
+    g_c->message_callback = function;
+    g_c->message_callback_userdata = userdata;
+}
+
+/* Set the callback for group actions.
+ *
+ *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ */
+void g_callback_group_action(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
+                             void *), void *userdata)
+{
+    g_c->action_callback = function;
+    g_c->action_callback_userdata = userdata;
+}
+
+/* Set handlers for custom lossy packets.
+ *
+ * NOTE: Handler must return 0 if packet is to be relayed, -1 if the packet should not be relayed.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
+ */
+void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, int, int, void *,
+                                        const uint8_t *, uint16_t))
+{
+    g_c->lossy_packethandlers[byte].function = function;
+}
+
+/* Set callback function for peer name list changes.
+ *
+ * It gets called every time the name list changes(new peer/name, deleted peer)
+ *  Function(Group_Chats *g_c, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
+ */
+void g_callback_group_namelistchange(Group_Chats *g_c, void (*function)(Messenger *m, int, int, uint8_t, void *),
+                                     void *userdata)
+{
+    g_c->peer_namelistchange = function;
+    g_c->group_namelistchange_userdata = userdata;
+}
+
+/* Set callback function for title changes.
+ *
+ * Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * title, uint8_t length, void *userdata)
+ * if friendgroupnumber == -1, then author is unknown (e.g. initial joining the group)
+ */
+void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint8_t,
+                            void *), void *userdata)
+{
+    g_c->title_callback = function;
+    g_c->title_callback_userdata = userdata;
+}
+
+/* Set a function to be called when a new peer joins a group chat.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber)
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_peer_new(const Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int))
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    g->peer_on_join = function;
+    return 0;
+}
+
+/* Set a function to be called when a peer leaves a group chat.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object))
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_peer_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int, void *))
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    g->peer_on_leave = function;
+    return 0;
+}
+
+/* Set a function to be called when the group chat is deleted.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber)
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int))
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    g->group_on_delete = function;
+    return 0;
+}
+
+static unsigned int send_message_group(const Group_Chats *g_c, int groupnumber, uint8_t message_id, const uint8_t *data,
+                                       uint16_t len);
+
+#define GROUP_MESSAGE_PING_ID 0
+int group_ping_send(const Group_Chats *g_c, int groupnumber)
+{
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_PING_ID, 0, 0)) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+#define GROUP_MESSAGE_NEW_PEER_ID 16
+#define GROUP_MESSAGE_NEW_PEER_LENGTH (sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2)
+/* send a new_peer message
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_new_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num, const uint8_t *real_pk,
+                        uint8_t *temp_pk)
+{
+    uint8_t packet[GROUP_MESSAGE_NEW_PEER_LENGTH];
+
+    peer_num = htons(peer_num);
+    memcpy(packet, &peer_num, sizeof(uint16_t));
+    memcpy(packet + sizeof(uint16_t), real_pk, crypto_box_PUBLICKEYBYTES);
+    memcpy(packet + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES, temp_pk, crypto_box_PUBLICKEYBYTES);
+
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NEW_PEER_ID, packet, sizeof(packet))) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+#define GROUP_MESSAGE_KILL_PEER_ID 17
+#define GROUP_MESSAGE_KILL_PEER_LENGTH (sizeof(uint16_t))
+
+/* send a kill_peer message
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_kill_peer_send(const Group_Chats *g_c, int groupnumber, uint16_t peer_num)
+{
+    uint8_t packet[GROUP_MESSAGE_KILL_PEER_LENGTH];
+
+    peer_num = htons(peer_num);
+    memcpy(packet, &peer_num, sizeof(uint16_t));
+
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_KILL_PEER_ID, packet, sizeof(packet))) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+#define GROUP_MESSAGE_NAME_ID 48
+
+/* send a name message
+ * return 0 on success
+ * return -1 on failure
+ */
+static int group_name_send(const Group_Chats *g_c, int groupnumber, const uint8_t *nick, uint16_t nick_len)
+{
+    if (nick_len > MAX_NAME_LENGTH)
+        return -1;
+
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_NAME_ID, nick, nick_len)) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+#define GROUP_MESSAGE_TITLE_ID 49
+
+/* set the group's title, limited to MAX_NAME_LENGTH
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_title_send(const Group_Chats *g_c, int groupnumber, const uint8_t *title, uint8_t title_len)
+{
+    if (title_len > MAX_NAME_LENGTH || title_len == 0)
+        return -1;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    /* same as already set? */
+    if (g->title_len == title_len && !memcmp(g->title, title, title_len))
+        return 0;
+
+    memcpy(g->title, title, title_len);
+    g->title_len = title_len;
+
+    if (g->numpeers == 1)
+        return 0;
+
+    if (send_message_group(g_c, groupnumber, GROUP_MESSAGE_TITLE_ID, title, title_len))
+        return 0;
+    else
+        return -1;
+}
+
+/* Get group title from groupnumber and put it in title.
+ * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
+ *
+ *  return length of copied title if success.
+ *  return -1 if failure.
+ */
+int group_title_get(const Group_Chats *g_c, int groupnumber, uint8_t *title, uint32_t max_length)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if (g->title_len == 0 || g->title_len > MAX_NAME_LENGTH)
+        return -1;
+
+    if (max_length > g->title_len)
+        max_length = g->title_len;
+
+    memcpy(title, g->title, max_length);
+    return max_length;
+}
+
+static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, const uint8_t *data, uint16_t length)
+{
+    Group_Chats *g_c = m->group_chat_object;
+
+    if (length <= 1)
+        return;
+
+    const uint8_t *invite_data = data + 1;
+    uint16_t invite_length = length - 1;
+
+    switch (data[0]) {
+        case INVITE_ID: {
+            if (length != INVITE_PACKET_SIZE)
+                return;
+
+            int groupnumber = get_group_num(g_c, data + 1 + sizeof(uint16_t));
+
+            if (groupnumber == -1) {
+                if (g_c->invite_callback)
+                    g_c->invite_callback(m, friendnumber, *(invite_data + sizeof(uint16_t)), invite_data, invite_length,
+                                         g_c->invite_callback_userdata);
+
+                return;
+            }
+
+            break;
+        }
+
+        case INVITE_RESPONSE_ID: {
+            if (length != INVITE_RESPONSE_PACKET_SIZE)
+                return;
+
+            uint16_t other_groupnum, groupnum;
+            memcpy(&groupnum, data + 1 + sizeof(uint16_t), sizeof(uint16_t));
+            groupnum = ntohs(groupnum);
+
+            Group_c *g = get_group_c(g_c, groupnum);
+
+            if (!g)
+                return;
+
+            if (memcmp(data + 1 + sizeof(uint16_t) * 2, g->identifier, GROUP_IDENTIFIER_LENGTH) != 0)
+                return;
+
+            uint16_t peer_number = rand(); /* TODO: what if two people enter the group at the same time and
+  are given the same peer_number by different nodes? */
+
+            unsigned int tries = 0;
+
+            while (get_peer_index(g, peer_number) != -1) {
+                peer_number = rand();
+                ++tries;
+
+                if (tries > 32)
+                    return;
+            }
+
+            memcpy(&other_groupnum, data + 1, sizeof(uint16_t));
+            other_groupnum = ntohs(other_groupnum);
+
+            int friendcon_id = getfriendcon_id(m, friendnumber);
+            uint8_t real_pk[crypto_box_PUBLICKEYBYTES], temp_pk[crypto_box_PUBLICKEYBYTES];
+            get_friendcon_public_keys(real_pk, temp_pk, g_c->fr_c, friendcon_id);
+
+            addpeer(g_c, groupnum, real_pk, temp_pk, peer_number);
+            int close_index = add_conn_to_groupchat(g_c, friendcon_id, groupnum, 0, 1);
+
+            if (close_index != -1) {
+                g->close[close_index].group_number = other_groupnum;
+                g->close[close_index].type = GROUPCHAT_CLOSE_ONLINE;
+            }
+
+            group_new_peer_send(g_c, groupnum, peer_number, real_pk, temp_pk);
+            break;
+        }
+
+        default:
+            return;
+    }
+}
+
+/* Find index of friend in the close list;
+ *
+ * returns index on success
+ * returns -1 on failure.
+ */
+static int friend_in_close(Group_c *g, int friendcon_id)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_NONE)
+            continue;
+
+        if (g->close[i].number != (uint32_t)friendcon_id)
+            continue;
+
+        return i;
+    }
+
+    return -1;
+}
+
+/* return number of connected close connections.
+ */
+static unsigned int count_close_connected(Group_c *g)
+{
+    unsigned int i, count = 0;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type == GROUPCHAT_CLOSE_ONLINE) {
+            ++count;
+        }
+    }
+
+    return count;
+}
+
+#define ONLINE_PACKET_DATA_SIZE (sizeof(uint16_t) + GROUP_IDENTIFIER_LENGTH)
+
+static int send_packet_online(Friend_Connections *fr_c, int friendcon_id, uint16_t group_num, uint8_t *identifier)
+{
+    uint8_t packet[1 + ONLINE_PACKET_DATA_SIZE];
+    group_num = htons(group_num);
+    packet[0] = PACKET_ID_ONLINE_PACKET;
+    memcpy(packet + 1, &group_num, sizeof(uint16_t));
+    memcpy(packet + 1 + sizeof(uint16_t), identifier, GROUP_IDENTIFIER_LENGTH);
+    return write_cryptpacket(fr_c->net_crypto, friend_connection_crypt_connection_id(fr_c, friendcon_id), packet,
+                             sizeof(packet), 0) != -1;
+}
+
+static unsigned int send_peer_kill(Group_Chats *g_c, int friendcon_id, uint16_t group_num);
+
+static int handle_packet_online(Group_Chats *g_c, int friendcon_id, uint8_t *data, uint16_t length)
+{
+    if (length != ONLINE_PACKET_DATA_SIZE)
+        return -1;
+
+    int groupnumber = get_group_num(g_c, data + sizeof(uint16_t));
+    uint16_t other_groupnum;
+    memcpy(&other_groupnum, data, sizeof(uint16_t));
+    other_groupnum = ntohs(other_groupnum);
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    int index = friend_in_close(g, friendcon_id);
+
+    if (index == -1)
+        return -1;
+
+    if (g->close[index].type == GROUPCHAT_CLOSE_ONLINE) {
+        return -1;
+    }
+
+    if (count_close_connected(g) == 0) {
+        send_peer_query(g_c, friendcon_id, other_groupnum);
+    }
+
+    g->close[index].group_number = other_groupnum;
+    g->close[index].type = GROUPCHAT_CLOSE_ONLINE;
+    send_packet_online(g_c->fr_c, friendcon_id, groupnumber, g->identifier);
+
+    if (g->number_joined != -1 && count_close_connected(g) >= DESIRED_CLOSE_CONNECTIONS) {
+        int fr_close_index = friend_in_close(g, g->number_joined);
+
+        if (fr_close_index == -1)
+            return -1;
+
+        if (!g->close[fr_close_index].closest) {
+            g->close[fr_close_index].type = GROUPCHAT_CLOSE_NONE;
+            send_peer_kill(g_c, g->close[fr_close_index].number, g->close[fr_close_index].group_number);
+            kill_friend_connection(g_c->fr_c, g->close[fr_close_index].number);
+            g->number_joined = -1;
+        }
+    }
+
+    return 0;
+}
+
+#define PEER_KILL_ID 1
+#define PEER_QUERY_ID 8
+#define PEER_RESPONSE_ID 9
+#define PEER_TITLE_ID 10
+// we could send title with invite, but then if it changes between sending and accepting inv, joinee won't see it
+
+/* return 1 on success.
+ * return 0 on failure
+ */
+static unsigned int send_peer_kill(Group_Chats *g_c, int friendcon_id, uint16_t group_num)
+{
+    uint8_t packet[1];
+    packet[0] = PEER_KILL_ID;
+    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, sizeof(packet));
+}
+
+
+/* return 1 on success.
+ * return 0 on failure
+ */
+static unsigned int send_peer_query(Group_Chats *g_c, int friendcon_id, uint16_t group_num)
+{
+    uint8_t packet[1];
+    packet[0] = PEER_QUERY_ID;
+    return send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, sizeof(packet));
+}
+
+/* return number of peers sent on success.
+ * return 0 on failure.
+ */
+static unsigned int send_peers(Group_Chats *g_c, int groupnumber, int friendcon_id, uint16_t group_num)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint8_t packet[MAX_CRYPTO_DATA_SIZE - (1 + sizeof(uint16_t))];
+    packet[0] = PEER_RESPONSE_ID;
+    uint8_t *p = packet + 1;
+
+    uint16_t sent = 0;
+    unsigned int i;
+
+    for (i = 0; i < g->numpeers; ++i) {
+        if ((p - packet) + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1 + g->group[i].nick_len > sizeof(packet)) {
+            if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, (p - packet))) {
+                sent = i;
+            } else {
+                return sent;
+            }
+
+            p = packet + 1;
+        }
+
+        uint16_t peer_num = htons(g->group[i].peer_number);
+        memcpy(p, &peer_num, sizeof(peer_num));
+        p += sizeof(peer_num);
+        memcpy(p, g->group[i].real_pk, crypto_box_PUBLICKEYBYTES);
+        p += crypto_box_PUBLICKEYBYTES;
+        memcpy(p, g->group[i].temp_pk, crypto_box_PUBLICKEYBYTES);
+        p += crypto_box_PUBLICKEYBYTES;
+        *p = g->group[i].nick_len;
+        p += 1;
+        memcpy(p, g->group[i].nick, g->group[i].nick_len);
+        p += g->group[i].nick_len;
+    }
+
+    if (sent != i) {
+        if (send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, packet, (p - packet))) {
+            sent = i;
+        }
+    }
+
+    if (g->title_len) {
+        uint8_t Packet[1 + g->title_len];
+        Packet[0] = PEER_TITLE_ID;
+        memcpy(Packet + 1, g->title, g->title_len);
+        send_packet_group_peer(g_c->fr_c, friendcon_id, PACKET_ID_DIRECT_GROUPCHAT, group_num, Packet, sizeof(Packet));
+    }
+
+    return sent;
+}
+
+static int handle_send_peers(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length)
+{
+    if (length == 0)
+        return -1;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    const uint8_t *d = data;
+
+    while ((length - (d - data)) >= sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1) {
+        uint16_t peer_num;
+        memcpy(&peer_num, d, sizeof(peer_num));
+        peer_num = ntohs(peer_num);
+        d += sizeof(uint16_t);
+        int peer_index = addpeer(g_c, groupnumber, d, d + crypto_box_PUBLICKEYBYTES, peer_num);
+
+        if (peer_index == -1)
+            return -1;
+
+        if (g->status == GROUPCHAT_STATUS_VALID
+                && memcmp(d, g_c->m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+            g->peer_number = peer_num;
+            g->status = GROUPCHAT_STATUS_CONNECTED;
+            group_name_send(g_c, groupnumber, g_c->m->name, g_c->m->name_length);
+        }
+
+        d += crypto_box_PUBLICKEYBYTES * 2;
+        uint8_t name_length = *d;
+        d += 1;
+
+        if (name_length > (length - (d - data)) || name_length > MAX_NAME_LENGTH)
+            return -1;
+
+        setnick(g_c, groupnumber, peer_index, d, name_length);
+        d += name_length;
+    }
+
+    return 0;
+}
+
+static void handle_direct_packet(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
+                                 int close_index)
+{
+    if (length == 0)
+        return;
+
+    switch (data[0]) {
+        case PEER_KILL_ID: {
+            Group_c *g = get_group_c(g_c, groupnumber);
+
+            if (!g)
+                return;
+
+            if (!g->close[close_index].closest) {
+                g->close[close_index].type = GROUPCHAT_CLOSE_NONE;
+                kill_friend_connection(g_c->fr_c, g->close[close_index].number);
+            }
+        }
+
+        break;
+
+        case PEER_QUERY_ID: {
+            Group_c *g = get_group_c(g_c, groupnumber);
+
+            if (!g)
+                return;
+
+            send_peers(g_c, groupnumber, g->close[close_index].number, g->close[close_index].group_number);
+        }
+
+        break;
+
+        case PEER_RESPONSE_ID: {
+            handle_send_peers(g_c, groupnumber, data + 1, length - 1);
+        }
+
+        break;
+
+        case PEER_TITLE_ID: {
+            settitle(g_c, groupnumber, -1, data + 1, length - 1);
+        }
+
+        break;
+    }
+}
+
+#define MIN_MESSAGE_PACKET_LEN (sizeof(uint16_t) * 2 + sizeof(uint32_t) + 1)
+
+/* Send message to all close except receiver (if receiver isn't -1)
+ * NOTE: this function appends the group chat number to the data passed to it.
+ *
+ * return number of messages sent.
+ */
+static unsigned int send_message_all_close(const Group_Chats *g_c, int groupnumber, const uint8_t *data,
+        uint16_t length, int receiver)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return 0;
+
+    uint16_t i, sent = 0;
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE)
+            continue;
+
+        if ((int)i == receiver)
+            continue;
+
+        if (send_packet_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_MESSAGE_GROUPCHAT, g->close[i].group_number, data,
+                                   length))
+            ++sent;
+    }
+
+    return sent;
+}
+
+/* Send lossy message to all close except receiver (if receiver isn't -1)
+ * NOTE: this function appends the group chat number to the data passed to it.
+ *
+ * return number of messages sent.
+ */
+static unsigned int send_lossy_all_close(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
+        int receiver)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return 0;
+
+    unsigned int i, sent = 0, num_connected_closest = 0, connected_closest[DESIRED_CLOSE_CONNECTIONS];
+
+    for (i = 0; i < MAX_GROUP_CONNECTIONS; ++i) {
+        if (g->close[i].type != GROUPCHAT_CLOSE_ONLINE)
+            continue;
+
+        if ((int)i == receiver)
+            continue;
+
+        if (g->close[i].closest) {
+            connected_closest[num_connected_closest] = i;
+            ++num_connected_closest;
+            continue;
+        }
+
+        if (send_lossy_group_peer(g_c->fr_c, g->close[i].number, PACKET_ID_LOSSY_GROUPCHAT, g->close[i].group_number, data,
+                                  length))
+            ++sent;
+    }
+
+    if (!num_connected_closest) {
+        return sent;
+    }
+
+    unsigned int to_send = 0;
+    uint64_t comp_val_old = ~0;
+
+    for (i = 0; i < num_connected_closest; ++i) {
+        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[connected_closest[i]].number);
+        uint64_t comp_val = calculate_comp_value(g->real_pk, real_pk);
+
+        if (comp_val < comp_val_old) {
+            to_send = connected_closest[i];
+            comp_val_old = comp_val;
+        }
+    }
+
+    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send].number, PACKET_ID_LOSSY_GROUPCHAT,
+                              g->close[to_send].group_number, data, length)) {
+        ++sent;
+    }
+
+    unsigned int to_send_other = 0;
+    comp_val_old = ~0;
+
+    for (i = 0; i < num_connected_closest; ++i) {
+        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t dht_temp_pk[crypto_box_PUBLICKEYBYTES];
+        get_friendcon_public_keys(real_pk, dht_temp_pk, g_c->fr_c, g->close[connected_closest[i]].number);
+        uint64_t comp_val = calculate_comp_value(real_pk, g->real_pk);
+
+        if (comp_val < comp_val_old) {
+            to_send_other = connected_closest[i];
+            comp_val_old = comp_val;
+        }
+    }
+
+    if (to_send_other == to_send) {
+        return sent;
+    }
+
+    if (send_lossy_group_peer(g_c->fr_c, g->close[to_send_other].number, PACKET_ID_LOSSY_GROUPCHAT,
+                              g->close[to_send_other].group_number, data, length)) {
+        ++sent;
+    }
+
+    return sent;
+}
+
+#define MAX_GROUP_MESSAGE_DATA_LEN (MAX_CRYPTO_DATA_SIZE - (1 + MIN_MESSAGE_PACKET_LEN))
+
+/* Send data of len with message_id to groupnumber.
+ *
+ * return number of peers it was sent to on success.
+ * return 0 on failure.
+ */
+static unsigned int send_message_group(const Group_Chats *g_c, int groupnumber, uint8_t message_id, const uint8_t *data,
+                                       uint16_t len)
+{
+    if (len > MAX_GROUP_MESSAGE_DATA_LEN)
+        return 0;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return 0;
+
+    if (g->status != GROUPCHAT_STATUS_CONNECTED)
+        return 0;
+
+    uint8_t packet[sizeof(uint16_t) + sizeof(uint32_t) + 1 + len];
+    uint16_t peer_num = htons(g->peer_number);
+    memcpy(packet, &peer_num, sizeof(peer_num));
+
+    ++g->message_number;
+
+    if (!g->message_number)
+        ++g->message_number;
+
+    uint32_t message_num = htonl(g->message_number);
+    memcpy(packet + sizeof(uint16_t), &message_num, sizeof(message_num));
+
+    packet[sizeof(uint16_t) + sizeof(uint32_t)] = message_id;
+
+    if (len)
+        memcpy(packet + sizeof(uint16_t) + sizeof(uint32_t) + 1, data, len);
+
+    return send_message_all_close(g_c, groupnumber, packet, sizeof(packet), -1);
+}
+
+/* send a group message
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_message_send(const Group_Chats *g_c, int groupnumber, const uint8_t *message, uint16_t length)
+{
+    if (send_message_group(g_c, groupnumber, PACKET_ID_MESSAGE, message, length)) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+/* send a group action
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_action_send(const Group_Chats *g_c, int groupnumber, const uint8_t *action, uint16_t length)
+{
+    if (send_message_group(g_c, groupnumber, PACKET_ID_ACTION, action, length)) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+/* High level function to send custom lossy packets.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int send_group_lossy_packet(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length)
+{
+    //TODO: length check here?
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint8_t packet[sizeof(uint16_t) * 2 + length];
+    uint16_t peer_number = htons(g->peer_number);
+    memcpy(packet, &peer_number, sizeof(uint16_t));
+    uint16_t message_num = htons(g->lossy_message_number);
+    memcpy(packet + sizeof(uint16_t), &message_num, sizeof(uint16_t));
+    memcpy(packet + sizeof(uint16_t) * 2, data, length);
+
+    if (send_lossy_all_close(g_c, groupnumber, packet, sizeof(packet), -1) == 0) {
+        return -1;
+    }
+
+    ++g->lossy_message_number;
+    return 0;
+}
+
+static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length,
+                                        int close_index)
+{
+    if (length < sizeof(uint16_t) + sizeof(uint32_t) + 1)
+        return;
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return;
+
+    uint16_t peer_number;
+    memcpy(&peer_number, data, sizeof(uint16_t));
+    peer_number = ntohs(peer_number);
+
+    int index = get_peer_index(g, peer_number);
+
+    if (index == -1) {
+        /* We don't know the peer this packet came from so we query the list of peers from that peer.
+          (They would not have relayed it if they didn't know the peer.) */
+        send_peer_query(g_c, g->close[close_index].number, g->close[close_index].group_number);
+        return;
+    }
+
+    uint32_t message_number;
+    memcpy(&message_number, data + sizeof(uint16_t), sizeof(message_number));
+    message_number = ntohl(message_number);
+
+    if (g->group[index].last_message_number == 0) {
+        g->group[index].last_message_number = message_number;
+    } else if (message_number - g->group[index].last_message_number > 64 ||
+               message_number == g->group[index].last_message_number) {
+        return;
+    }
+
+    g->group[index].last_message_number = message_number;
+
+    uint8_t message_id = data[sizeof(uint16_t) + sizeof(message_number)];
+    const uint8_t *msg_data = data + sizeof(uint16_t) + sizeof(message_number) + 1;
+    uint16_t msg_data_len = length - (sizeof(uint16_t) + sizeof(message_number) + 1);
+
+    switch (message_id) {
+        case GROUP_MESSAGE_PING_ID: {
+            if (msg_data_len != 0)
+                return;
+
+            g->group[index].last_recv = unix_time();
+        }
+        break;
+
+        case GROUP_MESSAGE_NEW_PEER_ID: {
+            if (msg_data_len != GROUP_MESSAGE_NEW_PEER_LENGTH)
+                return;
+
+            uint16_t new_peer_number;
+            memcpy(&new_peer_number, msg_data, sizeof(uint16_t));
+            new_peer_number = ntohs(new_peer_number);
+            addpeer(g_c, groupnumber, msg_data + sizeof(uint16_t), msg_data + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES,
+                    new_peer_number);
+        }
+        break;
+
+        case GROUP_MESSAGE_KILL_PEER_ID: {
+            if (msg_data_len != GROUP_MESSAGE_KILL_PEER_LENGTH)
+                return;
+
+            uint16_t kill_peer_number;
+            memcpy(&kill_peer_number, msg_data, sizeof(uint16_t));
+            kill_peer_number = ntohs(kill_peer_number);
+
+            if (peer_number == kill_peer_number) {
+                delpeer(g_c, groupnumber, index);
+            } else {
+                return;
+                //TODO
+            }
+        }
+        break;
+
+        case GROUP_MESSAGE_NAME_ID: {
+            if (setnick(g_c, groupnumber, index, msg_data, msg_data_len) == -1)
+                return;
+        }
+        break;
+
+        case GROUP_MESSAGE_TITLE_ID: {
+            if (settitle(g_c, groupnumber, index, msg_data, msg_data_len) == -1)
+                return;
+        }
+        break;
+
+        case PACKET_ID_MESSAGE: {
+            if (msg_data_len == 0)
+                return;
+
+            uint8_t newmsg[msg_data_len + 1];
+            memcpy(newmsg, msg_data, msg_data_len);
+            newmsg[msg_data_len] = 0;
+
+            //TODO
+            if (g_c->message_callback)
+                g_c->message_callback(g_c->m, groupnumber, index, newmsg, msg_data_len, g_c->message_callback_userdata);
+
+            break;
+        }
+
+        case PACKET_ID_ACTION: {
+            if (msg_data_len == 0)
+                return;
+
+            uint8_t newmsg[msg_data_len + 1];
+            memcpy(newmsg, msg_data, msg_data_len);
+            newmsg[msg_data_len] = 0;
+
+            //TODO
+            if (g_c->action_callback)
+                g_c->action_callback(g_c->m, groupnumber, index, newmsg, msg_data_len, g_c->action_callback_userdata);
+
+            break;
+        }
+
+        default:
+            return;
+    }
+
+    send_message_all_close(g_c, groupnumber, data, length, -1/*TODO close_index*/);
+}
+
+static int handle_packet(void *object, int friendcon_id, uint8_t *data, uint16_t length)
+{
+    Group_Chats *g_c = object;
+
+    if (length < 1 + sizeof(uint16_t) + 1)
+        return -1;
+
+    if (data[0] == PACKET_ID_ONLINE_PACKET) {
+        return handle_packet_online(g_c, friendcon_id, data + 1, length - 1);
+    }
+
+    if (data[0] != PACKET_ID_DIRECT_GROUPCHAT && data[0] != PACKET_ID_MESSAGE_GROUPCHAT)
+        return -1;
+
+    uint16_t groupnumber;
+    memcpy(&groupnumber, data + 1, sizeof(uint16_t));
+    groupnumber = ntohs(groupnumber);
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    int index = friend_in_close(g, friendcon_id);
+
+    if (index == -1)
+        return -1;
+
+    switch (data[0]) {
+        case PACKET_ID_DIRECT_GROUPCHAT: {
+            handle_direct_packet(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index);
+            break;
+        }
+
+        case PACKET_ID_MESSAGE_GROUPCHAT: {
+            handle_message_packet_group(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index);
+            break;
+        }
+
+        default: {
+            return 0;
+        }
+    }
+
+    return 0;
+}
+
+/* Did we already receive the lossy packet or not.
+ *
+ * return -1 on failure.
+ * return 0 if packet was not received.
+ * return 1 if packet was received.
+ *
+ * TODO: test this
+ */
+static unsigned int lossy_packet_not_received(Group_c *g, int peer_index, uint16_t message_number)
+{
+    if (peer_index == -1)
+        return -1;
+
+    if (g->group[peer_index].bottom_lossy_number == g->group[peer_index].top_lossy_number) {
+        g->group[peer_index].top_lossy_number = message_number;
+        g->group[peer_index].bottom_lossy_number = (message_number - MAX_LOSSY_COUNT) + 1;
+        g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
+        return 0;
+    }
+
+    if ((uint16_t)(message_number - g->group[peer_index].bottom_lossy_number) < MAX_LOSSY_COUNT) {
+        if (g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT]) {
+            return 1;
+        }
+
+        g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
+        return 0;
+    }
+
+    if ((uint16_t)(message_number - g->group[peer_index].bottom_lossy_number) > (1 << 15))
+        return -1;
+
+    uint16_t top_distance = message_number - g->group[peer_index].top_lossy_number;
+
+    if (top_distance >= MAX_LOSSY_COUNT) {
+        memset(g->group[peer_index].recv_lossy, 0, sizeof(g->group[peer_index].recv_lossy));
+        g->group[peer_index].top_lossy_number = message_number;
+        g->group[peer_index].bottom_lossy_number = (message_number - MAX_LOSSY_COUNT) + 1;
+        g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
+        return 0;
+    }
+
+    if (top_distance < MAX_LOSSY_COUNT) {
+        unsigned int i;
+
+        for (i = g->group[peer_index].bottom_lossy_number; i != (g->group[peer_index].bottom_lossy_number + top_distance);
+                ++i) {
+            g->group[peer_index].recv_lossy[i % MAX_LOSSY_COUNT] = 0;
+        }
+
+        g->group[peer_index].top_lossy_number = message_number;
+        g->group[peer_index].bottom_lossy_number = (message_number - MAX_LOSSY_COUNT) + 1;
+        g->group[peer_index].recv_lossy[message_number % MAX_LOSSY_COUNT] = 1;
+        return 0;
+    }
+
+    return -1;
+}
+
+static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length)
+{
+    Group_Chats *g_c = object;
+
+    if (length < 1 + sizeof(uint16_t) * 3 + 1)
+        return -1;
+
+    if (data[0] != PACKET_ID_LOSSY_GROUPCHAT)
+        return -1;
+
+    uint16_t groupnumber, peer_number, message_number;
+    memcpy(&groupnumber, data + 1, sizeof(uint16_t));
+    memcpy(&peer_number, data + 1 + sizeof(uint16_t), sizeof(uint16_t));
+    memcpy(&message_number, data + 1 + sizeof(uint16_t) * 2, sizeof(uint16_t));
+    groupnumber = ntohs(groupnumber);
+    peer_number = ntohs(peer_number);
+    message_number = ntohs(message_number);
+
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    int index = friend_in_close(g, friendcon_id);
+
+    if (index == -1)
+        return -1;
+
+    if (peer_number == g->peer_number)
+        return -1;
+
+    int peer_index = get_peer_index(g, peer_number);
+
+    if (peer_index == -1)
+        return -1;
+
+    if (lossy_packet_not_received(g, peer_index, message_number))
+        return -1;
+
+    const uint8_t *lossy_data = data + 1 + sizeof(uint16_t) * 3;
+    uint16_t lossy_length = length - (1 + sizeof(uint16_t) * 3);
+    uint8_t message_id = lossy_data[0];
+    ++lossy_data;
+    --lossy_length;
+
+    if (g_c->lossy_packethandlers[message_id].function) {
+        if (g_c->lossy_packethandlers[message_id].function(g->object, groupnumber, peer_index, g->group[peer_index].object,
+                lossy_data, lossy_length) == -1) {
+            return -1;
+        }
+    } else {
+        return -1;
+    }
+
+    send_lossy_all_close(g_c, groupnumber, data + 1 + sizeof(uint16_t), length - (1 + sizeof(uint16_t)), index);
+    return 0;
+}
+
+/* Set the object that is tied to the group chat.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int group_set_object(const Group_Chats *g_c, int groupnumber, void *object)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    g->object = object;
+    return 0;
+}
+
+/* Set the object that is tied to the group peer.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int group_peer_set_object(const Group_Chats *g_c, int groupnumber, int peernumber, void *object)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if ((uint32_t)peernumber >= g->numpeers)
+        return -1;
+
+    g->group[peernumber].object = object;
+    return 0;
+}
+
+/* Return the object tide to the group chat previously set by group_set_object.
+ *
+ * return NULL on failure.
+ * return object on success.
+ */
+void *group_get_object(const Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return NULL;
+
+    return g->object;
+}
+
+/* Return the object tide to the group chat peer previously set by group_peer_set_object.
+ *
+ * return NULL on failure.
+ * return object on success.
+ */
+void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return NULL;
+
+    if ((uint32_t)peernumber >= g->numpeers)
+        return NULL;
+
+    return g->group[peernumber].object;
+}
+
+/* Interval in seconds to send ping messages */
+#define GROUP_PING_INTERVAL 20
+
+static int ping_groupchat(Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    if (is_timeout(g->last_sent_ping, GROUP_PING_INTERVAL)) {
+        if (group_ping_send(g_c, groupnumber) != -1) /* Ping */
+            g->last_sent_ping = unix_time();
+    }
+
+    return 0;
+}
+
+static int groupchat_clear_timedout(Group_Chats *g_c, int groupnumber)
+{
+    Group_c *g = get_group_c(g_c, groupnumber);
+
+    if (!g)
+        return -1;
+
+    uint32_t i;
+
+    for (i = 0; i < g->numpeers; ++i) {
+        if (g->peer_number != g->group[i].peer_number && is_timeout(g->group[i].last_recv, GROUP_PING_INTERVAL * 3)) {
+            delpeer(g_c, groupnumber, i);
+        }
+
+        if (g->group == NULL || i >= g->numpeers)
+            break;
+    }
+
+    return 0;
+}
+
+/* Send current name (set in messenger) to all online groups.
+ */
+void send_name_all_groups(Group_Chats *g_c)
+{
+    unsigned int i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        Group_c *g = get_group_c(g_c, i);
+
+        if (!g)
+            continue;
+
+        if (g->status == GROUPCHAT_STATUS_CONNECTED) {
+            group_name_send(g_c, i, g_c->m->name, g_c->m->name_length);
+        }
+    }
+}
+
+/* Create new groupchat instance. */
+Group_Chats *new_groupchats(Messenger *m)
+{
+    if (!m)
+        return NULL;
+
+    Group_Chats *temp = calloc(1, sizeof(Group_Chats));
+
+    if (temp == NULL)
+        return NULL;
+
+    temp->m = m;
+    temp->fr_c = m->fr_c;
+    m->group_chat_object = temp;
+    m_callback_group_invite(m, &handle_friend_invite_packet);
+
+    return temp;
+}
+
+/* main groupchats loop. */
+void do_groupchats(Group_Chats *g_c)
+{
+    unsigned int i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        Group_c *g = get_group_c(g_c, i);
+
+        if (!g)
+            continue;
+
+        if (g->status == GROUPCHAT_STATUS_CONNECTED) {
+            connect_to_closest(g_c, i);
+            ping_groupchat(g_c, i);
+            groupchat_clear_timedout(g_c, i);
+        }
+    }
+
+    //TODO
+}
+
+/* Free everything related with group chats. */
+void kill_groupchats(Group_Chats *g_c)
+{
+    unsigned int i;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        del_groupchat(g_c, i);
+    }
+
+    m_callback_group_invite(g_c->m, NULL);
+    g_c->m->group_chat_object = 0;
+    free(g_c);
+}
+
+/* Return the number of chats in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_chatlist.
+ */
+uint32_t count_chatlist(Group_Chats *g_c)
+{
+    uint32_t ret = 0;
+    uint32_t i;
+
+    for (i = 0; i < g_c->num_chats; i++) {
+        if (g_c->chats[i].status != GROUPCHAT_STATUS_NONE) {
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
+/* Copy a list of valid chat IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t copy_chatlist(Group_Chats *g_c, int32_t *out_list, uint32_t list_size)
+{
+    if (!out_list) {
+        return 0;
+    }
+
+    if (g_c->num_chats == 0) {
+        return 0;
+    }
+
+    uint32_t i, ret = 0;
+
+    for (i = 0; i < g_c->num_chats; ++i) {
+        if (ret >= list_size) {
+            break;  /* Abandon ship */
+        }
+
+        if (g_c->chats[i].status > GROUPCHAT_STATUS_NONE) {
+            out_list[ret] = i;
+            ret++;
+        }
+    }
+
+    return ret;
+}
diff --git a/toxcore/group.h b/toxcore/group.h
new file mode 100644
index 00000000..8ae0e40e
--- /dev/null
+++ b/toxcore/group.h
@@ -0,0 +1,380 @@
+/* group.h
+ *
+ * Slightly better groupchats implementation.
+ *
+ *  Copyright (C) 2014 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef GROUP_H
+#define GROUP_H
+
+#include "Messenger.h"
+
+enum {
+    GROUPCHAT_STATUS_NONE,
+    GROUPCHAT_STATUS_VALID,
+    GROUPCHAT_STATUS_CONNECTED
+};
+
+enum {
+    GROUPCHAT_TYPE_TEXT,
+    GROUPCHAT_TYPE_AV
+};
+
+#define MAX_LOSSY_COUNT 256
+
+typedef struct {
+    uint8_t     real_pk[crypto_box_PUBLICKEYBYTES];
+    uint8_t     temp_pk[crypto_box_PUBLICKEYBYTES];
+
+    uint64_t    last_recv;
+    uint32_t    last_message_number;
+
+    uint8_t     nick[MAX_NAME_LENGTH];
+    uint8_t     nick_len;
+
+    uint16_t peer_number;
+
+    uint8_t  recv_lossy[MAX_LOSSY_COUNT];
+    uint16_t bottom_lossy_number, top_lossy_number;
+
+    void *object;
+} Group_Peer;
+
+#define DESIRED_CLOSE_CONNECTIONS 4
+#define MAX_GROUP_CONNECTIONS 16
+#define GROUP_IDENTIFIER_LENGTH (1 + crypto_box_KEYBYTES) /* type + crypto_box_KEYBYTES so we can use new_symmetric_key(...) to fill it */
+
+enum {
+    GROUPCHAT_CLOSE_NONE,
+    GROUPCHAT_CLOSE_CONNECTION,
+    GROUPCHAT_CLOSE_ONLINE
+};
+
+typedef struct {
+    uint8_t status;
+
+    Group_Peer *group;
+    uint32_t numpeers;
+
+    struct {
+        uint8_t type; /* GROUPCHAT_CLOSE_* */
+        uint8_t closest;
+        uint32_t number;
+        uint16_t group_number;
+    } close[MAX_GROUP_CONNECTIONS];
+
+    uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+    struct {
+        uint8_t entry;
+        uint8_t real_pk[crypto_box_PUBLICKEYBYTES];
+        uint8_t temp_pk[crypto_box_PUBLICKEYBYTES];
+    } closest_peers[DESIRED_CLOSE_CONNECTIONS];
+    uint8_t changed;
+
+    uint8_t identifier[GROUP_IDENTIFIER_LENGTH];
+
+    uint8_t title[MAX_NAME_LENGTH];
+    uint8_t title_len;
+
+    uint32_t message_number;
+    uint16_t lossy_message_number;
+    uint16_t peer_number;
+
+    uint64_t last_sent_ping;
+
+    int number_joined; /* friendcon_id of person that invited us to the chat. (-1 means none) */
+
+    void *object;
+
+    void (*peer_on_join)(void *, int, int);
+    void (*peer_on_leave)(void *, int, int, void *);
+    void (*group_on_delete)(void *, int);
+} Group_c;
+
+typedef struct {
+    Messenger *m;
+    Friend_Connections *fr_c;
+
+    Group_c *chats;
+    uint32_t num_chats;
+
+    void (*invite_callback)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t, void *);
+    void *invite_callback_userdata;
+    void (*message_callback)(Messenger *m, int, int, const uint8_t *, uint16_t, void *);
+    void *message_callback_userdata;
+    void (*action_callback)(Messenger *m, int, int, const uint8_t *, uint16_t, void *);
+    void *action_callback_userdata;
+    void (*peer_namelistchange)(Messenger *m, int, int, uint8_t, void *);
+    void *group_namelistchange_userdata;
+    void (*title_callback)(Messenger *m, int, int, const uint8_t *, uint8_t, void *);
+    void *title_callback_userdata;
+
+    struct {
+        int (*function)(void *, int, int, void *, const uint8_t *, uint16_t);
+    } lossy_packethandlers[256];
+} Group_Chats;
+
+/* Set the callback for group invites.
+ *
+ *  Function(Group_Chats *g_c, int32_t friendnumber, uint8_t type, uint8_t *data, uint16_t length, void *userdata)
+ *
+ *  data of length is what needs to be passed to join_groupchat().
+ */
+void g_callback_group_invite(Group_Chats *g_c, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *,
+                             uint16_t, void *), void *userdata);
+
+/* Set the callback for group messages.
+ *
+ *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ */
+void g_callback_group_message(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
+                              void *), void *userdata);
+
+/* Set the callback for group actions.
+ *
+ *  Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ */
+void g_callback_group_action(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t,
+                             void *), void *userdata);
+
+/* Set callback function for title changes.
+ *
+ * Function(Group_Chats *g_c, int groupnumber, int friendgroupnumber, uint8_t * title, uint8_t length, void *userdata)
+ * if friendgroupnumber == -1, then author is unknown (e.g. initial joining the group)
+ */
+void g_callback_group_title(Group_Chats *g_c, void (*function)(Messenger *m, int, int, const uint8_t *, uint8_t,
+                            void *), void *userdata);
+
+/* Set callback function for peer name list changes.
+ *
+ * It gets called every time the name list changes(new peer/name, deleted peer)
+ *  Function(Group_Chats *g_c, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
+ */
+enum {
+    CHAT_CHANGE_PEER_ADD,
+    CHAT_CHANGE_PEER_DEL,
+    CHAT_CHANGE_PEER_NAME,
+};
+void g_callback_group_namelistchange(Group_Chats *g_c, void (*function)(Messenger *m, int, int, uint8_t, void *),
+                                     void *userdata);
+
+/* Creates a new groupchat and puts it in the chats array.
+ *
+ * type is one of GROUPCHAT_TYPE_*
+ *
+ * return group number on success.
+ * return -1 on failure.
+ */
+int add_groupchat(Group_Chats *g_c, uint8_t type);
+
+/* Delete a groupchat from the chats array.
+ *
+ * return 0 on success.
+ * return -1 if failure.
+ */
+int del_groupchat(Group_Chats *g_c, int groupnumber);
+
+/* Copy the public key of peernumber who is in groupnumber to pk.
+ * pk must be crypto_box_PUBLICKEYBYTES long.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int group_peer_pubkey(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *pk);
+
+/* Copy the name of peernumber who is in groupnumber to name.
+ * name must be at least MAX_NAME_LENGTH long.
+ *
+ * return length of name if success
+ * return -1 if failure
+ */
+int group_peername(const Group_Chats *g_c, int groupnumber, int peernumber, uint8_t *name);
+
+/* invite friendnumber to groupnumber
+ * return 0 on success
+ * return -1 on failure
+ */
+int invite_friend(Group_Chats *g_c, int32_t friendnumber, int groupnumber);
+
+/* Join a group (you need to have been invited first.)
+ *
+ * expected_type is the groupchat type we expect the chat we are joining is.
+ *
+ * returns group number on success
+ * returns -1 on failure.
+ */
+int join_groupchat(Group_Chats *g_c, int32_t friendnumber, uint8_t expected_type, const uint8_t *data, uint16_t length);
+
+/* send a group message
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_message_send(const Group_Chats *g_c, int groupnumber, const uint8_t *message, uint16_t length);
+
+/* send a group action
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_action_send(const Group_Chats *g_c, int groupnumber, const uint8_t *action, uint16_t length);
+
+/* set the group's title, limited to MAX_NAME_LENGTH
+ * return 0 on success
+ * return -1 on failure
+ */
+int group_title_send(const Group_Chats *g_c, int groupnumber, const uint8_t *title, uint8_t title_len);
+
+
+/* Get group title from groupnumber and put it in title.
+ * title needs to be a valid memory location with a max_length size of at least MAX_NAME_LENGTH (128) bytes.
+ *
+ *  return length of copied title if success.
+ *  return -1 if failure.
+ */
+int group_title_get(const Group_Chats *g_c, int groupnumber, uint8_t *title, uint32_t max_length);
+
+/* Return the number of peers in the group chat on success.
+ * return -1 on failure
+ */
+int group_number_peers(const Group_Chats *g_c, int groupnumber);
+
+/* return 1 if the peernumber corresponds to ours.
+ * return 0 on failure.
+ */
+unsigned int group_peernumber_is_ours(const Group_Chats *g_c, int groupnumber, int peernumber);
+
+/* List all the peers in the group chat.
+ *
+ * Copies the names of the peers to the name[length][MAX_NAME_LENGTH] array.
+ *
+ * Copies the lengths of the names to lengths[length]
+ *
+ * returns the number of peers on success.
+ *
+ * return -1 on failure.
+ */
+int group_names(const Group_Chats *g_c, int groupnumber, uint8_t names[][MAX_NAME_LENGTH], uint16_t lengths[],
+                uint16_t length);
+
+/* Set handlers for custom lossy packets.
+ *
+ * NOTE: Handler must return 0 if packet is to be relayed, -1 if the packet should not be relayed.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object), const uint8_t *packet, uint16_t length)
+ */
+void group_lossy_packet_registerhandler(Group_Chats *g_c, uint8_t byte, int (*function)(void *, int, int, void *,
+                                        const uint8_t *, uint16_t));
+
+/* High level function to send custom lossy packets.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int send_group_lossy_packet(const Group_Chats *g_c, int groupnumber, const uint8_t *data, uint16_t length);
+
+/* Return the number of chats in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_chatlist.
+ */
+uint32_t count_chatlist(Group_Chats *g_c);
+
+/* Copy a list of valid chat IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t copy_chatlist(Group_Chats *g_c, int32_t *out_list, uint32_t list_size);
+
+/* return the type of groupchat (GROUPCHAT_TYPE_) that groupnumber is.
+ *
+ * return -1 on failure.
+ * return type on success.
+ */
+int group_get_type(const Group_Chats *g_c, int groupnumber);
+
+/* Send current name (set in messenger) to all online groups.
+ */
+void send_name_all_groups(Group_Chats *g_c);
+
+/* Set the object that is tied to the group chat.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int group_set_object(const Group_Chats *g_c, int groupnumber, void *object);
+
+/* Set the object that is tied to the group peer.
+ *
+ * return 0 on success.
+ * return -1 on failure
+ */
+int group_peer_set_object(const Group_Chats *g_c, int groupnumber, int peernumber, void *object);
+
+/* Return the object tide to the group chat previously set by group_set_object.
+ *
+ * return NULL on failure.
+ * return object on success.
+ */
+void *group_get_object(const Group_Chats *g_c, int groupnumber);
+
+/* Return the object tide to the group chat peer previously set by group_peer_set_object.
+ *
+ * return NULL on failure.
+ * return object on success.
+ */
+void *group_peer_get_object(const Group_Chats *g_c, int groupnumber, int peernumber);
+
+/* Set a function to be called when a new peer joins a group chat.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber)
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_peer_new(const Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int));
+
+/* Set a function to be called when a peer leaves a group chat.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber, int friendgroupnumber, void *group peer object (set with group_peer_set_object))
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_peer_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int, int, void *));
+
+/* Set a function to be called when the group chat is deleted.
+ *
+ * Function(void *group object (set with group_set_object), int groupnumber)
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int callback_groupchat_delete(Group_Chats *g_c, int groupnumber, void (*function)(void *, int));
+
+/* Create new groupchat instance. */
+Group_Chats *new_groupchats(Messenger *m);
+
+/* main groupchats loop. */
+void do_groupchats(Group_Chats *g_c);
+
+/* Free everything related with group chats. */
+void kill_groupchats(Group_Chats *g_c);
+
+#endif
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
deleted file mode 100644
index 77fa6acd..00000000
--- a/toxcore/group_chats.c
+++ /dev/null
@@ -1,837 +0,0 @@
-/* group_chats.c
- *
- * An implementation of massive text only group chats.
- *
- *
- *  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
-
-#include "DHT.h"
-#include "assoc.h"
-#include "group_chats.h"
-#include "LAN_discovery.h"
-#include "util.h"
-
-#define GROUPCHAT_MAXDATA_LENGTH (MAX_CRYPTO_REQUEST_SIZE - (1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES))
-#define GROUPCHAT_MAXPLAINDATA_LENGTH (GROUPCHAT_MAXDATA_LENGTH - crypto_box_MACBYTES)
-
-#define GROUP_MAX_SENDNODES (GROUP_CLOSE_CONNECTIONS * 2)
-
-typedef struct {
-    uint64_t   pingid;
-    //uint8_t    client_id[crypto_box_PUBLICKEYBYTES];
-
-} getnodes_data;
-
-typedef struct {
-    uint8_t    client_id[crypto_box_PUBLICKEYBYTES];
-    IP_Port    ip_port;
-
-} groupchat_nodes;
-
-typedef struct {
-    uint64_t   pingid;
-    groupchat_nodes nodes[GROUP_CLOSE_CONNECTIONS];
-    //uint8_t    client_id[crypto_box_PUBLICKEYBYTES];
-
-} sendnodes_data;
-
-/*
- * check if peer with client_id is in peer array.
- *
- * return peer number if peer is in chat.
- * return -1 if peer is not in chat.
- *
- * TODO: make this more efficient.
- */
-
-static int peer_in_chat(const Group_Chat *chat, const uint8_t *client_id)
-{
-    uint32_t i;
-
-    for (i = 0; i < chat->numpeers; ++i)
-        if (id_equal(chat->group[i].client_id, client_id))
-            return i;
-
-    return -1;
-}
-
-/* Compares client_id1 and client_id2 with client_id.
- *
- *  return 0 if both are same distance.
- *  return 1 if client_id1 is closer.
- *  return 2 if client_id2 is closer.
- */
-static int id_closest_groupchats(const uint8_t *id, const uint8_t *id1, const uint8_t *id2)
-{
-    size_t   i;
-    uint8_t distance1, distance2;
-
-    for (i = 0; i < CLIENT_ID_SIZE; ++i) {
-
-        distance1 = abs(((int8_t *)id)[i] - ((int8_t *)id1)[i]);
-        distance2 = abs(((int8_t *)id)[i] - ((int8_t *)id2)[i]);
-
-        if (distance1 < distance2)
-            return 1;
-
-        if (distance1 > distance2)
-            return 2;
-    }
-
-    return 0;
-}
-
-#define BAD_GROUPNODE_TIMEOUT 30
-
-/*
- * Check if peer is closer to us that the other peers in the list and if the peer is in the list.
- * Return the number of peers it is closer to if it is not in the closelist.
- * Return -1 if the peer is in the closelist.
- */
-
-static int peer_okping(const Group_Chat *chat, const uint8_t *client_id)
-{
-    uint32_t i, j = 0;
-
-    if (id_equal(chat->self_public_key, client_id))
-        return -1;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) {
-        if (is_timeout(chat->close[i].last_recv, BAD_GROUPNODE_TIMEOUT)) {
-            ++j;
-            continue;
-        }
-
-        /* Equal */
-        if (id_equal(chat->close[i].client_id, client_id))
-            return -1;
-
-        if (id_closest_groupchats(chat->self_public_key, chat->close[i].client_id, client_id) == 2)
-            ++j;
-    }
-
-    return j;
-}
-
-
-
-/* Attempt to add a peer to the close list.
- * Update last_recv if it is in list.
- * Attempt to add it to list if it is not.
- *
- * Return 0 if success.
- * Return -1 if peer was not put in list/updated.
- */
-static int add_closepeer(Group_Chat *chat, const uint8_t *client_id, IP_Port ip_port)
-{
-    uint32_t i;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) { /* Check if node is already in list, if it is update its last_recv */
-        if (id_equal(chat->close[i].client_id, client_id)) {
-            chat->close[i].last_recv = unix_time();
-            return 0;
-        }
-    }
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) { /* Try replacing bad nodes first */
-        if (is_timeout(chat->close[i].last_recv, BAD_GROUPNODE_TIMEOUT)) {
-            id_copy(chat->close[i].client_id, client_id);
-            chat->close[i].ip_port = ip_port;
-            chat->close[i].last_recv = unix_time();
-            return 0;
-        }
-    }
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) { /* Replace nodes if given one is closer. */
-        if (id_closest_groupchats(chat->self_public_key, chat->close[i].client_id, client_id) == 2) {
-            id_copy(chat->close[i].client_id, client_id);
-            chat->close[i].ip_port = ip_port;
-            chat->close[i].last_recv = unix_time();
-            return 0;
-        }
-    }
-
-    return -1;
-}
-
-static int send_groupchatpacket(const Group_Chat *chat, IP_Port ip_port, const uint8_t *public_key, const uint8_t *data,
-                                uint32_t length, uint8_t request_id)
-{
-    if (id_equal(chat->self_public_key, public_key))
-        return -1;
-
-    uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
-    int len = create_request(chat->self_public_key, chat->self_secret_key, packet, public_key, data, length, request_id);
-    packet[0] = NET_PACKET_GROUP_CHATS;
-
-    if (len == -1)
-        return -1;
-
-    if (sendpacket(chat->net, ip_port, packet, len) == len)
-        return 0;
-
-    return -1;
-
-}
-
-/*
- * Send data to all peers in close peer list.
- *
- * return the number of peers the packet was sent to.
- */
-static uint8_t sendto_allpeers(const Group_Chat *chat, const uint8_t *data, uint16_t length, uint8_t request_id)
-{
-    uint16_t sent = 0;
-    uint32_t i;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) {
-        if (ip_isset(&chat->close[i].ip_port.ip) &&
-                !is_timeout(chat->close[i].last_recv, BAD_GROUPNODE_TIMEOUT)) {
-            if (send_groupchatpacket(chat, chat->close[i].ip_port, chat->close[i].client_id,
-                                     data, length, request_id) == 0)
-                ++sent;
-        }
-    }
-
-    return sent;
-}
-
-
-/*
- * Add a peer to the group chat.
- *
- * return peernum if success or peer already in chat.
- * return -1 if error.
- */
-static int addpeer(Group_Chat *chat, const uint8_t *client_id)
-{
-    int peernum = peer_in_chat(chat, client_id);
-
-    if (peernum != -1)
-        return peernum;
-
-    Group_Peer *temp;
-    temp = realloc(chat->group, sizeof(Group_Peer) * (chat->numpeers + 1));
-
-    if (temp == NULL)
-        return -1;
-
-    memset(&(temp[chat->numpeers]), 0, sizeof(Group_Peer));
-    chat->group = temp;
-
-    id_copy(chat->group[chat->numpeers].client_id, client_id);
-    chat->group[chat->numpeers].last_recv = unix_time();
-    chat->group[chat->numpeers].last_recv_msgping = unix_time();
-    ++chat->numpeers;
-
-    if (chat->peer_namelistchange != NULL)
-        (*chat->peer_namelistchange)(chat, chat->numpeers - 1, CHAT_CHANGE_PEER_ADD, chat->group_namelistchange_userdata);
-
-    return (chat->numpeers - 1);
-}
-
-/*
- * Set a peer from the group chat to deleted.
- *
- * return 0 if success
- * return -1 if error.
- */
-static int del_peer_set(Group_Chat *chat, int peernum)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return -1;
-
-    chat->group[peernum].deleted = 1;
-    chat->group[peernum].deleted_time = unix_time();
-    return 0;
-}
-
-/*
- * Delete a peer from the group chat.
- *
- * return 0 if success
- * return -1 if error.
- */
-static int delpeer(Group_Chat *chat, int peernum)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return -1;
-
-    uint32_t i;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) { /* If peer is in close list, time it out forcefully. */
-        if (id_equal(chat->close[i].client_id, chat->group[peernum].client_id)) {
-            chat->close[i].last_recv = 0;
-            break;
-        }
-    }
-
-    Group_Peer *temp;
-    --chat->numpeers;
-
-    if (chat->numpeers == 0) {
-        free(chat->group);
-        chat->group = NULL;
-        return 0;
-    }
-
-    if (chat->numpeers != (uint32_t)peernum)
-        memcpy(&chat->group[peernum], &chat->group[chat->numpeers], sizeof(Group_Peer));
-
-    temp = realloc(chat->group, sizeof(Group_Peer) * (chat->numpeers));
-
-    if (temp == NULL)
-        return -1;
-
-    chat->group = temp;
-
-    if (chat->peer_namelistchange != NULL) {
-        (*chat->peer_namelistchange)(chat, peernum, CHAT_CHANGE_PEER_DEL, chat->group_namelistchange_userdata);
-    }
-
-    return 0;
-}
-
-/* Copy the name of peernum to name.
- * name must be at least MAX_NICK_BYTES long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int group_peername(const Group_Chat *chat, int peernum, uint8_t *name)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return -1;
-
-    if (chat->group[peernum].nick_len == 0) {
-        /* memcpy(name, "NSA agent", 10); */ /* Srsly? */ /* Kindly remind the user that someone with no name might be a moronic NSA agent.*/
-        name[0] = 0;
-        return 0;
-    }
-
-    memcpy(name, chat->group[peernum].nick, chat->group[peernum].nick_len);
-    return chat->group[peernum].nick_len;
-}
-
-static void setnick(Group_Chat *chat, int peernum, const uint8_t *contents, uint16_t contents_len)
-{
-    if (contents_len > MAX_NICK_BYTES || contents_len == 0)
-        return;
-
-    /* same name as already stored? */
-    if (chat->group[peernum].nick_len == contents_len)
-        if (!memcmp(chat->group[peernum].nick, contents, contents_len))
-            return;
-
-    memcpy(chat->group[peernum].nick, contents, contents_len);
-    chat->group[peernum].nick_len = contents_len;
-
-    if (chat->peer_namelistchange != NULL)
-        (*chat->peer_namelistchange)(chat, peernum, CHAT_CHANGE_PEER_NAME, chat->group_namelistchange_userdata);
-}
-
-/* min time between pings sent to one peer in seconds */
-/* TODO: move this to global section */
-#define GROUP_PING_TIMEOUT 5
-
-static int send_getnodes(const Group_Chat *chat, IP_Port ip_port, int peernum)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return -1;
-
-    if (!is_timeout(chat->group[peernum].last_pinged, GROUP_PING_TIMEOUT))
-        return -1;
-
-    getnodes_data contents;
-    contents.pingid = random_64b();
-
-    chat->group[peernum].last_pinged = unix_time();
-    chat->group[peernum].pingid = contents.pingid;
-    chat->group[peernum].ping_via = ip_port;
-
-    if (chat->assoc) {
-        IPPTs ippts;
-        ippts.timestamp = unix_time();
-        ippts.ip_port = ip_port;
-
-        Assoc_add_entry(chat->assoc, chat->group[peernum].client_id, &ippts, NULL, 1);
-    }
-
-    return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents, sizeof(contents),
-                                CRYPTO_PACKET_GROUP_CHAT_GET_NODES);
-}
-
-static int send_sendnodes(const Group_Chat *chat, IP_Port ip_port, int peernum, uint64_t pingid)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return -1;
-
-    sendnodes_data contents;
-    contents.pingid = pingid;
-    uint32_t i, j = 0;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) {
-        if (!is_timeout(chat->close[i].last_recv, BAD_GROUPNODE_TIMEOUT)) {
-            id_copy(contents.nodes[j].client_id, chat->close[i].client_id);
-            contents.nodes[j].ip_port = chat->close[i].ip_port;
-            to_net_family(&contents.nodes[j].ip_port.ip);
-            ++j;
-        }
-    }
-
-    return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents,
-                                sizeof(contents.pingid) + sizeof(groupchat_nodes) * j, CRYPTO_PACKET_GROUP_CHAT_SEND_NODES);
-}
-
-static int handle_getnodes(const Group_Chat *chat, IP_Port source, int peernum, const uint8_t *data, uint32_t len)
-{
-    if (len != sizeof(getnodes_data))
-        return 1;
-
-    if ((uint32_t)peernum >= chat->numpeers)
-        return 1;
-
-    getnodes_data contents;
-    memcpy(&contents, data, sizeof(contents));
-    send_sendnodes(chat, source, peernum, contents.pingid);
-
-    if (peer_okping(chat, chat->group[peernum].client_id) > 0)
-        send_getnodes(chat, source, peernum);
-
-    return 0;
-}
-
-static int handle_sendnodes(Group_Chat *chat, IP_Port source, int peernum, const uint8_t *data, uint32_t len)
-{
-    if ((uint32_t)peernum >= chat->numpeers)
-        return 1;
-
-    if (len > sizeof(sendnodes_data) || len < sizeof(uint64_t))
-        return 1;
-
-    if ((len - sizeof(uint64_t)) % sizeof(groupchat_nodes) != 0)
-        return 1;
-
-    if (is_timeout(chat->group[peernum].last_pinged, GROUP_PING_TIMEOUT))
-        return 1;
-
-    sendnodes_data contents;
-    memcpy(&contents, data, len);
-
-    if (contents.pingid != chat->group[peernum].pingid)
-        return 1;
-
-    uint16_t numnodes = (len - sizeof(contents.pingid)) / sizeof(groupchat_nodes);
-    uint32_t i;
-
-    IPPTs ippts_send;
-    ippts_send.timestamp = unix_time();
-
-    for (i = 0; i < numnodes; ++i) {
-        if (peer_okping(chat, contents.nodes[i].client_id) > 0) {
-            int peern = peer_in_chat(chat, contents.nodes[i].client_id);
-
-            if (peern == -1) { /*NOTE: This is just for testing and will be removed later.*/
-                peern = addpeer(chat, contents.nodes[i].client_id);
-            }
-
-            if (peern == -1)
-                continue;
-
-            to_host_family(&contents.nodes[i].ip_port.ip);
-            send_getnodes(chat, contents.nodes[i].ip_port, peern);
-
-            if (chat->assoc) {
-                ippts_send.ip_port = contents.nodes[i].ip_port;
-                Assoc_add_entry(chat->assoc, contents.nodes[i].client_id, &ippts_send, NULL, 0);
-            }
-        }
-    }
-
-    int ok = add_closepeer(chat, chat->group[peernum].client_id, source);
-
-    return 0;
-}
-
-#define GROUP_DATA_MIN_SIZE (crypto_box_PUBLICKEYBYTES + sizeof(uint32_t) + 1)
-static void send_names_new_peer(Group_Chat *chat);
-
-static int handle_data(Group_Chat *chat, const uint8_t *data, uint32_t len)
-{
-    if (len < GROUP_DATA_MIN_SIZE)
-        return 1;
-
-//TODO:
-    int peernum = peer_in_chat(chat, data);
-
-    if (peernum == -1) { /*NOTE: This is just for testing and will be removed later.*/
-        if (data[crypto_box_PUBLICKEYBYTES + sizeof(uint32_t)] != GROUP_CHAT_QUIT)
-            peernum = addpeer(chat, data);
-    }
-
-    if (peernum == -1)
-        return 1;
-
-    if (chat->group[peernum].deleted)
-        return 1;
-
-    /* Spam prevention (1 message per peer per second limit.)
-
-        if (chat->group[peernum].last_recv == temp_time)
-            return 1;
-    */
-    chat->group[peernum].last_recv = unix_time();
-
-    uint32_t message_num;
-    memcpy(&message_num, data + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
-    message_num = ntohl(message_num);
-
-    if (chat->group[peernum].last_message_number == 0) {
-        chat->group[peernum].last_message_number = message_num;
-    } else if (message_num - chat->group[peernum].last_message_number > 64 ||
-               message_num == chat->group[peernum].last_message_number)
-        return 1;
-
-    chat->group[peernum].last_message_number = message_num;
-
-    int handled = 1;
-    const uint8_t *contents = data + GROUP_DATA_MIN_SIZE;
-    uint16_t contents_len = len - GROUP_DATA_MIN_SIZE;
-
-    switch (data[crypto_box_PUBLICKEYBYTES + sizeof(message_num)]) {
-        case GROUP_CHAT_PING: /* If message is ping */
-            if (contents_len != 0)
-                return 1;
-
-            chat->group[peernum].last_recv_msgping = unix_time();
-            break;
-
-        case GROUP_CHAT_NEW_PEER: /* If message is new peer */
-            if (contents_len != crypto_box_PUBLICKEYBYTES)
-                return 1;
-
-            addpeer(chat, contents);
-            send_names_new_peer(chat);
-            break;
-
-        case GROUP_CHAT_QUIT: /* If peer tells us he is quitting */
-            if (contents_len != 0)
-                return 1;
-
-            del_peer_set(chat, peernum);
-            break;
-
-        case GROUP_CHAT_PEER_NICK:
-            if (contents_len > MAX_NICK_BYTES || contents_len == 0)
-                return 1;
-
-            setnick(chat, peernum, contents, contents_len);
-            break;
-
-        case GROUP_CHAT_CHAT_MESSAGE: /* If message is chat message */
-            if (chat->group_message != NULL)
-                (*chat->group_message)(chat, peernum, contents, contents_len, chat->group_message_userdata);
-
-            break;
-
-        case GROUP_CHAT_ACTION: /* if message is a peer action */
-            if (chat->group_action != NULL)
-                (*chat->group_action)(chat, peernum, contents, contents_len, chat->group_action_userdata);
-
-            break;
-
-        default:
-            handled = 0;
-            break;
-
-    }
-
-    if (handled == 1) {
-        sendto_allpeers(chat, data, len, CRYPTO_PACKET_GROUP_CHAT_BROADCAST);
-        return 0;
-    }
-
-    return 1;
-}
-
-static uint8_t send_data(Group_Chat *chat, const uint8_t *data, uint32_t len, uint8_t message_id)
-{
-    if (len + GROUP_DATA_MIN_SIZE > MAX_CRYPTO_REQUEST_SIZE) /*NOTE: not the real maximum len.*/
-        return 1;
-
-    uint8_t packet[MAX_CRYPTO_REQUEST_SIZE];
-    ++chat->message_number;
-
-    if (chat->message_number == 0)
-        chat->message_number = 1;
-
-    uint32_t message_num = htonl(chat->message_number);
-//TODO
-    id_copy(packet, chat->self_public_key);
-    memcpy(packet + crypto_box_PUBLICKEYBYTES, &message_num, sizeof(message_num));
-
-    if (len != 0)
-        memcpy(packet + GROUP_DATA_MIN_SIZE, data, len);
-
-    packet[crypto_box_PUBLICKEYBYTES + sizeof(message_num)] = message_id;
-    return sendto_allpeers(chat, packet, len + GROUP_DATA_MIN_SIZE, CRYPTO_PACKET_GROUP_CHAT_BROADCAST);
-}
-/*
- * Handle get nodes group packet.
- *
- * return 0 if handled correctly.
- * return 1 if error.
- */
-
-int handle_groupchatpacket(Group_Chat *chat, IP_Port source, const uint8_t *packet, uint32_t length)
-{
-    if (length > MAX_CRYPTO_REQUEST_SIZE)
-        return 1;
-
-    uint8_t public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t data[MAX_CRYPTO_REQUEST_SIZE];
-    uint8_t number;
-    int len = handle_request(chat->self_public_key, chat->self_secret_key, public_key, data, &number, packet, length);
-
-    if (len <= 0)
-        return 1;
-
-    if (id_equal(chat->self_public_key, public_key))
-        return 1;
-
-    int peernum = peer_in_chat(chat, public_key);
-
-    if (peernum == -1)
-        return 1;
-
-    switch (number) {
-        case CRYPTO_PACKET_GROUP_CHAT_GET_NODES:
-            return handle_getnodes(chat, source, peernum, data, len);
-
-        case CRYPTO_PACKET_GROUP_CHAT_SEND_NODES:
-            return handle_sendnodes(chat, source, peernum, data, len);
-
-        case CRYPTO_PACKET_GROUP_CHAT_BROADCAST:
-            return handle_data(chat, data, len);
-
-        default:
-            return 1;
-    }
-
-    return 1;
-}
-
-uint32_t group_sendmessage(Group_Chat *chat, const uint8_t *message, uint32_t length)
-{
-    return send_data(chat, message, length, GROUP_CHAT_CHAT_MESSAGE); //TODO: better return values?
-}
-
-uint32_t group_sendaction(Group_Chat *chat, const uint8_t *action, uint32_t length)
-{
-    return send_data(chat, action, length, GROUP_CHAT_ACTION);
-}
-
-/*
- * Send id/nick combo to the group.
- *
- * returns the number of peers it has sent it to.
- */
-static uint32_t group_send_nick(Group_Chat *chat, uint8_t *nick, uint16_t nick_len)
-{
-    if (nick_len > MAX_NICK_BYTES)
-        return 0;
-
-    return send_data(chat, nick, nick_len, GROUP_CHAT_PEER_NICK);
-}
-
-int set_nick(Group_Chat *chat, const uint8_t *nick, uint16_t nick_len)
-{
-    if (nick_len > MAX_NICK_BYTES || nick_len == 0)
-        return -1;
-
-    memcpy(chat->nick, nick, nick_len);
-    chat->nick_len = nick_len;
-    group_send_nick(chat, chat->nick, chat->nick_len);
-    return 0;
-}
-
-uint32_t group_newpeer(Group_Chat *chat, const uint8_t *client_id)
-{
-    addpeer(chat, client_id);
-    return send_data(chat, client_id, crypto_box_PUBLICKEYBYTES, GROUP_CHAT_NEW_PEER); //TODO: better return values?
-}
-
-void callback_groupmessage(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
-                           void *userdata)
-{
-    chat->group_message = function;
-    chat->group_message_userdata = userdata;
-}
-
-void callback_groupaction(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
-                          void *userdata)
-{
-    chat->group_action = function;
-    chat->group_action_userdata = userdata;
-}
-
-void callback_namelistchange(Group_Chat *chat, void (*function)(Group_Chat *chat, int peer, uint8_t change, void *),
-                             void *userdata)
-{
-    chat->peer_namelistchange = function;
-    chat->group_namelistchange_userdata = userdata;
-}
-
-uint32_t group_numpeers(const Group_Chat *chat)
-{
-    return chat->numpeers;
-}
-
-uint32_t group_client_names(const Group_Chat *chat, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
-                            uint16_t length)
-{
-    uint32_t i;
-
-    for (i = 0; i < chat->numpeers && i < length; ++i) {
-        lengths[i] = group_peername(chat, i, names[i]);
-    }
-
-    return i;
-}
-
-Group_Chat *new_groupchat(Networking_Core *net)
-{
-    unix_time_update();
-
-    if (net == 0)
-        return 0;
-
-    Group_Chat *chat = calloc(1, sizeof(Group_Chat));
-    chat->net = net;
-    crypto_box_keypair(chat->self_public_key, chat->self_secret_key);
-
-    /* (2^4) * 5 = 80 entries seems to be a moderate size */
-    chat->assoc = new_Assoc(4, 5, chat->self_public_key);
-
-    return chat;
-}
-
-#define NODE_PING_INTERVAL 10
-
-static void ping_close(Group_Chat *chat)
-{
-    uint32_t i;
-
-    for (i = 0; i < GROUP_CLOSE_CONNECTIONS; ++i) {
-        if (!is_timeout(chat->close[i].last_recv, BAD_GROUPNODE_TIMEOUT)) {
-            int peernum = peer_in_chat(chat, chat->close[i].client_id);
-
-            if (peernum == -1)
-                continue;
-
-            if (is_timeout(chat->group[peernum].last_pinged, NODE_PING_INTERVAL))
-                send_getnodes(chat, chat->close[i].ip_port, peernum);
-        }
-    }
-}
-
-/* Interval in seconds to send ping messages */
-#define GROUP_PING_INTERVAL 30
-
-static void ping_group(Group_Chat *chat)
-{
-    if (is_timeout(chat->last_sent_ping, GROUP_PING_INTERVAL)) {
-        if (send_data(chat, 0, 0, GROUP_CHAT_PING) != 0) /* Ping */
-            chat->last_sent_ping = unix_time();
-    }
-}
-
-#define DEL_PEER_DELAY 3
-static void del_dead_peers(Group_Chat *chat)
-{
-    uint32_t i;
-
-    for (i = 0; i < chat->numpeers; ++i) {
-        if (is_timeout(chat->group[i].last_recv_msgping, GROUP_PING_INTERVAL * 4)) {
-            delpeer(chat, i);
-        }
-
-        if (chat->group == NULL || i >= chat->numpeers)
-            break;
-
-        if (chat->group[i].deleted) {
-            if (is_timeout(chat->group[i].deleted_time, DEL_PEER_DELAY))
-                delpeer(chat, i);
-        }
-    }
-}
-
-#define NICK_SEND_INTERVAL 180
-static void send_names_new_peer(Group_Chat *chat)
-{
-    group_send_nick(chat, chat->nick, chat->nick_len);
-    chat->last_sent_nick = (unix_time() - NICK_SEND_INTERVAL) + 15;
-}
-static void send_names(Group_Chat *chat)
-{
-    /* send own nick from time to time, to let newly added peers be informed
-    * first time only: use a shorter timeframe, because we might not be in our own
-    * peer list yet */
-    if (is_timeout(chat->last_sent_nick, 180))
-        if (group_send_nick(chat, chat->nick, chat->nick_len) > 0) {
-            if (!chat->last_sent_nick)
-                chat->last_sent_nick = (unix_time() - NICK_SEND_INTERVAL) + 10;
-            else
-                chat->last_sent_nick = unix_time();
-        }
-}
-
-void do_groupchat(Group_Chat *chat)
-{
-    unix_time_update();
-    ping_close(chat);
-    ping_group(chat);
-    /* TODO: Maybe run this less? */
-    del_dead_peers(chat);
-    send_names(chat);
-}
-
-void kill_groupchat(Group_Chat *chat)
-{
-    send_data(chat, 0, 0, GROUP_CHAT_QUIT);
-    kill_Assoc(chat->assoc);
-    free(chat->group);
-    free(chat);
-}
-
-void chat_bootstrap(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id)
-{
-    send_getnodes(chat, ip_port, addpeer(chat, client_id));
-}
-
-void chat_bootstrap_nonlazy(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id)
-{
-    send_getnodes(chat, ip_port, addpeer(chat, client_id));
-    add_closepeer(chat, client_id, ip_port);
-}
diff --git a/toxcore/group_chats.h b/toxcore/group_chats.h
deleted file mode 100644
index 1a7a2e04..00000000
--- a/toxcore/group_chats.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/* group_chats.h
- *
- * An implementation of massive text only group chats.
- *
- *
- *  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 GROUP_CHATS_H
-#define GROUP_CHATS_H
-
-#define MAX_NICK_BYTES 128
-
-typedef struct {
-    uint8_t     client_id[crypto_box_PUBLICKEYBYTES];
-    uint64_t    pingid;
-    uint64_t    last_pinged;
-    IP_Port     ping_via;
-
-    uint64_t    last_recv;
-    uint64_t    last_recv_msgping;
-    uint32_t    last_message_number;
-
-    uint8_t     nick[MAX_NICK_BYTES];
-    uint16_t    nick_len;
-
-    uint8_t     deleted;
-    uint64_t    deleted_time;
-} Group_Peer;
-
-typedef struct {
-    uint8_t     client_id[crypto_box_PUBLICKEYBYTES];
-    IP_Port     ip_port;
-    uint64_t    last_recv;
-} Group_Close;
-
-#define GROUP_CLOSE_CONNECTIONS 6
-
-typedef struct Group_Chat {
-    Networking_Core *net;
-    uint8_t     self_public_key[crypto_box_PUBLICKEYBYTES];
-    uint8_t     self_secret_key[crypto_box_SECRETKEYBYTES];
-
-    Group_Peer *group;
-    Group_Close  close[GROUP_CLOSE_CONNECTIONS];
-    uint32_t numpeers;
-
-    uint32_t message_number;
-    void (*group_message)(struct Group_Chat *m, int, const uint8_t *, uint16_t, void *);
-    void *group_message_userdata;
-    void (*group_action)(struct Group_Chat *m, int, const uint8_t *, uint16_t, void *);
-    void *group_action_userdata;
-    void (*peer_namelistchange)(struct Group_Chat *m, int peer, uint8_t change, void *);
-    void *group_namelistchange_userdata;
-
-    uint64_t last_sent_ping;
-
-    uint8_t        nick[MAX_NICK_BYTES];
-    uint16_t       nick_len;
-    uint64_t       last_sent_nick;
-
-    struct Assoc  *assoc;
-} Group_Chat;
-
-#define GROUP_CHAT_PING 0
-#define GROUP_CHAT_NEW_PEER 16
-#define GROUP_CHAT_QUIT 24
-#define GROUP_CHAT_PEER_NICK 48
-#define GROUP_CHAT_CHAT_MESSAGE 64
-#define GROUP_CHAT_ACTION 63
-
-/* Copy the name of peernum to name.
- * name must be at least MAX_NICK_BYTES long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int group_peername(const Group_Chat *chat, int peernum, uint8_t *name);
-
-/*
- * Set callback function for chat messages.
- *
- * format of function is: function(Group_Chat *chat, peer number, message, message length, userdata)
- */
-void callback_groupmessage(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
-                           void *userdata);
-
-/*
- * Set callback function for actions.
- *
- * format of function is: function(Group_Chat *chat, peer number, action, action length, userdata)
- */
-void callback_groupaction(Group_Chat *chat, void (*function)(Group_Chat *chat, int, const uint8_t *, uint16_t, void *),
-                          void *userdata);
-
-/*
- * Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *
- * format of function is: function(Group_Chat *chat, userdata)
- */
-typedef enum {
-    CHAT_CHANGE_PEER_ADD,
-    CHAT_CHANGE_PEER_DEL,
-    CHAT_CHANGE_PEER_NAME,
-} CHAT_CHANGE;
-
-void callback_namelistchange(Group_Chat *chat, void (*function)(Group_Chat *chat, int peer, uint8_t change, void *),
-                             void *userdata);
-
-/*
- * Send a message to the group.
- *
- * returns the number of peers it has sent it to.
- */
-uint32_t group_sendmessage(Group_Chat *chat, const uint8_t *message, uint32_t length);
-
-/*
- * Send an action to the group.
- *
- * returns the number of peers it has sent it to.
- */
-uint32_t group_sendaction(Group_Chat *chat, const uint8_t *action, uint32_t length);
-
-/*
- * Set our nick for this group.
- *
- * returns -1 on failure, 0 on success.
- */
-int set_nick(Group_Chat *chat, const uint8_t *nick, uint16_t nick_len);
-
-/*
- * Tell everyone about a new peer (a person we are inviting for example.)
- *
- */
-uint32_t group_newpeer(Group_Chat *chat, const uint8_t *client_id);
-
-
-/* Create a new group chat.
- *
- * Returns a new group chat instance if success.
- *
- * Returns a NULL pointer if fail.
- */
-Group_Chat *new_groupchat(Networking_Core *net);
-
-
-/* Return the number of peers in the group chat.
- */
-uint32_t group_numpeers(const Group_Chat *chat);
-
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
- *
- * returns the number of peers.
- */
-uint32_t group_client_names(const Group_Chat *chat, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
-                            uint16_t length);
-
-/* Kill a group chat
- *
- * Frees the memory and everything.
- */
-void kill_groupchat(Group_Chat *chat);
-
-/*
- * This is the main loop.
- */
-void do_groupchat(Group_Chat *chat);
-
-/* if we receive a group chat packet we call this function so it can be handled.
-    return 0 if packet is handled correctly.
-    return 1 if it didn't handle the packet or if the packet was shit. */
-int handle_groupchatpacket(Group_Chat *chat, IP_Port source, const uint8_t *packet, uint32_t length);
-
-
-void chat_bootstrap(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id);
-void chat_bootstrap_nonlazy(Group_Chat *chat, IP_Port ip_port, const uint8_t *client_id);
-
-
-#endif
diff --git a/toxcore/logger.c b/toxcore/logger.c
index 48a2f303..e8aef7e0 100644
--- a/toxcore/logger.c
+++ b/toxcore/logger.c
@@ -1,8 +1,6 @@
 /*  logger.c
  *
- *  Wrapping logger functions in nice macros
- *
- *  Copyright (C) 2013 Tox project All Rights Reserved.
+ *  Copyright (C) 2013, 2015 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
  *
@@ -26,10 +24,7 @@
 #endif /* HAVE_CONFIG_H */
 
 #include "logger.h"
-
-#ifdef LOGGING
-
-#include "network.h" /* for time */
+#include "crypto_core.h" /* for random_int() */
 
 #include <stdio.h>
 #include <errno.h>
@@ -37,117 +32,206 @@
 #include <stdarg.h>
 #include <inttypes.h>
 #include <time.h>
+#include <pthread.h>
 
 #if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-#define strerror_r(errno,buf,len) strerror_s(buf,len,errno)
+#   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
 
-static struct logger_config {
+
+struct logger {
     FILE *log_file;
-    LoggerLevel level;
+    LOG_LEVEL level;
     uint64_t start_time; /* Time when lib loaded */
-}
-logger = {
-    NULL,
-    DEBUG,
-    0
+    char *id;
+
+    /* Allocate these once */
+    char *tstr;
+    char *posstr;
+    char *msg;
+
+    /* For thread synchronisation */
+    pthread_mutex_t mutex[1];
 };
 
-void __attribute__((destructor)) terminate_logger()
-{
-    if ( !logger.log_file ) return;
+Logger *global = NULL;
+
+const char *LOG_LEVEL_STR [] = {
+    [LOG_TRACE]   = "TRACE",
+    [LOG_DEBUG]   = "DEBUG",
+    [LOG_INFO]    = "INFO" ,
+    [LOG_WARNING] = "WARN" ,
+    [LOG_ERROR]   = "ERROR",
+};
 
-    time_t tim = time(NULL);
+char *strtime(char *dest, size_t max_len)
+{
+    time_t timer;
+    struct tm *tm_info;
 
-    logger_write(ERROR, "\n============== Closing logger [%u] ==============\n"
-                 "Time: %s", logger_get_pid(), asctime(localtime(&tim)));
+    time(&timer);
+    tm_info = localtime(&timer);
 
-    fclose(logger.log_file);
+    strftime(dest, max_len, "%m:%d %H:%M:%S", tm_info);
+    return dest;
 }
 
-unsigned logger_get_pid()
+
+/**
+ * Public Functions
+ */
+Logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
 {
-    return
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-        GetCurrentProcessId();
-#else
-        getpid();
+#ifndef LOGGING /* Disabled */
+    return NULL;
 #endif
-}
 
-const char *logger_stringify_level(LoggerLevel level)
-{
-    static const char *strings [] = {
-        "INFO",
-        "DEBUG",
-        "WARNING",
-        "ERROR"
-    };
-
-    return strings[level];
-}
+    Logger *retu = calloc(1, sizeof(Logger));
 
+    if (!retu)
+        return NULL;
 
-int logger_init(const char *file_name, LoggerLevel level)
-{
-    char *final_l = calloc(sizeof(char), strlen(file_name) + 32);
-    sprintf(final_l, "%s"/*.%u"*/, file_name/*, logger_get_pid()*/);
+    if ( pthread_mutex_init(retu->mutex, NULL) != 0 ) {
+        free(retu);
+        return NULL;
+    }
 
-    if ( logger.log_file ) {
-        fprintf(stderr, "Error opening logger name: %s with level %d: file already opened!\n", final_l, level);
-        free (final_l);
-        return -1;
+    if (!(retu->log_file = fopen(file_name, "ab"))) {
+        fprintf(stderr, "Error opening logger file: %s; info: %s" WIN_CR "\n", file_name, strerror(errno));
+        free(retu);
+        pthread_mutex_destroy(retu->mutex);
+        return NULL;
     }
 
-    logger.log_file = fopen(final_l, "ab");
+    if (!(retu->tstr = calloc(16, sizeof (char))) ||
+            !(retu->posstr = calloc(300, sizeof (char))) ||
+            !(retu->msg = calloc(4096, sizeof (char))) )
+        goto FAILURE;
+
+    if (id) {
+        if (!(retu->id = calloc(strlen(id) + 1, 1)))
+            goto FAILURE;
 
-    if ( logger.log_file == NULL ) {
-        fprintf(stderr, "Error opening logger file: %s; info: %s\n", final_l, strerror(errno));
+        strcpy(retu->id, id);
+    } else {
+        if (!(retu->id = malloc(8)))
+            goto FAILURE;
 
-        free (final_l);
-        return -1;
+        snprintf(retu->id, 8, "%u", random_int());
     }
 
+    retu->level = level;
+    retu->start_time = current_time_monotonic();
 
-    logger.level = level;
-    logger.start_time = current_time_monotonic();
+    fprintf(retu->log_file, "Successfully created and running logger id: %s; time: %s" WIN_CR "\n",
+            retu->id, strtime(retu->tstr, 16));
 
+    return retu;
 
-    time_t tim = time(NULL);
-    logger_write(ERROR, "\n============== Starting logger [%u] ==============\n"
-                 "Time: %s", logger_get_pid(), asctime(localtime(&tim)));
+FAILURE:
+    fprintf(stderr, "Failed to create logger!" WIN_CR "\n");
+    pthread_mutex_destroy(retu->mutex);
+    fclose(retu->log_file);
+    free(retu->tstr);
+    free(retu->posstr);
+    free(retu->msg);
+    free(retu->id);
+    free(retu);
+    return NULL;
+}
 
+void logger_kill(Logger *log)
+{
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
 
+    if (!log)
+        return;
+
+    pthread_mutex_lock(log->mutex);
+    free(log->id);
+    free(log->tstr);
+    free(log->posstr);
+    free(log->msg);
+
+    if (fclose(log->log_file) != 0 )
+        perror("Could not close log file");
+
+    pthread_mutex_unlock(log->mutex);
+    pthread_mutex_destroy(log->mutex);
 
-    free (final_l);
-    return 0;
+    free(log);
 }
 
+void logger_kill_global(void)
+{
+    logger_kill(global);
+    global = NULL;
+}
 
-void logger_write (LoggerLevel level, const char *format, ...)
+void logger_set_global(Logger *log)
 {
-    if (logger.log_file == NULL) {
-        /*fprintf(stderr, "Logger file is NULL!\n");*/
-        return;
-    }
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
 
-    if (logger.level > level) return; /* Don't print some levels xuh */
+    global = log;
+}
 
-    va_list _arg;
-    va_start (_arg, format);
-    vfprintf (logger.log_file, format, _arg);
-    va_end (_arg);
+Logger *logger_get_global(void)
+{
+#ifndef LOGGING /* Disabled */
+    return NULL;
+#endif
 
-    fflush(logger.log_file);
+    return global;
 }
 
-char *logger_timestr(char *dest, size_t max_size)
+void logger_write (Logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...)
 {
-    uint64_t diff = (current_time_monotonic() - logger.start_time); /* ms */
-    snprintf(dest, max_size, "%"PRIu64"", diff);
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
 
-    return dest;
-}
+    static const char *logger_format =
+        "%s  "   /* Logger id string */
+        "%-16s"  /* Time string of format: %m:%d %H:%M:%S */
+        "%u  "   /* Thread id */
+        "%-5s  " /* Logger lever string */
+        "%-20s " /* File:line string */
+        "- %s"   /* Output message */
+        WIN_CR "\n";    /* Every new print new line */
+
+
+    Logger *this_log = log ? log : global;
+
+    if (!this_log)
+        return;
 
+    /* Don't print levels lesser than set one */
+    if (this_log->level > level)
+        return;
+
+    pthread_mutex_lock(this_log->mutex);
+
+    /* Set position str */
+    snprintf(this_log->posstr, 300, "%s:%d", SFILE(file), line);
 
-#endif /* LOGGING */
+    /* Set message */
+    va_list args;
+    va_start (args, format);
+    vsnprintf(this_log->msg, 4096, format, args);
+    va_end (args);
+
+    fprintf(this_log->log_file, logger_format, this_log->id, strtime(this_log->tstr, 16), pthread_self(),
+            LOG_LEVEL_STR[level], this_log->posstr, this_log->msg);
+    fflush(this_log->log_file);
+
+    pthread_mutex_unlock(this_log->mutex);
+}
diff --git a/toxcore/logger.h b/toxcore/logger.h
index 56fe086d..0513b32c 100644
--- a/toxcore/logger.h
+++ b/toxcore/logger.h
@@ -1,7 +1,5 @@
 /*  logger.h
  *
- *  Wrapping logger functions in nice macros
- *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
@@ -22,63 +20,74 @@
  */
 
 
-#ifndef __TOXLOGGER
-#define __TOXLOGGER
+#ifndef TOXLOGGER_H
+#define TOXLOGGER_H
 
 #include <string.h>
 
-#ifdef LOGGING
-
-typedef enum _LoggerLevel {
-    INFO,
-    DEBUG,
-    WARNING,
-    ERROR
-} LoggerLevel;
+/* In case these are undefined; define 'empty' */
+#ifndef LOGGER_OUTPUT_FILE
+#   define LOGGER_OUTPUT_FILE ""
+#endif
 
-/*
- * Set 'level' as the lowest printable level
- */
-int logger_init(const char *file_name, LoggerLevel level);
-const char *logger_stringify_level(LoggerLevel level);
-unsigned logger_get_pid();
-void logger_write (LoggerLevel level, const char *format, ...);
-char *logger_timestr (char *dest, size_t max_size);
-
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-#define _SFILE (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
-#else
-#define _SFILE (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#ifndef LOGGER_LEVEL
+#   define LOGGER_LEVEL LOG_ERROR
 #endif
 
-#define WRITE_FORMAT(__LEVEL__, format) char __time__[20]; char* the_str = calloc(sizeof(char), strlen(format)+ 500); sprintf(the_str, "\n[%u] [%s] [%s] [%s:%d %s()] %s", \
-                             logger_get_pid(), logger_stringify_level(__LEVEL__), logger_timestr(__time__, 20), _SFILE, __LINE__, __func__, format)
 
-/* Use these macros */
+typedef enum {
+    LOG_TRACE,
+    LOG_DEBUG,
+    LOG_INFO,
+    LOG_WARNING,
+    LOG_ERROR
+} LOG_LEVEL;
 
-#define LOGGER_INIT(name, level) logger_init(name, level);
-#define LOGGER_INFO(format, ...) do { WRITE_FORMAT(INFO, format); logger_write( INFO, the_str, ##__VA_ARGS__ ); free(the_str); } while (0)
-#define LOGGER_DEBUG(format, ...) do { WRITE_FORMAT(DEBUG, format); logger_write( DEBUG, the_str, ##__VA_ARGS__ ); free(the_str); } while (0)
-#define LOGGER_WARNING(format, ...) do { WRITE_FORMAT(WARNING, format); logger_write( WARNING, the_str, ##__VA_ARGS__ ); free(the_str); } while (0)
-#define LOGGER_ERROR(format, ...) do { WRITE_FORMAT(ERROR, format); logger_write( ERROR, the_str, ##__VA_ARGS__ ); free(the_str); } while (0)
+typedef struct logger Logger;
 
-/* To do some checks or similar only when logging use this */
-#define LOGGER_SCOPE(__SCOPE_DO__) do { __SCOPE_DO__ } while(0)
+/**
+ * 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);
 
-#else
+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);
 
-#define LOGGER_INIT(name, level) do {} while(0)
-#define LOGGER_INFO(format, ...) do {} while(0)
-#define LOGGER_DEBUG(format, ...) do {} while(0)
-#define LOGGER_WARNING(format, ...) do {} while(0)
-#define LOGGER_ERROR(format, ...) do {} while(0)
+/**
+ * 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, ...);
 
-#define LOGGER_SCOPE(__SCOPE_DO__) do {} while(0)
 
+/* To do some checks or similar only when logging, use this */
+#ifdef LOGGING
+#   define LOGGER_SCOPE(__SCOPE_DO__) do { __SCOPE_DO__ } while(0)
+#   define LOGGER_WRITE(log, level, format, ...) \
+            logger_write(log, level, __FILE__, __LINE__, format, ##__VA_ARGS__ )
+#else
+#   define LOGGER_SCOPE(__SCOPE_DO__) do {} while(0)
+#   define LOGGER_WRITE(log, level, format, ...) do {} while(0)
 #endif /* LOGGING */
 
+/* To log with an logger */
+#define LOGGER_TRACE_(log, format, ...) LOGGER_WRITE(log, LOG_TRACE, format, ##__VA_ARGS__ )
+#define LOGGER_DEBUG_(log, format, ...) LOGGER_WRITE(log, LOG_DEBUG, format, ##__VA_ARGS__ )
+#define LOGGER_INFO_(log, format, ...) LOGGER_WRITE(log, LOG_INFO, format, ##__VA_ARGS__ )
+#define LOGGER_WARNING_(log, format, ...) LOGGER_WRITE(log, LOG_WARNING, format, ##__VA_ARGS__ )
+#define LOGGER_ERROR_(log, format, ...) LOGGER_WRITE(log, LOG_ERROR, format, ##__VA_ARGS__ )
 
+/* To log with the global logger */
+#define LOGGER_TRACE(format, ...) LOGGER_TRACE_(NULL, format, ##__VA_ARGS__)
+#define LOGGER_DEBUG(format, ...) LOGGER_DEBUG_(NULL, format, ##__VA_ARGS__)
+#define LOGGER_INFO(format, ...) LOGGER_INFO_(NULL, format, ##__VA_ARGS__)
+#define LOGGER_WARNING(format, ...) LOGGER_WARNING_(NULL, format, ##__VA_ARGS__)
+#define LOGGER_ERROR(format, ...) LOGGER_ERROR_(NULL, format, ##__VA_ARGS__)
 
 
-#endif /* __TOXLOGGER */
+#endif /* TOXLOGGER_H */
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index ea04d71c..bd5616a2 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -31,6 +31,7 @@
 #include "net_crypto.h"
 #include "util.h"
 #include "math.h"
+#include "logger.h"
 
 static uint8_t crypt_connection_id_not_valid(const Net_Crypto *c, int crypt_connection_id)
 {
@@ -182,7 +183,7 @@ static int handle_cookie_request(const Net_Crypto *c, uint8_t *request_plain, ui
 
 /* Handle the cookie request packet (for raw UDP)
  */
-static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Net_Crypto *c = object;
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
@@ -206,7 +207,7 @@ static int udp_handle_cookie_request(void *object, IP_Port source, const uint8_t
 /* Handle the cookie request packet (for TCP)
  */
 static int tcp_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connection *TCP_con, uint8_t conn_id,
-                                     const uint8_t *packet, uint32_t length)
+                                     const uint8_t *packet, uint16_t length)
 {
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -229,7 +230,7 @@ static int tcp_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connection
 /* Handle the cookie request packet (for TCP oob packets)
  */
 static int tcp_oob_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connection *TCP_con,
-        const uint8_t *dht_public_key, const uint8_t *packet, uint32_t length)
+        const uint8_t *dht_public_key, const uint8_t *packet, uint16_t length)
 {
     uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -260,7 +261,7 @@ static int tcp_oob_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connect
  * return -1 on failure.
  * return COOKIE_LENGTH on success.
  */
-static int handle_cookie_response(uint8_t *cookie, uint64_t *number, const uint8_t *packet, uint32_t length,
+static int handle_cookie_response(uint8_t *cookie, uint64_t *number, const uint8_t *packet, uint16_t length,
                                   const uint8_t *shared_key)
 {
     if (length != COOKIE_RESPONSE_LENGTH)
@@ -334,7 +335,7 @@ static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const u
  * return 0 on success.
  */
 static int handle_crypto_handshake(const Net_Crypto *c, uint8_t *nonce, uint8_t *session_pk, uint8_t *peer_real_pk,
-                                   uint8_t *dht_public_key, uint8_t *cookie, const uint8_t *packet, uint32_t length, const uint8_t *expected_real_pk)
+                                   uint8_t *dht_public_key, uint8_t *cookie, const uint8_t *packet, uint16_t length, const uint8_t *expected_real_pk)
 {
     if (length != HANDSHAKE_PACKET_LENGTH)
         return -1;
@@ -395,13 +396,17 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t
 
     int direct_send_attempt = 0;
 
+    pthread_mutex_lock(&conn->mutex);
+
     //TODO: on bad networks, direct connections might not last indefinitely.
     if (conn->ip_port.ip.family != 0) {
         uint8_t direct_connected = 0;
         crypto_connection_status(c, crypt_connection_id, &direct_connected);
 
-        if (direct_connected && (uint32_t)sendpacket(c->dht->net, conn->ip_port, data, length) == length)
+        if (direct_connected && (uint32_t)sendpacket(c->dht->net, conn->ip_port, data, length) == length) {
+            pthread_mutex_unlock(&conn->mutex);
             return 0;
+        }
 
         //TODO: a better way of sending packets directly to confirm the others ip.
         if (length < 96 || data[0] == NET_PACKET_COOKIE_REQUEST || data[0] == NET_PACKET_CRYPTO_HS) {
@@ -411,40 +416,53 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t
 
     }
 
+    pthread_mutex_unlock(&conn->mutex);
+
     //TODO: detect and kill bad relays.
     uint32_t i;
 
-    unsigned int r = crypt_connection_id;
+    unsigned int r;
 
-    for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
-        pthread_mutex_lock(&c->tcp_mutex);
+    if (!conn->last_relay_sentto) {
+        r = rand();
+    } else {
+        r = conn->last_relay_sentto - 1;
+    }
 
-        int ret = 0;
+    if (conn->num_tcp_online) {
+        for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
+            pthread_mutex_lock(&c->tcp_mutex);
 
-        if (conn->status_tcp[(i + r) % MAX_TCP_CONNECTIONS] == STATUS_TCP_ONLINE) {/* friend is connected to this relay. */
-            ret = send_data(c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS], conn->con_number_tcp[(i + r) % MAX_TCP_CONNECTIONS],
-                            data, length);
-        }
+            unsigned int tcp_index = (i + r) % MAX_TCP_CONNECTIONS;
+            int ret = 0;
 
-        pthread_mutex_unlock(&c->tcp_mutex);
+            if (conn->status_tcp[tcp_index] == STATUS_TCP_ONLINE) {/* friend is connected to this relay. */
+                ret = send_data(c->tcp_connections[tcp_index], conn->con_number_tcp[tcp_index], data, length);
+            }
 
-        if (ret == 1) {
-            return 0;
+            pthread_mutex_unlock(&c->tcp_mutex);
+
+            if (ret == 1) {
+                conn->last_relay_sentto = tcp_index + 1;
+                return 0;
+            }
         }
     }
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
         pthread_mutex_lock(&c->tcp_mutex);
 
+        unsigned int tcp_index = (i + r) % MAX_TCP_CONNECTIONS;
         int ret = 0;
 
-        if (conn->status_tcp[(i + r) % MAX_TCP_CONNECTIONS] == STATUS_TCP_INVISIBLE) {
-            ret = send_oob_packet(c->tcp_connections[(i + r) % MAX_TCP_CONNECTIONS], conn->dht_public_key, data, length);
+        if (conn->status_tcp[tcp_index] == STATUS_TCP_INVISIBLE) {
+            ret = send_oob_packet(c->tcp_connections[tcp_index], conn->dht_public_key, data, length);
         }
 
         pthread_mutex_unlock(&c->tcp_mutex);
 
         if (ret == 1) {
+            conn->last_relay_sentto = tcp_index + 1;
             return 0;
         }
     }
@@ -590,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.
@@ -657,7 +692,7 @@ static int generate_request_packet(uint8_t *data, uint16_t length, const Packets
 }
 
 /* Handle a request data packet.
- * Remove all the packets the other recieved from the array.
+ * Remove all the packets the other received from the array.
  *
  * return -1 on failure.
  * return number of requested packets on success.
@@ -746,9 +781,9 @@ static int send_data_packet(Net_Crypto *c, int crypt_connection_id, const uint8_
     }
 
     increment_nonce(conn->sent_nonce);
-    int ret = send_packet_to(c, crypt_connection_id, packet, sizeof(packet));
     pthread_mutex_unlock(&conn->mutex);
-    return ret;
+
+    return send_packet_to(c, crypt_connection_id, packet, sizeof(packet));
 }
 
 /* Creates and sends a data packet with buffer_start and num to the peer using the fastest route.
@@ -757,7 +792,7 @@ static int send_data_packet(Net_Crypto *c, int crypt_connection_id, const uint8_
  * return 0 on success.
  */
 static int send_data_packet_helper(Net_Crypto *c, int crypt_connection_id, uint32_t buffer_start, uint32_t num,
-                                   const uint8_t *data, uint32_t length)
+                                   const uint8_t *data, uint16_t length)
 {
     if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
         return -1;
@@ -777,7 +812,8 @@ static int send_data_packet_helper(Net_Crypto *c, int crypt_connection_id, uint3
 /*  return -1 if data could not be put in packet queue.
  *  return positive packet number if data was put into the queue.
  */
-static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
+static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length,
+                                    uint8_t congestion_control)
 {
     if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
         return -1;
@@ -796,35 +832,51 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
         uint32_t packet_num = conn->send_array.buffer_end - 1;
         int ret = get_data_pointer(&conn->send_array, &dt, packet_num);
 
+        uint8_t send_failed = 0;
+
         if (ret == 1) {
             if (!dt->time) {
                 if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, dt->data,
                                             dt->length) != 0) {
-                    return -1;
+                    if (congestion_control) {
+                        return -1;
+                    } else {
+                        send_failed = 1;
+                    }
+                } else {
+                    dt->time = temp_time;
                 }
-
-                dt->time = temp_time;
             }
         }
+
+        if (!send_failed) {
+            conn->maximum_speed_reached = 0;
+        }
     }
 
     Packet_Data dt;
-    dt.time = temp_time;
+    dt.time = 0;
     dt.length = length;
     memcpy(dt.data, data, length);
+    pthread_mutex_lock(&conn->mutex);
     int64_t packet_num = add_data_end_of_buffer(&conn->send_array, &dt);
+    pthread_mutex_unlock(&conn->mutex);
 
     if (packet_num == -1)
         return -1;
 
-    conn->maximum_speed_reached = 0;
+    if (!congestion_control && conn->maximum_speed_reached) {
+        return packet_num;
+    }
 
-    if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, data, length) != 0) {
+    if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, data, length) == 0) {
         Packet_Data *dt1 = NULL;
-        get_data_pointer(&conn->send_array, &dt1, packet_num);
-        dt1->time = 0;
+
+        if (get_data_pointer(&conn->send_array, &dt1, packet_num) == 1)
+            dt1->time = temp_time;
+    } else {
         conn->maximum_speed_reached = 1;
-        fprintf(stderr, "send_data_packet failed\n");
+        LOGGER_ERROR("send_data_packet failed\n");
     }
 
     return packet_num;
@@ -1070,7 +1122,7 @@ static int send_kill_packet(Net_Crypto *c, int crypt_connection_id)
                                    &kill_packet, sizeof(kill_packet));
 }
 
-/* Handle a recieved data packet.
+/* Handle a received data packet.
  *
  * return -1 on failure.
  * return 0 on success.
@@ -1144,10 +1196,24 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
         if (add_data_to_buffer(&conn->recv_array, num, &dt) != 0)
             return -1;
 
-        while (read_data_beg_buffer(&conn->recv_array, &dt) != -1) {
+
+        while (1) {
+            pthread_mutex_lock(&conn->mutex);
+            int ret = read_data_beg_buffer(&conn->recv_array, &dt);
+            pthread_mutex_unlock(&conn->mutex);
+
+            if (ret == -1)
+                break;
+
             if (conn->connection_data_callback)
                 conn->connection_data_callback(conn->connection_data_callback_object, conn->connection_data_callback_id, dt.data,
                                                dt.length);
+
+            /* conn might get killed in callback. */
+            conn = get_crypto_connection(c, crypt_connection_id);
+
+            if (conn == 0)
+                return -1;
         }
 
         /* Packet counter. */
@@ -1155,11 +1221,12 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
     } else if (real_data[0] >= PACKET_ID_LOSSY_RANGE_START &&
                real_data[0] < (PACKET_ID_LOSSY_RANGE_START + PACKET_ID_LOSSY_RANGE_SIZE)) {
 
+        set_buffer_end(&conn->recv_array, num);
+
         if (conn->connection_lossy_data_callback)
             conn->connection_lossy_data_callback(conn->connection_lossy_data_callback_object,
                                                  conn->connection_lossy_data_callback_id, real_data, real_length);
 
-        set_buffer_end(&conn->recv_array, num);
     } else {
         return -1;
     }
@@ -1167,7 +1234,7 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
     return 0;
 }
 
-/* Handle a packet that was recieved for the connection.
+/* Handle a packet that was received for the connection.
  *
  * return -1 on failure.
  * return 0 on success.
@@ -1223,7 +1290,11 @@ static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, cons
 
                 conn->status = CRYPTO_CONN_NOT_CONFIRMED;
                 /* Status needs to be CRYPTO_CONN_NOT_CONFIRMED for this to work. */
-                set_connection_dht_public_key(c, crypt_connection_id, dht_public_key, current_time_monotonic());
+                set_connection_dht_public_key(c, crypt_connection_id, dht_public_key);
+
+                if (conn->dht_pk_callback)
+                    conn->dht_pk_callback(conn->dht_pk_callback_object, conn->dht_pk_callback_number, dht_public_key);
+
             } else {
                 return -1;
             }
@@ -1299,10 +1370,14 @@ static int create_crypto_connection(Net_Crypto *c)
     int id = -1;
 
     if (realloc_cryptoconnection(c, c->crypto_connections_length + 1) == 0) {
-        memset(&(c->crypto_connections[c->crypto_connections_length]), 0, sizeof(Crypto_Connection));
         id = c->crypto_connections_length;
-        pthread_mutex_init(&c->crypto_connections[id].mutex, NULL);
         ++c->crypto_connections_length;
+        memset(&(c->crypto_connections[id]), 0, sizeof(Crypto_Connection));
+
+        if (pthread_mutex_init(&c->crypto_connections[id].mutex, NULL) != 0) {
+            pthread_mutex_unlock(&c->connections_mutex);
+            return -1;
+        }
     }
 
     pthread_mutex_unlock(&c->connections_mutex);
@@ -1320,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) {
@@ -1373,7 +1454,7 @@ static int getcryptconnection_id_dht_pubkey(const Net_Crypto *c, const uint8_t *
 }
 
 /* Add a source to the crypto connection.
- * This is to be used only when we have recieved a packet from that source.
+ * This is to be used only when we have received a packet from that source.
  *
  *  return -1 on failure.
  *  return positive number on success.
@@ -1456,7 +1537,11 @@ static int handle_new_connection_handshake(Net_Crypto *c, IP_Port source, const
             if (create_send_handshake(c, crypt_connection_id, n_c.cookie, n_c.dht_public_key) == 0) {
                 conn->status = CRYPTO_CONN_NOT_CONFIRMED;
                 /* Status needs to be CRYPTO_CONN_NOT_CONFIRMED for this to work. */
-                set_connection_dht_public_key(c, crypt_connection_id, n_c.dht_public_key, current_time_monotonic());
+                set_connection_dht_public_key(c, crypt_connection_id, n_c.dht_public_key);
+
+                if (conn->dht_pk_callback)
+                    conn->dht_pk_callback(conn->dht_pk_callback_object, conn->dht_pk_callback_number, n_c.dht_public_key);
+
                 ret = 0;
             }
         }
@@ -1505,7 +1590,7 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
 
     conn->status = CRYPTO_CONN_NOT_CONFIRMED;
     /* Status needs to be CRYPTO_CONN_NOT_CONFIRMED for this to work. */
-    set_connection_dht_public_key(c, crypt_connection_id, n_c->dht_public_key, current_time_monotonic());
+    set_connection_dht_public_key(c, crypt_connection_id, n_c->dht_public_key);
     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
     conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
     crypto_connection_add_source(c, crypt_connection_id, n_c->source);
@@ -1544,6 +1629,25 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key)
     return crypt_connection_id;
 }
 
+/* Set the status for the TCP connection for conn in location to status.
+ */
+static void set_conn_tcp_status(Crypto_Connection *conn, unsigned int location, unsigned int status)
+{
+    if (conn->status_tcp[location] == status) {
+        return;
+    }
+
+    if (conn->status_tcp[location] == STATUS_TCP_ONLINE) {
+        --conn->num_tcp_online;
+    }
+
+    if (status == STATUS_TCP_ONLINE) {
+        ++conn->num_tcp_online;
+    }
+
+    conn->status_tcp[location] = status;
+}
+
 /* Disconnect peer from all associated TCP connections.
  *
  * return -1 on failure.
@@ -1562,7 +1666,7 @@ static int disconnect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
         if (conn->status_tcp[i] != STATUS_TCP_NULL) {
             pthread_mutex_lock(&c->tcp_mutex);
             send_disconnect_request(c->tcp_connections[i], conn->con_number_tcp[i]);
-            conn->status_tcp[i] = STATUS_TCP_NULL;
+            set_conn_tcp_status(conn, i, STATUS_TCP_NULL);
             conn->con_number_tcp[i] = 0;
             pthread_mutex_unlock(&c->tcp_mutex);
         }
@@ -1601,9 +1705,9 @@ static int connect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
 /* Copy friends DHT public key into dht_key.
  *
  * return 0 on failure (no key copied).
- * return timestamp on success (key copied).
+ * return 1 on success (key copied).
  */
-uint64_t get_connection_dht_key(const Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key)
+unsigned int get_connection_dht_key(const Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
@@ -1614,28 +1718,22 @@ uint64_t get_connection_dht_key(const Net_Crypto *c, int crypt_connection_id, ui
         return 0;
 
     memcpy(dht_public_key, conn->dht_public_key, crypto_box_PUBLICKEYBYTES);
-    return conn->dht_public_key_timestamp;
+    return 1;
 }
 
 
 /* Set the DHT public key of the crypto connection.
- * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
- * the other peer.
  *
  * return -1 on failure.
  * return 0 on success.
  */
-int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key,
-                                  uint64_t timestamp)
+int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
     if (conn == 0)
         return -1;
 
-    if (timestamp <= conn->dht_public_key_timestamp)
-        return -1;
-
     if (conn->dht_public_key_set == 1 && memcmp(conn->dht_public_key, dht_public_key, crypto_box_PUBLICKEYBYTES) == 0)
         return -1;
 
@@ -1645,7 +1743,6 @@ int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, const
 
     memcpy(conn->dht_public_key, dht_public_key, crypto_box_PUBLICKEYBYTES);
     conn->dht_public_key_set = 1;
-    conn->dht_public_key_timestamp = timestamp;
 
     if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING) {
         conn->cookie_request_number = random_64b();
@@ -1675,7 +1772,15 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port)
     if (conn == 0)
         return -1;
 
+    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+        return -1;
+
     if (!ipport_equal(&ip_port, &conn->ip_port)) {
+        if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_time) > current_time_monotonic()) {
+            if (LAN_ip(ip_port.ip) == 0 && LAN_ip(conn->ip_port.ip) == 0 && conn->ip_port.port == ip_port.port)
+                return -1;
+        }
+
         if (bs_list_add(&c->ip_port_list, &ip_port, crypt_connection_id)) {
             bs_list_remove(&c->ip_port_list, &conn->ip_port, crypt_connection_id);
             conn->ip_port = ip_port;
@@ -1716,13 +1821,13 @@ 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) {
-            conn->status_tcp[location] = STATUS_TCP_INVISIBLE;
+        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;
         }
     }
 
-    conn->status_tcp[location] = STATUS_TCP_OFFLINE;
+    set_conn_tcp_status(conn, location, STATUS_TCP_OFFLINE);
     return 0;
 }
 
@@ -1745,9 +1850,9 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
         return -1;
 
     if (status == 1) {
-        conn->status_tcp[location] = STATUS_TCP_OFFLINE;
+        set_conn_tcp_status(conn, location, STATUS_TCP_OFFLINE);
     } else if (status == 2) {
-        conn->status_tcp[location] = STATUS_TCP_ONLINE;
+        set_conn_tcp_status(conn, location, STATUS_TCP_ONLINE);
     }
 
     conn->con_number_tcp[location] = connection_id;
@@ -1772,7 +1877,11 @@ static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_i
     if (conn == 0)
         return -1;
 
-    if (handle_packet_connection(c, number, data, length) != 0)
+    pthread_mutex_unlock(&c->tcp_mutex);
+    int ret = handle_packet_connection(c, number, data, length);
+    pthread_mutex_lock(&c->tcp_mutex);
+
+    if (ret != 0)
         return -1;
 
     //TODO detect and kill bad TCP connections.
@@ -1796,11 +1905,12 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
 
     if (crypt_connection_id == -1) {
         IP_Port source;
+        source.port = 0;
         source.ip.family = TCP_FAMILY;
         source.ip.ip6.uint32[0] = location;
 
         if (data[0] != NET_PACKET_CRYPTO_HS) {
-            fprintf(stderr, "tcp snhappen %u\n", data[0]);
+            LOGGER_DEBUG("tcp snhappen %u\n", data[0]);
             return -1;
         }
 
@@ -1810,7 +1920,11 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
         return 0;
     }
 
-    if (handle_packet_connection(c, crypt_connection_id, data, length) != 0)
+    pthread_mutex_unlock(&c->tcp_mutex);
+    int ret = handle_packet_connection(c, crypt_connection_id, data, length);
+    pthread_mutex_lock(&c->tcp_mutex);
+
+    if (ret != 0)
         return -1;
 
     return 0;
@@ -1886,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;
         }
@@ -1895,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;
     }
 
@@ -1908,7 +2022,7 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
 
         if (memcmp(c->tcp_connections[i]->public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
             if (conn->status_tcp[i] == STATUS_TCP_OFFLINE)
-                conn->status_tcp[i] = STATUS_TCP_INVISIBLE;
+                set_conn_tcp_status(conn, i, STATUS_TCP_INVISIBLE);
         }
     }
 
@@ -1938,13 +2052,8 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key)
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
         if (c->tcp_connections_new[i] == NULL) {
-            if (c->proxy_set) {
-                c->tcp_connections_new[i] = new_TCP_connection(ip_port, public_key, c->dht->self_public_key, c->dht->self_secret_key,
-                                            &c->proxy_info);
-            } else {
-                c->tcp_connections_new[i] = new_TCP_connection(ip_port, public_key, c->dht->self_public_key, c->dht->self_secret_key,
-                                            0);
-            }
+            c->tcp_connections_new[i] = new_TCP_connection(ip_port, public_key, c->dht->self_public_key, c->dht->self_secret_key,
+                                        &c->proxy_info);
 
             return 0;
         }
@@ -1953,30 +2062,51 @@ 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;
 }
 
-/* Set the function to be called when an onion response packet is recieved by one of the TCP connections.
+/* 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,
                                 uint16_t length), void *object)
@@ -2001,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) {
@@ -2076,7 +2206,9 @@ static void do_tcp(Net_Crypto *c)
         if (c->tcp_connections_new[i] == NULL)
             continue;
 
+        pthread_mutex_lock(&c->tcp_mutex);
         do_TCP_connection(c->tcp_connections_new[i]);
+        pthread_mutex_unlock(&c->tcp_mutex);
 
         if (c->tcp_connections_new[i]->status == TCP_CLIENT_CONFIRMED) {
             pthread_mutex_lock(&c->tcp_mutex);
@@ -2110,7 +2242,7 @@ static void clear_disconnected_tcp_peer(Crypto_Connection *conn, uint32_t number
     if (number >= MAX_TCP_CONNECTIONS)
         return;
 
-    conn->status_tcp[number] = STATUS_TCP_NULL;
+    set_conn_tcp_status(conn, number, STATUS_TCP_NULL);
     conn->con_number_tcp[number] = 0;
 }
 
@@ -2226,6 +2358,29 @@ int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
     return 0;
 }
 
+
+/* Set the function for this friend that will be callbacked with object and number
+ * when that friend gives us his DHT temporary public key.
+ *
+ * object and number will be passed as argument to this function.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int nc_dht_pk_callback(Net_Crypto *c, int crypt_connection_id, void (*function)(void *data, int32_t number,
+                       const uint8_t *dht_public_key), void *object, uint32_t number)
+{
+    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
+
+    if (conn == 0)
+        return -1;
+
+    conn->dht_pk_callback = function;
+    conn->dht_pk_callback_object = object;
+    conn->dht_pk_callback_number = number;
+    return 0;
+}
+
 /* Get the crypto connection id from the ip_port.
  *
  * return -1 on failure.
@@ -2246,7 +2401,7 @@ static int crypto_id_ip_port(const Net_Crypto *c, IP_Port ip_port)
  * Crypto data packets.
  *
  */
-static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     if (length <= CRYPTO_MIN_PACKET_SIZE || length > MAX_CRYPTO_PACKET_SIZE)
         return 1;
@@ -2272,13 +2427,15 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
     if (conn == 0)
         return -1;
 
+    pthread_mutex_lock(&conn->mutex);
     conn->direct_lastrecv_time = current_time_monotonic();
+    pthread_mutex_unlock(&conn->mutex);
     return 0;
 }
 
-/* The dT for the average packet recieving rate calculations.
+/* 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
@@ -2334,7 +2491,7 @@ static void send_crypto_packets(Net_Crypto *c)
                 conn->packet_counter_set = temp_time;
 
                 uint32_t packets_sent = conn->packets_sent;
-                conn->packets_sent = conn->packets_resent = 0;
+                conn->packets_sent = 0;
 
                 /* conjestion control
                     calculate a new value of conn->packet_send_rate based on some data
@@ -2361,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;
@@ -2375,8 +2532,8 @@ static void send_crypto_packets(Net_Crypto *c)
             } else if (((1000.0 / conn->packet_send_rate) + conn->last_packets_left_set) < temp_time) {
                 uint32_t num_packets = conn->packet_send_rate * ((double)(temp_time - conn->last_packets_left_set) / 1000.0) + 0.5;
 
-                if (conn->packets_left > num_packets * 2 + CRYPTO_MIN_QUEUE_LENGTH) {
-                    conn->packets_left = num_packets * 2 + CRYPTO_MIN_QUEUE_LENGTH;
+                if (conn->packets_left > num_packets * 4 + CRYPTO_MIN_QUEUE_LENGTH) {
+                    conn->packets_left = num_packets * 4 + CRYPTO_MIN_QUEUE_LENGTH;
                 } else {
                     conn->packets_left += num_packets;
                 }
@@ -2388,7 +2545,6 @@ static void send_crypto_packets(Net_Crypto *c)
 
             if (ret != -1) {
                 conn->packets_left -= ret;
-                conn->packets_resent += ret;
             }
 
             if (conn->packet_send_rate > CRYPTO_PACKET_MIN_RATE * 1.5) {
@@ -2438,9 +2594,10 @@ uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connecti
  * return -1 if data could not be put in packet queue.
  * return positive packet number if data was put into the queue.
  *
- * The first byte of data must be in the CRYPTO_RESERVED_PACKETS to PACKET_ID_LOSSY_RANGE_START range.
+ * congestion_control: should congestion control apply to this packet?
  */
-int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
+int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length,
+                          uint8_t congestion_control)
 {
     if (length == 0)
         return -1;
@@ -2459,16 +2616,19 @@ int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t
     if (conn->status != CRYPTO_CONN_ESTABLISHED)
         return -1;
 
-    if (conn->packets_left == 0)
+    if (congestion_control && conn->packets_left == 0)
         return -1;
 
-    int64_t ret = send_lossless_packet(c, crypt_connection_id, data, length);
+    int64_t ret = send_lossless_packet(c, crypt_connection_id, data, length, congestion_control);
 
     if (ret == -1)
         return -1;
 
-    --conn->packets_left;
-    conn->packets_sent++;
+    if (congestion_control) {
+        --conn->packets_left;
+        conn->packets_sent++;
+    }
+
     return ret;
 }
 
@@ -2501,7 +2661,7 @@ int cryptpacket_received(Net_Crypto *c, int crypt_connection_id, uint32_t packet
  *
  * Sends a lossy cryptopacket. (first byte must in the PACKET_ID_LOSSY_RANGE_*)
  */
-int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
+int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
     if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
         return -1;
@@ -2521,8 +2681,11 @@ int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t
     int ret = -1;
 
     if (conn) {
-        ret = send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, conn->send_array.buffer_end, data,
-                                      length);
+        pthread_mutex_lock(&conn->mutex);
+        uint32_t buffer_start = conn->recv_array.buffer_start;
+        uint32_t buffer_end = conn->send_array.buffer_end;
+        pthread_mutex_unlock(&conn->mutex);
+        ret = send_data_packet_helper(c, crypt_connection_id, buffer_start, buffer_end, data, length);
     }
 
     pthread_mutex_lock(&c->connections_mutex);
@@ -2559,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);
     }
 
@@ -2624,6 +2790,12 @@ Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info)
     if (temp == NULL)
         return NULL;
 
+    if (create_recursive_mutex(&temp->tcp_mutex) != 0 ||
+            pthread_mutex_init(&temp->connections_mutex, NULL) != 0) {
+        free(temp);
+        return NULL;
+    }
+
     temp->dht = dht;
 
     new_keys(temp);
@@ -2638,16 +2810,7 @@ Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info)
 
     bs_list_init(&temp->ip_port_list, sizeof(IP_Port), 8);
 
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    pthread_mutex_init(&temp->tcp_mutex, &attr);
-    pthread_mutex_init(&temp->connections_mutex, NULL);
-
-    if (proxy_info) {
-        temp->proxy_info = *proxy_info;
-        temp->proxy_set = 1;
-    }
+    temp->proxy_info = *proxy_info;
 
     return temp;
 }
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index d750080f..7e59475e 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -25,47 +25,52 @@
 #define NET_CRYPTO_H
 
 #include "DHT.h"
+#include "LAN_discovery.h"
 #include "TCP_client.h"
 #include <pthread.h>
 
 #define CRYPTO_CONN_NO_CONNECTION 0
 #define CRYPTO_CONN_COOKIE_REQUESTING 1 //send cookie request packets
 #define CRYPTO_CONN_HANDSHAKE_SENT 2 //send handshake packets
-#define CRYPTO_CONN_NOT_CONFIRMED 3 //send handshake packets
+#define CRYPTO_CONN_NOT_CONFIRMED 3 //send handshake packets, we have received one from the other
 #define CRYPTO_CONN_ESTABLISHED 4
 #define CRYPTO_CONN_TIMED_OUT 5
 
+/* Maximum size of receiving and sending packet buffers. */
 #define CRYPTO_PACKET_BUFFER_SIZE 16384 /* Must be a power of 2 */
 
 /* Minimum packet rate per second. */
-#define CRYPTO_PACKET_MIN_RATE 16.0
+#define CRYPTO_PACKET_MIN_RATE 8.0
 
 /* Minimum packet queue max length. */
-#define CRYPTO_MIN_QUEUE_LENGTH 16
+#define CRYPTO_MIN_QUEUE_LENGTH 64
 
+/* Maximum total size of packets that net_crypto sends. */
 #define MAX_CRYPTO_PACKET_SIZE 1400
 
 #define CRYPTO_DATA_PACKET_MIN_SIZE (1 + sizeof(uint16_t) + (sizeof(uint32_t) + sizeof(uint32_t)) + crypto_box_MACBYTES)
 
-/* Max size of data in packets TODO*/
+/* Max size of data in packets */
 #define MAX_CRYPTO_DATA_SIZE (MAX_CRYPTO_PACKET_SIZE - CRYPTO_DATA_PACKET_MIN_SIZE)
 
 /* Interval in ms between sending cookie request/handshake packets. */
-#define CRYPTO_SEND_PACKET_INTERVAL 500
+#define CRYPTO_SEND_PACKET_INTERVAL 1000
+
 /* The maximum number of times we try to send the cookie request and handshake
    before giving up. */
 #define MAX_NUM_SENDPACKET_TRIES 8
 
-/* The timeout of no recieved UDP packets before the direct UDP connection is considered dead. */
-#define UDP_DIRECT_TIMEOUT (MAX_NUM_SENDPACKET_TRIES * CRYPTO_SEND_PACKET_INTERVAL * 2)
+/* The timeout of no received UDP packets before the direct UDP connection is considered dead. */
+#define UDP_DIRECT_TIMEOUT (MAX_NUM_SENDPACKET_TRIES * CRYPTO_SEND_PACKET_INTERVAL)
 
-#define PACKET_ID_PADDING 0
-#define PACKET_ID_REQUEST 1
-#define PACKET_ID_KILL    2
+#define PACKET_ID_PADDING 0 /* Denotes padding */
+#define PACKET_ID_REQUEST 1 /* Used to request unreceived packets */
+#define PACKET_ID_KILL    2 /* Used to kill connection */
 
+/* Packet ids 0 to CRYPTO_RESERVED_PACKETS - 1 are reserved for use by net_crypto. */
 #define CRYPTO_RESERVED_PACKETS 16
 
-#define MAX_TCP_CONNECTIONS 32
+#define MAX_TCP_CONNECTIONS 64
 #define MAX_TCP_RELAYS_PEER 4
 
 #define STATUS_TCP_NULL      0
@@ -79,8 +84,9 @@
 
 #define CRYPTO_MAX_PADDING 8 /* All packets will be padded a number of bytes based on this number. */
 
-
-#define CONGESTION_QUEUE_ARRAY_SIZE 8
+/* 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 24
 
 typedef struct {
     uint64_t time;
@@ -111,7 +117,6 @@ typedef struct {
     uint64_t cookie_request_number; /* number used in the cookie request packets for this connection */
     uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES]; /* The dht public key of the peer */
     uint8_t dht_public_key_set; /* True if the dht public key is set, false if it isn't. */
-    uint64_t dht_public_key_timestamp; /* Timestamp of the last time we confirmed the key was correct. */
 
     uint8_t *temp_packet; /* Where the cookie request/handshake packet is stored while it is being sent. */
     uint16_t temp_packet_length;
@@ -148,12 +153,14 @@ typedef struct {
 
     uint32_t last_sendqueue_size[CONGESTION_QUEUE_ARRAY_SIZE], last_sendqueue_counter;
     long signed int last_num_packets_sent[CONGESTION_QUEUE_ARRAY_SIZE];
-    uint32_t packets_sent, packets_resent;
+    uint32_t packets_sent;
 
     uint8_t killed; /* set to 1 to kill the connection. */
 
     uint8_t status_tcp[MAX_TCP_CONNECTIONS]; /* set to one of STATUS_TCP_* */
     uint8_t con_number_tcp[MAX_TCP_CONNECTIONS];
+    unsigned int last_relay_sentto;
+    unsigned int num_tcp_online;
 
     Node_format tcp_relays[MAX_TCP_RELAYS_PEER];
     uint16_t num_tcp_relays;
@@ -161,6 +168,10 @@ typedef struct {
     uint8_t maximum_speed_reached;
 
     pthread_mutex_t mutex;
+
+    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key);
+    void *dht_pk_callback_object;
+    uint32_t dht_pk_callback_number;
 } Crypto_Connection;
 
 typedef struct {
@@ -204,7 +215,6 @@ typedef struct {
     int (*tcp_onion_callback)(void *object, const uint8_t *data, uint16_t length);
     void *tcp_onion_callback_object;
 
-    uint8_t proxy_set;
     TCP_Proxy_Info proxy_info;
 } Net_Crypto;
 
@@ -236,19 +246,16 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key);
 /* Copy friends DHT public key into dht_key.
  *
  * return 0 on failure (no key copied).
- * return timestamp on success (key copied).
+ * return 1 on success (key copied).
  */
-uint64_t get_connection_dht_key(const Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key);
+unsigned int get_connection_dht_key(const Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key);
 
 /* Set the DHT public key of the crypto connection.
- * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
- * the other peer.
  *
  * return -1 on failure.
  * return 0 on success.
  */
-int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key,
-                                  uint64_t timestamp);
+int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key);
 
 /* Set the direct ip of the crypto connection.
  *
@@ -294,6 +301,17 @@ int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
                                   int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
                                   int id);
 
+/* Set the function for this friend that will be callbacked with object and number
+ * when that friend gives us his DHT temporary public key.
+ *
+ * object and number will be passed as argument to this function.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int nc_dht_pk_callback(Net_Crypto *c, int crypt_connection_id, void (*function)(void *data, int32_t number,
+                       const uint8_t *dht_public_key), void *object, uint32_t number);
+
 /* returns the number of packet slots left in the sendbuffer.
  * return 0 if failure.
  */
@@ -305,8 +323,11 @@ uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connecti
  * return positive packet number if data was put into the queue.
  *
  * The first byte of data must be in the CRYPTO_RESERVED_PACKETS to PACKET_ID_LOSSY_RANGE_START range.
+ *
+ * congestion_control: should congestion control apply to this packet?
  */
-int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length);
+int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length,
+                          uint8_t congestion_control);
 
 /* Check if packet_number was received by the other side.
  *
@@ -322,7 +343,7 @@ int cryptpacket_received(Net_Crypto *c, int crypt_connection_id, uint32_t packet
  *
  * Sends a lossy cryptopacket. (first byte must in the PACKET_ID_LOSSY_RANGE_*)
  */
-int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length);
+int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length);
 
 /* Add a tcp relay, associating it to a crypt_connection_id.
  *
@@ -338,17 +359,24 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
  */
 int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key);
 
-/* Set the function to be called when an onion response packet is recieved by one of the TCP connections.
+/* 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,
                                 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/network.c b/toxcore/network.c
index 43030a08..deccbb63 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -264,15 +264,15 @@ uint64_t current_time_monotonic(void)
 #define loglogdata(__message__, __buffer__, __buflen__, __ip_port__, __res__) \
     (__ip_port__) .ip; \
     if (__res__ < 0) /* Windows doesn't necessarily know %zu */ \
-        LOGGER_INFO("[%2u] %s %3hu%c %s:%hu (%u: %s) | %04x%04x", \
+        LOGGER_TRACE("[%2u] %s %3hu%c %s:%hu (%u: %s) | %04x%04x", \
                  __buffer__[0], __message__, (__buflen__ < 999 ? (uint16_t)__buflen__ : 999), 'E', \
                  ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), errno, strerror(errno), data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__)); \
     else if ((__res__ > 0) && ((size_t)__res__ <= __buflen__)) \
-        LOGGER_INFO("[%2u] %s %3zu%c %s:%hu (%u: %s) | %04x%04x", \
+        LOGGER_TRACE("[%2u] %s %3zu%c %s:%hu (%u: %s) | %04x%04x", \
                  __buffer__[0], __message__, (__res__ < 999 ? (size_t)__res__ : 999), ((size_t)__res__ < __buflen__ ? '<' : '='), \
                  ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), 0, "OK", data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__)); \
     else /* empty or overwrite */ \
-        LOGGER_INFO("[%2u] %s %zu%c%zu %s:%hu (%u: %s) | %04x%04x", \
+        LOGGER_TRACE("[%2u] %s %zu%c%zu %s:%hu (%u: %s) | %04x%04x", \
                  __buffer__[0], __message__, (size_t)__res__, (!__res__ ? '!' : '>'), __buflen__, \
                  ip_ntoa(&((__ip_port__).ip)), ntohs((__ip_port__).port), 0, "OK", data_0(__buflen__, __buffer__), data_1(__buflen__, __buffer__));
 
@@ -281,7 +281,7 @@ uint64_t current_time_monotonic(void)
 /* Basic network functions:
  * Function to send packet(data) of length length to ip_port.
  */
-int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint32_t length)
+int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint16_t length)
 {
     if (net->family == 0) /* Socket not initialized */
         return -1;
@@ -518,6 +518,12 @@ Networking_Core *new_networking(IP ip, uint16_t port)
     int broadcast = 1;
     setsockopt(temp->sock, SOL_SOCKET, SO_BROADCAST, (char *)&broadcast, sizeof(broadcast));
 
+    /* iOS UDP sockets are weird and apparently can SIGPIPE */
+    if (!set_socket_nosigpipe(temp->sock)) {
+        kill_networking(temp);
+        return NULL;
+    }
+
     /* Set socket nonblocking. */
     if (!set_socket_nonblock(temp->sock)) {
         kill_networking(temp);
@@ -750,34 +756,12 @@ void ipport_copy(IP_Port *target, const IP_Port *source)
     memcpy(target, source, sizeof(IP_Port));
 };
 
-/* packing and unpacking functions */
-void ip_pack(uint8_t *data, const IP *source)
-{
-    data[0] = source->family;
-    memcpy(data + 1, &source->ip6, SIZE_IP6);
-}
-
-void ip_unpack(IP *target, const uint8_t *data)
-{
-    target->family = data[0];
-    memcpy(&target->ip6, data + 1, SIZE_IP6);
-}
-
-void ipport_pack(uint8_t *data, const IP_Port *source)
-{
-    ip_pack(data, &source->ip);
-    memcpy(data + SIZE_IP, &source->port, SIZE_PORT);
-}
-
-void ipport_unpack(IP_Port *target, const uint8_t *data)
-{
-    ip_unpack(&target->ip, data);
-    memcpy(&target->port, data + SIZE_IP, SIZE_PORT);
-}
-
 /* ip_ntoa
  *   converts ip into a string
  *   uses a static buffer, so mustn't used multiple times in the same output
+ *
+ *   IPv6 addresses are enclosed into square brackets, i.e. "[IPv6]"
+ *   writes error message into the buffer on error
  */
 /* there would be INET6_ADDRSTRLEN, but it might be too short for the error message */
 static char addresstext[96];
@@ -810,6 +794,38 @@ const char *ip_ntoa(const IP *ip)
 }
 
 /*
+ * ip_parse_addr
+ *  parses IP structure into an address string
+ *
+ * input
+ *  ip: ip of AF_INET or AF_INET6 families
+ *  length: length of the address buffer
+ *          Must be at least INET_ADDRSTRLEN for AF_INET
+ *          and INET6_ADDRSTRLEN for AF_INET6
+ *
+ * output
+ *  address: dotted notation (IPv4: quad, IPv6: 16) or colon notation (IPv6)
+ *
+ * returns 1 on success, 0 on failure
+ */
+int ip_parse_addr(const IP *ip, char *address, size_t length)
+{
+    if (!address || !ip) {
+        return 0;
+    }
+
+    if (ip->family == AF_INET) {
+        struct in_addr *addr = (struct in_addr *)&ip->ip4;
+        return inet_ntop(ip->family, addr, address, length) != NULL;
+    } else if (ip->family == AF_INET6) {
+        struct in6_addr *addr = (struct in6_addr *)&ip->ip6;
+        return inet_ntop(ip->family, addr, address, length) != NULL;
+    }
+
+    return 0;
+}
+
+/*
  * addr_parse_ip
  *  directly parses the input into an IP structure
  *  tries IPv4 first, then IPv6
diff --git a/toxcore/network.h b/toxcore/network.h
index 1f4b757c..15e1c0a4 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -92,12 +92,11 @@ typedef int sock_t;
 #endif
 #endif
 
-#define MAX_UDP_PACKET_SIZE 65507
+#define MAX_UDP_PACKET_SIZE 2048
 
 #define NET_PACKET_PING_REQUEST    0   /* Ping request packet ID. */
 #define NET_PACKET_PING_RESPONSE   1   /* Ping response packet ID. */
 #define NET_PACKET_GET_NODES       2   /* Get nodes request packet ID. */
-#define NET_PACKET_SEND_NODES      3   /* Send nodes response packet ID for IPv4 addresses. */
 #define NET_PACKET_SEND_NODES_IPV6 4   /* Send nodes response packet ID for other addresses. */
 #define NET_PACKET_COOKIE_REQUEST  24  /* Cookie request packet */
 #define NET_PACKET_COOKIE_RESPONSE 25  /* Cookie response packet */
@@ -105,7 +104,6 @@ typedef int sock_t;
 #define NET_PACKET_CRYPTO_DATA     27  /* Crypto data packet */
 #define NET_PACKET_CRYPTO          32  /* Encrypted data packet ID. */
 #define NET_PACKET_LAN_DISCOVERY   33  /* LAN discovery packet ID. */
-#define NET_PACKET_GROUP_CHATS     48  /* Group chats packet ID. */
 
 /* See:  docs/Prevent_Tracking.txt and onion.{c, h} */
 #define NET_PACKET_ONION_SEND_INITIAL 128
@@ -135,8 +133,7 @@ typedef int sock_t;
 #define TCP_INET6 (AF_INET6 + 3)
 #define TCP_FAMILY (AF_INET6 + 4)
 
-typedef union __attribute__ ((__packed__))
-{
+typedef union {
     uint8_t uint8[4];
     uint16_t uint16[2];
     uint32_t uint32;
@@ -144,8 +141,7 @@ typedef union __attribute__ ((__packed__))
 }
 IP4;
 
-typedef union __attribute__ ((__packed__))
-{
+typedef union {
     uint8_t uint8[16];
     uint16_t uint16[8];
     uint32_t uint32[4];
@@ -154,8 +150,7 @@ typedef union __attribute__ ((__packed__))
 }
 IP6;
 
-typedef struct __attribute__ ((__packed__))
-{
+typedef struct {
     uint8_t family;
     union {
         IP4 ip4;
@@ -164,8 +159,7 @@ typedef struct __attribute__ ((__packed__))
 }
 IP;
 
-typedef struct __attribute__ ((__packed__)) __attribute__((gcc_struct))
-{
+typedef struct {
     IP ip;
     uint16_t port;
 }
@@ -185,10 +179,30 @@ IP_Port;
 /* ip_ntoa
  *   converts ip into a string
  *   uses a static buffer, so mustn't used multiple times in the same output
+ *
+ *   IPv6 addresses are enclosed into square brackets, i.e. "[IPv6]"
+ *   writes error message into the buffer on error
  */
 const char *ip_ntoa(const IP *ip);
 
 /*
+ * ip_parse_addr
+ *  parses IP structure into an address string
+ *
+ * input
+ *  ip: ip of AF_INET or AF_INET6 families
+ *  length: length of the address buffer
+ *          Must be at least INET_ADDRSTRLEN for AF_INET
+ *          and INET6_ADDRSTRLEN for AF_INET6
+ *
+ * output
+ *  address: dotted notation (IPv4: quad, IPv6: 16) or colon notation (IPv6)
+ *
+ * returns 1 on success, 0 on failure
+ */
+int ip_parse_addr(const IP *ip, char *address, size_t length);
+
+/*
  * addr_parse_ip
  *  directly parses the input into an IP structure
  *  tries IPv4 first, then IPv6
@@ -232,16 +246,6 @@ void ip_copy(IP *target, const IP *source);
 /* copies an ip_port structure */
 void ipport_copy(IP_Port *target, const IP_Port *source);
 
-
-/* packs IP into data, writes SIZE_IP bytes to data */
-void ip_pack(uint8_t *data, const IP *source);
-/* unpacks IP from data, reads SIZE_IP bytes from data */
-void ip_unpack(IP *target, const uint8_t *data);
-/* packs IP_Port into data, writes SIZE_IPPORT bytes to data */
-void ipport_pack(uint8_t *data, const IP_Port *source);
-/* unpacks IP_Port from data, reads SIZE_IPPORT bytes to data */
-void ipport_unpack(IP_Port *target, const uint8_t *data);
-
 /*
  * addr_resolve():
  *  uses getaddrinfo to resolve an address into an IP address
@@ -282,7 +286,7 @@ int addr_resolve_or_parse_ip(const char *address, IP *to, IP *extra);
  * Packet data is put into data.
  * Packet length is put into length.
  */
-typedef int (*packet_handler_callback)(void *object, IP_Port ip_port, const uint8_t *data, uint32_t len);
+typedef int (*packet_handler_callback)(void *object, IP_Port ip_port, const uint8_t *data, uint16_t len);
 
 typedef struct {
     packet_handler_callback function;
@@ -343,7 +347,7 @@ uint64_t current_time_monotonic(void);
 /* Basic network functions: */
 
 /* Function to send packet(data) of length length to ip_port. */
-int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint32_t length);
+int sendpacket(Networking_Core *net, IP_Port ip_port, const uint8_t *data, uint16_t length);
 
 /* Function to call when packet beginning with byte is received. */
 void networking_registerhandler(Networking_Core *net, uint8_t byte, packet_handler_callback cb, void *object);
@@ -356,8 +360,8 @@ void networking_poll(Networking_Core *net);
  * ip must be in network order EX: 127.0.0.1 = (7F000001).
  * port is in host byte order (this means don't worry about it).
  *
- *  return 0 if no problems.
- *  return -1 if there were problems.
+ * return Networking_Core object if no problems
+ * return NULL if there are problems.
  */
 Networking_Core *new_networking(IP ip, uint16_t port);
 
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 938b861e..c6093f0c 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -45,6 +45,63 @@ static void change_symmetric_key(Onion *onion)
     }
 }
 
+/* packing and unpacking functions */
+static void ip_pack(uint8_t *data, IP source)
+{
+    to_net_family(&source);
+
+    data[0] = source.family;
+
+    if (source.family == TOX_AF_INET || source.family == TOX_TCP_INET) {
+        memset(data + 1, 0, SIZE_IP6);
+        memcpy(data + 1, source.ip4.uint8, SIZE_IP4);
+    } else {
+        memcpy(data + 1, source.ip6.uint8, SIZE_IP6);
+    }
+}
+
+/* return 0 on success, -1 on failure. */
+static int ip_unpack(IP *target, const uint8_t *data, unsigned int data_size, _Bool disable_family_check)
+{
+    if (data_size < (1 + SIZE_IP6))
+        return -1;
+
+    target->family = data[0];
+
+    if (target->family == TOX_AF_INET || target->family == TOX_TCP_INET) {
+        memcpy(target->ip4.uint8, data + 1, SIZE_IP4);
+    } else {
+        memcpy(target->ip6.uint8, data + 1, SIZE_IP6);
+    }
+
+    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)
+{
+    ip_pack(data, source->ip);
+    memcpy(data + SIZE_IP, &source->port, SIZE_PORT);
+}
+
+/* return 0 on success, -1 on failure. */
+static int ipport_unpack(IP_Port *target, const uint8_t *data, unsigned int data_size, _Bool disable_family_check)
+{
+    if (data_size < (SIZE_IP + SIZE_PORT))
+        return -1;
+
+    if (ip_unpack(&target->ip, data, data_size, disable_family_check) == -1)
+        return -1;
+
+    memcpy(&target->port, data + SIZE_IP, SIZE_PORT);
+    return 0;
+}
+
+
 /* Create a new onion path.
  *
  * Create a new onion path out of nodes (nodes is a list of 3 nodes)
@@ -59,31 +116,51 @@ 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;
 
-    /* to_net_family(&new_path->ip_port1.ip); */
-    to_net_family(&new_path->ip_port2.ip);
-    to_net_family(&new_path->ip_port3.ip);
+    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;
 }
 
+/* Dump nodes in onion path to nodes of length num_nodes;
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_Path *path)
+{
+    if (num_nodes < 3)
+        return -1;
+
+    nodes[0].ip_port = path->ip_port1;
+    nodes[1].ip_port = path->ip_port2;
+    nodes[2].ip_port = path->ip_port3;
+
+    memcpy(nodes[0].public_key, path->node_public_key1, crypto_box_PUBLICKEYBYTES);
+    memcpy(nodes[1].public_key, path->node_public_key2, crypto_box_PUBLICKEYBYTES);
+    memcpy(nodes[2].public_key, path->node_public_key3, crypto_box_PUBLICKEYBYTES);
+    return 0;
+}
+
 /* Create a onion packet.
  *
  * Use Onion_Path path to create packet for data of length to dest.
@@ -94,15 +171,13 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
  * return length of created packet on success.
  */
 int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
-                        const uint8_t *data, uint32_t length)
+                        const uint8_t *data, uint16_t length)
 {
     if (1 + length + SEND_1 > max_packet_length || length == 0)
         return -1;
 
-    to_net_family(&dest.ip);
     uint8_t step1[SIZE_IPPORT + length];
 
-
     ipport_pack(step1, &dest);
     memcpy(step1 + SIZE_IPPORT, data, length);
 
@@ -116,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];
@@ -125,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;
@@ -135,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;
@@ -151,15 +226,13 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
  * return length of created packet on success.
  */
 int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
-                            const uint8_t *data, uint32_t length)
+                            const uint8_t *data, uint16_t length)
 {
     if (crypto_box_NONCEBYTES + SIZE_IPPORT + SEND_BASE * 2 + length > max_packet_length || length == 0)
         return -1;
 
-    to_net_family(&dest.ip);
     uint8_t step1[SIZE_IPPORT + length];
 
-
     ipport_pack(step1, &dest);
     memcpy(step1 + SIZE_IPPORT, data, length);
 
@@ -173,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);
@@ -181,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);
@@ -197,7 +270,7 @@ int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const O
  * return -1 on failure.
  * return 0 on success.
  */
-int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *data, uint32_t length)
+int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *data, uint16_t length)
 {
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     int len = create_onion_packet(packet, sizeof(packet), path, dest, data, length);
@@ -217,7 +290,7 @@ int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest
  * return -1 on failure.
  * return 0 on success.
  */
-int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data, uint32_t length, const uint8_t *ret)
+int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data, uint16_t length, const uint8_t *ret)
 {
     if (length > ONION_RESPONSE_MAX_DATA_SIZE || length == 0)
         return -1;
@@ -233,7 +306,7 @@ int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data,
     return 0;
 }
 
-static int handle_send_initial(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_send_initial(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -251,13 +324,13 @@ 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);
 }
 
-int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port source, const uint8_t *nonce)
+int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port source, const uint8_t *nonce)
 {
     if (len > ONION_MAX_PACKET_SIZE + SIZE_IPPORT - (1 + crypto_box_NONCEBYTES + ONION_RETURN_1))
         return 1;
@@ -266,8 +339,9 @@ int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port
         return 1;
 
     IP_Port send_to;
-    ipport_unpack(&send_to, plain);
-    to_host_family(&send_to.ip);
+
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+        return 1;
 
     uint8_t ip_port[SIZE_IPPORT];
     ipport_pack(ip_port, &source);
@@ -276,7 +350,7 @@ int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port
     data[0] = NET_PACKET_ONION_SEND_1;
     memcpy(data + 1, nonce, crypto_box_NONCEBYTES);
     memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
-    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
+    uint16_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
     new_nonce(ret_part);
     len = encrypt_data_symmetric(onion->secret_symmetric_key, ret_part, ip_port, SIZE_IPPORT,
@@ -293,7 +367,7 @@ int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port
     return 0;
 }
 
-static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -311,18 +385,19 @@ 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;
-    ipport_unpack(&send_to, plain);
-    to_host_family(&send_to.ip);
+
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+        return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_SEND_2;
     memcpy(data + 1, packet + 1, crypto_box_NONCEBYTES);
     memcpy(data + 1 + crypto_box_NONCEBYTES, plain + SIZE_IPPORT, len - SIZE_IPPORT);
-    uint32_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
+    uint16_t data_len = 1 + crypto_box_NONCEBYTES + (len - SIZE_IPPORT);
     uint8_t *ret_part = data + data_len;
     new_nonce(ret_part);
     uint8_t ret_data[RETURN_1 + SIZE_IPPORT];
@@ -342,7 +417,7 @@ static int handle_send_1(void *object, IP_Port source, const uint8_t *packet, ui
     return 0;
 }
 
-static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -360,16 +435,17 @@ 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;
-    ipport_unpack(&send_to, plain);
-    to_host_family(&send_to.ip);
+
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+        return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     memcpy(data, plain + SIZE_IPPORT, len - SIZE_IPPORT);
-    uint32_t data_len = (len - SIZE_IPPORT);
+    uint16_t data_len = (len - SIZE_IPPORT);
     uint8_t *ret_part = data + (len - SIZE_IPPORT);
     new_nonce(ret_part);
     uint8_t ret_data[RETURN_2 + SIZE_IPPORT];
@@ -390,7 +466,7 @@ static int handle_send_2(void *object, IP_Port source, const uint8_t *packet, ui
 }
 
 
-static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -410,13 +486,15 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
         return 1;
 
     IP_Port send_to;
-    ipport_unpack(&send_to, plain);
+
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+        return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_2;
     memcpy(data + 1, plain + SIZE_IPPORT, RETURN_2);
     memcpy(data + 1 + RETURN_2, packet + 1 + RETURN_3, length - (1 + RETURN_3));
-    uint32_t data_len = 1 + RETURN_2 + (length - (1 + RETURN_3));
+    uint16_t data_len = 1 + RETURN_2 + (length - (1 + RETURN_3));
 
     if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
         return 1;
@@ -424,7 +502,7 @@ static int handle_recv_3(void *object, IP_Port source, const uint8_t *packet, ui
     return 0;
 }
 
-static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -444,13 +522,15 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
         return 1;
 
     IP_Port send_to;
-    ipport_unpack(&send_to, plain);
+
+    if (ipport_unpack(&send_to, plain, len, 0) == -1)
+        return 1;
 
     uint8_t data[ONION_MAX_PACKET_SIZE];
     data[0] = NET_PACKET_ONION_RECV_1;
     memcpy(data + 1, plain + SIZE_IPPORT, RETURN_1);
     memcpy(data + 1 + RETURN_1, packet + 1 + RETURN_2, length - (1 + RETURN_2));
-    uint32_t data_len = 1 + RETURN_1 + (length - (1 + RETURN_2));
+    uint16_t data_len = 1 + RETURN_1 + (length - (1 + RETURN_2));
 
     if ((uint32_t)sendpacket(onion->net, send_to, data, data_len) != data_len)
         return 1;
@@ -458,7 +538,7 @@ static int handle_recv_2(void *object, IP_Port source, const uint8_t *packet, ui
     return 0;
 }
 
-static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion *onion = object;
 
@@ -478,9 +558,11 @@ static int handle_recv_1(void *object, IP_Port source, const uint8_t *packet, ui
         return 1;
 
     IP_Port send_to;
-    ipport_unpack(&send_to, plain);
 
-    uint32_t data_len = length - (1 + RETURN_1);
+    if (ipport_unpack(&send_to, plain, len, 1) == -1)
+        return 1;
+
+    uint16_t data_len = length - (1 + RETURN_1);
 
     if (onion->recv_1_function && send_to.ip.family != AF_INET && send_to.ip.family != AF_INET6)
         return onion->recv_1_function(onion->callback_object, send_to, packet + (1 + RETURN_1), data_len);
diff --git a/toxcore/onion.h b/toxcore/onion.h
index e8e7042c..b05d2c8c 100644
--- a/toxcore/onion.h
+++ b/toxcore/onion.h
@@ -63,8 +63,13 @@ typedef struct {
     uint8_t public_key3[crypto_box_PUBLICKEYBYTES];
 
     IP_Port     ip_port1;
+    uint8_t     node_public_key1[crypto_box_PUBLICKEYBYTES];
+
     IP_Port     ip_port2;
+    uint8_t     node_public_key2[crypto_box_PUBLICKEYBYTES];
+
     IP_Port     ip_port3;
+    uint8_t     node_public_key3[crypto_box_PUBLICKEYBYTES];
 
     uint32_t path_num;
 } Onion_Path;
@@ -80,6 +85,13 @@ typedef struct {
  */
 int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *nodes);
 
+/* Dump nodes in onion path to nodes of length num_nodes;
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_Path *path);
+
 /* Create a onion packet.
  *
  * Use Onion_Path path to create packet for data of length to dest.
@@ -90,7 +102,7 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
  * return length of created packet on success.
  */
 int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
-                        const uint8_t *data, uint32_t length);
+                        const uint8_t *data, uint16_t length);
 
 
 /* Create a onion packet to be sent over tcp.
@@ -103,7 +115,7 @@ int create_onion_packet(uint8_t *packet, uint16_t max_packet_length, const Onion
  * return length of created packet on success.
  */
 int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
-                            const uint8_t *data, uint32_t length);
+                            const uint8_t *data, uint16_t length);
 
 /* Create and send a onion packet.
  *
@@ -113,7 +125,7 @@ int create_onion_packet_tcp(uint8_t *packet, uint16_t max_packet_length, const O
  * return -1 on failure.
  * return 0 on success.
  */
-int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *data, uint32_t length);
+int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *data, uint16_t length);
 
 /* Create and send a onion response sent initially to dest with.
  * Maximum length of data is ONION_RESPONSE_MAX_DATA_SIZE.
@@ -121,7 +133,7 @@ int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest
  * return -1 on failure.
  * return 0 on success.
  */
-int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data, uint32_t length, const uint8_t *ret);
+int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data, uint16_t length, const uint8_t *ret);
 
 /* Function to handle/send received decrypted versions of the packet sent with send_onion_packet.
  *
@@ -133,11 +145,11 @@ int send_onion_response(Networking_Core *net, IP_Port dest, const uint8_t *data,
  * Source family must be set to something else than AF_INET6 or AF_INET so that the callback gets called
  * when the response is received.
  */
-int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port source, const uint8_t *nonce);
+int onion_send_1(const Onion *onion, const uint8_t *plain, uint16_t len, IP_Port source, const uint8_t *nonce);
 
 /* Set the callback to be called when the dest ip_port doesn't have AF_INET6 or AF_INET as the family.
  *
- * Format: function(void *object, IP_Port dest, uint8_t *data, uint32_t length)
+ * Format: function(void *object, IP_Port dest, uint8_t *data, uint16_t length)
  */
 void set_callback_handle_recv_1(Onion *onion, int (*function)(void *, IP_Port, const uint8_t *, uint16_t),
                                 void *object);
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index f5c38eea..25f3e0f8 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -108,8 +108,8 @@ int create_data_request(uint8_t *packet, uint16_t max_packet_length, const uint8
     int len = encrypt_data(encrypt_public_key, random_secret_key, packet + 1 + crypto_box_PUBLICKEYBYTES, data, length,
                            packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
 
-    if (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES +
-            (uint32_t)len != DATA_REQUEST_MIN_SIZE + length)
+    if (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + len != DATA_REQUEST_MIN_SIZE +
+            length)
         return -1;
 
     return DATA_REQUEST_MIN_SIZE + length;
@@ -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))
@@ -178,6 +178,9 @@ int send_data_request(Networking_Core *net, const Onion_Path *path, IP_Port dest
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     len = create_onion_packet(packet, sizeof(packet), path, dest, request, len);
 
+    if (len == -1)
+        return -1;
+
     if (sendpacket(net, path->ip_port1, packet, len) != len)
         return -1;
 
@@ -204,7 +207,7 @@ static void generate_ping_id(const Onion_Announce *onion_a, uint64_t time, const
  */
 static int in_entries(const Onion_Announce *onion_a, const uint8_t *public_key)
 {
-    uint32_t i;
+    unsigned int i;
 
     for (i = 0; i < ONION_ANNOUNCE_MAX_ENTRIES; ++i) {
         if (!is_timeout(onion_a->entries[i].time, ONION_ANNOUNCE_TIMEOUT)
@@ -255,7 +258,7 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
 
     int pos = in_entries(onion_a, public_key);
 
-    uint32_t i;
+    unsigned int i;
 
     if (pos == -1) {
         for (i = 0; i < ONION_ANNOUNCE_MAX_ENTRIES; ++i) {
@@ -283,7 +286,7 @@ static int add_to_entries(Onion_Announce *onion_a, IP_Port ret_ip_port, const ui
     return in_entries(onion_a, public_key);
 }
 
-static int handle_announce_request(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_announce_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion_Announce *onion_a = object;
 
@@ -322,8 +325,8 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
 
     /*Respond with a announce response packet*/
     Node_format nodes_list[MAX_SENT_NODES];
-    uint32_t num_nodes = get_close_nodes(onion_a->dht, plain + ONION_PING_ID_SIZE, nodes_list, 0, LAN_ip(source.ip) == 0,
-                                         1);
+    unsigned int num_nodes = get_close_nodes(onion_a->dht, plain + ONION_PING_ID_SIZE, nodes_list, 0,
+                             LAN_ip(source.ip) == 0, 1);
     uint8_t nonce[crypto_box_NONCEBYTES];
     random_nonce(nonce);
 
@@ -333,10 +336,14 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
         pl[0] = 0;
         memcpy(pl + 1, ping_id2, ONION_PING_ID_SIZE);
     } else {
-        if (memcmp(onion_a->entries[index].public_key, packet_public_key, crypto_box_PUBLICKEYBYTES) == 0
-                && memcmp(onion_a->entries[index].data_public_key, data_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
-            pl[0] = 0;
-            memcpy(pl + 1, ping_id2, ONION_PING_ID_SIZE);
+        if (memcmp(onion_a->entries[index].public_key, packet_public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+            if (memcmp(onion_a->entries[index].data_public_key, data_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
+                pl[0] = 0;
+                memcpy(pl + 1, ping_id2, ONION_PING_ID_SIZE);
+            } else {
+                pl[0] = 2;
+                memcpy(pl + 1, ping_id2, ONION_PING_ID_SIZE);
+            }
         } else {
             pl[0] = 1;
             memcpy(pl + 1, onion_a->entries[index].data_public_key, crypto_box_PUBLICKEYBYTES);
@@ -372,7 +379,7 @@ static int handle_announce_request(void *object, IP_Port source, const uint8_t *
     return 0;
 }
 
-static int handle_data_request(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_data_request(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion_Announce *onion_a = object;
 
diff --git a/toxcore/onion_announce.h b/toxcore/onion_announce.h
index f2ba3715..36ffe767 100644
--- a/toxcore/onion_announce.h
+++ b/toxcore/onion_announce.h
@@ -25,7 +25,7 @@
 
 #include "onion.h"
 
-#define ONION_ANNOUNCE_MAX_ENTRIES 48
+#define ONION_ANNOUNCE_MAX_ENTRIES 64
 #define ONION_ANNOUNCE_TIMEOUT 300
 #define ONION_PING_ID_SIZE crypto_hash_sha256_BYTES
 
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index fb725ef6..3643cb2f 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -33,12 +33,42 @@
 #define ANNOUNCE_ARRAY_SIZE 256
 #define ANNOUNCE_TIMEOUT 10
 
+/* Add a node to the path_nodes bootstrap array.
+ *
+ * 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 *public_key)
+{
+    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+        return -1;
+
+    unsigned int i;
+
+    for (i = 0; i < MAX_PATH_NODES; ++i) {
+        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].public_key, public_key,
+           crypto_box_PUBLICKEYBYTES);
+
+    uint16_t last = onion_c->path_nodes_index_bs;
+    ++onion_c->path_nodes_index_bs;
+
+    if (onion_c->path_nodes_index_bs < last)
+        onion_c->path_nodes_index_bs = MAX_PATH_NODES + 1;
+
+    return 0;
+}
+
 /* Add a node to the path_nodes array.
  *
  * return -1 on failure
  * return 0 on success
  */
-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;
@@ -46,12 +76,13 @@ int onion_add_path_node(Onion_Client *onion_c, IP_Port ip_port, const uint8_t *c
     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;
@@ -103,20 +134,39 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
 
     //if (DHT_non_lan_connected(onion_c->dht)) {
     if (DHT_isconnected(onion_c->dht)) {
-        if (num_nodes < 3)
-            return random_nodes_path(onion_c->dht, nodes, max_num);
+        if (num_nodes == 0)
+            return 0;
 
         for (i = 0; i < max_num; ++i) {
             nodes[i] = onion_c->path_nodes[rand() % num_nodes];
         }
     } else {
-        if (num_nodes == 0)
+        int random_tcp = get_random_tcp_con_number(onion_c->c);
+
+        if (random_tcp == -1) {
             return 0;
+        }
 
-        nodes[0].ip_port.ip.family = TCP_FAMILY;
+        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];
+            for (i = 1; i < max_num; ++i) {
+                nodes[i] = onion_c->path_nodes[rand() % num_nodes];
+            }
+        } else {
+            unsigned int num_nodes_bs = (onion_c->path_nodes_index_bs < MAX_PATH_NODES) ? onion_c->path_nodes_index_bs :
+                                        MAX_PATH_NODES;
+
+            if (num_nodes_bs == 0)
+                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];
+            }
         }
     }
 
@@ -129,7 +179,7 @@ static uint16_t random_nodes_path_onion(const Onion_Client *onion_c, Node_format
  */
 static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format *nodes)
 {
-    uint32_t i;
+    unsigned int i;
 
     for (i = 0; i < NUMBER_ONION_PATHS; ++i) {
         if (is_timeout(onion_paths->last_path_success[i], ONION_PATH_TIMEOUT)) {
@@ -149,7 +199,7 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
 }
 
 /* Create a new path or use an old suitable one (if pathnum is valid)
- * or a rondom one from onion_paths.
+ * or a random one from onion_paths.
  *
  * return -1 on failure
  * return 0 on success
@@ -162,7 +212,8 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
     if (pathnum >= NUMBER_ONION_PATHS)
         pathnum = rand() % NUMBER_ONION_PATHS;
 
-    if (is_timeout(onion_paths->last_path_success[pathnum], ONION_PATH_TIMEOUT)
+    if ((onion_paths->last_path_success[pathnum] + ONION_PATH_TIMEOUT < onion_paths->last_path_used[pathnum]
+            && onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES)
             || is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME)) {
         Node_format nodes[3];
 
@@ -177,6 +228,8 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
 
             onion_paths->last_path_success[pathnum] = unix_time() + ONION_PATH_FIRST_TIMEOUT - ONION_PATH_TIMEOUT;
             onion_paths->path_creation_time[pathnum] = unix_time();
+            onion_paths->last_path_used_times[pathnum] = ONION_PATH_MAX_NO_RESPONSE_USES / 2;
+
             uint32_t path_num = rand();
             path_num /= NUMBER_ONION_PATHS;
             path_num *= NUMBER_ONION_PATHS;
@@ -188,6 +241,8 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
         }
     }
 
+    ++onion_paths->last_path_used_times[pathnum];
+    onion_paths->last_path_used[pathnum] = unix_time();
     memcpy(path, &onion_paths->paths[pathnum], sizeof(Onion_Path));
     return 0;
 }
@@ -203,13 +258,26 @@ 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) {
         onion_paths->last_path_success[path_num % NUMBER_ONION_PATHS] = unix_time();
+        onion_paths->last_path_used_times[path_num % NUMBER_ONION_PATHS] = 0;
+
+        unsigned int path_len = 3;
+        Node_format nodes[path_len];
+
+        if (onion_path_to_nodes(nodes, path_len, &onion_paths->paths[path_num % NUMBER_ONION_PATHS]) == 0) {
+            unsigned int i;
+
+            for (i = 0; i < path_len; ++i) {
+                onion_add_path_node(onion_c, nodes[i].ip_port, nodes[i].public_key);
+            }
+        }
+
         return path_num % NUMBER_ONION_PATHS;
     }
 
@@ -222,7 +290,7 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
  * return 0 on success.
  */
 static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Path *path, IP_Port dest,
-                                     const uint8_t *data, uint32_t length)
+                                     const uint8_t *data, uint16_t length)
 {
     if (path->ip_port1.ip.family == AF_INET || path->ip_port1.ip.family == AF_INET6) {
         uint8_t packet[ONION_MAX_PACKET_SIZE];
@@ -231,7 +299,7 @@ static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, const Onion_Pa
         if (len == -1)
             return -1;
 
-        if ((uint32_t)sendpacket(onion_c->net, path->ip_port1, packet, len) != len)
+        if (sendpacket(onion_c->net, path->ip_port1, packet, len) != len)
             return -1;
 
         return 0;
@@ -242,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;
     }
@@ -318,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;
     }
 
@@ -333,9 +401,6 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
     if (ping_id == NULL)
         ping_id = zero_ping_id;
 
-    Node_format dest_node;
-    dest_node.ip_port = dest;
-    memcpy(dest_node.client_id, dest_pubkey, crypto_box_PUBLICKEYBYTES);
     uint8_t request[ONION_ANNOUNCE_REQUEST_SIZE];
     int len;
 
@@ -345,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);
     }
 
@@ -374,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;
@@ -398,28 +463,31 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t
         list_nodes = onion_c->clients_announce_list;
         reference_id = onion_c->c->self_public_key;
 
-        if (is_stored && memcmp(pingid_or_key, onion_c->temp_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
+        if (is_stored == 1 && memcmp(pingid_or_key, onion_c->temp_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
             is_stored = 0;
         }
 
     } else {
+        if (is_stored >= 2)
+            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);
     qsort(list_nodes, MAX_ONION_CLIENTS, sizeof(Onion_Node), cmp_entry);
 
     int index = -1, stored = 0;
-    uint32_t i;
+    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;
@@ -429,13 +497,13 @@ 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.
     onion_add_path_node(onion_c, ip_port, public_key);
 
-    if (is_stored) {
+    if (is_stored == 1) {
         memcpy(list_nodes[index].data_public_key, pingid_or_key, crypto_box_PUBLICKEYBYTES);
     } else {
         memcpy(list_nodes[index].ping_id, pingid_or_key, ONION_PING_ID_SIZE);
@@ -451,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)
 {
-    uint32_t i;
+    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;
@@ -489,12 +557,12 @@ 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;
     }
 
-    uint32_t i, j;
+    unsigned int i, j;
     int lan_ips_accepted = (LAN_ip(source.ip) == 0);
 
     for (i = 0; i < num_nodes; ++i) {
@@ -504,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);
             }
         }
     }
@@ -521,7 +589,7 @@ static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_for
     return 0;
 }
 
-static int handle_announce_response(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_announce_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion_Client *onion_c = object;
 
@@ -572,12 +640,14 @@ static int handle_announce_response(void *object, IP_Port source, const uint8_t
             return 1;
     }
 
+    //TODO: LAN vs non LAN ips?, if we are connected only to LAN, are we offline?
+    onion_c->last_packet_recv = unix_time();
     return 0;
 }
 
 #define DATA_IN_RESPONSE_MIN_SIZE ONION_DATA_IN_RESPONSE_MIN_SIZE
 
-static int handle_data_response(void *object, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_data_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     Onion_Client *onion_c = object;
 
@@ -609,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, uint32_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);
@@ -635,10 +704,15 @@ static int handle_fakeid_announce(void *object, const uint8_t *source_pubkey, co
         return 1;
 
     onion_c->friends_list[friend_num].last_noreplay = no_replay;
-    onion_set_friend_DHT_pubkey(onion_c, friend_num, data + 1 + sizeof(uint64_t), current_time_monotonic());
+
+    if (onion_c->friends_list[friend_num].dht_pk_callback)
+        onion_c->friends_list[friend_num].dht_pk_callback(onion_c->friends_list[friend_num].dht_pk_callback_object,
+                onion_c->friends_list[friend_num].dht_pk_callback_number, data + 1 + sizeof(uint64_t));
+
+    onion_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];
@@ -654,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);
                 }
             }
         }
@@ -693,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, uint32_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;
@@ -704,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;
-
-    uint32_t i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0;
-    Onion_Path path[MAX_ONION_CLIENTS];
+    unsigned int i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0;
     Onion_Node *list_nodes = onion_c->friends_list[friend_num].clients_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
@@ -726,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;
         }
@@ -737,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;
 
-    uint32_t good = 0;
+    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, uint32_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];
@@ -775,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))
@@ -783,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_DHTPK);
 
     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,
-                             uint32_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.
  *
@@ -824,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));
@@ -842,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)
@@ -852,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;
@@ -871,15 +946,15 @@ 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)
 {
-    uint32_t i;
+    unsigned int i;
 
     for (i = 0; i < onion_c->num_friends; ++i) {
         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;
     }
 
@@ -913,14 +988,14 @@ 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;
 
-    uint32_t i, index = ~0;
+    unsigned int i, index = ~0;
 
     for (i = 0; i < onion_c->num_friends; ++i) {
         if (onion_c->friends_list[i].status == 0) {
@@ -939,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;
 }
@@ -954,11 +1029,11 @@ 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);
+    //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));
-    uint32_t i;
+    unsigned int i;
 
     for (i = onion_c->num_friends; i != 0; --i) {
         if (onion_c->friends_list[i - 1].status != 0)
@@ -993,40 +1068,50 @@ int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_rela
     return 0;
 }
 
-/* Set a friends DHT public key.
- * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
- * the other peer.
+/* Set the function for this friend that will be callbacked with object and number
+ * when that friend gives us his DHT temporary public key.
+ *
+ * object and number will be passed as argument to this function.
  *
  * return -1 on failure.
  * return 0 on success.
  */
-int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key, uint64_t timestamp)
+int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function)(void *data, int32_t number,
+                          const uint8_t *dht_public_key), void *object, uint32_t number)
 {
     if ((uint32_t)friend_num >= onion_c->num_friends)
         return -1;
 
-    if (onion_c->friends_list[friend_num].status == 0)
+    onion_c->friends_list[friend_num].dht_pk_callback = function;
+    onion_c->friends_list[friend_num].dht_pk_callback_object = object;
+    onion_c->friends_list[friend_num].dht_pk_callback_number = number;
+    return 0;
+}
+
+/* Set a friends DHT public key.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key)
+{
+    if ((uint32_t)friend_num >= onion_c->num_friends)
         return -1;
 
-    if (onion_c->friends_list[friend_num].fake_client_id_timestamp >= timestamp)
+    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;
         }
 
-        DHT_delfriend(onion_c->dht, onion_c->friends_list[friend_num].fake_client_id);
-    }
-
-    if (DHT_addfriend(onion_c->dht, dht_key) == 1) {
-        return -1;
+        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;
-    onion_c->friends_list[friend_num].fake_client_id_timestamp = timestamp;
-    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;
 }
@@ -1034,9 +1119,9 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
 /* Copy friends DHT public key into dht_key.
  *
  * return 0 on failure (no key copied).
- * return timestamp on success (key copied).
+ * return 1 on success (key copied).
  */
-uint64_t onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key)
+unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key)
 {
     if ((uint32_t)friend_num >= onion_c->num_friends)
         return 0;
@@ -1044,18 +1129,18 @@ uint64_t onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num,
     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);
-    return onion_c->friends_list[friend_num].fake_client_id_timestamp;
+    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)
@@ -1089,8 +1174,10 @@ int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_on
     onion_c->friends_list[friend_num].is_online = is_online;
 
     /* This should prevent some clock related issues */
-    if (!is_online)
+    if (!is_online) {
         onion_c->friends_list[friend_num].last_noreplay = 0;
+        onion_c->friends_list[friend_num].run_count = 0;
+    }
 
     return 0;
 }
@@ -1098,23 +1185,35 @@ 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, public_key, nodes_list, (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
+    unsigned int i;
 
-    uint32_t num_nodes = get_close_nodes(onion_c->dht, client_id, nodes_list, (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
+    for (i = 0; i < num_nodes; ++i) {
+        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].public_key);
+    }
+}
+
+static void populate_path_nodes_tcp(Onion_Client *onion_c)
+{
+    Node_format nodes_list[MAX_SENT_NODES];
+
+    unsigned int num_nodes = copy_connected_tcp_relays(onion_c->c, nodes_list, MAX_SENT_NODES);;
     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);
     }
 }
 
-#define ANNOUNCE_FRIEND (ONION_NODE_PING_INTERVAL * 3)
-#define ANNOUNCE_FRIEND_BEGINNING 5
-#define FRIEND_ONION_NODE_TIMEOUT (ONION_NODE_TIMEOUT * 3)
+#define ANNOUNCE_FRIEND (ONION_NODE_PING_INTERVAL * 6)
+#define ANNOUNCE_FRIEND_BEGINNING 3
+#define FRIEND_ONION_NODE_TIMEOUT (ONION_NODE_TIMEOUT * 6)
 
-#define RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING 15
+#define RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING 17
 
 static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
 {
@@ -1124,18 +1223,15 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
     if (onion_c->friends_list[friendnum].status == 0)
         return;
 
-    uint32_t interval = ANNOUNCE_FRIEND;
+    unsigned int interval = ANNOUNCE_FRIEND;
 
     if (onion_c->friends_list[friendnum].run_count < RUN_COUNT_FRIEND_ANNOUNCE_BEGINNING)
         interval = ANNOUNCE_FRIEND_BEGINNING;
 
-    uint32_t i, count = 0;
+    unsigned int i, count = 0;
     Onion_Node *list_nodes = onion_c->friends_list[friendnum].clients_list;
 
     if (!onion_c->friends_list[friendnum].is_online) {
-
-        ++onion_c->friends_list[friendnum].run_count;
-
         for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
             if (is_timeout(list_nodes[i].timestamp, FRIEND_ONION_NODE_TIMEOUT))
                 continue;
@@ -1149,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();
                 }
             }
@@ -1169,40 +1265,27 @@ 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;
             }
+        } else {
+            ++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();
 
     }
 }
 
-/* Timeout before which a peer is considered dead and removed from the DHT search. */
-#define DEAD_ONION_TIMEOUT (10 * 60)
-
-static void cleanup_friend(Onion_Client *onion_c, uint16_t friendnum)
-{
-    if (friendnum >= onion_c->num_friends)
-        return;
-
-    if (onion_c->friends_list[friendnum].status == 0)
-        return;
-
-    if (onion_c->friends_list[friendnum].is_fake_clientid && !onion_c->friends_list[friendnum].is_online
-            && is_timeout(onion_c->friends_list[friendnum].last_seen, DEAD_ONION_TIMEOUT)) {
-        onion_c->friends_list[friendnum].is_fake_clientid = 0;
-        DHT_delfriend(onion_c->dht, onion_c->friends_list[friendnum].fake_client_id);
-    }
-}
 
 /* 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)
@@ -1211,12 +1294,12 @@ void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_ha
     onion_c->Onion_Data_Handlers[byte].object = object;
 }
 
-#define ANNOUNCE_INTERVAL_NOT_ANNOUNCED 5
+#define ANNOUNCE_INTERVAL_NOT_ANNOUNCED 3
 #define ANNOUNCE_INTERVAL_ANNOUNCED ONION_NODE_PING_INTERVAL
 
 static void do_announce(Onion_Client *onion_c)
 {
-    uint32_t i, count = 0;
+    unsigned int i, count = 0;
     Onion_Node *list_nodes = onion_c->clients_announce_list;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
@@ -1231,14 +1314,14 @@ static void do_announce(Onion_Client *onion_c)
             continue;
         }
 
-        uint32_t interval = ANNOUNCE_INTERVAL_NOT_ANNOUNCED;
+        unsigned int interval = ANNOUNCE_INTERVAL_NOT_ANNOUNCED;
 
         if (list_nodes[i].is_stored) {
             interval = ANNOUNCE_INTERVAL_ANNOUNCED;
         }
 
         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();
             }
@@ -1246,37 +1329,45 @@ static void do_announce(Onion_Client *onion_c)
     }
 
     if (count != MAX_ONION_CLIENTS) {
-        if (count < (uint32_t)rand() % MAX_ONION_CLIENTS) {
+        unsigned int num_nodes;
+        Node_format *path_nodes;
 
-            unsigned int num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
+        if (rand() % 2 == 0 || onion_c->path_nodes_index == 0) {
+            num_nodes = (onion_c->path_nodes_index_bs < MAX_PATH_NODES) ? onion_c->path_nodes_index_bs : MAX_PATH_NODES;
+            path_nodes = onion_c->path_nodes_bs;
+        } else {
+            num_nodes = (onion_c->path_nodes_index < MAX_PATH_NODES) ? onion_c->path_nodes_index : MAX_PATH_NODES;
+            path_nodes = onion_c->path_nodes;
+        }
 
+        if (count < (uint32_t)rand() % MAX_ONION_CLIENTS) {
             if (num_nodes != 0) {
-                unsigned int num = rand() % num_nodes;
-                client_send_announce_request(onion_c, 0, onion_c->path_nodes[num].ip_port, onion_c->path_nodes[num].client_id, 0, ~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].public_key, 0, ~0);
+                }
             }
         }
     }
 }
 
-#define NODE_POPULATE_TIMES 4
-
 void do_onion_client(Onion_Client *onion_c)
 {
-    uint32_t i;
+    unsigned int i;
 
     if (onion_c->last_run == unix_time())
         return;
 
-    for (i = 0; i < NODE_POPULATE_TIMES; ++i)
-        populate_path_nodes(onion_c);
+    populate_path_nodes(onion_c);
 
     do_announce(onion_c);
 
     if (onion_isconnected(onion_c)) {
         for (i = 0; i < onion_c->num_friends; ++i) {
             do_friend(onion_c, i);
-            cleanup_friend(onion_c, i);
         }
+    } else {
+        populate_path_nodes_tcp(onion_c);
     }
 
     onion_c->last_run = unix_time();
@@ -1304,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_DHTPK, &handle_dht_dhtpk, onion_c);
     tcp_onion_response_handler(onion_c->c, &handle_tcp_onion, onion_c);
 
     return onion_c;
@@ -1320,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_DHTPK, NULL, NULL);
     tcp_onion_response_handler(onion_c->c, NULL, NULL);
     memset(onion_c, 0, sizeof(Onion_Client));
     free(onion_c);
@@ -1333,10 +1424,34 @@ void kill_onion_client(Onion_Client *onion_c)
  */
 int onion_isconnected(const Onion_Client *onion_c)
 {
-    unsigned int i;
+    unsigned int i, num = 0, announced = 0;
+
+    if (is_timeout(onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT))
+        return 0;
+
+    if (onion_c->path_nodes_index == 0)
+        return 0;
 
     for (i = 0; i < MAX_ONION_CLIENTS; ++i) {
-        if (!is_timeout(onion_c->clients_announce_list[i].timestamp, ONION_NODE_TIMEOUT))
+        if (!is_timeout(onion_c->clients_announce_list[i].timestamp, ONION_NODE_TIMEOUT)) {
+            ++num;
+
+            if (onion_c->clients_announce_list[i].is_stored) {
+                ++announced;
+            }
+        }
+    }
+
+    unsigned int pnodes = onion_c->path_nodes_index;
+
+    if (pnodes > MAX_ONION_CLIENTS) {
+        pnodes = MAX_ONION_CLIENTS;
+    }
+
+    /* Consider ourselves online if we are announced to half or more nodes
+      we are connected to */
+    if (num && announced) {
+        if ((num / 2) <= announced && (pnodes / 2) <= num)
             return 1;
     }
 
diff --git a/toxcore/onion_client.h b/toxcore/onion_client.h
index cf0975d3..6851d929 100644
--- a/toxcore/onion_client.h
+++ b/toxcore/onion_client.h
@@ -29,28 +29,38 @@
 #include "ping_array.h"
 
 #define MAX_ONION_CLIENTS 8
-#define ONION_NODE_PING_INTERVAL 30
-#define ONION_NODE_TIMEOUT (ONION_NODE_PING_INTERVAL * 4)
+#define ONION_NODE_PING_INTERVAL 20
+#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 3
+#define NUMBER_ONION_PATHS 6
 
 /* The timeout the first time the path is added and
    then for all the next consecutive times */
-#define ONION_PATH_FIRST_TIMEOUT 5
-#define ONION_PATH_TIMEOUT 30
-#define ONION_PATH_MAX_LIFETIME 600
+#define ONION_PATH_FIRST_TIMEOUT 4
+#define ONION_PATH_TIMEOUT 10
+#define ONION_PATH_MAX_LIFETIME 1200
+#define ONION_PATH_MAX_NO_RESPONSE_USES 4
 
 #define MAX_STORED_PINGED_NODES 9
 #define MIN_NODE_PING_TIME 10
 
 #define MAX_PATH_NODES 32
 
+/* If no packets are received within that interval tox will
+ * be considered offline.
+ */
+#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_DHTPK
+
 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];
@@ -66,11 +76,14 @@ typedef struct {
 typedef struct {
     Onion_Path paths[NUMBER_ONION_PATHS];
     uint64_t last_path_success[NUMBER_ONION_PATHS];
+    uint64_t last_path_used[NUMBER_ONION_PATHS];
     uint64_t path_creation_time[NUMBER_ONION_PATHS];
+    /* number of times used without success. */
+    unsigned int last_path_used_times[NUMBER_ONION_PATHS];
 } Onion_Client_Paths;
 
 typedef struct {
-    uint8_t     client_id[CLIENT_ID_SIZE];
+    uint8_t     public_key[crypto_box_PUBLICKEYBYTES];
     uint64_t    timestamp;
 } Last_Pinged;
 
@@ -78,24 +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. */
-    uint64_t fake_client_id_timestamp;
-    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;
 
@@ -103,11 +113,15 @@ typedef struct {
     void *tcp_relay_node_callback_object;
     uint32_t tcp_relay_node_callback_number;
 
+    void (*dht_pk_callback)(void *data, int32_t number, const uint8_t *dht_public_key);
+    void *dht_pk_callback_object;
+    uint32_t dht_pk_callback_number;
+
     uint32_t run_count;
 } Onion_Friend;
 
 typedef int (*oniondata_handler_callback)(void *object, const uint8_t *source_pubkey, const uint8_t *data,
-        uint32_t len);
+        uint16_t len);
 
 typedef struct {
     DHT     *dht;
@@ -118,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;
@@ -131,21 +146,26 @@ typedef struct {
     Node_format path_nodes[MAX_PATH_NODES];
     uint16_t path_nodes_index;
 
+    Node_format path_nodes_bs[MAX_PATH_NODES];
+    uint16_t path_nodes_index_bs;
+
     Ping_Array announce_ping_array;
     uint8_t last_pinged_index;
     struct {
         oniondata_handler_callback function;
         void *object;
     } Onion_Data_Handlers[256];
+
+    uint64_t last_packet_recv;
 } Onion_Client;
 
 
-/* Add a node to the path_nodes array.
+/* Add a node to the path_nodes bootstrap array.
  *
  * return -1 on failure
  * return 0 on success
  */
-int onion_add_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.
  *
@@ -158,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.
  *
@@ -187,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);
@@ -205,6 +225,18 @@ int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_p
 int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_relay_node_callback)(void *object,
                            uint32_t number, IP_Port ip_port, const uint8_t *public_key), void *object, uint32_t number);
 
+
+/* Set the function for this friend that will be callbacked with object and number
+ * when that friend gives us his DHT temporary public key.
+ *
+ * object and number will be passed as argument to this function.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int onion_dht_pk_callback(Onion_Client *onion_c, int friend_num, void (*function)(void *data, int32_t number,
+                          const uint8_t *dht_public_key), void *object, uint32_t number);
+
 /* Set a friends DHT public key.
  * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
  * the other peer.
@@ -212,14 +244,14 @@ int recv_tcp_relay_handler(Onion_Client *onion_c, int friend_num, int (*tcp_rela
  * return -1 on failure.
  * return 0 on success.
  */
-int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key, uint64_t timestamp);
+int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uint8_t *dht_key);
 
 /* Copy friends DHT public key into dht_key.
  *
  * return 0 on failure (no key copied).
- * return timestamp on success (key copied).
+ * return 1 on success (key copied).
  */
-uint64_t onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key);
+unsigned int onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num, uint8_t *dht_key);
 
 #define ONION_DATA_IN_RESPONSE_MIN_SIZE (crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES)
 #define ONION_CLIENT_MAX_DATA_SIZE (MAX_DATA_REQUEST_SIZE - ONION_DATA_IN_RESPONSE_MIN_SIZE)
@@ -233,7 +265,7 @@ uint64_t onion_getfriend_DHT_pubkey(const Onion_Client *onion_c, int friend_num,
  * 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, uint32_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 e00036af..1c3564a3 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -39,10 +39,10 @@
 #define PING_NUM_MAX 512
 
 /* Maximum newly announced nodes to ping per TIME_TO_PING seconds. */
-#define MAX_TO_PING 8
+#define MAX_TO_PING 16
 
 /* Ping newly announced nodes to ping per TIME_TO_PING seconds*/
-#define TIME_TO_PING 8
+#define TIME_TO_PING 4
 
 
 struct PING {
@@ -129,7 +129,7 @@ static int send_ping_response(PING *ping, IP_Port ipp, const uint8_t *client_id,
     return sendpacket(ping->dht->net, ipp, pk, sizeof(pk));
 }
 
-static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     DHT       *dht = _dht;
     int        rc;
@@ -168,7 +168,7 @@ static int handle_ping_request(void *_dht, IP_Port source, const uint8_t *packet
     return 0;
 }
 
-static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packet, uint32_t length)
+static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packet, uint16_t length)
 {
     DHT      *dht = _dht;
     int       rc;
@@ -225,7 +225,7 @@ static int handle_ping_response(void *_dht, IP_Port source, const uint8_t *packe
  * return 1 if it is.
  * return 0 if it isn't.
  */
-static int in_list(const Client_data *list, uint32_t length, const uint8_t *client_id, IP_Port ip_port)
+static int in_list(const Client_data *list, uint16_t length, const uint8_t *client_id, IP_Port ip_port)
 {
     uint32_t i;
 
@@ -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;
         }
@@ -301,6 +301,9 @@ void do_to_ping(PING *ping)
     if (!is_timeout(ping->last_to_ping, TIME_TO_PING))
         return;
 
+    if (!ip_isset(&ping->to_ping[0].ip_port.ip))
+        return;
+
     ping->last_to_ping = unix_time();
     uint32_t i;
 
@@ -308,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 ca87bbe1..db100459 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -26,831 +26,685 @@
 #endif
 
 #include "Messenger.h"
+#include "group.h"
 #include "logger.h"
 
-#define __TOX_DEFINED__
+#include "../toxencryptsave/defines.h"
+
+#define TOX_DEFINED
 typedef struct Messenger Tox;
 
 #include "tox.h"
 
-/*
- * returns a FRIEND_ADDRESS_SIZE byte address to give to others.
- * Format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
- *
- */
-void tox_get_address(const Tox *tox, uint8_t *address)
-{
-    const Messenger *m = tox;
-    getaddress(m, address);
-}
+#define SET_ERROR_PARAMETER(param, x) {if(param) {*param = x;}}
 
-/*
- * Add a friend.
- * Set the data that will be sent along with friend request.
- * address is the address of the friend (returned by getaddress of the friend you wish to add) it must be FRIEND_ADDRESS_SIZE bytes. TODO: add checksum.
- * data is the data and length is the length.
- *
- *  return the friend number if success.
- *  return FA_TOOLONG if message length is too long.
- *  return FAERR_NOMESSAGE if no message (message length must be >= 1 byte).
- *  return FAERR_OWNKEY if user's own key.
- *  return FAERR_ALREADYSENT if friend request already sent or already a friend.
- *  return FAERR_UNKNOWN for unknown error.
- *  return FAERR_BADCHECKSUM if bad checksum in address.
- *  return FAERR_SETNEWNOSPAM if the friend was already there but the nospam was different.
- *  (the nospam for that friend was set to the new one).
- *  return FAERR_NOMEM if increasing the friend list size fails.
- */
-int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, uint16_t length)
+uint32_t tox_version_major(void)
 {
-    Messenger *m = tox;
-    return m_addfriend(m, address, data, length);
+    return 0;
 }
 
-/* Add a friend without sending a friendrequest.
- *
- *  return the friend number if success.
- *  return -1 if failure.
- */
-int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id)
+uint32_t tox_version_minor(void)
 {
-    Messenger *m = tox;
-    return m_addfriend_norequest(m, client_id);
+    return 0;
 }
 
-/*  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)
+uint32_t tox_version_patch(void)
 {
-    const Messenger *m = tox;
-    return getfriend_id(m, client_id);
+    return 0;
 }
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
- *
- *  return 0 if success.
- *  return -1 if failure.
- */
-int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id)
+bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)
 {
-    const Messenger *m = tox;
-    return getclient_id(m, friendnumber, client_id);
+    //TODO
+    return 1;
 }
 
-/* Remove a friend. */
-int tox_del_friend(Tox *tox, int32_t friendnumber)
-{
-    Messenger *m = tox;
-    return m_delfriend(m, friendnumber);
-}
 
-/* Checks friend's connecting status.
- *
- *  return 1 if friend is connected to us (Online).
- *  return 0 if friend is not connected to us (Offline).
- *  return -1 on failure.
- */
-int tox_get_friend_connection_status(const Tox *tox, int32_t friendnumber)
+void tox_options_default(struct Tox_Options *options)
 {
-    const Messenger *m = tox;
-    return m_get_friend_connectionstatus(m, friendnumber);
+    if (options) {
+        memset(options, 0, sizeof(struct Tox_Options));
+        options->ipv6_enabled = 1;
+        options->udp_enabled = 1;
+        options->proxy_type = TOX_PROXY_TYPE_NONE;
+    }
 }
 
-/* Checks if there exists a friend with given friendnumber.
- *
- *  return 1 if friend exists.
- *  return 0 if friend doesn't exist.
- */
-int tox_friend_exists(const Tox *tox, int32_t friendnumber)
+struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error)
 {
-    const Messenger *m = tox;
-    return m_friend_exists(m, friendnumber);
+    struct Tox_Options *options = calloc(sizeof(struct Tox_Options), 1);
+
+    if (options) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_OK);
+        return options;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_MALLOC);
+    return NULL;
 }
 
-/* Send a text chat message to an online friend.
- *  return the message id if packet was successfully put into the send queue.
- *  return 0 if it was not.
- *
- *  You will want to retain the return value, it will be passed to your read_receipt callback
- *  if one is received.
- */
-uint32_t tox_send_message(Tox *tox, int32_t friendnumber, const uint8_t *message, uint32_t length)
+void tox_options_free(struct Tox_Options *options)
 {
-    Messenger *m = tox;
-    return m_sendmessage(m, friendnumber, message, length);
+    free(options);
 }
 
-/* Send an action to an online friend.
- *
- *  return the message id if packet was successfully put into the send queue.
- *  return 0 if it was not.
- *
- *  You will want to retain the return value, it will be passed to your read_receipt callback
- *  if one is received.
- */
-uint32_t tox_send_action(Tox *tox, int32_t friendnumber, const uint8_t *action, uint32_t length)
+Tox *tox_new(const struct Tox_Options *options, const uint8_t *data, size_t length, TOX_ERR_NEW *error)
 {
-    Messenger *m = tox;
-    return m_sendaction(m, friendnumber, action, length);
+    if (!logger_get_global())
+        logger_set_global(logger_new(LOGGER_OUTPUT_FILE, LOGGER_LEVEL, "toxcore"));
+
+    if (data) {
+        if (memcmp(data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {
+            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_ENCRYPTED);
+            return NULL;
+        }
+    }
+
+    Messenger_Options m_options = {0};
+
+    if (options == NULL) {
+        m_options.ipv6enabled = TOX_ENABLE_IPV6_DEFAULT;
+    } else {
+        m_options.ipv6enabled = options->ipv6_enabled;
+        m_options.udp_disabled = !options->udp_enabled;
+
+        switch (options->proxy_type) {
+            case TOX_PROXY_TYPE_HTTP:
+                m_options.proxy_info.proxy_type = TCP_PROXY_HTTP;
+                break;
+
+            case TOX_PROXY_TYPE_SOCKS5:
+                m_options.proxy_info.proxy_type = TCP_PROXY_SOCKS5;
+                break;
+
+            case TOX_PROXY_TYPE_NONE:
+                m_options.proxy_info.proxy_type = TCP_PROXY_NONE;
+                break;
+
+            default:
+                SET_ERROR_PARAMETER(error, TOX_ERR_PROXY_TYPE);
+                return NULL;
+        }
+
+        if (m_options.proxy_info.proxy_type != TCP_PROXY_NONE) {
+            if (options->proxy_port == 0) {
+                SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_PORT);
+                return NULL;
+            }
+
+            ip_init(&m_options.proxy_info.ip_port.ip, m_options.ipv6enabled);
+
+            if (m_options.ipv6enabled)
+                m_options.proxy_info.ip_port.ip.family = AF_UNSPEC;
+
+            if (!addr_resolve_or_parse_ip(options->proxy_address, &m_options.proxy_info.ip_port.ip, NULL)) {
+                SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST);
+                //TODO: TOX_ERR_NEW_PROXY_NOT_FOUND if domain.
+                return NULL;
+            }
+
+            m_options.proxy_info.ip_port.port = htons(options->proxy_port);
+        }
+    }
+
+    Messenger *m = new_messenger(&m_options);
+    //TODO: TOX_ERR_NEW_MALLOC
+    //TODO: TOX_ERR_NEW_PORT_ALLOC
+
+    if (!new_groupchats(m)) {
+        kill_messenger(m);
+        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
+        return NULL;
+    }
+
+    if (messenger_load(m, data, length) == -1) {
+        /* TODO: uncomment this when tox is stable.
+        tox_kill(m);
+        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
+        return NULL;
+        */
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_NEW_OK);
+    return m;
 }
 
-/* Set our nickname.
- * name must be a string of maximum MAX_NAME_LENGTH length.
- * length must be at least 1 byte.
- * length is the length of name with the NULL terminator.
- *
- *  return 0 if success.
- *  return -1 if failure.
- */
-int tox_set_name(Tox *tox, const uint8_t *name, uint16_t length)
+void tox_kill(Tox *tox)
 {
     Messenger *m = tox;
-    return setname(m, name, length);
+    kill_groupchats(m->group_chat_object);
+    kill_messenger(m);
+    logger_kill_global();
 }
 
-/* Get your nickname.
- * m -  The messenger context to use.
- * name - Pointer to a string for the name. (must be at least MAX_NAME_LENGTH)
- *
- *  return length of the name.
- *  return 0 on error.
- */
-uint16_t tox_get_self_name(const Tox *tox, uint8_t *name)
+size_t tox_save_size(const Tox *tox)
 {
     const Messenger *m = tox;
-    return getself_name(m, name);
+    return messenger_size(m);
 }
 
-/* Get name of friendnumber and put it in name.
- * name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes.
- *
- *  return length of name (with the NULL terminator) if success.
- *  return -1 if failure.
- */
-int tox_get_name(const Tox *tox, int32_t friendnumber, uint8_t *name)
+void tox_save(const Tox *tox, uint8_t *data)
 {
-    const Messenger *m = tox;
-    return getname(m, friendnumber, name);
+    if (data) {
+        const Messenger *m = tox;
+        messenger_save(m, data);
+    }
 }
 
-/*  returns the length of name on success.
- *  returns -1 on failure.
- */
-int tox_get_name_size(const Tox *tox, int32_t friendnumber)
+static int address_to_ip(Messenger *m, const char *address, IP_Port *ip_port, IP_Port *ip_port_v4)
 {
-    const Messenger *m = tox;
-    return m_get_name_size(m, friendnumber);
-}
+    if (!addr_parse_ip(address, &ip_port->ip)) {
+        if (m->options.udp_disabled) { /* Disable DNS when udp is disabled. */
+            return -1;
+        }
 
-int tox_get_self_name_size(const Tox *tox)
-{
-    const Messenger *m = tox;
-    return m_get_self_name_size(m);
+        IP *ip_extra = NULL;
+        ip_init(&ip_port->ip, m->options.ipv6enabled);
+
+        if (m->options.ipv6enabled && ip_port_v4) {
+            /* setup for getting BOTH: an IPv6 AND an IPv4 address */
+            ip_port->ip.family = AF_UNSPEC;
+            ip_reset(&ip_port_v4->ip);
+            ip_extra = &ip_port_v4->ip;
+        }
+
+        if (!addr_resolve(address, &ip_port->ip, ip_extra)) {
+            return -1;
+        }
+    }
+
+    return 0;
 }
 
-/* Set our user status;
- * you are responsible for freeing status after.
- *
- *  return 0 on success, -1 on failure.
- */
-int tox_set_status_message(Tox *tox, const uint8_t *status, uint16_t length)
+bool tox_bootstrap(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key, TOX_ERR_BOOTSTRAP *error)
 {
+    if (!address || !public_key) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_NULL);
+        return 0;
+    }
+
     Messenger *m = tox;
-    return m_set_statusmessage(m, status, length);
+    bool ret = tox_add_tcp_relay(tox, address, port, public_key, error);
+
+    if (!ret) {
+        return 0;
+    }
+
+    if (m->options.udp_disabled) {
+        return ret;
+    } else { /* DHT only works on UDP. */
+        if (DHT_bootstrap_from_address(m->dht, address, m->options.ipv6enabled, htons(port), public_key) == 0) {
+            SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_ADDRESS);
+            return 0;
+        }
+
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
+        return 1;
+    }
 }
 
-int tox_set_user_status(Tox *tox, uint8_t status)
+bool tox_add_tcp_relay(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key,
+                       TOX_ERR_BOOTSTRAP *error)
 {
+    if (!address || !public_key) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_NULL);
+        return 0;
+    }
+
     Messenger *m = tox;
-    return m_set_userstatus(m, status);
-}
+    IP_Port ip_port, ip_port_v4;
 
-/*  returns the length of status message on success.
- *  returns -1 on failure.
- */
-int tox_get_status_message_size(const Tox *tox, int32_t friendnumber)
-{
-    const Messenger *m = tox;
-    return m_get_statusmessage_size(m, friendnumber);
-}
+    if (port == 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_PORT);
+        return 0;
+    }
 
-int tox_get_self_status_message_size(const Tox *tox)
-{
-    const Messenger *m = tox;
-    return m_get_self_statusmessage_size(m);
+    if (address_to_ip(m, address, &ip_port, &ip_port_v4) == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_ADDRESS);
+        return 0;
+    }
+
+    ip_port.port = htons(port);
+    add_tcp_relay(m->net_crypto, ip_port, public_key);
+    onion_add_bs_path_node(m->onion_c, ip_port, public_key); //TODO: move this
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
+    return 1;
 }
 
-/* Copy friendnumber's status message into buf, truncating if size is over maxlen.
- * Get the size you need to allocate from m_get_statusmessage_size.
- * The self variant will copy our own status message.
- */
-int tox_get_status_message(const Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
+TOX_CONNECTION tox_get_connection_status(const Tox *tox)
 {
     const Messenger *m = tox;
-    return m_copy_statusmessage(m, friendnumber, buf, maxlen);
+
+    if (onion_isconnected(m->onion_c)) {
+        if (DHT_non_lan_connected(m->dht)) {
+            return TOX_CONNECTION_UDP;
+        }
+
+        return TOX_CONNECTION_TCP;
+    }
+
+    return TOX_CONNECTION_NONE;
 }
 
-int tox_get_self_status_message(const Tox *tox, uint8_t *buf, uint32_t maxlen)
+
+void tox_callback_connection_status(Tox *tox, tox_connection_status_cb *function, void *user_data)
 {
-    const Messenger *m = tox;
-    return m_copy_self_statusmessage(m, buf, maxlen);
+    //TODO
 }
 
-/* Return one of USERSTATUS values.
- * Values unknown to your application should be represented as USERSTATUS_NONE.
- * As above, the self variant will return our own USERSTATUS.
- * If friendnumber is invalid, this shall return USERSTATUS_INVALID.
- */
-uint8_t tox_get_user_status(const Tox *tox, int32_t friendnumber)
+uint32_t tox_iteration_interval(const Tox *tox)
 {
     const Messenger *m = tox;
-    return m_get_userstatus(m, friendnumber);
+    return messenger_run_interval(m);
 }
 
-uint8_t tox_get_self_user_status(const Tox *tox)
+void tox_iteration(Tox *tox)
 {
-    const Messenger *m = tox;
-    return m_get_self_userstatus(m);
+    Messenger *m = tox;
+    do_messenger(m);
+    do_groupchats(m->group_chat_object);
 }
 
-/* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
- * returns -1 on error.
- */
-uint64_t tox_get_last_online(const Tox *tox, int32_t friendnumber)
+void tox_self_get_address(const Tox *tox, uint8_t *address)
 {
-    const Messenger *m = tox;
-    return m_get_last_online(m, friendnumber);
+    if (address) {
+        const Messenger *m = tox;
+        getaddress(m, address);
+    }
 }
 
-/* Set our typing status for a friend.
- * You are responsible for turning it on or off.
- *
- * returns 0 on success.
- * returns -1 on failure.
- */
-int tox_set_user_is_typing(Tox *tox, int32_t friendnumber, uint8_t is_typing)
+void tox_self_set_nospam(Tox *tox, uint32_t nospam)
 {
     Messenger *m = tox;
-    return m_set_usertyping(m, friendnumber, is_typing);
+    set_nospam(&(m->fr), nospam);
 }
 
-/* Get the typing status of a friend.
- *
- * returns 0 if friend is not typing.
- * returns 1 if friend is typing.
- */
-uint8_t tox_get_is_typing(const Tox *tox, int32_t friendnumber)
+uint32_t tox_self_get_nospam(const Tox *tox)
 {
     const Messenger *m = tox;
-    return m_get_istyping(m, friendnumber);
+    return get_nospam(&(m->fr));
 }
 
-/* Return the number of friends in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_friendlist. */
-uint32_t tox_count_friendlist(const Tox *tox)
+void tox_self_get_public_key(const Tox *tox, uint8_t *public_key)
 {
     const Messenger *m = tox;
-    return count_friendlist(m);
-}
 
-/* Return the number of online friends in the instance m. */
-uint32_t tox_get_num_online_friends(const Tox *tox)
-{
-    const Messenger *m = tox;
-    return get_num_online_friends(m);
+    if (public_key)
+        memcpy(public_key, m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
 }
 
-/* Copy a list of valid friend IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_friendlist(const Tox *tox, int32_t *out_list, uint32_t list_size)
+void tox_self_get_private_key(const Tox *tox, uint8_t *private_key)
 {
     const Messenger *m = tox;
-    return copy_friendlist(m, out_list, list_size);
-}
 
-/* Set the function that will be executed when a friend request is received.
- *  Function format is function(uint8_t * public_key, uint8_t * data, uint16_t length)
- */
-void tox_callback_friend_request(Tox *tox, void (*function)(Tox *tox, const uint8_t *, const uint8_t *, uint16_t,
-                                 void *), void *userdata)
-{
-    Messenger *m = tox;
-    m_callback_friendrequest(m, function, userdata);
+    if (private_key)
+        memcpy(private_key, m->net_crypto->self_secret_key, crypto_box_SECRETKEYBYTES);
 }
 
-
-/* Set the function that will be executed when a message from a friend is received.
- *  Function format is: function(int32_t friendnumber, uint8_t * message, uint32_t length)
- */
-void tox_callback_friend_message(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                 void *userdata)
+bool tox_self_set_name(Tox *tox, const uint8_t *name, size_t length, TOX_ERR_SET_INFO *error)
 {
-    Messenger *m = tox;
-    m_callback_friendmessage(m, function, userdata);
-}
+    if (!name && length != 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_NULL);
+        return 0;
+    }
 
-/* Set the function that will be executed when an action from a friend is received.
- *  function format is: function(int32_t friendnumber, uint8_t * action, uint32_t length)
- */
-void tox_callback_friend_action(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                void *userdata)
-{
     Messenger *m = tox;
-    m_callback_action(m, function, userdata);
+
+    if (setname(m, name, length) == 0) {
+        //TODO: function to set different per group names?
+        send_name_all_groups(m->group_chat_object);
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_OK);
+        return 1;
+    } else {
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
+        return 0;
+    }
 }
 
-/* Set the callback for name changes.
- *  function(int32_t friendnumber, uint8_t *newname, uint16_t length)
- *  You are not responsible for freeing newname.
- */
-void tox_callback_name_change(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
-                              void *userdata)
+size_t tox_self_get_name_size(const Tox *tox)
 {
-    Messenger *m = tox;
-    m_callback_namechange(m, function, userdata);
+    const Messenger *m = tox;
+    return m_get_self_name_size(m);
 }
 
-/* Set the callback for status message changes.
- *  function(int32_t friendnumber, uint8_t *newstatus, uint16_t length)
- *  You are not responsible for freeing newstatus.
- */
-void tox_callback_status_message(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                 void *userdata)
+void tox_self_get_name(const Tox *tox, uint8_t *name)
 {
-    Messenger *m = tox;
-    m_callback_statusmessage(m, function, userdata);
+    if (name) {
+        const Messenger *m = tox;
+        getself_name(m, name);
+    }
 }
 
-/* Set the callback for status type changes.
- *  function(int32_t friendnumber, USERSTATUS kind)
- */
-void tox_callback_user_status(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, void *),
-                              void *userdata)
+bool tox_self_set_status_message(Tox *tox, const uint8_t *status, size_t length, TOX_ERR_SET_INFO *error)
 {
+    if (!status && length != 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_NULL);
+        return 0;
+    }
+
     Messenger *m = tox;
-    m_callback_userstatus(m, function, userdata);
+
+    if (m_set_statusmessage(m, status, length) == 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_OK);
+        return 1;
+    } else {
+        SET_ERROR_PARAMETER(error, TOX_ERR_SET_INFO_TOO_LONG);
+        return 0;
+    }
 }
 
-/* Set the callback for typing changes.
- *  function (int32_t friendnumber, uint8_t is_typing)
- */
-void tox_callback_typing_change(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, void *), void *userdata)
+size_t tox_self_get_status_message_size(const Tox *tox)
 {
-    Messenger *m = tox;
-    m_callback_typingchange(m, function, userdata);
+    const Messenger *m = tox;
+    return m_get_self_statusmessage_size(m);
 }
 
-/* Set the callback for read receipts.
- *  function(int32_t friendnumber, uint32_t receipt)
- *
- *  If you are keeping a record of returns from m_sendmessage;
- *  receipt might be one of those values, meaning the message
- *  has been received on the other side.
- *  Since core doesn't track ids for you, receipt may not correspond to any message.
- *  in that case, you should discard it.
- */
-void tox_callback_read_receipt(Tox *tox, void (*function)(Messenger *tox, int32_t, uint32_t, void *), void *userdata)
+void tox_self_get_status_message(const Tox *tox, uint8_t *status)
 {
-    Messenger *m = tox;
-    m_callback_read_receipt(m, function, userdata);
+    if (status) {
+        const Messenger *m = tox;
+        m_copy_self_statusmessage(m, status);
+    }
 }
 
-/* Set the callback for connection status changes.
- *  function(int32_t friendnumber, uint8_t status)
- *
- *  Status:
- *    0 -- friend went offline after being previously online
- *    1 -- friend went online
- *
- *  NOTE: this callback is not called when adding friends, thus the "after
- *  being previously online" part. It's assumed that when adding friends,
- *  their connection status is offline.
- */
-void tox_callback_connection_status(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, void *),
-                                    void *userdata)
+void tox_self_set_status(Tox *tox, TOX_STATUS user_status)
 {
     Messenger *m = tox;
-    m_callback_connectionstatus(m, function, userdata);
+    m_set_userstatus(m, user_status);
 }
 
-/**********ADVANCED FUNCTIONS (If you don't know what they do you can safely ignore them.)  ************/
-
-/* Functions to get/set the nospam part of the id.
- */
-uint32_t tox_get_nospam(const Tox *tox)
+TOX_STATUS tox_self_get_status(const Tox *tox)
 {
     const Messenger *m = tox;
-    return get_nospam(&(m->fr));
+    return m_get_self_userstatus(m);
 }
 
-void tox_set_nospam(Tox *tox, uint32_t nospam)
+static void set_friend_error(int32_t ret, TOX_ERR_FRIEND_ADD *error)
 {
-    Messenger *m = tox;
-    set_nospam(&(m->fr), nospam);
-}
+    switch (ret) {
+        case FAERR_TOOLONG:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_TOO_LONG);
+            break;
 
-/* Copy the public and secret key from the Tox object.
-   public_key and secret_key must be 32 bytes big.
-   if the pointer is NULL, no data will be copied to it.*/
-void tox_get_keys(Tox *tox, uint8_t *public_key, uint8_t *secret_key)
-{
-    Messenger *m = tox;
+        case FAERR_NOMESSAGE:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_NO_MESSAGE);
+            break;
 
-    if (public_key)
-        memcpy(public_key, m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES);
+        case FAERR_OWNKEY:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_OWN_KEY);
+            break;
 
-    if (secret_key)
-        memcpy(secret_key, m->net_crypto->self_secret_key, crypto_box_SECRETKEYBYTES);
-}
+        case FAERR_ALREADYSENT:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_ALREADY_SENT);
+            break;
 
-/**********GROUP CHAT FUNCTIONS: WARNING Group chats will be rewritten so this might change ************/
+        case FAERR_BADCHECKSUM:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_BAD_CHECKSUM);
+            break;
 
-/* Set the callback for group invites.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t *group_public_key, void *userdata)
- */
-void tox_callback_group_invite(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, void *),
-                               void *userdata)
-{
-    Messenger *m = tox;
-    m_callback_group_invite(m, function, userdata);
-}
+        case FAERR_SETNEWNOSPAM:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM);
+            break;
 
-/* Set the callback for group messages.
- *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
- */
-void tox_callback_group_message(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
-                                void *userdata)
-{
-    Messenger *m = tox;
-    m_callback_group_message(m, function, userdata);
-}
+        case FAERR_NOMEM:
+            SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_MALLOC);
+            break;
 
-/* Set the callback for group actions.
- *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * action, uint16_t length, void *userdata)
- */
-void tox_callback_group_action(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
-                               void *userdata)
-{
-    Messenger *m = tox;
-    m_callback_group_action(m, function, userdata);
+    }
 }
 
-/* Set callback function for peer name list changes.
- *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, void *userdata)
- */
-void tox_callback_group_namelist_change(Tox *tox, void (*function)(Tox *tox, int, int, uint8_t, void *), void *userdata)
+uint32_t tox_friend_add(Tox *tox, const uint8_t *address, const uint8_t *message, size_t length,
+                        TOX_ERR_FRIEND_ADD *error)
 {
+    if (!address || !message) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_NULL);
+        return UINT32_MAX;
+    }
+
     Messenger *m = tox;
-    m_callback_group_namelistchange(m, function, userdata);
+    int32_t ret = m_addfriend(m, address, message, length);
+
+    if (ret >= 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_OK);
+        return ret;
+    }
+
+    set_friend_error(ret, error);
+    return UINT32_MAX;
 }
 
-/* Creates a new groupchat and puts it in the chats array.
- *
- * return group number on success.
- * return -1 on failure.
- */
-int tox_add_groupchat(Tox *tox)
+uint32_t tox_friend_add_norequest(Tox *tox, const uint8_t *public_key, TOX_ERR_FRIEND_ADD *error)
 {
+    if (!public_key) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_NULL);
+        return UINT32_MAX;
+    }
+
     Messenger *m = tox;
-    return add_groupchat(m);
+    int32_t ret = m_addfriend_norequest(m, public_key);
+
+    if (ret >= 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_ADD_OK);
+        return ret;
+    }
+
+    set_friend_error(ret, error);
+    return UINT32_MAX;
 }
-/* Delete a groupchat from the chats array.
- *
- * return 0 on success.
- * return -1 if failure.
- */
-int tox_del_groupchat(Tox *tox, int groupnumber)
+
+bool tox_friend_delete(Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_DELETE *error)
 {
     Messenger *m = tox;
-    return del_groupchat(m, groupnumber);
+    int ret = m_delfriend(m, friend_number);
+
+    //TODO handle if realloc fails?
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND);
+        return 0;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_DELETE_OK);
+    return 1;
 }
 
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least MAX_NICK_BYTES long.
- *
- * return length of name if success
- * return -1 if failure
- */
-int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name)
+uint32_t tox_friend_by_public_key(const Tox *tox, const uint8_t *public_key, TOX_ERR_FRIEND_BY_PUBLIC_KEY *error)
 {
+    if (!public_key) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL);
+        return UINT32_MAX;
+    }
+
     const Messenger *m = tox;
-    return m_group_peername(m, groupnumber, peernumber, name);
-}
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
- */
-int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber)
-{
-    Messenger *m = tox;
-    return invite_friend(m, friendnumber, groupnumber);
-}
-/* Join a group (you need to have been invited first.)
- *
- * returns group number on success
- * returns -1 on failure.
- */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *friend_group_public_key)
-{
-    Messenger *m = tox;
-    return join_groupchat(m, friendnumber, friend_group_public_key);
-}
+    int32_t ret = getfriend_id(m, public_key);
 
-/* send a group message
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_message_send(Tox *tox, int groupnumber, const uint8_t *message, uint32_t length)
-{
-    Messenger *m = tox;
-    return group_message_send(m, groupnumber, message, length);
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND);
+        return UINT32_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK);
+    return ret;
 }
 
-/* send a group action
- * return 0 on success
- * return -1 on failure
- */
-int tox_group_action_send(Tox *tox, int groupnumber, const uint8_t *action, uint32_t length)
+bool tox_friend_get_public_key(const Tox *tox, uint32_t friend_number, uint8_t *public_key,
+                               TOX_ERR_FRIEND_GET_PUBLIC_KEY *error)
 {
-    Messenger *m = tox;
-    return group_action_send(m, groupnumber, action, length);
+    if (!public_key) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_GET_PUBLIC_KEY_NULL);
+        return 0;
+    }
+
+    const Messenger *m = tox;
+
+    if (get_real_pk(m, friend_number, public_key) == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND);
+        return 0;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK);
+    return 1;
 }
 
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
- */
-int tox_group_number_peers(const Tox *tox, int groupnumber)
+bool tox_friend_exists(const Tox *tox, uint32_t friend_number)
 {
     const Messenger *m = tox;
-    return group_number_peers(m, groupnumber);
+    return m_friend_exists(m, friend_number);
 }
 
-/* List all the peers in the group chat.
- *
- * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
- *
- * Copies the lengths of the names to lengths[length]
- *
- * returns the number of peers on success.
- *
- * return -1 on failure.
- */
-int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
-                        uint16_t length)
+size_t tox_friend_list_size(const Tox *tox)
 {
     const Messenger *m = tox;
-    return group_names(m, groupnumber, names, lengths, length);
+    return count_friendlist(m);
 }
 
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t tox_count_chatlist(const Tox *tox)
+void tox_friend_list(const Tox *tox, uint32_t *list)
 {
-    const Messenger *m = tox;
-    return count_chatlist(m);
+    if (list) {
+        const Messenger *m = tox;
+        //TODO: size parameter?
+        copy_friendlist(m, list, tox_friend_list_size(tox));
+    }
 }
 
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_chatlist(const Tox *tox, int *out_list, uint32_t list_size)
+size_t tox_friend_get_name_size(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
 {
     const Messenger *m = tox;
-    return copy_chatlist(m, out_list, list_size);
+    int ret = m_get_name_size(m, friend_number);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return SIZE_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return ret;
 }
 
+bool tox_friend_get_name(const Tox *tox, uint32_t friend_number, uint8_t *name, TOX_ERR_FRIEND_QUERY *error)
+{
+    if (!name) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_NULL);
+        return 0;
+    }
 
-/****************FILE SENDING FUNCTIONS*****************/
+    const Messenger *m = tox;
+    int ret = getname(m, friend_number, name);
 
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return 0;
+    }
 
-/* Set the callback for file send requests.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
- */
-void tox_callback_file_send_request(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, uint64_t,
-                                    const uint8_t *, uint16_t, void *), void *userdata)
-{
-    Messenger *m = tox;
-    callback_file_sendrequest(m, function, userdata);
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return 1;
 }
-/* Set the callback for file control requests.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
- *
- */
-void tox_callback_file_control(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, uint8_t, uint8_t,
-                               const uint8_t *, uint16_t, void *), void *userdata)
-{
-    Messenger *m = tox;
-    callback_file_control(m, function, userdata);
-}
-/* Set the callback for file data.
- *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
- *
- */
-void tox_callback_file_data(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, const uint8_t *,
-                            uint16_t length, void *), void *userdata)
 
+void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *function, void *user_data)
 {
     Messenger *m = tox;
-    callback_file_data(m, function, userdata);
-}
-/* Send a file send request.
- * Maximum filename length is 255 bytes.
- *  return file number on success
- *  return -1 on failure
- */
-int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, const uint8_t *filename,
-                        uint16_t filename_length)
-{
-    Messenger *m = tox;
-    return new_filesender(m, friendnumber, filesize, filename, filename_length);
-}
-/* Send a file control request.
- * send_receive is 0 if we want the control packet to target a sending file, 1 if it targets a receiving file.
- *
- *  return 0 on success
- *  return -1 on failure
- */
-int tox_file_send_control(Tox *tox, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
-                          const uint8_t *data, uint16_t length)
-{
-    Messenger *m = tox;
-    return file_control(m, friendnumber, send_receive, filenumber, message_id, data, length);
-}
-/* Send file data.
- *
- *  return 0 on success
- *  return -1 on failure
- */
-int tox_file_send_data(Tox *tox, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length)
-{
-    Messenger *m = tox;
-    return file_data(m, friendnumber, filenumber, data, length);
+    m_callback_friendmessage(m, function, user_data);
 }
 
-/* Returns the recommended/maximum size of the filedata you send with tox_file_send_data()
- *
- *  return size on success
- *  return -1 on failure (currently will never return -1)
- */
-int tox_file_data_size(const Tox *tox, int32_t friendnumber)
+size_t tox_friend_get_status_message_size(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
 {
-    return MAX_CRYPTO_DATA_SIZE - 2;
+    const Messenger *m = tox;
+    int ret = m_get_statusmessage_size(m, friend_number);
+
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return SIZE_MAX;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return ret;
 }
 
-/* Give the number of bytes left to be sent/received.
- *
- *  send_receive is 0 if we want the sending files, 1 if we want the receiving.
- *
- *  return number of bytes remaining to be sent/received on success
- *  return 0 on failure
- */
-uint64_t tox_file_data_remaining(const Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
+bool tox_friend_get_status_message(const Tox *tox, uint32_t friend_number, uint8_t *message,
+                                   TOX_ERR_FRIEND_QUERY *error)
 {
-    const Messenger *m = tox;
-    return file_dataremaining(m, friendnumber, filenumber, send_receive);
-}
+    if (!message) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_NULL);
+        return 0;
+    }
 
-/***************END OF FILE SENDING FUNCTIONS******************/
+    const Messenger *m = tox;
+    //TODO: size parameter?
+    int ret = m_copy_statusmessage(m, friend_number, message, m_get_statusmessage_size(m, friend_number));
 
-/* TODO: expose this properly. */
-static int tox_add_tcp_relay(Tox *tox, const char *address, uint8_t ipv6enabled, uint16_t port,
-                             const uint8_t *public_key)
-{
-    Messenger *m = tox;
-    IP_Port ip_port_v64;
-    IP *ip_extra = NULL;
-    IP_Port ip_port_v4;
-    ip_init(&ip_port_v64.ip, ipv6enabled);
-
-    if (ipv6enabled) {
-        /* setup for getting BOTH: an IPv6 AND an IPv4 address */
-        ip_port_v64.ip.family = AF_UNSPEC;
-        ip_reset(&ip_port_v4.ip);
-        ip_extra = &ip_port_v4.ip;
-    }
-
-    if (addr_resolve_or_parse_ip(address, &ip_port_v64.ip, ip_extra)) {
-        ip_port_v64.port = port;
-        add_tcp_relay(m->net_crypto, ip_port_v64, public_key);
-        onion_add_path_node(m->onion_c, ip_port_v64, public_key); //TODO: move this
-        return 1;
-    } else {
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
         return 0;
     }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return 1;
 }
 
-int tox_bootstrap_from_address(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key)
+void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *function, void *user_data)
 {
     Messenger *m = tox;
-    tox_add_tcp_relay(tox, address, m->options.ipv6enabled, htons(port), public_key);
-    return DHT_bootstrap_from_address(m->dht, address, m->options.ipv6enabled, htons(port), public_key);
+    m_callback_statusmessage(m, function, user_data);
 }
 
-/*  return 0 if we are not connected to the DHT.
- *  return 1 if we are.
- */
-int tox_isconnected(const Tox *tox)
+TOX_STATUS tox_friend_get_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
 {
     const Messenger *m = tox;
-    return onion_isconnected(m->onion_c);
+
+    int ret = m_get_userstatus(m, friend_number);
+
+    if (ret == USERSTATUS_INVALID) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return TOX_STATUS_INVALID;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return ret;
 }
 
-/* Return the time in milliseconds before tox_do() should be called again
- * for optimal performance.
- *
- * returns time (in ms) before the next tox_do() needs to be run on success.
- */
-uint32_t tox_do_interval(Tox *tox)
+void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *function, void *user_data)
 {
     Messenger *m = tox;
-    return messenger_run_interval(m);
+    m_callback_userstatus(m, function, user_data);
 }
 
-/* Run this at startup.
- *
- *  return allocated instance of tox on success.
- *  return 0 if there are problems.
- */
-Tox *tox_new(Tox_Options *options)
+TOX_CONNECTION tox_friend_get_connection_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
 {
-    LOGGER_INIT(LOGGER_OUTPUT_FILE, LOGGER_LEVEL);
-    Messenger_Options m_options = {0};
-
-    if (options == NULL) {
-        m_options.ipv6enabled = TOX_ENABLE_IPV6_DEFAULT;
-    } else {
-        m_options.ipv6enabled = options->ipv6enabled;
-        m_options.udp_disabled = options->udp_disabled;
-        m_options.proxy_enabled = options->proxy_enabled;
-
-        if (m_options.proxy_enabled) {
-            ip_init(&m_options.proxy_info.ip_port.ip, m_options.ipv6enabled);
-
-            if (m_options.ipv6enabled)
-                m_options.proxy_info.ip_port.ip.family = AF_UNSPEC;
+    const Messenger *m = tox;
 
-            if (!addr_resolve_or_parse_ip(options->proxy_address, &m_options.proxy_info.ip_port.ip, NULL))
-                return NULL;
+    int ret = m_get_friend_connectionstatus(m, friend_number);
 
-            m_options.proxy_info.ip_port.port = htons(options->proxy_port);
-        }
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return TOX_CONNECTION_NONE;
     }
 
-    return new_messenger(&m_options);
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return ret;
 }
 
-/* Run this before closing shop.
- * Free all datastructures.
- */
-void tox_kill(Tox *tox)
+void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *function, void *user_data)
 {
     Messenger *m = tox;
-    kill_messenger(m);
+    m_callback_connectionstatus(m, function, user_data);
 }
 
-/* The main loop that needs to be run at least 20 times per second. */
-void tox_do(Tox *tox)
-{
-    Messenger *m = tox;
-    do_messenger(m);
-}
-
-/* SAVING AND LOADING FUNCTIONS: */
-
-/*  return size of the messenger data (for saving). */
-uint32_t tox_size(const Tox *tox)
+bool tox_friend_get_typing(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error)
 {
     const Messenger *m = tox;
-    return messenger_size(m);
-}
+    int ret = m_get_istyping(m, friend_number);
 
-/* Save the messenger in data (must be allocated memory of size Messenger_size()). */
-void tox_save(const Tox *tox, uint8_t *data)
-{
-    const Messenger *m = tox;
-    messenger_save(m, data);
+    if (ret == -1) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND);
+        return 0;
+    }
+
+    SET_ERROR_PARAMETER(error, TOX_ERR_FRIEND_QUERY_OK);
+    return !!ret;
 }
 
-/* Load the messenger from data of size length. */
-int tox_load(Tox *tox, const uint8_t *data, uint32_t length)
+void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *function, void *user_data)
 {
     Messenger *m = tox;
-    return messenger_load(m, data, length);
+    m_callback_typingchange(m, function, user_data);
 }
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 08c2b3a2..2acc70ea 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -24,650 +24,1893 @@
 #ifndef TOX_H
 #define TOX_H
 
+#include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define TOX_MAX_NAME_LENGTH 128
-
-/* Maximum length of single messages after which they should be split. */
-#define TOX_MAX_MESSAGE_LENGTH 1372
-#define TOX_MAX_STATUSMESSAGE_LENGTH 1007
-#define TOX_CLIENT_ID_SIZE 32
-
-#define TOX_FRIEND_ADDRESS_SIZE (TOX_CLIENT_ID_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
-
-#define TOX_ENABLE_IPV6_DEFAULT 1
+/** \page core Public core API for Tox clients.
+ *
+ * Every function that can fail takes a function-specific error code pointer
+ * that can be used to diagnose problems with the Tox state or the function
+ * arguments. The error code pointer can be NULL, which does not influence the
+ * function's behaviour, but can be done if the reason for failure is irrelevant
+ * to the client.
+ *
+ * The exception to this rule are simple allocation functions whose only failure
+ * mode is allocation failure. They return NULL in that case, and do not set an
+ * error code.
+ *
+ * Every error code type has an OK value to which functions will set their error
+ * code value on success. Clients can keep their error code uninitialised before
+ * passing it to a function. The library guarantees that after returning, the
+ * value pointed to by the error code pointer has been initialised.
+ *
+ * Functions with pointer parameters often have a NULL error code, meaning they
+ * could not perform any operation, because one of the required parameters was
+ * NULL. Some functions operate correctly or are defined as effectless on NULL.
+ *
+ * Some functions additionally return a value outside their
+ * return type domain, or a bool containing true on success and false on
+ * failure.
+ *
+ * All functions that take a Tox instance pointer will cause undefined behaviour
+ * when passed a NULL Tox pointer.
+ *
+ * All integer values are expected in host byte order.
+ *
+ * Functions with parameters with enum types cause unspecified behaviour if the
+ * enumeration value is outside the valid range of the type. If possible, the
+ * function will try to use a sane default, but there will be no error code,
+ * and one possible action for the function to take is to have no effect.
+ */
 
-/* Errors for m_addfriend
- * FAERR - Friend Add Error
+/** \subsection events Events and callbacks
+ *
+ * Events are handled by callbacks. One callback can be registered per event.
+ * All events have a callback function type named `tox_${event}_cb` and a
+ * function to register it named `tox_callback_${event}`. Passing a NULL
+ * callback will result in no callback being registered for that event. Only
+ * one callback per event can be registered, so if a client needs multiple
+ * event listeners, it needs to implement the dispatch functionality itself.
  */
-enum {
-    TOX_FAERR_TOOLONG = -1,
-    TOX_FAERR_NOMESSAGE = -2,
-    TOX_FAERR_OWNKEY = -3,
-    TOX_FAERR_ALREADYSENT = -4,
-    TOX_FAERR_UNKNOWN = -5,
-    TOX_FAERR_BADCHECKSUM = -6,
-    TOX_FAERR_SETNEWNOSPAM = -7,
-    TOX_FAERR_NOMEM = -8
-};
 
-/* USERSTATUS -
- * Represents userstatuses someone can have.
+/** \subsection threading Threading implications
+ *
+ * It is possible to run multiple concurrent threads with a Tox instance for
+ * each thread. It is also possible to run all Tox instances in the same thread.
+ * A common way to run Tox (multiple or single instance) is to have one thread
+ * running a simple tox_iteration loop, sleeping for tox_iteration_interval
+ * milliseconds on each iteration.
+ *
+ * If you want to access a single Tox instance from multiple threads, access
+ * to the instance must be synchronised. While multiple threads can concurrently
+ * access multiple different Tox instances, no more than one API function can
+ * operate on a single instance at any given time.
+ *
+ * Functions that write to variable length byte arrays will always have a size
+ * function associated with them. The result of this size function is only valid
+ * until another mutating function (one that takes a pointer to non-const Tox)
+ * is called. Thus, clients must ensure that no other thread calls a mutating
+ * function between the call to the size function and the call to the retrieval
+ * function.
+ *
+ * E.g. to get the current nickname, one would write
+ *
+ * \code
+ * size_t length = tox_self_get_name_size(tox);
+ * uint8_t *name = malloc(length);
+ * if (!name) abort();
+ * tox_self_get_name(tox, name);
+ * \endcode
+ *
+ * If any other thread calls tox_self_set_name while this thread is allocating
+ * memory, the length will have become invalid, and the call to
+ * tox_self_get_name may cause undefined behaviour.
  */
-typedef enum {
-    TOX_USERSTATUS_NONE,
-    TOX_USERSTATUS_AWAY,
-    TOX_USERSTATUS_BUSY,
-    TOX_USERSTATUS_INVALID
-}
-TOX_USERSTATUS;
 
-#ifndef __TOX_DEFINED__
-#define __TOX_DEFINED__
+#ifndef TOX_DEFINED
+#define TOX_DEFINED
+/**
+ * The Tox instance type. All the state associated with a connection is held
+ * within the instance. Multiple instances can exist and operate concurrently.
+ * The maximum number of Tox instances that can exist on a single network
+ * device is limited. Note that this is not just a per-process limit, since the
+ * limiting factor is the number of usable ports on a device.
+ */
 typedef struct Tox Tox;
 #endif
 
-/* NOTE: Strings in Tox are all UTF-8, (This means that there is no terminating NULL character.)
+
+/*******************************************************************************
  *
- * The exact buffer you send will be received at the other end without modification.
+ * :: API version
  *
- * Do not treat Tox strings as C strings.
+ ******************************************************************************/
+
+
+/**
+ * The major version number. Incremented when the API or ABI changes in an
+ * incompatible way.
+ */
+#define TOX_VERSION_MAJOR               0u
+/**
+ * The minor version number. Incremented when functionality is added without
+ * breaking the API or ABI. Set to 0 when the major version number is
+ * incremented.
+ */
+#define TOX_VERSION_MINOR               0u
+/**
+ * The patch or revision number. Incremented when bugfixes are applied without
+ * changing any functionality or API or ABI.
+ */
+#define TOX_VERSION_PATCH               0u
+
+/**
+ * A macro to check at preprocessing time whether the client code is compatible
+ * with the installed version of Tox.
  */
+#define TOX_VERSION_IS_API_COMPATIBLE(MAJOR, MINOR, PATCH)      \
+  (TOX_VERSION_MAJOR == MAJOR &&                                \
+   (TOX_VERSION_MINOR > MINOR ||                                \
+    (TOX_VERSION_MINOR == MINOR &&                              \
+     TOX_VERSION_PATCH >= PATCH)))
+
+/**
+ * A macro to make compilation fail if the client code is not compatible with
+ * the installed version of Tox.
+ */
+#define TOX_VERSION_REQUIRE(MAJOR, MINOR, PATCH)                \
+  typedef char tox_required_version[TOX_IS_COMPATIBLE(MAJOR, MINOR, PATCH) ? 1 : -1]
+
 
-/*  return TOX_FRIEND_ADDRESS_SIZE byte address to give to others.
- * format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
+/**
+ * Return the major version number of the library. Can be used to display the
+ * Tox library version or to check whether the client is compatible with the
+ * dynamically linked version of Tox.
  */
-void tox_get_address(const Tox *tox, uint8_t *address);
+uint32_t tox_version_major(void);
 
-/* Add a friend.
- * Set the data that will be sent along with friend request.
- * address is the address of the friend (returned by getaddress of the friend you wish to add) it must be TOX_FRIEND_ADDRESS_SIZE bytes. TODO: add checksum.
- * data is the data and length is the length.
+/**
+ * Return the minor version number of the library.
+ */
+uint32_t tox_version_minor(void);
+
+/**
+ * Return the patch number of the library.
+ */
+uint32_t tox_version_patch(void);
+
+/**
+ * Return whether the compiled library version is compatible with the passed
+ * version numbers.
+ */
+bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch);
+
+/**
+ * A convenience macro to call tox_version_is_compatible with the currently
+ * compiling API version.
+ */
+#define TOX_VERSION_IS_ABI_COMPATIBLE()                         \
+  tox_version_is_compatible(TOX_VERSION_MAJOR, TOX_VERSION_MINOR, TOX_VERSION_PATCH)
+
+
+/*******************************************************************************
+ *
+ * :: Numeric constants
  *
- *  return the friend number if success.
- *  return TOX_FAERR_TOOLONG if message length is too long.
- *  return TOX_FAERR_NOMESSAGE if no message (message length must be >= 1 byte).
- *  return TOX_FAERR_OWNKEY if user's own key.
- *  return TOX_FAERR_ALREADYSENT if friend request already sent or already a friend.
- *  return TOX_FAERR_UNKNOWN for unknown error.
- *  return TOX_FAERR_BADCHECKSUM if bad checksum in address.
- *  return TOX_FAERR_SETNEWNOSPAM if the friend was already there but the nospam was different.
- *  (the nospam for that friend was set to the new one).
- *  return TOX_FAERR_NOMEM if increasing the friend list size fails.
+ ******************************************************************************/
+
+
+/**
+ * The size of a Tox Public Key in bytes.
  */
-int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, uint16_t length);
+#define TOX_PUBLIC_KEY_SIZE              32
 
+/**
+ * The size of a Tox address in bytes. Tox addresses are in the format
+ * [Public Key (TOX_PUBLIC_KEY_SIZE bytes)][nospam (4 bytes)][checksum (2 bytes)].
+ *
+ * The checksum is computed over the Public Key and the nospam value. The first
+ * byte is an XOR of all the even bytes (0, 2, 4, ...), the second byte is an
+ * XOR of all the odd bytes (1, 3, 5, ...) of the Public Key and nospam.
+ */
+#define TOX_ADDRESS_SIZE                (TOX_PUBLIC_KEY_SIZE + sizeof(uint32_t) + sizeof(uint16_t))
+
+/**
+ * Maximum length of a nickname in bytes.
+ */
+#define TOX_MAX_NAME_LENGTH             128
+
+/**
+ * Maximum length of a status message in bytes.
+ */
+#define TOX_MAX_STATUS_MESSAGE_LENGTH   1007
 
-/* Add a friend without sending a friendrequest.
- *  return the friend number if success.
- *  return -1 if failure.
+/**
+ * Maximum length of a friend request message in bytes.
  */
-int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id);
+#define TOX_MAX_FRIEND_REQUEST_LENGTH   1016
 
-/*  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);
+/**
+ * Maximum length of a single message after which it should be split.
+ */
+#define TOX_MAX_MESSAGE_LENGTH          1372
 
-/* Copies the public key associated to that friend id into client_id buffer.
- * Make sure that client_id is of size CLIENT_ID_SIZE.
- *  return 0 if success.
- *  return -1 if failure.
+/**
+ * Maximum size of custom packets. TODO: should be LENGTH?
  */
-int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id);
+#define TOX_MAX_CUSTOM_PACKET_SIZE      1373
 
-/* Remove a friend.
+/**
+ * The number of bytes in a hash generated by tox_hash.
+ */
+#define TOX_HASH_LENGTH                 /*crypto_hash_sha256_BYTES*/ 32
+
+/*******************************************************************************
+ *
+ * :: Global enumerations
  *
- *  return 0 if success.
- *  return -1 if failure.
+ ******************************************************************************/
+
+
+/**
+ * Represents the possible statuses a client can have.
  */
-int tox_del_friend(Tox *tox, int32_t friendnumber);
+enum TOX_STATUS {
+    /**
+     * User is online and available.
+     */
+    TOX_STATUS_NONE,
+    /**
+     * User is away. Clients can set this e.g. after a user defined
+     * inactivity time.
+     */
+    TOX_STATUS_AWAY,
+    /**
+     * User is busy. Signals to other clients that this client does not
+     * currently wish to communicate.
+     */
+    TOX_STATUS_BUSY,
+    /**
+     * Invalid status used when function returns an error.
+     */
+    TOX_STATUS_INVALID
+};
+typedef uint8_t TOX_STATUS;
 
-/* Checks friend's connecting status.
+/*******************************************************************************
  *
- *  return 1 if friend is connected to us (Online).
- *  return 0 if friend is not connected to us (Offline).
- *  return -1 on failure.
+ * :: Startup options
+ *
+ ******************************************************************************/
+
+
+enum TOX_PROXY_TYPE {
+    /**
+     * Don't use a proxy.
+     */
+    TOX_PROXY_TYPE_NONE,
+    /**
+     * HTTP proxy using CONNECT.
+     */
+    TOX_PROXY_TYPE_HTTP,
+    /**
+     * SOCKS proxy for simple socket pipes.
+     */
+    TOX_PROXY_TYPE_SOCKS5
+};
+typedef uint8_t TOX_PROXY_TYPE;
+
+/**
+ * This struct contains all the startup options for Tox. You can either allocate
+ * this object yourself, and pass it to tox_options_default, or call
+ * tox_options_new to get a new default options object.
  */
-int tox_get_friend_connection_status(const Tox *tox, int32_t friendnumber);
+struct Tox_Options {
+    /**
+     * The type of socket to create.
+     *
+     * If this is set to false, an IPv4 socket is created, which subsequently
+     * only allows IPv4 communication.
+     * If it is set to true, an IPv6 socket is created, allowing both IPv4 and
+     * IPv6 communication.
+     */
+    bool ipv6_enabled;
+
+    /**
+     * Enable the use of UDP communication when available.
+     *
+     * Setting this to false will force Tox to use TCP only. Communications will
+     * need to be relayed through a TCP relay node, potentially slowing them down.
+     * Disabling UDP support is necessary when using anonymous proxies or Tor.
+     */
+    bool udp_enabled;
+
+    /**
+     * Pass communications through a proxy.
+     */
+    TOX_PROXY_TYPE proxy_type;
+
+    /**
+     * The IP address or DNS name of the proxy to be used.
+     *
+     * If used, this must be non-NULL and be a valid DNS name. The name must not
+     * exceed 255 characters, and be in a NUL-terminated C string format
+     * (255 chars + 1 NUL byte).
+     *
+     * This member is ignored (it can be NULL) if proxy_enabled is false.
+     */
+    const char *proxy_address;
+
+    /**
+     * The port to use to connect to the proxy server.
+     *
+     * Ports must be in the range (1, 65535). The value is ignored if
+     * proxy_enabled is false.
+     */
+    uint16_t proxy_port;
+};
 
-/* Checks if there exists a friend with given friendnumber.
+
+/**
+ * Initialises a Tox_Options object with the default options.
+ *
+ * The result of this function is independent of the original options. All
+ * values will be overwritten, no values will be read (so it is permissible
+ * to pass an uninitialised object).
+ *
+ * If options is NULL, this function has no effect.
  *
- *  return 1 if friend exists.
- *  return 0 if friend doesn't exist.
+ * @param options An options object to be filled with default options.
  */
-int tox_friend_exists(const Tox *tox, int32_t friendnumber);
+void tox_options_default(struct Tox_Options *options);
 
-/* Send a text chat message to an online friend.
+
+enum TOX_ERR_OPTIONS_NEW {
+    TOX_ERR_OPTIONS_NEW_OK,
+    /**
+     * The function failed to allocate enough memory for the options struct.
+     */
+    TOX_ERR_OPTIONS_NEW_MALLOC
+};
+typedef uint8_t TOX_ERR_OPTIONS_NEW;
+
+/**
+ * Allocates a new Tox_Options object and initialises it with the default
+ * options. This function can be used to preserve long term ABI compatibility by
+ * giving the responsibility of allocation and deallocation to the Tox library.
  *
- *  return the message id if packet was successfully put into the send queue.
- *  return 0 if it was not.
+ * Objects returned from this function must be freed using the tox_options_free
+ * function.
  *
- * maximum length of messages is TOX_MAX_MESSAGE_LENGTH, your client must split larger messages
- * or else sending them will not work. No the core will not split messages for you because that
- * requires me to parse UTF-8.
+ * @return A new Tox_Options object with default options or NULL on failure.
+ */
+struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error);
+
+
+/**
+ * Releases all resources associated with an options objects.
  *
- * You will want to retain the return value, it will be passed to your read_receipt callback
- * if one is received.
+ * Passing a pointer that was not returned by tox_options_new results in
+ * undefined behaviour.
  */
-uint32_t tox_send_message(Tox *tox, int32_t friendnumber, const uint8_t *message, uint32_t length);
+void tox_options_free(struct Tox_Options *options);
+
+
+/*******************************************************************************
+ *
+ * :: Creation and destruction
+ *
+ ******************************************************************************/
+
+
+enum TOX_ERR_NEW {
+    TOX_ERR_NEW_OK,
+    TOX_ERR_NEW_NULL,
+    /**
+     * The function was unable to allocate enough memory to store the internal
+     * structures for the Tox object.
+     */
+    TOX_ERR_NEW_MALLOC,
+    /**
+     * The function was unable to bind to a port. This may mean that all ports
+     * have already been bound, e.g. by other Tox instances, or it may mean
+     * a permission error. You may be able to gather more information from errno.
+     */
+    TOX_ERR_NEW_PORT_ALLOC,
+    /**
+     * proxy_type was invalid.
+     */
+    TOX_ERR_PROXY_TYPE,
+    /**
+     * proxy_type was valid but the proxy_address passed had an invalid format
+     * or was NULL.
+     */
+    TOX_ERR_NEW_PROXY_BAD_HOST,
+    /**
+     * proxy_type was valid, but the proxy_port was invalid.
+     */
+    TOX_ERR_NEW_PROXY_BAD_PORT,
+    /**
+     * The proxy address passed could not be resolved.
+     */
+    TOX_ERR_NEW_PROXY_NOT_FOUND,
+    /**
+     * The byte array to be loaded contained an encrypted save.
+     */
+    TOX_ERR_NEW_LOAD_ENCRYPTED,
+    /**
+     * The data format was invalid. This can happen when loading data that was
+     * saved by an older version of Tox, or when the data has been corrupted.
+     * When loading from badly formatted data, some data may have been loaded,
+     * and the rest is discarded. Passing an invalid length parameter also
+     * causes this error.
+     */
+    TOX_ERR_NEW_LOAD_BAD_FORMAT
+};
+typedef uint8_t TOX_ERR_NEW;
 
-/* Send an action to an online friend.
+/**
+ * @brief Creates and initialises a new Tox instance with the options passed.
+ *
+ * This function will bring the instance into a valid state. Running the event
+ * loop with a new instance will operate correctly.
+ *
+ * If the data parameter is not NULL, this function will load the Tox instance
+ * from a byte array previously filled by tox_save.
  *
- *  return the message id if packet was successfully put into the send queue.
- *  return 0 if it was not.
+ * If loading failed or succeeded only partially, the new or partially loaded
+ * instance is returned and an error code is set.
  *
- * maximum length of actions is TOX_MAX_MESSAGE_LENGTH, your client must split larger actions
- * or else sending them will not work. No the core will not split actions for you because that
- * requires me to parse UTF-8.
+ * @param options An options object as described above. If this parameter is
+ *   NULL, the default options are used.
+ * @param data A byte array containing data previously stored by tox_save.
+ * @param length The length of the byte array data. If this parameter is 0, the
+ *   data parameter is ignored.
  *
- *  You will want to retain the return value, it will be passed to your read_receipt callback
- *  if one is received.
+ * @see tox_iteration for the event loop.
  */
-uint32_t tox_send_action(Tox *tox, int32_t friendnumber, const uint8_t *action, uint32_t length);
+Tox *tox_new(const struct Tox_Options *options, const uint8_t *data, size_t length, TOX_ERR_NEW *error);
 
-/* Set our nickname.
- * name must be a string of maximum MAX_NAME_LENGTH length.
- * length must be at least 1 byte.
- * length is the length of name with the NULL terminator.
+
+/**
+ * Releases all resources associated with the Tox instance and disconnects from
+ * the network.
  *
- *  return 0 if success.
- *  return -1 if failure.
+ * After calling this function, the Tox pointer becomes invalid. No other
+ * functions can be called, and the pointer value can no longer be read.
  */
-int tox_set_name(Tox *tox, const uint8_t *name, uint16_t length);
+void tox_kill(Tox *tox);
 
-/*
- * Get your nickname.
- * m - The messenger context to use.
- * name - needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes.
+
+/**
+ * Calculates the number of bytes required to store the tox instance with
+ * tox_save. This function cannot fail. The result is always greater than 0.
  *
- *  return length of name.
- *  return 0 on error.
+ * @see threading for concurrency implications.
  */
-uint16_t tox_get_self_name(const Tox *tox, uint8_t *name);
+size_t tox_save_size(const Tox *tox);
 
-/* Get name of friendnumber and put it in name.
- * name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH (128) bytes.
+/**
+ * Store all information associated with the tox instance to a byte array.
  *
- *  return length of name if success.
- *  return -1 if failure.
+ * @param data A memory region large enough to store the tox instance data.
+ *   Call tox_save_size to find the number of bytes required. If this parameter
+ *   is NULL, this function has no effect.
  */
-int tox_get_name(const Tox *tox, int32_t friendnumber, uint8_t *name);
+void tox_save(const Tox *tox, uint8_t *data);
 
-/*  returns the length of name on success.
- *  returns -1 on failure.
+
+/*******************************************************************************
+ *
+ * :: Connection lifecycle and event loop
+ *
+ ******************************************************************************/
+
+
+enum TOX_ERR_BOOTSTRAP {
+    TOX_ERR_BOOTSTRAP_OK,
+    TOX_ERR_BOOTSTRAP_NULL,
+    /**
+     * The address could not be resolved to an IP address, or the IP address
+     * passed was invalid.
+     */
+    TOX_ERR_BOOTSTRAP_BAD_ADDRESS,
+    /**
+     * The port passed was invalid. The valid port range is (1, 65535).
+     */
+    TOX_ERR_BOOTSTRAP_BAD_PORT
+};
+typedef uint8_t TOX_ERR_BOOTSTRAP;
+
+/**
+ * Sends a "get nodes" request to the given bootstrap node with IP, port, and
+ * public key to setup connections.
+ *
+ * This function will attempt to connect to the node using UDP and TCP at the
+ * same time.
+ *
+ * Tox will use the node as a TCP relay in case Tox_Options.udp_enabled was
+ * false, and also to connect to friends that are in TCP-only mode. Tox will
+ * also use the TCP connection when NAT hole punching is slow, and later switch
+ * to UDP if hole punching succeeds.
+ *
+ * @param address The hostname or IP address (IPv4 or IPv6) of the node.
+ * @param port The port on the host on which the bootstrap Tox instance is
+ *   listening.
+ * @param public_key The long term public key of the bootstrap node
+ *   (TOX_PUBLIC_KEY_SIZE bytes).
+ * @return true on success.
  */
-int tox_get_name_size(const Tox *tox, int32_t friendnumber);
-int tox_get_self_name_size(const Tox *tox);
+bool tox_bootstrap(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key, TOX_ERR_BOOTSTRAP *error);
+
 
-/* Set our user status.
+/**
+ * Adds additional host:port pair as TCP relay.
  *
- * userstatus must be one of TOX_USERSTATUS values.
- * max length of the status is TOX_MAX_STATUSMESSAGE_LENGTH.
+ * This function can be used to initiate TCP connections to different ports on
+ * the same bootstrap node, or to add TCP relays without using them as
+ * bootstrap nodes.
  *
- *  returns 0 on success.
- *  returns -1 on failure.
+ * @param address The hostname or IP address (IPv4 or IPv6) of the TCP relay.
+ * @param port The port on the host on which the TCP relay is listening.
+ * @param public_key The long term public key of the TCP relay
+ *   (TOX_PUBLIC_KEY_SIZE bytes).
+ * @return true on success.
  */
-int tox_set_status_message(Tox *tox, const uint8_t *status, uint16_t length);
-int tox_set_user_status(Tox *tox, uint8_t userstatus);
+bool tox_add_tcp_relay(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key,
+                       TOX_ERR_BOOTSTRAP *error);
+
+
+enum TOX_CONNECTION {
+    /**
+     * There is no connection. This instance, or the friend the state change is
+     * about, is now offline.
+     */
+    TOX_CONNECTION_NONE,
+    /**
+     * A TCP connection has been established. For the own instance, this means it
+     * is connected through a TCP relay, only. For a friend, this means that the
+     * connection to that particular friend goes through a TCP relay.
+     */
+    TOX_CONNECTION_TCP,
+    /**
+     * A UDP connection has been established. For the own instance, this means it
+     * is able to send UDP packets to DHT nodes, but may still be connected to
+     * a TCP relay. For a friend, this means that the connection to that
+     * particular friend was built using direct UDP packets.
+     */
+    TOX_CONNECTION_UDP
+};
+typedef uint8_t TOX_CONNECTION;
 
-/*  returns the length of status message on success.
- *  returns -1 on failure.
+/**
+ * Return whether we are connected to the DHT. The return value is equal to the
+ * last value received through the `connection_status` callback.
  */
-int tox_get_status_message_size(const Tox *tox, int32_t friendnumber);
-int tox_get_self_status_message_size(const Tox *tox);
+TOX_CONNECTION tox_get_connection_status(const Tox *tox);
 
-/* Copy friendnumber's status message into buf, truncating if size is over maxlen.
- * Get the size you need to allocate from m_get_statusmessage_size.
- * The self variant will copy our own status message.
+/**
+ * The function type for the `connection_status` callback.
  *
- * returns the length of the copied data on success
- * retruns -1 on failure.
+ * @param connection_status Equal to the return value of
+ *   tox_get_connection_status.
  */
-int tox_get_status_message(const Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
-int tox_get_self_status_message(const Tox *tox, uint8_t *buf, uint32_t maxlen);
+typedef void tox_connection_status_cb(Tox *tox, TOX_CONNECTION connection_status, void *user_data);
 
-/*  return one of TOX_USERSTATUS values.
- *  Values unknown to your application should be represented as TOX_USERSTATUS_NONE.
- *  As above, the self variant will return our own TOX_USERSTATUS.
- *  If friendnumber is invalid, this shall return TOX_USERSTATUS_INVALID.
+/**
+ * Set the callback for the `connection_status` event. Pass NULL to unset.
+ *
+ * This event is triggered whenever there is a change in the DHT connection
+ * state. When disconnected, a client may choose to call tox_bootstrap again, to
+ * reconnect to the DHT. Note that this state may frequently change for short
+ * amounts of time. Clients should therefore not immediately bootstrap on
+ * receiving a disconnect.
+ *
+ * TODO: how long should a client wait before bootstrapping again?
  */
-uint8_t tox_get_user_status(const Tox *tox, int32_t friendnumber);
-uint8_t tox_get_self_user_status(const Tox *tox);
+void tox_callback_connection_status(Tox *tox, tox_connection_status_cb *function, void *user_data);
 
 
-/* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
- * returns -1 on error.
+/**
+ * Return the time in milliseconds before tox_iteration() should be called again
+ * for optimal performance.
  */
-uint64_t tox_get_last_online(const Tox *tox, int32_t friendnumber);
+uint32_t tox_iteration_interval(const Tox *tox);
 
-/* Set our typing status for a friend.
- * You are responsible for turning it on or off.
- *
- * returns 0 on success.
- * returns -1 on failure.
+
+/**
+ * The main loop that needs to be run in intervals of tox_iteration_interval()
+ * milliseconds.
  */
-int tox_set_user_is_typing(Tox *tox, int32_t friendnumber, uint8_t is_typing);
+void tox_iteration(Tox *tox);
+
 
-/* Get the typing status of a friend.
+/*******************************************************************************
+ *
+ * :: Internal client information (Tox address/id)
  *
- * returns 0 if friend is not typing.
- * returns 1 if friend is typing.
+ ******************************************************************************/
+
+
+/**
+ * Writes the Tox friend address of the client to a byte array. The address is
+ * not in human-readable format. If a client wants to display the address,
+ * formatting is required.
+ *
+ * @param address A memory region of at least TOX_ADDRESS_SIZE bytes. If this
+ *   parameter is NULL, this function has no effect.
+ * @see TOX_ADDRESS_SIZE for the address format.
  */
-uint8_t tox_get_is_typing(const Tox *tox, int32_t friendnumber);
+void tox_self_get_address(const Tox *tox, uint8_t *address);
 
-/* Return the number of friends in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_friendlist. */
-uint32_t tox_count_friendlist(const Tox *tox);
 
-/* Return the number of online friends in the instance m. */
-uint32_t tox_get_num_online_friends(const Tox *tox);
+/**
+ * Set the 4-byte nospam part of the address.
+ *
+ * @param nospam Any 32 bit unsigned integer.
+ */
+void tox_self_set_nospam(Tox *tox, uint32_t nospam);
 
-/* Copy a list of valid friend IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_friendlist(const Tox *tox, int32_t *out_list, uint32_t list_size);
+/**
+ * Get the 4-byte nospam part of the address.
+ */
+uint32_t tox_self_get_nospam(const Tox *tox);
 
-/* Set the function that will be executed when a friend request is received.
- *  Function format is function(Tox *tox, uint8_t * public_key, uint8_t * data, uint16_t length, void *userdata)
+/**
+ * Copy the Tox Public Key (long term public key) from the Tox object.
+ *
+ * @param public_key A memory region of at least TOX_PUBLIC_KEY_SIZE bytes. If
+ *   this parameter is NULL, this function has no effect.
  */
-void tox_callback_friend_request(Tox *tox, void (*function)(Tox *tox, const uint8_t *, const uint8_t *, uint16_t,
-                                 void *), void *userdata);
+void tox_self_get_public_key(const Tox *tox, uint8_t *public_key);
 
-/* Set the function that will be executed when a message from a friend is received.
- *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * message, uint16_t length, void *userdata)
+/**
+ * Copy the private key from the Tox object.
+ *
+ * @param private_key A memory region of at least TOX_PUBLIC_KEY_SIZE bytes. If
+ *   this parameter is NULL, this function has no effect.
  */
-void tox_callback_friend_message(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                 void *userdata);
+void tox_self_get_private_key(const Tox *tox, uint8_t *private_key);
+
 
-/* Set the function that will be executed when an action from a friend is received.
- *  Function format is: function(Tox *tox, int32_t friendnumber, uint8_t * action, uint16_t length, void *userdata)
+/*******************************************************************************
+ *
+ * :: User-visible client information (nickname/status)
+ *
+ ******************************************************************************/
+
+
+/**
+ * Common error codes for all functions that set a piece of user-visible
+ * client information.
  */
-void tox_callback_friend_action(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                void *userdata);
+enum TOX_ERR_SET_INFO {
+    TOX_ERR_SET_INFO_OK,
+    TOX_ERR_SET_INFO_NULL,
+    /**
+     * Information length exceeded maximum permissible size.
+     */
+    TOX_ERR_SET_INFO_TOO_LONG
+};
+typedef uint8_t TOX_ERR_SET_INFO;
 
-/* Set the callback for name changes.
- *  function(Tox *tox, int32_t friendnumber, uint8_t *newname, uint16_t length, void *userdata)
- *  You are not responsible for freeing newname
+/**
+ * Set the nickname for the Tox client.
+ *
+ * Nickname length cannot exceed TOX_MAX_NAME_LENGTH. If length is 0, the name
+ * parameter is ignored (it can be NULL), and the nickname is set back to empty.
+ *
+ * @param name A byte array containing the new nickname.
+ * @param length The size of the name byte array.
+ *
+ * @return true on success.
  */
-void tox_callback_name_change(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
-                              void *userdata);
+bool tox_self_set_name(Tox *tox, const uint8_t *name, size_t length, TOX_ERR_SET_INFO *error);
 
-/* Set the callback for status message changes.
- *  function(Tox *tox, int32_t friendnumber, uint8_t *newstatus, uint16_t length, void *userdata)
- *  You are not responsible for freeing newstatus.
+/**
+ * Return the length of the current nickname as passed to tox_self_set_name.
+ *
+ * If no nickname was set before calling this function, the name is empty,
+ * and this function returns 0.
+ *
+ * @see threading for concurrency implications.
  */
-void tox_callback_status_message(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
-                                 void *userdata);
+size_t tox_self_get_name_size(const Tox *tox);
 
-/* Set the callback for status type changes.
- *  function(Tox *tox, int32_t friendnumber, uint8_t TOX_USERSTATUS, void *userdata)
+/**
+ * Write the nickname set by tox_self_set_name to a byte array.
+ *
+ * If no nickname was set before calling this function, the name is empty,
+ * and this function has no effect.
+ *
+ * Call tox_self_get_name_size to find out how much memory to allocate for
+ * the result.
+ *
+ * @param name A valid memory location large enough to hold the nickname.
+ *   If this parameter is NULL, the function has no effect.
  */
-void tox_callback_user_status(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, void *), void *userdata);
+void tox_self_get_name(const Tox *tox, uint8_t *name);
 
-/* Set the callback for typing changes.
- *  function (Tox *tox, int32_t friendnumber, uint8_t is_typing, void *userdata)
+/**
+ * Set the client's status message.
+ *
+ * Status message length cannot exceed TOX_MAX_STATUS_MESSAGE_LENGTH. If
+ * length is 0, the status parameter is ignored (it can be NULL), and the
+ * user status is set back to empty.
  */
-void tox_callback_typing_change(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, void *), void *userdata);
+bool tox_self_set_status_message(Tox *tox, const uint8_t *status, size_t length, TOX_ERR_SET_INFO *error);
 
-/* Set the callback for read receipts.
- *  function(Tox *tox, int32_t friendnumber, uint32_t receipt, void *userdata)
+/**
+ * Return the length of the current status message as passed to
+ * tox_self_set_status_message.
+ *
+ * If no status message was set before calling this function, the status
+ * is empty, and this function returns 0.
  *
- *  If you are keeping a record of returns from m_sendmessage;
- *  receipt might be one of those values, meaning the message
- *  has been received on the other side.
- *  Since core doesn't track ids for you, receipt may not correspond to any message.
- *  In that case, you should discard it.
+ * @see threading for concurrency implications.
  */
-void tox_callback_read_receipt(Tox *tox, void (*function)(Tox *tox, int32_t, uint32_t, void *), void *userdata);
+size_t tox_self_get_status_message_size(const Tox *tox);
 
-/* Set the callback for connection status changes.
- *  function(Tox *tox, int32_t friendnumber, uint8_t status, void *userdata)
+/**
+ * Write the status message set by tox_self_set_status_message to a byte array.
  *
- *  Status:
- *    0 -- friend went offline after being previously online
- *    1 -- friend went online
+ * If no status message was set before calling this function, the status is
+ * empty, and this function has no effect.
  *
- *  NOTE: This callback is not called when adding friends, thus the "after
- *  being previously online" part. it's assumed that when adding friends,
- *  their connection status is offline.
+ * Call tox_self_status_message_size to find out how much memory to allocate for
+ * the result.
+ *
+ * @param status A valid memory location large enough to hold the status message.
+ *   If this parameter is NULL, the function has no effect.
  */
-void tox_callback_connection_status(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t, void *), void *userdata);
+void tox_self_get_status_message(const Tox *tox, uint8_t *status);
 
 
-/**********ADVANCED FUNCTIONS (If you don't know what they do you can safely ignore them.)  ************/
+/**
+ * Set the client's user status.
+ *
+ * @param user_status One of the user statuses listed in the enumeration above.
+ */
+void tox_self_set_status(Tox *tox, TOX_STATUS user_status);
 
-/* Functions to get/set the nospam part of the id.
+/**
+ * Returns the client's user status.
  */
-uint32_t tox_get_nospam(const Tox *tox);
-void tox_set_nospam(Tox *tox, uint32_t nospam);
+TOX_STATUS tox_self_get_status(const Tox *tox);
+
+
+/*******************************************************************************
+ *
+ * :: Friend list management
+ *
+ ******************************************************************************/
+
+
+enum TOX_ERR_FRIEND_ADD {
+    TOX_ERR_FRIEND_ADD_OK,
+    TOX_ERR_FRIEND_ADD_NULL,
+    /**
+     * The length of the friend request message exceeded
+     * TOX_MAX_FRIEND_REQUEST_LENGTH.
+     */
+    TOX_ERR_FRIEND_ADD_TOO_LONG,
+    /**
+     * The friend request message was empty. This, and the TOO_LONG code will
+     * never be returned from tox_friend_add_norequest.
+     */
+    TOX_ERR_FRIEND_ADD_NO_MESSAGE,
+    /**
+     * The friend address belongs to the sending client.
+     */
+    TOX_ERR_FRIEND_ADD_OWN_KEY,
+    /**
+     * A friend request has already been sent, or the address belongs to a friend
+     * that is already on the friend list.
+     */
+    TOX_ERR_FRIEND_ADD_ALREADY_SENT,
+    /**
+     * The friend address checksum failed.
+     */
+    TOX_ERR_FRIEND_ADD_BAD_CHECKSUM,
+    /**
+     * The friend was already there, but the nospam value was different.
+     */
+    TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM,
+    /**
+     * A memory allocation failed when trying to increase the friend list size.
+     */
+    TOX_ERR_FRIEND_ADD_MALLOC
+};
+typedef uint8_t TOX_ERR_FRIEND_ADD;
 
-/* Copy the public and secret key from the Tox object.
-   public_key and secret_key must be 32 bytes big.
-   if the pointer is NULL, no data will be copied to it.*/
-void tox_get_keys(Tox *tox, uint8_t *public_key, uint8_t *secret_key);
+/**
+ * Add a friend to the friend list and send a friend request.
+ *
+ * A friend request message must be at least 1 byte long and at most
+ * TOX_MAX_FRIEND_REQUEST_LENGTH.
+ *
+ * Friend numbers are unique identifiers used in all functions that operate on
+ * friends. Once added, a friend number is stable for the lifetime of the Tox
+ * object. After saving the state and reloading it, the friend numbers may not
+ * be the same as before. Deleting a friend creates a gap in the friend number
+ * set, which is filled by the next adding of a friend.
+ *
+ * If more than INT32_MAX friends are added, this function causes undefined
+ * behaviour.
+ *
+ * @param address The address of the friend (returned by tox_self_get_address of
+ *   the friend you wish to add) it must be TOX_ADDRESS_SIZE bytes.
+ * @param message The message that will be sent along with the friend request.
+ * @param length The length of the data byte array.
+ *
+ * @return the friend number on success, UINT32_MAX on failure.
+ */
+uint32_t tox_friend_add(Tox *tox, const uint8_t *address, const uint8_t *message, size_t length,
+                        TOX_ERR_FRIEND_ADD *error);
 
-/**********GROUP CHAT FUNCTIONS: WARNING Group chats will be rewritten so this might change ************/
 
-/* Set the callback for group invites.
+/**
+ * Add a friend without sending a friend request.
  *
- *  Function(Tox *tox, int friendnumber, uint8_t *group_public_key, void *userdata)
+ * This function is used to add a friend in response to a friend request. If the
+ * client receives a friend request, it can be reasonably sure that the other
+ * client added this client as a friend, eliminating the need for a friend
+ * request.
+ *
+ * This function is also useful in a situation where both instances are
+ * controlled by the same entity, so that this entity can perform the mutual
+ * friend adding. In this case, there is no need for a friend request, either.
+ *
+ * @param public_key A byte array of length TOX_PUBLIC_KEY_SIZE containing the
+ *   Public Key (not the Address) of the friend to add.
+ *
+ * @return the friend number on success, UINT32_MAX on failure.
+ * @see tox_friend_add for a more detailed description of friend numbers.
  */
-void tox_callback_group_invite(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, void *), void *userdata);
+uint32_t tox_friend_add_norequest(Tox *tox, const uint8_t *public_key, TOX_ERR_FRIEND_ADD *error);
 
-/* Set the callback for group messages.
+
+enum TOX_ERR_FRIEND_DELETE {
+    TOX_ERR_FRIEND_DELETE_OK,
+    /**
+     * There was no friend with the given friend number. No friends were deleted.
+     */
+    TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND
+};
+typedef uint8_t TOX_ERR_FRIEND_DELETE;
+
+/**
+ * Remove a friend from the friend list.
+ *
+ * This does not notify the friend of their deletion. After calling this
+ * function, this client will appear offline to the friend and no communication
+ * can occur between the two.
  *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * message, uint16_t length, void *userdata)
+ * @friend_number Friend number for the friend to be deleted.
+ *
+ * @return true on success.
  */
-void tox_callback_group_message(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
-                                void *userdata);
+bool tox_friend_delete(Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_DELETE *error);
+
 
-/* Set the callback for group actions.
+/*******************************************************************************
  *
- *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * action, uint16_t length, void *userdata)
+ * :: Friend list queries
+ *
+ ******************************************************************************/
+
+
+enum TOX_ERR_FRIEND_BY_PUBLIC_KEY {
+    TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK,
+    TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL,
+    /**
+     * No friend with the given Public Key exists on the friend list.
+     */
+    TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND
+};
+typedef uint8_t TOX_ERR_FRIEND_BY_PUBLIC_KEY;
+
+/**
+ * Return the friend number associated with that Public Key.
+ *
+ * @return the friend number on success, UINT32_MAX on failure.
+ * @param public_key A byte array containing the Public Key.
  */
-void tox_callback_group_action(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
-                               void *userdata);
+uint32_t tox_friend_by_public_key(const Tox *tox, const uint8_t *public_key, TOX_ERR_FRIEND_BY_PUBLIC_KEY *error);
+
+
+enum TOX_ERR_FRIEND_GET_PUBLIC_KEY {
+    TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK,
+    TOX_ERR_FRIEND_GET_PUBLIC_KEY_NULL,
+    /**
+     * No friend with the given number exists on the friend list.
+     */
+    TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND
+};
+typedef uint8_t TOX_ERR_FRIEND_GET_PUBLIC_KEY;
 
-/* Set callback function for peer name list changes.
+/**
+ * Copies the Public Key associated with a given friend number to a byte array.
  *
- * It gets called every time the name list changes(new peer/name, deleted peer)
- *  Function(Tox *tox, int groupnumber, int peernumber, TOX_CHAT_CHANGE change, void *userdata)
+ * @param friend_number The friend number you want the Public Key of.
+ * @param public_key A memory region of at least TOX_PUBLIC_KEY_SIZE bytes. If
+ *   this parameter is NULL, this function has no effect.
+ *
+ * @return true on success.
  */
-typedef enum {
-    TOX_CHAT_CHANGE_PEER_ADD,
-    TOX_CHAT_CHANGE_PEER_DEL,
-    TOX_CHAT_CHANGE_PEER_NAME,
-} TOX_CHAT_CHANGE;
+bool tox_friend_get_public_key(const Tox *tox, uint32_t friend_number, uint8_t *public_key,
+                               TOX_ERR_FRIEND_GET_PUBLIC_KEY *error);
+
 
-void tox_callback_group_namelist_change(Tox *tox, void (*function)(Tox *tox, int, int, uint8_t, void *),
-                                        void *userdata);
+/**
+ * Checks if a friend with the given friend number exists and returns true if
+ * it does.
+ */
+bool tox_friend_exists(const Tox *tox, uint32_t friend_number);
 
-/* Creates a new groupchat and puts it in the chats array.
+
+/**
+ * Return the number of friends on the friend list.
  *
- * return group number on success.
- * return -1 on failure.
+ * This function can be used to determine how much memory to allocate for
+ * tox_friend_list.
  */
-int tox_add_groupchat(Tox *tox);
+size_t tox_friend_list_size(const Tox *tox);
+
 
-/* Delete a groupchat from the chats array.
+/**
+ * Copy a list of valid friend numbers into an array.
  *
- * return 0 on success.
- * return -1 if failure.
+ * Call tox_friend_list_size to determine the number of elements to allocate.
+ *
+ * @param list A memory region with enough space to hold the friend list. If
+ *   this parameter is NULL, this function has no effect.
  */
-int tox_del_groupchat(Tox *tox, int groupnumber);
+void tox_friend_list(const Tox *tox, uint32_t *list);
+
 
-/* Copy the name of peernumber who is in groupnumber to name.
- * name must be at least TOX_MAX_NAME_LENGTH long.
+
+/*******************************************************************************
+ *
+ * :: Friend-specific state queries (can also be received through callbacks)
  *
- * return length of name if success
- * return -1 if failure
+ ******************************************************************************/
+
+
+/**
+ * Common error codes for friend state query functions.
  */
-int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name);
+enum TOX_ERR_FRIEND_QUERY {
+    TOX_ERR_FRIEND_QUERY_OK,
+    /**
+     * The pointer parameter for storing the query result (name, message) was
+     * NULL. Unlike the `_self_` variants of these functions, which have no effect
+     * when a parameter is NULL, these functions return an error in that case.
+     */
+    TOX_ERR_FRIEND_QUERY_NULL,
+    /**
+     * The friend_number did not designate a valid friend.
+     */
+    TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND
+};
+typedef uint8_t TOX_ERR_FRIEND_QUERY;
 
-/* invite friendnumber to groupnumber
- * return 0 on success
- * return -1 on failure
+/**
+ * Return the length of the friend's name. If the friend number is invalid, the
+ * return value is SIZE_MAX.
+ *
+ * The return value is equal to the `length` argument received by the last
+ * `friend_name` callback.
  */
-int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber);
+size_t tox_friend_get_name_size(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
-/* Join a group (you need to have been invited first.)
+/**
+ * Write the name of the friend designated by the given friend number to a byte
+ * array.
+ *
+ * Call tox_friend_get_name_size to determine the allocation size for the `name`
+ * parameter.
  *
- * returns group number on success
- * returns -1 on failure.
+ * The data written to `name` is equal to the data received by the last
+ * `friend_name` callback.
+ *
+ * @param name A valid memory region large enough to store the friend's name.
+ *
+ * @return true on success.
  */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *friend_group_public_key);
+bool tox_friend_get_name(const Tox *tox, uint32_t friend_number, uint8_t *name, TOX_ERR_FRIEND_QUERY *error);
 
-/* send a group message
- * return 0 on success
- * return -1 on failure
+/**
+ * The function type for the `friend_name` callback.
+ *
+ * @param friend_number The friend number of the friend whose name changed.
+ * @param name A byte array containing the same data as
+ *   tox_friend_get_name would write to its `name` parameter.
+ * @param length A value equal to the return value of
+ *   tox_friend_get_name_size.
  */
-int tox_group_message_send(Tox *tox, int groupnumber, const uint8_t *message, uint32_t length);
+typedef void tox_friend_name_cb(Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length, void *user_data);
 
-/* send a group action
- * return 0 on success
- * return -1 on failure
+/**
+ * Set the callback for the `friend_name` event. Pass NULL to unset.
+ *
+ * This event is triggered when a friend changes their name.
  */
-int tox_group_action_send(Tox *tox, int groupnumber, const uint8_t *action, uint32_t length);
+void tox_callback_friend_name(Tox *tox, tox_friend_name_cb *function, void *user_data);
+
 
-/* Return the number of peers in the group chat on success.
- * return -1 on failure
+/**
+ * Return the length of the friend's status message. If the friend number is
+ * invalid, the return value is SIZE_MAX.
  */
-int tox_group_number_peers(const Tox *tox, int groupnumber);
+size_t tox_friend_get_status_message_size(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
-/* List all the peers in the group chat.
+/**
+ * Write the name of the friend designated by the given friend number to a byte
+ * array.
  *
- * Copies the names of the peers to the name[length][TOX_MAX_NAME_LENGTH] array.
+ * Call tox_friend_get_name_size to determine the allocation size for the `name`
+ * parameter.
  *
- * Copies the lengths of the names to lengths[length]
+ * The data written to `message` is equal to the data received by the last
+ * `friend_status_message` callback.
  *
- * returns the number of peers on success.
+ * @param name A valid memory region large enough to store the friend's name.
+ */
+bool tox_friend_get_status_message(const Tox *tox, uint32_t friend_number, uint8_t *message,
+                                   TOX_ERR_FRIEND_QUERY *error);
+
+/**
+ * The function type for the `friend_status_message` callback.
+ *
+ * @param friend_number The friend number of the friend whose status message
+ *   changed.
+ * @param message A byte array containing the same data as
+ *   tox_friend_get_status_message would write to its `message` parameter.
+ * @param length A value equal to the return value of
+ *   tox_friend_get_status_message_size.
+ */
+typedef void tox_friend_status_message_cb(Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length,
+        void *user_data);
+
+/**
+ * Set the callback for the `friend_status_message` event. Pass NULL to unset.
  *
- * return -1 on failure.
+ * This event is triggered when a friend changes their name.
  */
-int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
-                        uint16_t length);
+void tox_callback_friend_status_message(Tox *tox, tox_friend_status_message_cb *function, void *user_data);
 
-/* Return the number of chats in the instance m.
- * You should use this to determine how much memory to allocate
- * for copy_chatlist. */
-uint32_t tox_count_chatlist(const Tox *tox);
 
-/* Copy a list of valid chat IDs into the array out_list.
- * If out_list is NULL, returns 0.
- * Otherwise, returns the number of elements copied.
- * If the array was too small, the contents
- * of out_list will be truncated to list_size. */
-uint32_t tox_get_chatlist(const Tox *tox, int *out_list, uint32_t list_size);
+/**
+ * Return the friend's user status (away/busy/...). If the friend number is
+ * invalid, the return value is unspecified.
+ *
+ * The status returned is equal to the last status received through the
+ * `friend_status` callback.
+ */
+TOX_STATUS tox_friend_get_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
 
+/**
+ * The function type for the `friend_status` callback.
+ *
+ * @param friend_number The friend number of the friend whose user status
+ *   changed.
+ * @param status The new user status.
+ */
+typedef void tox_friend_status_cb(Tox *tox, uint32_t friend_number, TOX_STATUS status, void *user_data);
 
-/****************FILE SENDING FUNCTIONS*****************/
-/* NOTE: This how to will be updated.
+/**
+ * Set the callback for the `friend_status` event. Pass NULL to unset.
  *
- * HOW TO SEND FILES CORRECTLY:
- * 1. Use tox_new_file_sender(...) to create a new file sender.
- * 2. Wait for the callback set with tox_callback_file_control(...) to be called with receive_send == 1 and control_type == TOX_FILECONTROL_ACCEPT
- * 3. Send the data with tox_file_send_data(...) with chunk size tox_file_data_size(...)
- * 4. When sending is done, send a tox_file_send_control(...) with send_receive = 0 and message_id = TOX_FILECONTROL_FINISHED
- * 5. when the callback set with tox_callback_file_control(...) is called with receive_send == 1 and control_type == TOX_FILECONTROL_FINISHED
- * the other person has received the file correctly.
+ * This event is triggered when a friend changes their user status.
+ */
+void tox_callback_friend_status(Tox *tox, tox_friend_status_cb *function, void *user_data);
+
+
+/**
+ * Check whether a friend is currently connected to this client.
  *
- * HOW TO RECEIVE FILES CORRECTLY:
- * 1. wait for the callback set with tox_callback_file_send_request(...)
- * 2. accept or refuse the connection with tox_file_send_control(...) with send_receive = 1 and message_id = TOX_FILECONTROL_ACCEPT or TOX_FILECONTROL_KILL
- * 3. save all the data received with the callback set with tox_callback_file_data(...) to a file.
- * 4. when the callback set with tox_callback_file_control(...) is called with receive_send == 0 and control_type == TOX_FILECONTROL_FINISHED
- * the file is done transferring.
- * 5. send a tox_file_send_control(...) with send_receive = 1 and message_id = TOX_FILECONTROL_FINISHED to confirm that we did receive the file.
+ * The result of this function is equal to the last value received by the
+ * `friend_connection_status` callback.
  *
- * tox_file_data_remaining(...) can be used to know how many bytes are left to send/receive.
+ * @param friend_number The friend number for which to query the connection
+ *   status.
  *
- * If the connection breaks during file sending (The other person goes offline without pausing the sending and then comes back)
- * the receiver must send a control packet with send_receive == 1 message_id = TOX_FILECONTROL_RESUME_BROKEN and the data being
- * a uint64_t (in host byte order) containing the number of bytes received.
+ * @return the friend's connection status as it was received through the
+ *   `friend_connection_status` event.
+ */
+TOX_CONNECTION tox_friend_get_connection_status(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
+
+/**
+ * The function type for the `friend_connection_status` callback.
  *
- * If the sender receives this packet, he must send a control packet with send_receive == 0 and control_type == TOX_FILECONTROL_ACCEPT
- * then he must start sending file data from the position (data , uint64_t in host byte order) received in the TOX_FILECONTROL_RESUME_BROKEN packet.
+ * @param friend_number The friend number of the friend whose connection status
+ *   changed.
+ * @param connection_status The result of calling
+ *   tox_friend_get_connection_status on the passed friend_number.
+ */
+typedef void tox_friend_connection_status_cb(Tox *tox, uint32_t friend_number, TOX_CONNECTION connection_status,
+        void *user_data);
+
+/**
+ * Set the callback for the `friend_connection_status` event. Pass NULL to
+ * unset.
+ *
+ * This event is triggered when a friend goes offline after having been online,
+ * or when a friend goes online.
+ *
+ * This callback is not called when adding friends. It is assumed that when
+ * adding friends, their connection status is offline.
+ */
+void tox_callback_friend_connection_status(Tox *tox, tox_friend_connection_status_cb *function, void *user_data);
+
+
+/**
+ * Check whether a friend is currently typing a message.
  *
- * To pause a file transfer send a control packet with control_type == TOX_FILECONTROL_PAUSE.
- * To unpause a file transfer send a control packet with control_type == TOX_FILECONTROL_ACCEPT.
+ * @param friend_number The friend number for which to query the typing status.
  *
- * If you receive a control packet with receive_send == 1 and control_type == TOX_FILECONTROL_PAUSE, you must stop sending filenumber until the other
- * person sends a control packet with send_receive == 0 and control_type == TOX_FILECONTROL_ACCEPT with the filenumber being a paused filenumber.
+ * @return true if the friend is typing.
+ * @return false if the friend is not typing, or the friend number was
+ *   invalid. Inspect the error code to determine which case it is.
+ */
+bool tox_friend_get_typing(const Tox *tox, uint32_t friend_number, TOX_ERR_FRIEND_QUERY *error);
+
+/**
+ * The function type for the `friend_typing` callback.
  *
- * If you receive a control packet with receive_send == 0 and control_type == TOX_FILECONTROL_PAUSE, it means the sender of filenumber has paused the
- * transfer and will resume it later with a control packet with send_receive == 1 and control_type == TOX_FILECONTROL_ACCEPT for that file number.
+ * @param friend_number The friend number of the friend who started or stopped
+ *   typing.
+ * @param is_typing The result of calling tox_friend_get_typing on the passed
+ *   friend_number.
+ */
+typedef void tox_friend_typing_cb(Tox *tox, uint32_t friend_number, bool is_typing, void *user_data);
+
+/**
+ * Set the callback for the `friend_typing` event. Pass NULL to unset.
  *
- * More to come...
+ * This event is triggered when a friend starts or stops typing.
  */
+void tox_callback_friend_typing(Tox *tox, tox_friend_typing_cb *function, void *user_data);
+
+
+/*******************************************************************************
+ *
+ * :: Sending private messages
+ *
+ ******************************************************************************/
 
-enum {
-    TOX_FILECONTROL_ACCEPT,
-    TOX_FILECONTROL_PAUSE,
-    TOX_FILECONTROL_KILL,
-    TOX_FILECONTROL_FINISHED,
-    TOX_FILECONTROL_RESUME_BROKEN
+
+enum TOX_ERR_SET_TYPING {
+    TOX_ERR_SET_TYPING_OK,
+    /**
+     * The friend number did not designate a valid friend.
+     */
+    TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND
 };
-/* Set the callback for file send requests.
+typedef uint8_t TOX_ERR_SET_TYPING;
+
+/**
+ * Set the client's typing status for a friend.
+ *
+ * The client is responsible for turning it on or off.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length, void *userdata)
+ * @param friend_number The friend to which the client is typing a message.
+ * @param is_typing The typing status. True means the client is typing.
+ *
+ * @return true on success.
  */
-void tox_callback_file_send_request(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, uint64_t, const uint8_t *,
-                                    uint16_t, void *), void *userdata);
+bool tox_self_set_typing(Tox *tox, uint32_t friend_number, bool is_typing, TOX_ERR_SET_TYPING *error);
+
+
+enum TOX_ERR_SEND_MESSAGE {
+    TOX_ERR_SEND_MESSAGE_OK,
+    TOX_ERR_SEND_MESSAGE_NULL,
+    /**
+     * The friend number did not designate a valid friend.
+     */
+    TOX_ERR_SEND_MESSAGE_FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    TOX_ERR_SEND_MESSAGE_FRIEND_NOT_CONNECTED,
+    /**
+     * An allocation error occurred while increasing the send queue size.
+     */
+    TOX_ERR_SEND_MESSAGE_SENDQ,
+    /**
+     * Message length exceeded TOX_MAX_MESSAGE_LENGTH.
+     */
+    TOX_ERR_SEND_MESSAGE_TOO_LONG,
+    /**
+     * Attempted to send a zero-length message.
+     */
+    TOX_ERR_SEND_MESSAGE_EMPTY
+};
+typedef uint8_t TOX_ERR_SEND_MESSAGE;
 
-/* Set the callback for file control requests.
+/**
+ * Send a text chat message to an online friend.
  *
- *  receive_send is 1 if the message is for a slot on which we are currently sending a file and 0 if the message
- *  is for a slot on which we are receiving the file
+ * This function creates a chat message packet and pushes it into the send
+ * queue.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber, uint8_t control_type, uint8_t *data, uint16_t length, void *userdata)
+ * The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
+ * must be split by the client and sent as separate messages. Other clients can
+ * then reassemble the fragments. Messages may not be empty.
+ *
+ * The return value of this function is the message ID. If a read receipt is
+ * received, the triggered `read_receipt` event will be passed this message ID.
+ *
+ * Message IDs are unique per friend. The first message ID is 0. Message IDs are
+ * incremented by 1 each time a message is sent. If UINT32_MAX messages were
+ * sent, the next message ID is 0.
+ */
+uint32_t tox_send_message(Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length,
+                          TOX_ERR_SEND_MESSAGE *error);
+
+
+/**
+ * Send an action to an online friend.
+ *
+ * This is similar to /me (CTCP ACTION) on IRC.
+ *
+ * Message ID space is shared between tox_send_message and tox_send_action. This
+ * means that sending a message will cause the next message ID from sending an
+ * action will be incremented.
+ *
+ * @see tox_send_message for more details.
+ */
+uint32_t tox_send_action(Tox *tox, uint32_t friend_number, const uint8_t *action, size_t length,
+                         TOX_ERR_SEND_MESSAGE *error);
+
+
+/**
+ * The function type for the `read_receipt` callback.
+ *
+ * @param friend_number The friend number of the friend who received the message.
+ * @param message_id The message ID as returned from tox_send_message or
+ *   tox_send_action corresponding to the message sent.
+ */
+typedef void tox_read_receipt_cb(Tox *tox, uint32_t friend_number, uint32_t message_id, void *user_data);
+
+/**
+ * Set the callback for the `read_receipt` event. Pass NULL to unset.
+ *
+ * This event is triggered when a read receipt is received from a friend. This
+ * normally means that the message has been received by the friend, however a
+ * friend can send a read receipt with any message ID in it, so the number
+ * received here may not correspond to any message sent through tox_send_message
+ * or tox_send_action. In that case, the receipt should be discarded.
+ */
+void tox_callback_read_receipt(Tox *tox, tox_read_receipt_cb *function, void *user_data);
+
+
+/*******************************************************************************
+ *
+ * :: Receiving private messages and friend requests
+ *
+ ******************************************************************************/
+
+
+/**
+ * The function type for the `friend_request` callback.
+ *
+ * @param public_key The Public Key of the user who sent the friend request.
+ * @param time_delta A delta in seconds between when the message was composed
+ *   and when it is being transmitted. For messages that are sent immediately,
+ *   it will be 0. If a message was written and couldn't be sent immediately
+ *   (due to a connection failure, for example), the time_delta is an
+ *   approximation of when it was composed.
+ * @param message The message they sent along with the request.
+ * @param length The size of the message byte array.
+ */
+typedef void tox_friend_request_cb(Tox *tox, const uint8_t *public_key, /*uint32_t time_delta, */const uint8_t *message,
+                                   size_t length, void *user_data);
+
+/**
+ * Set the callback for the `friend_request` event. Pass NULL to unset.
+ *
+ * This event is triggered when a friend request is received.
+ */
+void tox_callback_friend_request(Tox *tox, tox_friend_request_cb *function, void *user_data);
+
+
+/**
+ * The function type for the `friend_message` callback.
+ *
+ * @param friend_number The friend number of the friend who sent the message.
+ * @param time_delta Time between composition and sending.
+ * @param message The message data they sent.
+ * @param length The size of the message byte array.
+ *
+ * @see tox_friend_request_cb for more information on time_delta.
+ */
+typedef void tox_friend_message_cb(Tox *tox, uint32_t friend_number, /*uint32_t time_delta, */const uint8_t *message,
+                                   size_t length, void *user_data);
+
+/**
+ * Set the callback for the `friend_message` event. Pass NULL to unset.
  *
+ * This event is triggered when a message from a friend is received.
  */
-void tox_callback_file_control(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, uint8_t, uint8_t, const uint8_t *,
-                               uint16_t, void *), void *userdata);
+void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *function, void *user_data);
+
 
-/* Set the callback for file data.
+/**
+ * The function type for the `friend_action` callback.
  *
- *  Function(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+ * @param friend_number The friend number of the friend who sent the action.
+ * @param time_delta Time between composition and sending.
+ * @param action The action message data they sent.
+ * @param length The size of the action byte array.
  *
+ * @see tox_friend_request_cb for more information on time_delta.
  */
-void tox_callback_file_data(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
-                            void *), void *userdata);
+typedef void tox_friend_action_cb(Tox *tox, uint32_t friend_number, /*uint32_t time_delta, */const uint8_t *action,
+                                  size_t length, void *user_data);
 
+/**
+ * Set the callback for the `friend_action` event. Pass NULL to unset.
+ *
+ * This event is triggered when an action from a friend is received.
+ */
+void tox_callback_friend_action(Tox *tox, tox_friend_action_cb *function, void *user_data);
+
+
+
+/*******************************************************************************
+ *
+ * :: File transmission: common between sending and receiving
+ *
+ ******************************************************************************/
+
+
+enum TOX_FILE_KIND {
+    /**
+     * Arbitrary file data. Clients can choose to handle it based on the file name
+     * or magic or any other way they choose.
+     */
+    TOX_FILE_KIND_DATA,
+    /**
+     * Avatar data. This consists of tox_hash(image) + image.
+     *
+     * Avatars can be sent at any time the client wishes. Generally, a client will
+     * send the avatar to a friend when that friend comes online, and to all
+     * friends when the avatar changed. A client can save some traffic by
+     * remembering which friend received the updated avatar already and only send
+     * it if the friend has an out of date avatar.
+     *
+     * Clients who receive avatar send requests can reject it (by sending
+     * TOX_FILE_CONTROL_CANCEL before any other controls), or accept it (by
+     * sending TOX_FILE_CONTROL_RESUME). The first chunk will contain the hash in
+     * its first TOX_HASH_LENGTH bytes. A client can compare this hash with a
+     * saved hash and send TOX_FILE_CONTROL_CANCEL to terminate the avatar
+     * transfer if it matches.
+     */
+    TOX_FILE_KIND_AVATAR
+};
+typedef uint8_t TOX_FILE_KIND;
 
-/* Send a file send request.
- * Maximum filename length is 255 bytes.
- *  return file number on success
- *  return -1 on failure
+/**
+ * Generates a cryptographic hash of the given data.
+ *
+ * This function may be used by clients for any purpose, but is provided
+ * primarily for validating cached avatars. This use is highly recommended to
+ * avoid unnecessary avatar updates.
+ *
+ * If length is zero or data is NULL, the hash will contain all zero. If hash is
+ * NULL, the function returns false, otherwise it returns true.
+ *
+ * This function is a wrapper to internal message-digest functions.
+ *
+ * @param hash A valid memory location the hash data. It must be at least
+ *   TOX_HASH_LENGTH bytes in size.
+ * @param data Data to be hashed or NULL.
+ * @param length Size of the data array or 0.
+ *
+ * @return true if hash was not NULL.
  */
-int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, const uint8_t *filename,
-                        uint16_t filename_length);
+bool tox_hash(uint8_t *hash, const uint8_t *data, size_t length);
+
+
+enum TOX_FILE_CONTROL {
+    /**
+     * Sent by the receiving side to accept a file send request. Also sent after a
+     * TOX_FILE_CONTROL_PAUSE command to continue sending or receiving.
+     */
+    TOX_FILE_CONTROL_RESUME,
+    /**
+     * Sent by clients to pause the file transfer. The initial state of a file
+     * transfer is always paused on the receiving side and running on the sending
+     * side. If both the sending and receiving side pause the transfer, then both
+     * need to send TOX_FILE_CONTROL_RESUME for the transfer to resume.
+     */
+    TOX_FILE_CONTROL_PAUSE,
+    /**
+     * Sent by the receiving side to reject a file send request before any other
+     * commands are sent. Also sent by either side to terminate a file transfer.
+     */
+    TOX_FILE_CONTROL_CANCEL
+};
+typedef uint8_t TOX_FILE_CONTROL;
+
+enum TOX_ERR_FILE_CONTROL {
+    TOX_ERR_FILE_CONTROL_OK,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    TOX_ERR_FILE_CONTROL_NOT_FOUND,
+    /**
+     * A RESUME control was sent, but the file transfer is running normally.
+     */
+    TOX_ERR_FILE_CONTROL_NOT_PAUSED,
+    /**
+     * A RESUME control was sent, but the file transfer was paused by the other
+     * party. Only the party that paused the transfer can resume it.
+     */
+    TOX_ERR_FILE_CONTROL_DENIED,
+    /**
+     * A PAUSE control was sent, but the file transfer was already paused.
+     */
+    TOX_ERR_FILE_CONTROL_ALREADY_PAUSED
+};
+typedef uint8_t TOX_ERR_FILE_CONTROL;
 
-/* Send a file control request.
+/**
+ * Sends a file control command to a friend for a given file transfer.
  *
- * send_receive is 0 if we want the control packet to target a file we are currently sending,
- * 1 if it targets a file we are currently receiving.
+ * @param friend_number The friend number of the friend the file is being
+ *   transferred to.
+ * @param file_number The friend-specific identifier for the file transfer.
+ * @param control The control command to send.
  *
- *  return 0 on success
- *  return -1 on failure
+ * @return true on success.
  */
-int tox_file_send_control(Tox *tox, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
-                          const uint8_t *data, uint16_t length);
+bool tox_file_control(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
+                      TOX_ERR_FILE_CONTROL *error);
+
 
-/* Send file data.
+/**
+ * The function type for the `file_control` callback.
  *
- *  return 0 on success
- *  return -1 on failure
+ * When receiving TOX_FILE_CONTROL_CANCEL, the client should release the
+ * resources associated with the file number and consider the transfer failed.
+ *
+ * @param friend_number The friend number of the friend who is sending the file.
+ * @param file_number The friend-specific file number the data received is
+ *   associated with.
+ * @param control The file control command received.
  */
-int tox_file_send_data(Tox *tox, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length);
+typedef void tox_file_control_cb(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
+                                 void *user_data);
 
-/* Returns the recommended/maximum size of the filedata you send with tox_file_send_data()
+/**
+ * Set the callback for the `file_control` event. Pass NULL to unset.
  *
- *  return size on success
- *  return -1 on failure (currently will never return -1)
+ * This event is triggered when a file control command is received from a
+ * friend.
  */
-int tox_file_data_size(const Tox *tox, int32_t friendnumber);
+void tox_callback_file_control(Tox *tox, tox_file_control_cb *function, void *user_data);
+
+
+/*******************************************************************************
+ *
+ * :: File transmission: sending
+ *
+ ******************************************************************************/
+
+
+enum TOX_ERR_FILE_SEND {
+    TOX_ERR_FILE_SEND_OK,
+    TOX_ERR_FILE_SEND_NULL,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED,
+    /**
+     * Filename length was 0.
+     */
+    TOX_ERR_FILE_SEND_NAME_EMPTY,
+    /**
+     * Filename length exceeded 255 bytes.
+     */
+    TOX_ERR_FILE_SEND_NAME_TOO_LONG,
+    /**
+     * Too many ongoing transfers. The maximum number of concurrent file transfers
+     * is 256 per friend per direction (sending and receiving).
+     */
+    TOX_ERR_FILE_SEND_TOO_MANY
+};
+typedef uint8_t TOX_ERR_FILE_SEND;
+
+/**
+ * Send a file transmission request.
+ *
+ * Maximum filename length is 255 bytes. The filename should generally just be
+ * a file name, not a path with directory names.
+ *
+ * If a non-zero file size is provided, this can be used by both sides to
+ * determine the sending progress. File size can be set to zero for streaming
+ * data of unknown size.
+ *
+ * File transmission occurs in chunks, which are requested through the
+ * `file_request_chunk` event.
+ *
+ * File numbers are stable across tox_save/tox_load cycles, so that file
+ * transfers can be resumed when a client restarts. The client needs to
+ * associate (friend Public Key, file number) with the local path of the file and
+ * persist this information to support resuming of transfers across restarts.
+ *
+ * If the file contents change during a transfer, the behaviour is unspecified
+ * in general. What will actually happen depends on the mode in which the file
+ * was modified and how the client determines the file size.
+ *
+ * - If the file size was increased
+ *   - and sending mode was streaming (file_size = 0), the behaviour will be as
+ *     expected.
+ *   - and sending mode was file (file_size != 0), the file_request_chunk
+ *     callback will receive length = 0 when Core thinks the file transfer has
+ *     finished. If the client remembers the file size as it was when sending
+ *     the request, it will terminate the transfer normally. If the client
+ *     re-reads the size, it will think the friend cancelled the transfer.
+ * - If the file size was decreased
+ *   - and sending mode was streaming, the behaviour is as expected.
+ *   - and sending mode was file, the callback will return 0 at the new
+ *     (earlier) end-of-file, signalling to the friend that the transfer was
+ *     cancelled.
+ * - If the file contents were modified
+ *   - at a position before the current read, the two files (local and remote)
+ *     will differ after the transfer terminates.
+ *   - at a position after the current read, the file transfer will succeed as
+ *     expected.
+ *   - In either case, both sides will regard the transfer as complete and
+ *     successful.
+ *
+ * @param friend_number The friend number of the friend the file send request
+ *   should be sent to.
+ * @param kind The meaning of the file to be sent.
+ * @param file_size Size in bytes of the file the client wants to send, 0 if
+ *   unknown or streaming.
+ * @param filename Name of the file. Does not need to be the actual name. This
+ *   name will be sent along with the file send request.
+ * @param filename_length Size in bytes of the filename.
+ *
+ * @return A file number used as an identifier in subsequent callbacks. This
+ *   number is per friend. File numbers are reused after a transfer terminates.
+ */
+uint32_t tox_file_send(Tox *tox, uint32_t friend_number, TOX_FILE_KIND kind, uint64_t file_size,
+                       const uint8_t *filename, size_t filename_length, TOX_ERR_FILE_SEND *error);
+
+
+enum TOX_ERR_FILE_SEND_CHUNK {
+    TOX_ERR_FILE_SEND_CHUNK_OK,
+    /**
+     * The length parameter was non-zero, but data was NULL.
+     */
+    TOX_ERR_FILE_SEND_CHUNK_NULL,
+    /**
+     * The friend_number passed did not designate a valid friend.
+     */
+    TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED,
+    /**
+     * No file transfer with the given file number was found for the given friend.
+     */
+    TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND,
+    /**
+     * Attempted to send more data than requested. The requested data size is
+     * adjusted according to maximum transmission unit and the expected end of
+     * the file. Trying to send more will result in no data being sent.
+     */
+    TOX_ERR_FILE_SEND_CHUNK_TOO_LARGE
+};
+typedef uint8_t TOX_ERR_FILE_SEND_CHUNK;
 
-/* Give the number of bytes left to be sent/received.
+/**
+ * Send a chunk of file data to a friend.
  *
- *  send_receive is 0 if we want the sending files, 1 if we want the receiving.
+ * This function is called in response to the `file_request_chunk` callback. The
+ * length parameter should be equal to or less than the one received though the
+ * callback. If it is zero, the transfer is assumed complete. For files with
+ * known size, Core will know that the transfer is complete after the last byte
+ * has been received, so it is not necessary (though not harmful) to send a
+ * zero-length chunk to terminate. For streams, it is necessary for the last
+ * chunk sent to be zero-length.
  *
- *  return number of bytes remaining to be sent/received on success
- *  return 0 on failure
+ * @return true on success.
  */
-uint64_t tox_file_data_remaining(const Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive);
+bool tox_file_send_chunk(Tox *tox, uint32_t friend_number, uint32_t file_number, const uint8_t *data, size_t length,
+                         TOX_ERR_FILE_SEND_CHUNK *error);
+
+
+/**
+ * The function type for the `file_request_chunk` callback.
+ *
+ * If the length parameter is 0, the file transfer is finished, and the client's
+ * resources associated with the file number should be released. After a call
+ * with zero length, the file number can be reused for future file transfers.
+ *
+ * If the requested position is not equal to the client's idea of the current
+ * file or stream position, it will need to seek. In case of read-once streams,
+ * the client should keep the last read chunk so that a seek back can be
+ * supported. A seek-back only ever needs to read from the last requested chunk.
+ * This happens when a chunk was requested, but the send failed. A seek-back
+ * request can occur an arbitrary number of times for any given chunk.
+ *
+ * In response to receiving this callback, the client should call the function
+ * `tox_file_send_chunk` with the requested chunk. If the number of bytes sent
+ * through that function is zero, the file transfer is assumed complete. A
+ * client may choose to send less than requested, if it is reading from a
+ * stream that doesn't have more data, yet, and it still wants to send some
+ * data to the other side. However, this will generally be less efficient than
+ * waiting for a full chunk size of data to be ready.
+ *
+ * @param friend_number The friend number of the receiving friend for this file.
+ * @param file_number The file transfer identifier returned by tox_file_send.
+ * @param position The file or stream position from which to continue reading.
+ * @param length The number of bytes requested for the current chunk.
+ */
+typedef void tox_file_request_chunk_cb(Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position,
+                                       size_t length, void *user_data);
 
-/***************END OF FILE SENDING FUNCTIONS******************/
+/**
+ * Set the callback for the `file_request_chunk` event. Pass NULL to unset.
+ */
+void tox_callback_file_request_chunk(Tox *tox, tox_file_request_chunk_cb *function, void *user_data);
 
-/*
- * Use this function to bootstrap the client.
+
+/*******************************************************************************
+ *
+ * :: File transmission: receiving
+ *
+ ******************************************************************************/
+
+
+/**
+ * The function type for the `file_receive` callback.
+ *
+ * The client should acquire resources to be associated with the file transfer.
+ * Incoming file transfers start in the PAUSED state. After this callback
+ * returns, a transfer can be rejected by sending a TOX_FILE_CONTROL_CANCEL
+ * control command before any other control commands. It can be accepted by
+ * sending TOX_FILE_CONTROL_RESUME.
+ *
+ * @param friend_number The friend number of the friend who is sending the file
+ *   transfer request.
+ * @param file_number The friend-specific file number the data received is
+ *   associated with.
+ */
+typedef void tox_file_receive_cb(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_KIND kind,
+                                 uint64_t file_size, const uint8_t *filename, size_t filename_length, void *user_data);
+
+/**
+ * Set the callback for the `file_receive` event. Pass NULL to unset.
+ *
+ * This event is triggered when a file transfer request is received.
  */
+void tox_callback_file_receive(Tox *tox, tox_file_receive_cb *function, void *user_data);
+
 
-/* Resolves address into an IP address. If successful, sends a "get nodes"
- *   request to the given node with ip, port (in host byte order).
- *   and public_key to setup connections
+/**
+ * The function type for the `file_receive_chunk` callback.
+ *
+ * This function is first called when a file transfer request is received, and
+ * subsequently when a chunk of file data for an accepted request was received.
  *
- * address can be a hostname or an IP address (IPv4 or IPv6).
+ * When length is 0, the transfer is finished and the client should release the
+ * resources it acquired for the transfer. After a call with length = 0, the
+ * file number can be reused for new file transfers.
  *
- *  returns 1 if the address could be converted into an IP address
- *  returns 0 otherwise
+ * If position is equal to file_size (received in the file_receive callback)
+ * when the transfer finishes, the file was received completely. Otherwise, if
+ * file_size was 0, streaming ended successfully when length is 0.
+ *
+ * @param friend_number The friend number of the friend who is sending the file.
+ * @param file_number The friend-specific file number the data received is
+ *   associated with.
+ * @param position The file position of the first byte in data.
+ * @param data A byte array containing the received chunk.
+ * @param length The length of the received chunk.
  */
-int tox_bootstrap_from_address(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key);
+typedef void tox_file_receive_chunk_cb(Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position,
+                                       const uint8_t *data, size_t length, void *user_data);
 
-/*  return 0 if we are not connected to the DHT.
- *  return 1 if we are.
+/**
+ * Set the callback for the `file_receive_chunk` event. Pass NULL to unset.
  */
-int tox_isconnected(const Tox *tox);
+void tox_callback_file_receive_chunk(Tox *tox, tox_file_receive_chunk_cb *function, void *user_data);
+
+
+/*******************************************************************************
+ *
+ * :: Group chat management
+ *
+ ******************************************************************************/
+
 
-typedef struct {
-    /*
-    *  The type of UDP socket created depends on ipv6enabled:
-    *  If set to 0 (zero), creates an IPv4 socket which subsequently only allows
-    *    IPv4 communication
-    *  If set to anything else (default), creates an IPv6 socket which allows both IPv4 AND
-    *    IPv6 communication
-    */
-    uint8_t ipv6enabled;
+/******************************************************************************
+ *
+ * :: Group chat message sending and receiving
+ *
+ ******************************************************************************/
+
+
+/*******************************************************************************
+ *
+ * :: Low-level custom packet sending and receiving
+ *
+ ******************************************************************************/
 
-    /* Set to 1 to disable udp support. (default: 0)
-       This will force Tox to use TCP only which may slow things down.
-       Disabling udp support is necessary when using anonymous proxies or Tor.*/
-    uint8_t udp_disabled;
 
-    /* Enable proxy support. (only basic TCP socks5 proxy currently supported.) (default: 0 (disabled))*/
-    uint8_t proxy_enabled;
-    char proxy_address[256]; /* Proxy ip or domain in NULL terminated string format. */
-    uint16_t proxy_port; /* Proxy port: in host byte order. */
-} Tox_Options;
+enum TOX_ERR_SEND_CUSTOM_PACKET {
+    TOX_ERR_SEND_CUSTOM_PACKET_OK,
+    TOX_ERR_SEND_CUSTOM_PACKET_NULL,
+    /**
+     * The friend number did not designate a valid friend.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_FRIEND_NOT_FOUND,
+    /**
+     * This client is currently not connected to the friend.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED,
+    /**
+     * The first byte of data was not in the specified range for the packet type.
+     * This range is 200-254 for lossy, and 160-191 for lossless packets.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_INVALID,
+    /**
+     * Attempted to send an empty packet.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_EMPTY,
+    /**
+     * Packet data length exceeded TOX_MAX_CUSTOM_PACKET_SIZE.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_TOO_LONG,
+    /**
+     * Send queue size exceeded.
+     */
+    TOX_ERR_SEND_CUSTOM_PACKET_SENDQ
+};
+typedef uint8_t TOX_ERR_SEND_CUSTOM_PACKET;
 
-/*
- *  Run this function at startup.
+/**
+ * Send a custom lossy packet to a friend.
+ *
+ * The first byte of data must be in the range 200-254. Maximum length of a
+ * custom packet is TOX_MAX_CUSTOM_PACKET_SIZE.
  *
- * Options are some options that can be passed to the Tox instance (see above struct).
+ * Lossy packets behave like UDP packets, meaning they might never reach the
+ * other side or might arrive more than once (if someone is messing with the
+ * connection) or might arrive in the wrong order.
  *
- * If options is NULL, tox_new() will use default settings.
+ * Unless latency is an issue, it is recommended that you use lossless custom
+ * packets instead.
  *
- * Initializes a tox structure
- *  return allocated instance of tox on success.
- *  return NULL on failure.
+ * @param friend_number The friend number of the friend this lossy packet
+ *   should be sent to.
+ * @param data A byte array containing the packet data.
+ * @param length The length of the packet data byte array.
+ *
+ * @return true on success.
  */
-Tox *tox_new(Tox_Options *options);
+bool tox_send_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
+                           TOX_ERR_SEND_CUSTOM_PACKET *error);
 
-/* Run this before closing shop.
- * Free all datastructures. */
-void tox_kill(Tox *tox);
+/**
+ * The function type for the `friend_lossy_packet` callback.
+ *
+ * @param friend_number The friend number of the friend who sent a lossy packet.
+ * @param data A byte array containing the received packet data.
+ * @param length The length of the packet data byte array.
+ */
+typedef void tox_friend_lossy_packet_cb(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
+                                        void *user_data);
 
-/* Return the time in milliseconds before tox_do() should be called again
- * for optimal performance.
+/**
+ * Set the callback for the `friend_lossy_packet` event. Pass NULL to unset.
+ */
+void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *function, void *user_data);
+
+
+/**
+ * Send a custom lossless packet to a friend.
+ *
+ * The first byte of data must be in the range 160-191. Maximum length of a
+ * custom packet is TOX_MAX_CUSTOM_PACKET_SIZE.
+ *
+ * Lossless packet behaviour is comparable to TCP (reliability, arrive in order)
+ * but with packets instead of a stream.
+ *
+ * @param friend_number The friend number of the friend this lossless packet
+ *   should be sent to.
+ * @param data A byte array containing the packet data.
+ * @param length The length of the packet data byte array.
  *
- * returns time (in ms) before the next tox_do() needs to be run on success.
+ * @return true on success.
  */
-uint32_t tox_do_interval(Tox *tox);
+bool tox_send_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
+                              TOX_ERR_SEND_CUSTOM_PACKET *error);
 
-/* The main loop that needs to be run in intervals of tox_do_interval() ms. */
-void tox_do(Tox *tox);
+/**
+ * The function type for the `friend_lossless_packet` callback.
+ *
+ * @param friend_number The friend number of the friend who sent the packet.
+ * @param data A byte array containing the received packet data.
+ * @param length The length of the packet data byte array.
+ */
+typedef void tox_friend_lossless_packet_cb(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
+        void *user_data);
 
-/* SAVING AND LOADING FUNCTIONS: */
+/**
+ * Set the callback for the `friend_lossless_packet` event. Pass NULL to unset.
+ */
+void tox_callback_friend_lossless_packet(Tox *tox, tox_friend_lossless_packet_cb *function, void *user_data);
 
-/*  return size of messenger data (for saving). */
-uint32_t tox_size(const Tox *tox);
 
-/* Save the messenger in data (must be allocated memory of size Messenger_size()). */
-void tox_save(const Tox *tox, uint8_t *data);
 
-/* Load the messenger from data of size length.
+/*******************************************************************************
+ *
+ * :: Low-level network information
+ *
+ ******************************************************************************/
+
+
+/**
+ * Writes the temporary DHT public key of this instance to a byte array.
+ *
+ * This can be used in combination with an externally accessible IP address and
+ * the bound port (from tox_get_udp_port) to run a temporary bootstrap node.
  *
- *  returns 0 on success
- *  returns -1 on failure
+ * Be aware that every time a new instance is created, the DHT public key
+ * changes, meaning this cannot be used to run a permanent bootstrap node.
+ *
+ * @param dht_id A memory region of at least TOX_PUBLIC_KEY_SIZE bytes. If this
+ *   parameter is NULL, this function has no effect.
  */
-int tox_load(Tox *tox, const uint8_t *data, uint32_t length);
+void tox_get_dht_id(const Tox *tox, uint8_t *dht_id);
+
+
+enum TOX_ERR_GET_PORT {
+    TOX_ERR_GET_PORT_OK,
+    /**
+     * The instance was not bound to any port.
+     */
+    TOX_ERR_GET_PORT_NOT_BOUND
+};
+typedef uint8_t TOX_ERR_GET_PORT;
+
+/**
+ * Return the UDP port this Tox instance is bound to.
+ */
+uint16_t tox_get_udp_port(const Tox *tox, TOX_ERR_GET_PORT *error);
+
+/**
+ * Return the TCP port this Tox instance is bound to. This is only relevant if
+ * the instance is acting as a TCP relay.
+ */
+uint16_t tox_get_tcp_port(const Tox *tox, TOX_ERR_GET_PORT *error);
+
 
 #ifdef __cplusplus
 }
diff --git a/toxcore/util.c b/toxcore/util.c
index 969ee704..5a72c4a4 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -84,6 +84,35 @@ void host_to_net(uint8_t *num, uint16_t numbytes)
     return;
 }
 
+uint16_t lendian_to_host16(uint16_t lendian)
+{
+#ifdef WORDS_BIGENDIAN
+    return  (lendian << 8) | (lendian >> 8 );
+#else
+    return lendian;
+#endif
+}
+
+void host_to_lendian32(uint8_t *dest,  uint32_t num)
+{
+#ifdef WORDS_BIGENDIAN
+    num = ((num << 8) & 0xFF00FF00 ) | ((num >> 8) & 0xFF00FF );
+    num = (num << 16) | (num >> 16);
+#endif
+    memcpy(dest, &num, sizeof(uint32_t));
+}
+
+void lendian_to_host32(uint32_t *dest, const uint8_t *lendian)
+{
+    uint32_t d;
+    memcpy(&d, lendian, sizeof(uint32_t));
+#ifdef WORDS_BIGENDIAN
+    d = ((d << 8) & 0xFF00FF00 ) | ((d >> 8) & 0xFF00FF );
+    d = (d << 16) | (d >> 16);
+#endif
+    *dest = d;
+}
+
 /* state load/save */
 int load_state(load_state_callback_func load_state_callback, void *outer,
                const uint8_t *data, uint32_t length, uint16_t cookie_inner)
@@ -101,8 +130,8 @@ int load_state(load_state_callback_func load_state_callback, void *outer,
     uint32_t size_head = sizeof(uint32_t) * 2;
 
     while (length >= size_head) {
-        memcpy(&length_sub, data, sizeof(length_sub));
-        memcpy(&cookie_type, data + sizeof(length_sub), sizeof(cookie_type));
+        lendian_to_host32(&length_sub, data);
+        lendian_to_host32(&cookie_type, data + sizeof(length_sub));
         data += size_head;
         length -= size_head;
 
@@ -114,7 +143,7 @@ int load_state(load_state_callback_func load_state_callback, void *outer,
             return -1;
         }
 
-        if ((cookie_type >> 16) != cookie_inner) {
+        if (lendian_to_host16((cookie_type >> 16)) != cookie_inner) {
             /* something is not matching up in a bad way, give up */
 #ifdef DEBUG
             fprintf(stderr, "state file garbeled: %04hx != %04hx\n", (cookie_type >> 16), cookie_inner);
@@ -122,7 +151,7 @@ int load_state(load_state_callback_func load_state_callback, void *outer,
             return -1;
         }
 
-        type = cookie_type & 0xFFFF;
+        type = lendian_to_host16(cookie_type & 0xFFFF);
 
         if (-1 == load_state_callback(outer, data, length_sub, type))
             return -1;
@@ -134,60 +163,25 @@ int load_state(load_state_callback_func load_state_callback, void *outer,
     return length == 0 ? 0 : -1;
 };
 
-/* Converts 4 bytes to uint32_t */
-inline__ void bytes_to_U32(uint32_t *dest, const uint8_t *bytes)
+int create_recursive_mutex(pthread_mutex_t *mutex)
 {
-    *dest =
-#ifdef WORDS_BIGENDIAN
-        ( ( uint32_t ) *  bytes )              |
-        ( ( uint32_t ) * ( bytes + 1 ) << 8 )  |
-        ( ( uint32_t ) * ( bytes + 2 ) << 16 ) |
-        ( ( uint32_t ) * ( bytes + 3 ) << 24 ) ;
-#else
-        ( ( uint32_t ) *  bytes        << 24 ) |
-        ( ( uint32_t ) * ( bytes + 1 ) << 16 ) |
-        ( ( uint32_t ) * ( bytes + 2 ) << 8 )  |
-        ( ( uint32_t ) * ( bytes + 3 ) ) ;
-#endif
-}
+    pthread_mutexattr_t attr;
 
-/* Converts 2 bytes to uint16_t */
-inline__ void bytes_to_U16(uint16_t *dest, const uint8_t *bytes)
-{
-    *dest =
-#ifdef WORDS_BIGENDIAN
-        ( ( uint16_t ) *   bytes ) |
-        ( ( uint16_t ) * ( bytes + 1 ) << 8 );
-#else
-        ( ( uint16_t ) *   bytes << 8 ) |
-        ( ( uint16_t ) * ( bytes + 1 ) );
-#endif
-}
+    if (pthread_mutexattr_init(&attr) != 0)
+        return -1;
 
-/* Convert uint32_t to byte string of size 4 */
-inline__ void U32_to_bytes(uint8_t *dest, uint32_t value)
-{
-#ifdef WORDS_BIGENDIAN
-    *(dest)     = ( value );
-    *(dest + 1) = ( value >> 8 );
-    *(dest + 2) = ( value >> 16 );
-    *(dest + 3) = ( value >> 24 );
-#else
-    *(dest)     = ( value >> 24 );
-    *(dest + 1) = ( value >> 16 );
-    *(dest + 2) = ( value >> 8 );
-    *(dest + 3) = ( value );
-#endif
-}
+    if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) {
+        pthread_mutexattr_destroy(&attr);
+        return -1;
+    }
 
-/* Convert uint16_t to byte string of size 2 */
-inline__ void U16_to_bytes(uint8_t *dest, uint16_t value)
-{
-#ifdef WORDS_BIGENDIAN
-    *(dest)     = ( value );
-    *(dest + 1) = ( value >> 8 );
-#else
-    *(dest)     = ( value >> 8 );
-    *(dest + 1) = ( value );
-#endif
-}
\ No newline at end of file
+    /* Create queue mutex */
+    if (pthread_mutex_init(mutex, &attr) != 0) {
+        pthread_mutexattr_destroy(&attr);
+        return -1;
+    }
+
+    pthread_mutexattr_destroy(&attr);
+
+    return 0;
+}
diff --git a/toxcore/util.h b/toxcore/util.h
index 955ce8c4..7cd6bb8b 100644
--- a/toxcore/util.h
+++ b/toxcore/util.h
@@ -27,8 +27,9 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include <pthread.h>
 
-#define inline__ inline __attribute__((always_inline))
+#define MIN(a,b) (((a)<(b))?(a):(b))
 
 void unix_time_update();
 uint64_t unix_time();
@@ -42,22 +43,16 @@ uint32_t id_copy(uint8_t *dest, const uint8_t *src); /* return value is CLIENT_I
 void host_to_net(uint8_t *num, uint16_t numbytes);
 #define net_to_host(x, y) host_to_net(x, y)
 
+uint16_t lendian_to_host16(uint16_t lendian);
+#define host_tolendian16(x) lendian_to_host16(x)
+
+void host_to_lendian32(uint8_t *dest,  uint32_t num);
+
 /* state load/save */
 typedef int (*load_state_callback_func)(void *outer, const uint8_t *data, uint32_t len, uint16_t type);
 int load_state(load_state_callback_func load_state_callback, void *outer,
                const uint8_t *data, uint32_t length, uint16_t cookie_inner);
 
-/* Converts 4 bytes to uint32_t */
-void bytes_to_U32(uint32_t *dest, const uint8_t *bytes);
-
-/* Converts 2 bytes to uint16_t */
-void bytes_to_U16(uint16_t *dest, const uint8_t *bytes);
-
-/* Convert uint32_t to byte string of size 4 */
-void U32_to_bytes(uint8_t *dest, uint32_t value);
-
-/* Convert uint16_t to byte string of size 2 */
-void U16_to_bytes(uint8_t *dest, uint16_t value);
-
+int create_recursive_mutex(pthread_mutex_t *mutex);
 
 #endif /* __UTIL_H__ */
diff --git a/toxdns/toxdns.c b/toxdns/toxdns.c
index 7a7a052d..186ea82b 100644
--- a/toxdns/toxdns.c
+++ b/toxdns/toxdns.c
@@ -95,7 +95,7 @@ void tox_dns3_kill(void *dns3_object)
  * This is what the string returned looks like:
  * 4haaaaipr1o3mz0bxweox541airydbovqlbju51mb4p0ebxq.rlqdj4kkisbep2ks3fj2nvtmk4daduqiueabmexqva1jc
  *
- * returns length of string on sucess.
+ * returns length of string on success.
  * returns -1 on failure.
  */
 int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string_max_len, uint32_t *request_id,
diff --git a/toxdns/toxdns.h b/toxdns/toxdns.h
index a0cc323b..06071b82 100644
--- a/toxdns/toxdns.h
+++ b/toxdns/toxdns.h
@@ -24,8 +24,15 @@
 #ifndef TOXDNS_H
 #define TOXDNS_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdint.h>
 
+/* Clients are encouraged to set this as the maximum length names can have. */
+#define TOXDNS_MAX_RECOMMENDED_NAME_LENGTH 32
+
 /* How to use this api to make secure tox dns3 requests:
  *
  * 1. Get the public key of a server that supports tox dns3.
@@ -61,7 +68,7 @@ void tox_dns3_kill(void *dns3_object);
  * This is what the string returned looks like:
  * 4haaaaipr1o3mz0bxweox541airydbovqlbju51mb4p0ebxq.rlqdj4kkisbep2ks3fj2nvtmk4daduqiueabmexqva1jc
  *
- * returns length of string on sucess.
+ * returns length of string on success.
  * returns -1 on failure.
  */
 int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string_max_len, uint32_t *request_id,
@@ -82,4 +89,8 @@ int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string
 int tox_decrypt_dns3_TXT(void *dns3_object, uint8_t *tox_id, uint8_t *id_record, uint32_t id_record_len,
                          uint32_t request_id);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/toxencryptsave/Makefile.inc b/toxencryptsave/Makefile.inc
new file mode 100644
index 00000000..1155e954
--- /dev/null
+++ b/toxencryptsave/Makefile.inc
@@ -0,0 +1,45 @@
+lib_LTLIBRARIES += libtoxencryptsave.la
+
+libtoxencryptsave_la_include_HEADERS = \
+                        ../toxencryptsave/toxencryptsave.h
+
+libtoxencryptsave_la_includedir = $(includedir)/tox
+
+libtoxencryptsave_la_SOURCES = ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt-common.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/export.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/scrypt_platform.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sysendian.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/nosse/pwhash_scryptsalsa208sha256_nosse.c \
+                        ../toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sse/pwhash_scryptsalsa208sha256_sse.c \
+                        ../toxencryptsave/toxencryptsave.h \
+                        ../toxencryptsave/toxencryptsave.c
+                        
+
+libtoxencryptsave_la_CFLAGS =   -I$(top_srcdir) \
+                        -I$(top_srcdir)/toxcore \
+                        $(LIBSODIUM_CFLAGS) \
+                        $(NACL_CFLAGS) \
+                        $(PTHREAD_CFLAGS)
+
+libtoxencryptsave_la_LDFLAGS =  $(TOXCORE_LT_LDFLAGS) \
+                        $(EXTRA_LT_LDFLAGS) \
+                        $(LIBSODIUM_LDFLAGS) \
+                        $(NACL_LDFLAGS) \
+                        $(MATH_LDFLAGS) \
+                        $(RT_LIBS) \
+                        $(WINSOCK2_LIBS)
+
+libtoxencryptsave_la_LIBADD =   $(LIBSODIUM_LIBS) \
+                        $(NACL_OBJECTS) \
+                        $(NAC_LIBS) \
+                        $(PTHREAD_LIBS) \
+                        libtoxcore.la
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h
new file mode 100644
index 00000000..5cb32f8d
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h
@@ -0,0 +1,92 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef crypto_pwhash_scryptsalsa208sha256_H
+#define crypto_pwhash_scryptsalsa208sha256_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+# if __GNUC__
+#  pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+extern "C" {
+#endif
+
+#define crypto_pwhash_scryptsalsa208sha256_SALTBYTES 32U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_saltbytes(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_STRBYTES 102U
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_strbytes(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_STRPREFIX "$7$"
+SODIUM_EXPORT
+const char *crypto_pwhash_scryptsalsa208sha256_strprefix(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE 524288ULL
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE 16777216ULL
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE 33554432ULL
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(void);
+
+#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE 1073741824ULL
+SODIUM_EXPORT
+size_t crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void);
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
+                                       unsigned long long outlen,
+                                       const char * const passwd,
+                                       unsigned long long passwdlen,
+                                       const unsigned char * const salt,
+                                       unsigned long long opslimit,
+                                       size_t memlimit);
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                           const char * const passwd,
+                                           unsigned long long passwdlen,
+                                           unsigned long long opslimit,
+                                           size_t memlimit);
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                                  const char * const passwd,
+                                                  unsigned long long passwdlen);
+
+SODIUM_EXPORT
+int crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
+                                          const uint8_t * salt, size_t saltlen,
+                                          uint64_t N, uint32_t r, uint32_t p,
+                                          uint8_t * buf, size_t buflen);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Backward compatibility with version 0.5.0 */
+
+#define crypto_pwhash_scryptxsalsa208sha256_SALTBYTES crypto_pwhash_scryptsalsa208sha256_SALTBYTES
+#define crypto_pwhash_scryptxsalsa208sha256_saltbytes crypto_pwhash_scryptsalsa208sha256_saltbytes
+#define crypto_pwhash_scryptxsalsa208sha256_STRBYTES crypto_pwhash_scryptsalsa208sha256_STRBYTES
+#define crypto_pwhash_scryptxsalsa208sha256_strbytes crypto_pwhash_scryptsalsa208sha256_strbytes
+#define crypto_pwhash_scryptxsalsa208sha256 crypto_pwhash_scryptsalsa208sha256
+#define crypto_pwhash_scryptxsalsa208sha256_str crypto_pwhash_scryptsalsa208sha256_str
+#define crypto_pwhash_scryptxsalsa208sha256_str_verify crypto_pwhash_scryptsalsa208sha256_str_verify
+
+#endif
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt-common.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt-common.c
new file mode 100644
index 00000000..5a5c5525
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt-common.c
@@ -0,0 +1,257 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2013 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "crypto_pwhash_scryptsalsa208sha256.h"
+#include "crypto_scrypt.h"
+#include "runtime.h"
+#include "utils.h"
+
+static const char * const itoa64 =
+    "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static uint8_t *
+encode64_uint32(uint8_t * dst, size_t dstlen, uint32_t src, uint32_t srcbits)
+{
+    uint32_t bit;
+
+    for (bit = 0; bit < srcbits; bit += 6) {
+        if (dstlen < 1) {
+            return NULL;
+        }
+        *dst++ = itoa64[src & 0x3f];
+        dstlen--;
+        src >>= 6;
+    }
+
+    return dst;
+}
+
+static uint8_t *
+encode64(uint8_t * dst, size_t dstlen, const uint8_t * src, size_t srclen)
+{
+    size_t i;
+
+    for (i = 0; i < srclen; ) {
+        uint8_t * dnext;
+        uint32_t value = 0, bits = 0;
+        do {
+            value |= (uint32_t)src[i++] << bits;
+            bits += 8;
+        } while (bits < 24 && i < srclen);
+        dnext = encode64_uint32(dst, dstlen, value, bits);
+        if (!dnext) {
+            return NULL;
+        }
+        dstlen -= dnext - dst;
+        dst = dnext;
+    }
+
+    return dst;
+}
+
+static int
+decode64_one(uint32_t * dst, uint8_t src)
+{
+    const char *ptr = strchr(itoa64, src);
+
+    if (ptr) {
+        *dst = ptr - itoa64;
+        return 0;
+    }
+    *dst = 0;
+    return -1;
+}
+
+static const uint8_t *
+decode64_uint32(uint32_t * dst, uint32_t dstbits, const uint8_t * src)
+{
+    uint32_t bit;
+    uint32_t value;
+
+    value = 0;
+    for (bit = 0; bit < dstbits; bit += 6) {
+        uint32_t one;
+        if (decode64_one(&one, *src)) {
+            *dst = 0;
+            return NULL;
+        }
+        src++;
+        value |= one << bit;
+    }
+
+    *dst = value;
+    return src;
+}
+
+uint8_t *
+escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
+          const uint8_t * setting, uint8_t * buf, size_t buflen)
+{
+    uint8_t        hash[crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES];
+    escrypt_kdf_t  escrypt_kdf;
+    const uint8_t *src;
+    const uint8_t *salt;
+    uint8_t       *dst;
+    size_t         prefixlen;
+    size_t         saltlen;
+    size_t         need;
+    uint64_t       N;
+    uint32_t       N_log2;
+    uint32_t       r;
+    uint32_t       p;
+
+    if (setting[0] != '$' || setting[1] != '7' || setting[2] != '$') {
+        return NULL;
+    }
+    src = setting + 3;
+
+    if (decode64_one(&N_log2, *src)) {
+        return NULL;
+    }
+    src++;
+    N = (uint64_t)1 << N_log2;
+
+    src = decode64_uint32(&r, 30, src);
+    if (!src) {
+        return NULL;
+    }
+    src = decode64_uint32(&p, 30, src);
+    if (!src) {
+        return NULL;
+    }
+    prefixlen = src - setting;
+
+    salt = src;
+    src = (uint8_t *) strrchr((char *)salt, '$');
+    if (src) {
+        saltlen = src - salt;
+    } else {
+        saltlen = strlen((char *)salt);
+    }
+    need = prefixlen + saltlen + 1 +
+        crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1;
+    if (need > buflen || need < saltlen) {
+        return NULL;
+    }
+#if defined(HAVE_EMMINTRIN_H) || defined(_MSC_VER)
+    escrypt_kdf =
+        sodium_runtime_has_sse2() ? escrypt_kdf_sse : escrypt_kdf_nosse;
+#else
+    escrypt_kdf = escrypt_kdf_nosse;
+#endif
+    if (escrypt_kdf(local, passwd, passwdlen, salt, saltlen,
+                    N, r, p, hash, sizeof(hash))) {
+        return NULL;
+    }
+
+    dst = buf;
+    memcpy(dst, setting, prefixlen + saltlen);
+    dst += prefixlen + saltlen;
+    *dst++ = '$';
+
+    dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
+    sodium_memzero(hash, sizeof hash);
+    if (!dst || dst >= buf + buflen) { /* Can't happen */
+        return NULL;
+    }
+    *dst = 0; /* NUL termination */
+
+    return buf;
+}
+
+uint8_t *
+escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p,
+                  const uint8_t * src, size_t srclen,
+                  uint8_t * buf, size_t buflen)
+{
+    uint8_t *dst;
+    size_t   prefixlen =
+        (sizeof "$7$" - 1U) + (1U /* N_log2 */) + (5U /* r */) + (5U /* p */);
+    size_t   saltlen = BYTES2CHARS(srclen);
+    size_t   need;
+
+    need = prefixlen + saltlen + 1;
+    if (need > buflen || need < saltlen || saltlen < srclen) {
+        return NULL;
+    }
+    if (N_log2 > 63 || ((uint64_t)r * (uint64_t)p >= (1U << 30))) {
+        return NULL;
+    }
+    dst = buf;
+    *dst++ = '$';
+    *dst++ = '7';
+    *dst++ = '$';
+
+    *dst++ = itoa64[N_log2];
+
+    dst = encode64_uint32(dst, buflen - (dst - buf), r, 30);
+    if (!dst) { /* Can't happen */
+        return NULL;
+    }
+    dst = encode64_uint32(dst, buflen - (dst - buf), p, 30);
+    if (!dst) { /* Can't happen */
+        return NULL;
+    }
+    dst = encode64(dst, buflen - (dst - buf), src, srclen);
+    if (!dst || dst >= buf + buflen) { /* Can't happen */
+        return NULL;
+    }
+    *dst = 0; /* NUL termination */
+
+    return buf;
+}
+
+int
+crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
+                                      const uint8_t * salt, size_t saltlen,
+                                      uint64_t N, uint32_t r, uint32_t p,
+                                      uint8_t * buf, size_t buflen)
+{
+    escrypt_kdf_t   escrypt_kdf;
+    escrypt_local_t local;
+    int             retval;
+
+    if (escrypt_init_local(&local)) {
+        return -1;
+    }
+#if defined(HAVE_EMMINTRIN_H) || defined(_MSC_VER)
+    escrypt_kdf =
+        sodium_runtime_has_sse2() ? escrypt_kdf_sse : escrypt_kdf_nosse;
+#else
+    escrypt_kdf = escrypt_kdf_nosse;
+#endif
+    retval = escrypt_kdf(&local,
+                         passwd, passwdlen, salt, saltlen,
+                         N, r, p, buf, buflen);
+    if (escrypt_free_local(&local)) {
+        return -1;
+    }
+    return retval;
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt.h
new file mode 100644
index 00000000..3f0b7d72
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/crypto_scrypt.h
@@ -0,0 +1,93 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2009 Colin Percival
+ * Copyright 2013 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+#ifndef _CRYPTO_SCRYPT_H_
+#define _CRYPTO_SCRYPT_H_
+
+#include <stdint.h>
+
+#define crypto_pwhash_scryptsalsa208sha256_STRPREFIXBYTES 14
+#define crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES 57
+#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES 32
+#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES_ENCODED 43
+#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES 32
+#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED 43
+
+#define BYTES2CHARS(bytes) ((((bytes) * 8) + 5) / 6)
+
+typedef struct {
+        void * base, * aligned;
+        size_t size;
+} escrypt_region_t;
+
+typedef escrypt_region_t escrypt_local_t;
+
+extern int escrypt_init_local(escrypt_local_t * __local);
+
+extern int escrypt_free_local(escrypt_local_t * __local);
+
+extern void *alloc_region(escrypt_region_t * region, size_t size);
+extern int free_region(escrypt_region_t * region);
+
+typedef int (*escrypt_kdf_t)(escrypt_local_t * __local,
+                             const uint8_t * __passwd, size_t __passwdlen,
+                             const uint8_t * __salt, size_t __saltlen,
+                             uint64_t __N, uint32_t __r, uint32_t __p,
+                             uint8_t * __buf, size_t __buflen);
+
+extern int escrypt_kdf_nosse(escrypt_local_t * __local,
+    const uint8_t * __passwd, size_t __passwdlen,
+    const uint8_t * __salt, size_t __saltlen,
+    uint64_t __N, uint32_t __r, uint32_t __p,
+    uint8_t * __buf, size_t __buflen);
+
+extern int escrypt_kdf_sse(escrypt_local_t * __local,
+    const uint8_t * __passwd, size_t __passwdlen,
+    const uint8_t * __salt, size_t __saltlen,
+    uint64_t __N, uint32_t __r, uint32_t __p,
+    uint8_t * __buf, size_t __buflen);
+
+extern uint8_t * escrypt_r(escrypt_local_t * __local,
+    const uint8_t * __passwd, size_t __passwdlen,
+    const uint8_t * __setting,
+    uint8_t * __buf, size_t __buflen);
+
+extern uint8_t * escrypt_gensalt_r(
+    uint32_t __N_log2, uint32_t __r, uint32_t __p,
+    const uint8_t * __src, size_t __srclen,
+    uint8_t * __buf, size_t __buflen);
+
+#endif /* !_CRYPTO_SCRYPT_H_ */
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/export.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/export.h
new file mode 100644
index 00000000..ee5b30f7
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/export.h
@@ -0,0 +1,38 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef __SODIUM_EXPORT_H__
+#define __SODIUM_EXPORT_H__
+
+#ifndef __GNUC__
+# ifdef __attribute__
+#  undef __attribute__
+# endif
+# define __attribute__(a)
+#endif
+
+#ifdef SODIUM_STATIC
+# define SODIUM_EXPORT
+#else
+# if defined(_MSC_VER)
+#  ifdef DLL_EXPORT
+#   define SODIUM_EXPORT __declspec(dllexport)
+#  else
+#   define SODIUM_EXPORT __declspec(dllimport)
+#  endif
+# else
+#  if defined(__SUNPRO_C)
+#   define SODIUM_EXPORT __attribute__ __global
+#  elif defined(_MSG_VER)
+#   define SODIUM_EXPORT extern __declspec(dllexport)
+#  else
+#   define SODIUM_EXPORT __attribute__ ((visibility ("default")))
+#  endif
+# endif
+#endif
+
+#endif
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/nosse/pwhash_scryptsalsa208sha256_nosse.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/nosse/pwhash_scryptsalsa208sha256_nosse.c
new file mode 100644
index 00000000..97d9ba68
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/nosse/pwhash_scryptsalsa208sha256_nosse.c
@@ -0,0 +1,309 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2009 Colin Percival
+ * Copyright 2013 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../pbkdf2-sha256.h"
+#include "../sysendian.h"
+#include "../crypto_scrypt.h"
+
+static inline void
+blkcpy(void * dest, const void * src, size_t len)
+{
+        size_t * D = (size_t *) dest;
+        const size_t * S = (const size_t *) src;
+        size_t L = len / sizeof(size_t);
+        size_t i;
+
+        for (i = 0; i < L; i++)
+                D[i] = S[i];
+}
+
+static inline void
+blkxor(void * dest, const void * src, size_t len)
+{
+        size_t * D = (size_t *) dest;
+        const size_t * S = (const size_t *) src;
+        size_t L = len / sizeof(size_t);
+        size_t i;
+
+        for (i = 0; i < L; i++)
+                D[i] ^= S[i];
+}
+
+/**
+ * salsa20_8(B):
+ * Apply the salsa20/8 core to the provided block.
+ */
+static void
+salsa20_8(uint32_t B[16])
+{
+        uint32_t x[16];
+        size_t i;
+
+        blkcpy(x, B, 64);
+        for (i = 0; i < 8; i += 2) {
+#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
+                /* Operate on columns. */
+                x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
+                x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);
+
+                x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);
+                x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);
+
+                x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);
+                x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);
+
+                x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);
+                x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);
+
+                /* Operate on rows. */
+                x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
+                x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
+
+                x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
+                x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
+
+                x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);
+                x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);
+
+                x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);
+                x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);
+#undef R
+        }
+        for (i = 0; i < 16; i++)
+                B[i] += x[i];
+}
+
+/**
+ * blockmix_salsa8(Bin, Bout, X, r):
+ * Compute Bout = BlockMix_{salsa20/8, r}(Bin).  The input Bin must be 128r
+ * bytes in length; the output Bout must also be the same size.  The
+ * temporary space X must be 64 bytes.
+ */
+static void
+blockmix_salsa8(const uint32_t * Bin, uint32_t * Bout, uint32_t * X, size_t r)
+{
+        size_t i;
+
+        /* 1: X <-- B_{2r - 1} */
+        blkcpy(X, &Bin[(2 * r - 1) * 16], 64);
+
+        /* 2: for i = 0 to 2r - 1 do */
+        for (i = 0; i < 2 * r; i += 2) {
+                /* 3: X <-- H(X \xor B_i) */
+                blkxor(X, &Bin[i * 16], 64);
+                salsa20_8(X);
+
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                blkcpy(&Bout[i * 8], X, 64);
+
+                /* 3: X <-- H(X \xor B_i) */
+                blkxor(X, &Bin[i * 16 + 16], 64);
+                salsa20_8(X);
+
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                blkcpy(&Bout[i * 8 + r * 16], X, 64);
+        }
+}
+
+/**
+ * integerify(B, r):
+ * Return the result of parsing B_{2r-1} as a little-endian integer.
+ */
+static inline uint64_t
+integerify(const void * B, size_t r)
+{
+        const uint32_t * X = (const uint32_t *)((uintptr_t)(B) + (2 * r - 1) * 64);
+
+        return (((uint64_t)(X[1]) << 32) + X[0]);
+}
+
+/**
+ * smix(B, r, N, V, XY):
+ * Compute B = SMix_r(B, N).  The input B must be 128r bytes in length;
+ * the temporary storage V must be 128rN bytes in length; the temporary
+ * storage XY must be 256r + 64 bytes in length.  The value N must be a
+ * power of 2 greater than 1.  The arrays B, V, and XY must be aligned to a
+ * multiple of 64 bytes.
+ */
+static void
+smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)
+{
+        uint32_t * X = XY;
+        uint32_t * Y = &XY[32 * r];
+        uint32_t * Z = &XY[64 * r];
+        uint64_t i;
+        uint64_t j;
+        size_t k;
+
+        /* 1: X <-- B */
+        for (k = 0; k < 32 * r; k++)
+                X[k] = le32dec(&B[4 * k]);
+
+        /* 2: for i = 0 to N - 1 do */
+        for (i = 0; i < N; i += 2) {
+                /* 3: V_i <-- X */
+                blkcpy(&V[i * (32 * r)], X, 128 * r);
+
+                /* 4: X <-- H(X) */
+                blockmix_salsa8(X, Y, Z, r);
+
+                /* 3: V_i <-- X */
+                blkcpy(&V[(i + 1) * (32 * r)], Y, 128 * r);
+
+                /* 4: X <-- H(X) */
+                blockmix_salsa8(Y, X, Z, r);
+        }
+
+        /* 6: for i = 0 to N - 1 do */
+        for (i = 0; i < N; i += 2) {
+                /* 7: j <-- Integerify(X) mod N */
+                j = integerify(X, r) & (N - 1);
+
+                /* 8: X <-- H(X \xor V_j) */
+                blkxor(X, &V[j * (32 * r)], 128 * r);
+                blockmix_salsa8(X, Y, Z, r);
+
+                /* 7: j <-- Integerify(X) mod N */
+                j = integerify(Y, r) & (N - 1);
+
+                /* 8: X <-- H(X \xor V_j) */
+                blkxor(Y, &V[j * (32 * r)], 128 * r);
+                blockmix_salsa8(Y, X, Z, r);
+        }
+        /* 10: B' <-- X */
+        for (k = 0; k < 32 * r; k++)
+                le32enc(&B[4 * k], X[k]);
+}
+
+/**
+ * escrypt_kdf(local, passwd, passwdlen, salt, saltlen,
+ *     N, r, p, buf, buflen):
+ * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
+ * p, buflen) and write the result into buf.  The parameters r, p, and buflen
+ * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
+ * must be a power of 2 greater than 1.
+ *
+ * Return 0 on success; or -1 on error.
+ */
+int
+escrypt_kdf_nosse(escrypt_local_t * local,
+    const uint8_t * passwd, size_t passwdlen,
+    const uint8_t * salt, size_t saltlen,
+    uint64_t N, uint32_t _r, uint32_t _p,
+    uint8_t * buf, size_t buflen)
+{
+        size_t B_size, V_size, XY_size, need;
+        uint8_t * B;
+        uint32_t * V, * XY;
+    size_t r = _r, p = _p;
+        uint32_t i;
+
+        /* Sanity-check parameters. */
+#if SIZE_MAX > UINT32_MAX
+        if (buflen > (((uint64_t)(1) << 32) - 1) * 32) {
+                errno = EFBIG;
+                return -1;
+        }
+#endif
+        if ((uint64_t)(r) * (uint64_t)(p) >= (1 << 30)) {
+                errno = EFBIG;
+                return -1;
+        }
+        if (((N & (N - 1)) != 0) || (N < 2)) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (r == 0 || p == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+        if ((r > SIZE_MAX / 128 / p) ||
+#if SIZE_MAX / 256 <= UINT32_MAX
+            (r > SIZE_MAX / 256) ||
+#endif
+            (N > SIZE_MAX / 128 / r)) {
+                errno = ENOMEM;
+                return -1;
+        }
+
+        /* Allocate memory. */
+        B_size = (size_t)128 * r * p;
+        V_size = (size_t)128 * r * N;
+        need = B_size + V_size;
+        if (need < V_size) {
+                errno = ENOMEM;
+                return -1;
+        }
+        XY_size = (size_t)256 * r + 64;
+        need += XY_size;
+        if (need < XY_size) {
+                errno = ENOMEM;
+                return -1;
+        }
+        if (local->size < need) {
+                if (free_region(local))
+                        return -1;
+                if (!alloc_region(local, need))
+                        return -1;
+        }
+        B = (uint8_t *)local->aligned;
+        V = (uint32_t *)((uint8_t *)B + B_size);
+        XY = (uint32_t *)((uint8_t *)V + V_size);
+
+        /* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
+        PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, B_size);
+
+        /* 2: for i = 0 to p - 1 do */
+        for (i = 0; i < p; i++) {
+                /* 3: B_i <-- MF(B_i, N) */
+                smix(&B[(size_t)128 * i * r], r, N, V, XY);
+        }
+
+        /* 5: DK <-- PBKDF2(P, B, 1, dkLen) */
+        PBKDF2_SHA256(passwd, passwdlen, B, B_size, 1, buf, buflen);
+
+        /* Success! */
+        return 0;
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/note_to_maintainers.txt b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/note_to_maintainers.txt
new file mode 100644
index 00000000..66bbfe2d
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/note_to_maintainers.txt
@@ -0,0 +1,14 @@
+This folder is only meant for use with nacl, i.e. when sodium is unavailable.
+
+
+The files in this folder were mostly copied from
+https://github.com/jedisct1/libsodium/tree/0.7.0/src/libsodium/crypto_pwhash/scryptsalsa208sha256,
+with #ifdef VANILLA_NACL added around each of them as required for this module.
+
+export.h, utils.h, and runtime.h were copied from
+https://github.com/jedisct1/libsodium/tree/0.7.0/src/libsodium/include/sodium.
+utils.h was significantly truncated.
+
+utils.c and runtime.c were copied from 
+https://github.com/jedisct1/libsodium/blob/0.7.0/src/libsodium/sodium.
+utils.c was also significantly truncated.
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.c
new file mode 100644
index 00000000..3dfe54db
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.c
@@ -0,0 +1,97 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2005,2007,2009 Colin Percival
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <crypto_hash_sha256.h>
+#include <crypto_auth_hmacsha256.h>
+
+#include "pbkdf2-sha256.h"
+#include "sysendian.h"
+#include "utils.h"
+
+/**
+ * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
+ * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
+ * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
+ */
+void
+PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
+              size_t saltlen, uint64_t c, uint8_t * buf, size_t dkLen)
+{
+        uint8_t         key[32] = {0};
+        size_t          i;
+        uint8_t         salt_and_ivec[saltlen + 4];
+        uint8_t         U[32];
+        uint8_t         T[32];
+        uint64_t        j;
+        int             k;
+        size_t          clen;
+
+    if (passwdlen > 32) {
+        /* For some reason libsodium allows 64byte keys meaning keys 
+         * between 32byte and 64bytes are not compatible with libsodium. 
+           toxencryptsave should only give 32byte passwds so this isn't an issue here.*/
+        crypto_hash_sha256(key, passwd, passwdlen);
+    } else {
+        memcpy(key, passwd, passwdlen);
+    }
+
+    memcpy(salt_and_ivec, salt, saltlen);
+
+        for (i = 0; i * 32 < dkLen; i++) {
+                be32enc(salt_and_ivec + saltlen, (uint32_t)(i + 1));
+                crypto_auth_hmacsha256(U, salt_and_ivec, sizeof(salt_and_ivec), key);
+
+                memcpy(T, U, 32);
+
+                for (j = 2; j <= c; j++) {
+                        crypto_auth_hmacsha256(U, U, 32, key);
+
+                        for (k = 0; k < 32; k++) {
+                                T[k] ^= U[k];
+            }
+                }
+
+                clen = dkLen - i * 32;
+                if (clen > 32) {
+                        clen = 32;
+        }
+                memcpy(&buf[i * 32], T, clen);
+        }
+    sodium_memzero((void *) key, sizeof(key));
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.h
new file mode 100644
index 00000000..b74bc6a3
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pbkdf2-sha256.h
@@ -0,0 +1,52 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2005,2007,2009 Colin Percival
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+#ifndef _SHA256_H_
+#define _SHA256_H_
+
+#include <sys/types.h>
+
+#include <stdint.h>
+
+#include "crypto_auth_hmacsha256.h"
+
+/**
+ * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
+ * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
+ * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
+ */
+void PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t,
+                   uint64_t, uint8_t *, size_t);
+
+#endif /* !_SHA256_H_ */
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c
new file mode 100644
index 00000000..52c51abc
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c
@@ -0,0 +1,211 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+//#include <stdio.h>
+
+#include "crypto_pwhash_scryptsalsa208sha256.h"
+#include "crypto_scrypt.h"
+#include "randombytes.h"
+#include "utils.h"
+
+#define SETTING_SIZE(saltbytes) \
+    (sizeof "$7$" - 1U) + \
+    (1U /* N_log2 */) + (5U /* r */) + (5U /* p */) + BYTES2CHARS(saltbytes)
+
+static int
+pickparams(unsigned long long opslimit, const size_t memlimit,
+           uint32_t * const N_log2, uint32_t * const p, uint32_t * const r)
+{
+    unsigned long long maxN;
+    unsigned long long maxrp;
+
+    if (opslimit < 32768) {
+        opslimit = 32768;
+    }
+    *r = 8;
+    if (opslimit < memlimit / 32) {
+        *p = 1;
+        maxN = opslimit / (*r * 4);
+        for (*N_log2 = 1; *N_log2 < 63; *N_log2 += 1) {
+            if ((uint64_t)(1) << *N_log2 > maxN / 2) {
+                break;
+            }
+        }
+    } else {
+        maxN = memlimit / (*r * 128);
+        for (*N_log2 = 1; *N_log2 < 63; *N_log2 += 1) {
+            if ((uint64_t) (1) << *N_log2 > maxN / 2) {
+                break;
+            }
+        }
+        maxrp = (opslimit / 4) / ((uint64_t) (1) << *N_log2);
+        if (maxrp > 0x3fffffff) {
+            maxrp = 0x3fffffff;
+        }
+        *p = (uint32_t) (maxrp) / *r;
+    }
+    return 0;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_saltbytes(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_SALTBYTES;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_strbytes(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_STRBYTES;
+}
+
+const char *
+crypto_pwhash_scryptsalsa208sha256_strprefix(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_STRPREFIX;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE;
+}
+
+int
+crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
+                                    unsigned long long outlen,
+                                    const char * const passwd,
+                                    unsigned long long passwdlen,
+                                    const unsigned char * const salt,
+                                    unsigned long long opslimit,
+                                    size_t memlimit)
+{
+    //fprintf(stderr, "Doing that dirty thang!!!!\n");
+    uint32_t N_log2;
+    uint32_t p;
+    uint32_t r;
+
+    memset(out, 0, outlen);
+    if (passwdlen > SIZE_MAX || outlen > SIZE_MAX) {
+        errno = EFBIG;
+        return -1;
+    }
+    if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    return crypto_pwhash_scryptsalsa208sha256_ll((const uint8_t *) passwd,
+                                                 (size_t) passwdlen,
+                                                 (const uint8_t *) salt,
+                                                 crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
+                                                 (uint64_t) (1) << N_log2, r, p,
+                                                 out, (size_t) outlen);
+}
+
+int
+crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                        const char * const passwd,
+                                        unsigned long long passwdlen,
+                                        unsigned long long opslimit,
+                                        size_t memlimit)
+{
+    uint8_t         salt[crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES];
+    char            setting[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U];
+    escrypt_local_t escrypt_local;
+    uint32_t        N_log2;
+    uint32_t        p;
+    uint32_t        r;
+
+    memset(out, 0, crypto_pwhash_scryptsalsa208sha256_STRBYTES);
+    if (passwdlen > SIZE_MAX) {
+        errno = EFBIG;
+        return -1;
+    }
+    if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    randombytes(salt, sizeof salt);
+    if (escrypt_gensalt_r(N_log2, r, p, salt, sizeof salt,
+                          (uint8_t *) setting, sizeof setting) == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+    if (escrypt_init_local(&escrypt_local) != 0) {
+        return -1;
+    }
+    if (escrypt_r(&escrypt_local, (const uint8_t *) passwd, (size_t) passwdlen,
+                  (const uint8_t *) setting, (uint8_t *) out,
+                  crypto_pwhash_scryptsalsa208sha256_STRBYTES) == NULL) {
+        escrypt_free_local(&escrypt_local);
+        errno = EINVAL;
+        return -1;
+    }
+    escrypt_free_local(&escrypt_local);
+
+    (void) sizeof
+        (int[SETTING_SIZE(crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES)
+            == crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES ? 1 : -1]);
+    (void) sizeof
+        (int[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U +
+             crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1U
+             == crypto_pwhash_scryptsalsa208sha256_STRBYTES ? 1 : -1]);
+
+    return 0;
+}
+
+int
+crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+                                               const char * const passwd,
+                                               unsigned long long passwdlen)
+{
+    char            wanted[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
+    escrypt_local_t escrypt_local;
+    int             ret = -1;
+
+    if (memchr(str, 0, crypto_pwhash_scryptsalsa208sha256_STRBYTES) !=
+        &str[crypto_pwhash_scryptsalsa208sha256_STRBYTES - 1U]) {
+        return -1;
+    }
+    if (escrypt_init_local(&escrypt_local) != 0) {
+        return -1;
+    }
+    if (escrypt_r(&escrypt_local, (const uint8_t *) passwd, (size_t) passwdlen,
+                  (const uint8_t *) str, (uint8_t *) wanted,
+                  sizeof wanted) == NULL) {
+        escrypt_free_local(&escrypt_local);
+        return -1;
+    }
+    escrypt_free_local(&escrypt_local);
+    ret = sodium_memcmp(wanted, str, sizeof wanted);
+    sodium_memzero(wanted, sizeof wanted);
+
+    return ret;
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.c
new file mode 100644
index 00000000..9b5c5131
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.c
@@ -0,0 +1,140 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifdef HAVE_ANDROID_GETCPUFEATURES
+# include <cpu-features.h>
+#endif
+
+#include "runtime.h"
+
+typedef struct CPUFeatures_ {
+    int initialized;
+    int has_neon;
+    int has_sse2;
+    int has_sse3;
+} CPUFeatures;
+
+static CPUFeatures _cpu_features;
+
+#define CPUID_SSE2     0x04000000
+#define CPUIDECX_SSE3  0x00000001
+
+static int
+_sodium_runtime_arm_cpu_features(CPUFeatures * const cpu_features)
+{
+#ifndef __arm__
+    cpu_features->has_neon = 0;
+    return -1;
+#else
+# ifdef __APPLE__
+#  ifdef __ARM_NEON__
+    cpu_features->has_neon = 1;
+#  else
+    cpu_features->has_neon = 0;
+#  endif
+# elif defined(HAVE_ANDROID_GETCPUFEATURES) && defined(ANDROID_CPU_ARM_FEATURE_NEON)
+    cpu_features->has_neon =
+        (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0x0;
+# else
+    cpu_features->has_neon = 0;
+# endif
+    return 0;
+#endif
+}
+
+static void
+_cpuid(unsigned int cpu_info[4U], const unsigned int cpu_info_type)
+{
+#ifdef _MSC_VER
+    __cpuidex((int *) cpu_info, cpu_info_type, 0);
+#elif defined(HAVE_CPUID)
+    cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+# ifdef __i386__
+    __asm__ __volatile__ ("pushfl; pushfl; "
+                          "popl %0; "
+                          "movl %0, %1; xorl %2, %0; "
+                          "pushl %0; "
+                          "popfl; pushfl; popl %0; popfl" :
+                          "=&r" (cpu_info[0]), "=&r" (cpu_info[1]) :
+                          "i" (0x200000));
+    if (((cpu_info[0] ^ cpu_info[1]) & 0x200000) == 0x0) {
+        return;
+    }
+# endif
+# ifdef __i386__
+    __asm__ __volatile__ ("xchgl %%ebx, %k1; cpuid; xchgl %%ebx, %k1" :
+                          "=a" (cpu_info[0]), "=&r" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# elif defined(__x86_64__)
+    __asm__ __volatile__ ("xchgq %%rbx, %q1; cpuid; xchgq %%rbx, %q1" :
+                          "=a" (cpu_info[0]), "=&r" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# else
+    __asm__ __volatile__ ("cpuid" :
+                          "=a" (cpu_info[0]), "=b" (cpu_info[1]),
+                          "=c" (cpu_info[2]), "=d" (cpu_info[3]) :
+                          "0" (cpu_info_type), "2" (0U));
+# endif
+#else
+    cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+#endif
+}
+
+static int
+_sodium_runtime_intel_cpu_features(CPUFeatures * const cpu_features)
+{
+    unsigned int cpu_info[4];
+    unsigned int id;
+
+    _cpuid(cpu_info, 0x0);
+    if ((id = cpu_info[0]) == 0U) {
+        return -1;
+    }
+    _cpuid(cpu_info, 0x00000001);
+#ifndef HAVE_EMMINTRIN_H
+    cpu_features->has_sse2 = 0;
+#else
+    cpu_features->has_sse2 = ((cpu_info[3] & CPUID_SSE2) != 0x0);
+#endif
+
+#ifndef HAVE_PMMINTRIN_H
+    cpu_features->has_sse3 = 0;
+#else
+    cpu_features->has_sse3 = ((cpu_info[2] & CPUIDECX_SSE3) != 0x0);
+#endif
+
+    return 0;
+}
+
+int
+sodium_runtime_get_cpu_features(void)
+{
+    int ret = -1;
+
+    ret &= _sodium_runtime_arm_cpu_features(&_cpu_features);
+    ret &= _sodium_runtime_intel_cpu_features(&_cpu_features);
+    _cpu_features.initialized = 1;
+
+    return ret;
+}
+
+int
+sodium_runtime_has_neon(void) {
+    return _cpu_features.has_neon;
+}
+
+int
+sodium_runtime_has_sse2(void) {
+    return _cpu_features.has_sse2;
+}
+
+int
+sodium_runtime_has_sse3(void) {
+    return _cpu_features.has_sse3;
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.h
new file mode 100644
index 00000000..874915ef
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/runtime.h
@@ -0,0 +1,33 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef __SODIUM_RUNTIME_H__
+#define __SODIUM_RUNTIME_H__ 1
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SODIUM_EXPORT
+int sodium_runtime_get_cpu_features(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_neon(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_sse2(void);
+
+SODIUM_EXPORT
+int sodium_runtime_has_sse3(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/scrypt_platform.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/scrypt_platform.c
new file mode 100644
index 00000000..58196514
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/scrypt_platform.c
@@ -0,0 +1,107 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2013 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+#include <errno.h>
+#include <stdlib.h>
+
+#include "crypto_scrypt.h"
+#include "runtime.h"
+
+#if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)
+# define MAP_ANON MAP_ANONYMOUS
+#endif
+
+void *
+alloc_region(escrypt_region_t * region, size_t size)
+{
+        uint8_t * base, * aligned;
+#ifdef MAP_ANON
+        if ((base = (uint8_t *) mmap(NULL, size, PROT_READ | PROT_WRITE,
+#ifdef MAP_NOCORE
+            MAP_ANON | MAP_PRIVATE | MAP_NOCORE,
+#else
+            MAP_ANON | MAP_PRIVATE,
+#endif
+            -1, 0)) == MAP_FAILED)
+                base = NULL;
+        aligned = base;
+#elif defined(HAVE_POSIX_MEMALIGN)
+        if ((errno = posix_memalign((void **) &base, 64, size)) != 0)
+                base = NULL;
+        aligned = base;
+#else
+        base = aligned = NULL;
+        if (size + 63 < size)
+                errno = ENOMEM;
+        else if ((base = (uint8_t *) malloc(size + 63)) != NULL) {
+                aligned = base + 63;
+                aligned -= (uintptr_t)aligned & 63;
+        }
+#endif
+        region->base = base;
+        region->aligned = aligned;
+        region->size = base ? size : 0;
+        return aligned;
+}
+
+static inline void
+init_region(escrypt_region_t * region)
+{
+        region->base = region->aligned = NULL;
+        region->size = 0;
+}
+
+int
+free_region(escrypt_region_t * region)
+{
+        if (region->base) {
+#ifdef MAP_ANON
+                if (munmap(region->base, region->size))
+                        return -1;
+#else
+                free(region->base);
+#endif
+        }
+        init_region(region);
+        return 0;
+}
+
+int
+escrypt_init_local(escrypt_local_t * local)
+{
+        init_region(local);
+        return 0;
+}
+
+int
+escrypt_free_local(escrypt_local_t * local)
+{
+        return free_region(local);
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sse/pwhash_scryptsalsa208sha256_sse.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sse/pwhash_scryptsalsa208sha256_sse.c
new file mode 100644
index 00000000..856a655e
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sse/pwhash_scryptsalsa208sha256_sse.c
@@ -0,0 +1,398 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+/*-
+ * Copyright 2009 Colin Percival
+ * Copyright 2012,2013 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+
+#if defined(HAVE_EMMINTRIN_H) || defined(_MSC_VER)
+#if __GNUC__
+# pragma GCC target("sse2")
+#endif
+#include <emmintrin.h>
+#if defined(__XOP__) && defined(DISABLED)
+# include <x86intrin.h>
+#endif
+
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../pbkdf2-sha256.h"
+#include "../sysendian.h"
+#include "../crypto_scrypt.h"
+
+#if defined(__XOP__) && defined(DISABLED)
+#define ARX(out, in1, in2, s) \
+        out = _mm_xor_si128(out, _mm_roti_epi32(_mm_add_epi32(in1, in2), s));
+#else
+#define ARX(out, in1, in2, s) \
+        { \
+                __m128i T = _mm_add_epi32(in1, in2); \
+                out = _mm_xor_si128(out, _mm_slli_epi32(T, s)); \
+                out = _mm_xor_si128(out, _mm_srli_epi32(T, 32-s)); \
+        }
+#endif
+
+#define SALSA20_2ROUNDS \
+        /* Operate on "columns". */ \
+        ARX(X1, X0, X3, 7) \
+        ARX(X2, X1, X0, 9) \
+        ARX(X3, X2, X1, 13) \
+        ARX(X0, X3, X2, 18) \
+\
+        /* Rearrange data. */ \
+        X1 = _mm_shuffle_epi32(X1, 0x93); \
+        X2 = _mm_shuffle_epi32(X2, 0x4E); \
+        X3 = _mm_shuffle_epi32(X3, 0x39); \
+\
+        /* Operate on "rows". */ \
+        ARX(X3, X0, X1, 7) \
+        ARX(X2, X3, X0, 9) \
+        ARX(X1, X2, X3, 13) \
+        ARX(X0, X1, X2, 18) \
+\
+        /* Rearrange data. */ \
+        X1 = _mm_shuffle_epi32(X1, 0x39); \
+        X2 = _mm_shuffle_epi32(X2, 0x4E); \
+        X3 = _mm_shuffle_epi32(X3, 0x93);
+
+/**
+ * Apply the salsa20/8 core to the block provided in (X0 ... X3) ^ (Z0 ... Z3).
+ */
+#define SALSA20_8_XOR(in, out) \
+        { \
+                __m128i Y0 = X0 = _mm_xor_si128(X0, (in)[0]); \
+                __m128i Y1 = X1 = _mm_xor_si128(X1, (in)[1]); \
+                __m128i Y2 = X2 = _mm_xor_si128(X2, (in)[2]); \
+                __m128i Y3 = X3 = _mm_xor_si128(X3, (in)[3]); \
+                SALSA20_2ROUNDS \
+                SALSA20_2ROUNDS \
+                SALSA20_2ROUNDS \
+                SALSA20_2ROUNDS \
+                (out)[0] = X0 = _mm_add_epi32(X0, Y0); \
+                (out)[1] = X1 = _mm_add_epi32(X1, Y1); \
+                (out)[2] = X2 = _mm_add_epi32(X2, Y2); \
+                (out)[3] = X3 = _mm_add_epi32(X3, Y3); \
+        }
+
+/**
+ * blockmix_salsa8(Bin, Bout, r):
+ * Compute Bout = BlockMix_{salsa20/8, r}(Bin).  The input Bin must be 128r
+ * bytes in length; the output Bout must also be the same size.
+ */
+static inline void
+blockmix_salsa8(const __m128i * Bin, __m128i * Bout, size_t r)
+{
+        __m128i X0, X1, X2, X3;
+        size_t i;
+
+        /* 1: X <-- B_{2r - 1} */
+        X0 = Bin[8 * r - 4];
+        X1 = Bin[8 * r - 3];
+        X2 = Bin[8 * r - 2];
+        X3 = Bin[8 * r - 1];
+
+        /* 3: X <-- H(X \xor B_i) */
+        /* 4: Y_i <-- X */
+        /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+        SALSA20_8_XOR(Bin, Bout)
+
+        /* 2: for i = 0 to 2r - 1 do */
+        r--;
+        for (i = 0; i < r;) {
+                /* 3: X <-- H(X \xor B_i) */
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                SALSA20_8_XOR(&Bin[i * 8 + 4], &Bout[(r + i) * 4 + 4])
+
+                i++;
+
+                /* 3: X <-- H(X \xor B_i) */
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                SALSA20_8_XOR(&Bin[i * 8], &Bout[i * 4])
+        }
+
+        /* 3: X <-- H(X \xor B_i) */
+        /* 4: Y_i <-- X */
+        /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+        SALSA20_8_XOR(&Bin[i * 8 + 4], &Bout[(r + i) * 4 + 4])
+}
+
+#define XOR4(in) \
+        X0 = _mm_xor_si128(X0, (in)[0]); \
+        X1 = _mm_xor_si128(X1, (in)[1]); \
+        X2 = _mm_xor_si128(X2, (in)[2]); \
+        X3 = _mm_xor_si128(X3, (in)[3]);
+
+#define XOR4_2(in1, in2) \
+        X0 = _mm_xor_si128((in1)[0], (in2)[0]); \
+        X1 = _mm_xor_si128((in1)[1], (in2)[1]); \
+        X2 = _mm_xor_si128((in1)[2], (in2)[2]); \
+        X3 = _mm_xor_si128((in1)[3], (in2)[3]);
+
+static inline uint32_t
+blockmix_salsa8_xor(const __m128i * Bin1, const __m128i * Bin2, __m128i * Bout,
+    size_t r)
+{
+        __m128i X0, X1, X2, X3;
+        size_t i;
+
+        /* 1: X <-- B_{2r - 1} */
+        XOR4_2(&Bin1[8 * r - 4], &Bin2[8 * r - 4])
+
+        /* 3: X <-- H(X \xor B_i) */
+        /* 4: Y_i <-- X */
+        /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+        XOR4(Bin1)
+        SALSA20_8_XOR(Bin2, Bout)
+
+        /* 2: for i = 0 to 2r - 1 do */
+        r--;
+        for (i = 0; i < r;) {
+                /* 3: X <-- H(X \xor B_i) */
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                XOR4(&Bin1[i * 8 + 4])
+                SALSA20_8_XOR(&Bin2[i * 8 + 4], &Bout[(r + i) * 4 + 4])
+
+                i++;
+
+                /* 3: X <-- H(X \xor B_i) */
+                /* 4: Y_i <-- X */
+                /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+                XOR4(&Bin1[i * 8])
+                SALSA20_8_XOR(&Bin2[i * 8], &Bout[i * 4])
+        }
+
+        /* 3: X <-- H(X \xor B_i) */
+        /* 4: Y_i <-- X */
+        /* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */
+        XOR4(&Bin1[i * 8 + 4])
+        SALSA20_8_XOR(&Bin2[i * 8 + 4], &Bout[(r + i) * 4 + 4])
+
+        return _mm_cvtsi128_si32(X0);
+}
+
+#undef ARX
+#undef SALSA20_2ROUNDS
+#undef SALSA20_8_XOR
+#undef XOR4
+#undef XOR4_2
+
+/**
+ * integerify(B, r):
+ * Return the result of parsing B_{2r-1} as a little-endian integer.
+ */
+static inline uint32_t
+integerify(const void * B, size_t r)
+{
+        return *(const uint32_t *)((uintptr_t)(B) + (2 * r - 1) * 64);
+}
+
+/**
+ * smix(B, r, N, V, XY):
+ * Compute B = SMix_r(B, N).  The input B must be 128r bytes in length;
+ * the temporary storage V must be 128rN bytes in length; the temporary
+ * storage XY must be 256r + 64 bytes in length.  The value N must be a
+ * power of 2 greater than 1.  The arrays B, V, and XY must be aligned to a
+ * multiple of 64 bytes.
+ */
+static void
+smix(uint8_t * B, size_t r, uint32_t N, void * V, void * XY)
+{
+        size_t s = 128 * r;
+        __m128i * X = (__m128i *) V, * Y;
+        uint32_t * X32 = (uint32_t *) V;
+        uint32_t i, j;
+        size_t k;
+
+        /* 1: X <-- B */
+        /* 3: V_i <-- X */
+        for (k = 0; k < 2 * r; k++) {
+                for (i = 0; i < 16; i++) {
+                        X32[k * 16 + i] =
+                            le32dec(&B[(k * 16 + (i * 5 % 16)) * 4]);
+                }
+        }
+
+        /* 2: for i = 0 to N - 1 do */
+        for (i = 1; i < N - 1; i += 2) {
+                /* 4: X <-- H(X) */
+                /* 3: V_i <-- X */
+                Y = (__m128i *)((uintptr_t)(V) + i * s);
+                blockmix_salsa8(X, Y, r);
+
+                /* 4: X <-- H(X) */
+                /* 3: V_i <-- X */
+                X = (__m128i *)((uintptr_t)(V) + (i + 1) * s);
+                blockmix_salsa8(Y, X, r);
+        }
+
+        /* 4: X <-- H(X) */
+        /* 3: V_i <-- X */
+        Y = (__m128i *)((uintptr_t)(V) + i * s);
+        blockmix_salsa8(X, Y, r);
+
+        /* 4: X <-- H(X) */
+        /* 3: V_i <-- X */
+        X = (__m128i *) XY;
+        blockmix_salsa8(Y, X, r);
+
+        X32 = (uint32_t *) XY;
+        Y = (__m128i *)((uintptr_t)(XY) + s);
+
+        /* 7: j <-- Integerify(X) mod N */
+        j = integerify(X, r) & (N - 1);
+
+        /* 6: for i = 0 to N - 1 do */
+        for (i = 0; i < N; i += 2) {
+                __m128i * V_j = (__m128i *)((uintptr_t)(V) + j * s);
+
+                /* 8: X <-- H(X \xor V_j) */
+                /* 7: j <-- Integerify(X) mod N */
+                j = blockmix_salsa8_xor(X, V_j, Y, r) & (N - 1);
+                V_j = (__m128i *)((uintptr_t)(V) + j * s);
+
+                /* 8: X <-- H(X \xor V_j) */
+                /* 7: j <-- Integerify(X) mod N */
+                j = blockmix_salsa8_xor(Y, V_j, X, r) & (N - 1);
+        }
+
+        /* 10: B' <-- X */
+        for (k = 0; k < 2 * r; k++) {
+                for (i = 0; i < 16; i++) {
+                        le32enc(&B[(k * 16 + (i * 5 % 16)) * 4],
+                            X32[k * 16 + i]);
+                }
+        }
+}
+
+/**
+ * escrypt_kdf(local, passwd, passwdlen, salt, saltlen,
+ *     N, r, p, buf, buflen):
+ * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
+ * p, buflen) and write the result into buf.  The parameters r, p, and buflen
+ * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
+ * must be a power of 2 greater than 1.
+ *
+ * Return 0 on success; or -1 on error.
+ */
+int
+escrypt_kdf_sse(escrypt_local_t * local,
+    const uint8_t * passwd, size_t passwdlen,
+    const uint8_t * salt, size_t saltlen,
+    uint64_t N, uint32_t _r, uint32_t _p,
+    uint8_t * buf, size_t buflen)
+{
+        size_t B_size, V_size, XY_size, need;
+        uint8_t * B;
+        uint32_t * V, * XY;
+    size_t r = _r, p = _p;
+        uint32_t i;
+
+        /* Sanity-check parameters. */
+#if SIZE_MAX > UINT32_MAX
+        if (buflen > (((uint64_t)(1) << 32) - 1) * 32) {
+                errno = EFBIG;
+                return -1;
+        }
+#endif
+        if ((uint64_t)(r) * (uint64_t)(p) >= (1 << 30)) {
+                errno = EFBIG;
+                return -1;
+        }
+        if (N > UINT32_MAX) {
+                errno = EFBIG;
+                return -1;
+        }
+        if (((N & (N - 1)) != 0) || (N < 2)) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (r == 0 || p == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+        if ((r > SIZE_MAX / 128 / p) ||
+#if SIZE_MAX / 256 <= UINT32_MAX
+            (r > SIZE_MAX / 256) ||
+#endif
+            (N > SIZE_MAX / 128 / r)) {
+                errno = ENOMEM;
+                return -1;
+        }
+
+        /* Allocate memory. */
+        B_size = (size_t)128 * r * p;
+        V_size = (size_t)128 * r * N;
+        need = B_size + V_size;
+        if (need < V_size) {
+                errno = ENOMEM;
+                return -1;
+        }
+        XY_size = (size_t)256 * r + 64;
+        need += XY_size;
+        if (need < XY_size) {
+                errno = ENOMEM;
+                return -1;
+        }
+        if (local->size < need) {
+                if (free_region(local))
+                        return -1;
+                if (!alloc_region(local, need))
+                        return -1;
+        }
+        B = (uint8_t *)local->aligned;
+        V = (uint32_t *)((uint8_t *)B + B_size);
+        XY = (uint32_t *)((uint8_t *)V + V_size);
+
+        /* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
+        PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, B_size);
+
+        /* 2: for i = 0 to p - 1 do */
+        for (i = 0; i < p; i++) {
+                /* 3: B_i <-- MF(B_i, N) */
+                smix(&B[(size_t)128 * i * r], r, N, V, XY);
+        }
+
+        /* 5: DK <-- PBKDF2(P, B, 1, dkLen) */
+        PBKDF2_SHA256(passwd, passwdlen, B, B_size, 1, buf, buflen);
+
+        /* Success! */
+        return 0;
+}
+#endif
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sysendian.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sysendian.h
new file mode 100644
index 00000000..04e5c1ed
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/sysendian.h
@@ -0,0 +1,153 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef _SYSENDIAN_H_
+#define _SYSENDIAN_H_
+
+#include <stdint.h>
+
+/* Avoid namespace collisions with BSD <sys/endian.h>. */
+#define be16dec scrypt_be16dec
+#define be16enc scrypt_be16enc
+#define be32dec scrypt_be32dec
+#define be32enc scrypt_be32enc
+#define be64dec scrypt_be64dec
+#define be64enc scrypt_be64enc
+#define le16dec scrypt_le16dec
+#define le16enc scrypt_le16enc
+#define le32dec scrypt_le32dec
+#define le32enc scrypt_le32enc
+#define le64dec scrypt_le64dec
+#define le64enc scrypt_le64enc
+
+static inline uint16_t
+be16dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint16_t)(p[1]) + ((uint16_t)(p[0]) << 8));
+}
+
+static inline void
+be16enc(void *pp, uint16_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[1] = x & 0xff;
+        p[0] = (x >> 8) & 0xff;
+}
+
+static inline uint32_t
+be32dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
+            ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
+}
+
+static inline void
+be32enc(void *pp, uint32_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[3] = x & 0xff;
+        p[2] = (x >> 8) & 0xff;
+        p[1] = (x >> 16) & 0xff;
+        p[0] = (x >> 24) & 0xff;
+}
+
+static inline uint64_t
+be64dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) +
+            ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) +
+            ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) +
+            ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56));
+}
+
+static inline void
+be64enc(void *pp, uint64_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[7] = x & 0xff;
+        p[6] = (x >> 8) & 0xff;
+        p[5] = (x >> 16) & 0xff;
+        p[4] = (x >> 24) & 0xff;
+        p[3] = (x >> 32) & 0xff;
+        p[2] = (x >> 40) & 0xff;
+        p[1] = (x >> 48) & 0xff;
+        p[0] = (x >> 56) & 0xff;
+}
+
+static inline uint16_t
+le16dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint16_t)(p[0]) + ((uint16_t)(p[1]) << 8));
+}
+
+static inline void
+le16enc(void *pp, uint16_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[0] = x & 0xff;
+        p[1] = (x >> 8) & 0xff;
+}
+
+static inline uint32_t
+le32dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +
+            ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));
+}
+
+static inline void
+le32enc(void *pp, uint32_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[0] = x & 0xff;
+        p[1] = (x >> 8) & 0xff;
+        p[2] = (x >> 16) & 0xff;
+        p[3] = (x >> 24) & 0xff;
+}
+
+static inline uint64_t
+le64dec(const void *pp)
+{
+        const uint8_t *p = (uint8_t const *)pp;
+
+        return ((uint64_t)(p[0]) + ((uint64_t)(p[1]) << 8) +
+            ((uint64_t)(p[2]) << 16) + ((uint64_t)(p[3]) << 24) +
+            ((uint64_t)(p[4]) << 32) + ((uint64_t)(p[5]) << 40) +
+            ((uint64_t)(p[6]) << 48) + ((uint64_t)(p[7]) << 56));
+}
+
+static inline void
+le64enc(void *pp, uint64_t x)
+{
+        uint8_t * p = (uint8_t *)pp;
+
+        p[0] = x & 0xff;
+        p[1] = (x >> 8) & 0xff;
+        p[2] = (x >> 16) & 0xff;
+        p[3] = (x >> 24) & 0xff;
+        p[4] = (x >> 32) & 0xff;
+        p[5] = (x >> 40) & 0xff;
+        p[6] = (x >> 48) & 0xff;
+        p[7] = (x >> 56) & 0xff;
+}
+
+#endif /* !_SYSENDIAN_H_ */
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.c b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.c
new file mode 100644
index 00000000..e61ccf3e
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.c
@@ -0,0 +1,78 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef __STDC_WANT_LIB_EXT1__
+# define __STDC_WANT_LIB_EXT1__ 1
+#endif
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+
+#include "utils.h"
+
+#ifdef _WIN32
+# include <windows.h>
+# include <wincrypt.h>
+#else
+# include <unistd.h>
+#endif
+
+#ifdef HAVE_WEAK_SYMBOLS
+__attribute__((weak)) void
+__sodium_dummy_symbol_to_prevent_lto(void * const pnt, const size_t len)
+{
+    (void) pnt;
+    (void) len;
+}
+#endif
+
+void
+sodium_memzero(void * const pnt, const size_t len)
+{
+#ifdef _WIN32
+    SecureZeroMemory(pnt, len);
+#elif defined(HAVE_MEMSET_S)
+    if (memset_s(pnt, (rsize_t) len, 0, (rsize_t) len) != 0) {
+        abort();
+    }
+#elif defined(HAVE_EXPLICIT_BZERO)
+    explicit_bzero(pnt, len);
+#elif HAVE_WEAK_SYMBOLS
+    memset(pnt, 0, len);
+    __sodium_dummy_symbol_to_prevent_lto(pnt, len);
+#else
+    volatile unsigned char *pnt_ = (volatile unsigned char *) pnt;
+    size_t                     i = (size_t) 0U;
+
+    while (i < len) {
+        pnt_[i++] = 0U;
+    }
+#endif
+}
+
+int
+sodium_memcmp(const void * const b1_, const void * const b2_, size_t len)
+{
+    const unsigned char *b1 = (const unsigned char *) b1_;
+    const unsigned char *b2 = (const unsigned char *) b2_;
+    size_t               i;
+    unsigned char        d = (unsigned char) 0U;
+
+    for (i = 0U; i < len; i++) {
+        d |= b1[i] ^ b2[i];
+    }
+    return (int) ((1 & ((d - 1) >> 8)) - 1);
+}
+
+#endif
diff --git a/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h
new file mode 100644
index 00000000..fb2020c3
--- /dev/null
+++ b/toxencryptsave/crypto_pwhash_scryptsalsa208sha256/utils.h
@@ -0,0 +1,40 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#ifdef  VANILLA_NACL /* toxcore only uses this when libsodium is unavailable */
+
+#ifndef __SODIUM_UTILS_H__
+#define __SODIUM_UTILS_H__
+
+#include <stddef.h>
+
+#include "export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__cplusplus) || !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
+# define _SODIUM_C99(X)
+#else
+# define _SODIUM_C99(X) X
+#endif
+
+SODIUM_EXPORT
+void sodium_memzero(void * const pnt, const size_t len);
+
+/* WARNING: sodium_memcmp() must be used to verify if two secret keys
+ * are equal, in constant time.
+ * It returns 0 if the keys are equal, and -1 if they differ.
+ * This function is not designed for lexicographical comparisons.
+ */
+SODIUM_EXPORT
+int sodium_memcmp(const void * const b1_, const void * const b2_, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#endif
diff --git a/toxencryptsave/defines.h b/toxencryptsave/defines.h
new file mode 100644
index 00000000..e3fca073
--- /dev/null
+++ b/toxencryptsave/defines.h
@@ -0,0 +1,2 @@
+#define TOX_ENC_SAVE_MAGIC_NUMBER "toxEsave"
+#define TOX_ENC_SAVE_MAGIC_LENGTH 8
diff --git a/toxencryptsave/toxencryptsave.c b/toxencryptsave/toxencryptsave.c
new file mode 100644
index 00000000..13a34dea
--- /dev/null
+++ b/toxencryptsave/toxencryptsave.c
@@ -0,0 +1,346 @@
+/* toxencryptsave.c
+ *
+ * The Tox encrypted save functions.
+ *
+ *  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
+
+#include "toxencryptsave.h"
+#include "defines.h"
+#include "../toxcore/crypto_core.h"
+#include "../toxcore/tox.h"
+
+#ifdef VANILLA_NACL
+#include "crypto_pwhash_scryptsalsa208sha256/crypto_pwhash_scryptsalsa208sha256.h"
+#include "crypto_pwhash_scryptsalsa208sha256/utils.h" /* sodium_memzero */
+#include <crypto_hash_sha256.h>
+#endif
+
+#define TOX_PASS_ENCRYPTION_EXTRA_LENGTH (crypto_box_MACBYTES + crypto_box_NONCEBYTES \
+           + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH)
+
+#define TOX_PASS_KEY_LENGTH (crypto_pwhash_scryptsalsa208sha256_SALTBYTES + crypto_box_KEYBYTES)
+
+int tox_pass_encryption_extra_length()
+{
+    return TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
+}
+
+int tox_pass_key_length()
+{
+    return TOX_PASS_KEY_LENGTH;
+}
+
+int tox_pass_salt_length()
+{
+    return crypto_pwhash_scryptsalsa208sha256_SALTBYTES;
+}
+
+/* This "module" provides functions analogous to tox_load and tox_save in toxcore
+ * Clients should consider alerting their users that, unlike plain data, if even one bit
+ * becomes corrupted, the data will be entirely unrecoverable.
+ * Ditto if they forget their password, there is no way to recover the data.
+ */
+
+/*  return size of the messenger data (for encrypted saving). */
+uint32_t tox_encrypted_size(const Tox *tox)
+{
+    return tox_save_size(tox) + TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
+}
+
+/* This retrieves the salt used to encrypt the given data, which can then be passed to
+ * derive_key_with_salt to produce the same key as was previously used. Any encrpyted
+ * data with this module can be used as input.
+ *
+ * returns -1 if the magic number is wrong
+ * returns 0 otherwise (no guarantee about validity of data)
+ */
+int tox_get_salt(uint8_t *data, uint8_t *salt)
+{
+    if (memcmp(data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) != 0)
+        return -1;
+
+    data += TOX_ENC_SAVE_MAGIC_LENGTH;
+    memcpy(salt, data, crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+    return 0;
+}
+
+/* Generates a secret symmetric key from the given passphrase. out_key must be at least
+ * TOX_PASS_KEY_LENGTH bytes long.
+ * Be sure to not compromise the key! Only keep it in memory, do not write to disk.
+ * This function is fairly cheap, but irungentoo insists that you be allowed to
+ * cache the result if you want, to minimize computation for repeated encryptions.
+ * The password is zeroed after key derivation.
+ * The key should only be used with the other functions in this module, as it
+ * includes a salt.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_derive_key_from_pass(uint8_t *passphrase, uint32_t pplength, uint8_t *out_key)
+{
+    uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
+    randombytes(salt, sizeof salt);
+    return tox_derive_key_with_salt(passphrase, pplength, salt, out_key);
+}
+
+/* Same as above, except with use the given salt for deterministic key derivation.
+ * The salt must be tox_salt_length() bytes in length.
+ */
+int tox_derive_key_with_salt(uint8_t *passphrase, uint32_t pplength, uint8_t *salt, uint8_t *out_key)
+{
+    if (pplength == 0)
+        return -1;
+
+    uint8_t passkey[crypto_hash_sha256_BYTES];
+    crypto_hash_sha256(passkey, passphrase, pplength);
+
+    uint8_t key[crypto_box_KEYBYTES];
+
+    /* Derive a key from the password */
+    /* http://doc.libsodium.org/key_derivation/README.html */
+    /* 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), (char *)passkey, sizeof(passkey), salt,
+                crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 2, /* slightly stronger */
+                crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE) != 0) {
+        /* out of memory most likely */
+        return -1;
+    }
+
+    sodium_memzero(passkey, crypto_hash_sha256_BYTES); /* wipe plaintext pw */
+    memcpy(out_key, salt, crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+    memcpy(out_key + crypto_pwhash_scryptsalsa208sha256_SALTBYTES, key, crypto_box_KEYBYTES);
+    return 0;
+}
+
+/* Encrypt arbitrary with a key produced by tox_derive_key_from_pass. The output
+ * array must be at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long.
+ * key must be TOX_PASS_KEY_LENGTH bytes.
+ * If you already have a symmetric key from somewhere besides this module, simply
+ * call encrypt_data_symmetric in toxcore/crypto_core directly.
+ *
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_pass_key_encrypt(const uint8_t *data, uint32_t data_len, const uint8_t *key, uint8_t *out)
+{
+    /* the output data consists of, in order:
+     * salt, nonce, mac, enc_data
+     * where the mac is automatically prepended by the encrypt()
+     * the salt+nonce is called the prefix
+     * I'm not sure what else I'm supposed to do with the salt and nonce, since we
+     * need them to decrypt the data
+     */
+
+    /* first add the magic number */
+    memcpy(out, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH);
+    out += TOX_ENC_SAVE_MAGIC_LENGTH;
+
+    /* then add the rest prefix */
+    memcpy(out, key, crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+    key += crypto_pwhash_scryptsalsa208sha256_SALTBYTES;
+    out += crypto_pwhash_scryptsalsa208sha256_SALTBYTES;
+
+    uint8_t nonce[crypto_box_NONCEBYTES];
+    random_nonce(nonce);
+    memcpy(out, nonce, crypto_box_NONCEBYTES);
+    out += crypto_box_NONCEBYTES;
+
+    /* now encrypt */
+    if (encrypt_data_symmetric(key, nonce, data, data_len, out)
+            != data_len + crypto_box_MACBYTES) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Encrypts the given data with the given passphrase. The output array must be
+ * at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. This delegates
+ * to tox_derive_key_from_pass and tox_pass_key_encrypt.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_pass_encrypt(const uint8_t *data, uint32_t data_len, uint8_t *passphrase, uint32_t pplength, uint8_t *out)
+{
+    uint8_t key[TOX_PASS_KEY_LENGTH];
+
+    if (tox_derive_key_from_pass(passphrase, pplength, key) == -1)
+        return -1;
+
+    return tox_pass_key_encrypt(data, data_len, key, out);
+}
+
+/* Save the messenger data encrypted with the given password.
+ * data must be at least tox_encrypted_size().
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_save(const Tox *tox, uint8_t *data, uint8_t *passphrase, uint32_t pplength)
+{
+    /* first get plain save data */
+    uint32_t temp_size = tox_save_size(tox);
+    uint8_t temp_data[temp_size];
+    tox_save(tox, temp_data);
+
+    /* now encrypt */
+    return tox_pass_encrypt(temp_data, temp_size, passphrase, pplength, data);
+}
+
+/* Save the messenger data encrypted with the given key from tox_derive_key.
+ * data must be at least tox_encrypted_size().
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_key_save(const Tox *tox, uint8_t *data, uint8_t *key)
+{
+    /* first get plain save data */
+    uint32_t temp_size = tox_save_size(tox);
+    uint8_t temp_data[temp_size];
+    tox_save(tox, temp_data);
+
+    /* encrypt */
+    return tox_pass_key_encrypt(temp_data, temp_size, key, data);
+}
+
+/* This is the inverse of tox_pass_key_encrypt, also using only keys produced by
+ * tox_derive_key_from_pass.
+ *
+ * returns the length of the output data (== data_len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH) on success
+ * returns -1 on failure
+ */
+int tox_pass_key_decrypt(const uint8_t *data, uint32_t length, const uint8_t *key, uint8_t *out)
+{
+    if (length <= TOX_PASS_ENCRYPTION_EXTRA_LENGTH
+            || 0 != memcmp(data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH))
+        return -1;
+
+    data += TOX_ENC_SAVE_MAGIC_LENGTH;
+
+    uint32_t decrypt_length = length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
+    //uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
+    uint8_t nonce[crypto_box_NONCEBYTES];
+
+    //memcpy(salt, data, crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+    key += crypto_pwhash_scryptsalsa208sha256_SALTBYTES; // ignore the salt, which is only needed for kdf
+    data += crypto_pwhash_scryptsalsa208sha256_SALTBYTES;
+    memcpy(nonce, data, crypto_box_NONCEBYTES);
+    data += crypto_box_NONCEBYTES;
+
+    /* decrypt the data */
+    if (decrypt_data_symmetric(key, nonce, data, decrypt_length + crypto_box_MACBYTES, out)
+            != decrypt_length) {
+        return -1;
+    }
+
+    return decrypt_length;
+}
+
+/* Decrypts the given data with the given passphrase. The output array must be
+ * at least data_len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long.
+ *
+ * returns the length of the output data (== data_len - TOX_PASS_ENCRYPTION_EXTRA_LENGTH) on success
+ * returns -1 on failure
+ */
+int tox_pass_decrypt(const uint8_t *data, uint32_t length, uint8_t *passphrase, uint32_t pplength, uint8_t *out)
+{
+    uint8_t passkey[crypto_hash_sha256_BYTES];
+    crypto_hash_sha256(passkey, passphrase, pplength);
+
+    uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
+    memcpy(salt, data + TOX_ENC_SAVE_MAGIC_LENGTH, crypto_pwhash_scryptsalsa208sha256_SALTBYTES);
+
+    /* derive the key */
+    uint8_t key[crypto_box_KEYBYTES + crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
+
+    if (crypto_pwhash_scryptsalsa208sha256(
+                key + crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
+                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 */
+        return -1;
+    }
+
+    sodium_memzero(passkey, crypto_hash_sha256_BYTES); /* wipe plaintext pw */
+
+    return tox_pass_key_decrypt(data, length, key, out);
+}
+
+/* Load the messenger from encrypted data of size length.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_load(Tox *tox, const uint8_t *data, uint32_t length, uint8_t *passphrase, uint32_t pplength)
+{
+    uint32_t decrypt_length = length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
+    uint8_t temp_data[decrypt_length];
+
+    if (tox_pass_decrypt(data, length, passphrase, pplength, temp_data)
+            != decrypt_length)
+        return -1;
+
+    return tox_load(tox, temp_data, decrypt_length);
+}
+
+/* Load the messenger from encrypted data of size length, with key from tox_derive_key.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_key_load(Tox *tox, const uint8_t *data, uint32_t length, uint8_t *key)
+{
+    uint32_t decrypt_length = length - TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
+    uint8_t temp_data[decrypt_length];
+
+    if (tox_pass_key_decrypt(data, length, key, temp_data)
+            != decrypt_length)
+        return -1;
+
+    return tox_load(tox, temp_data, decrypt_length);
+}
+
+/* Determines whether or not the given data is encrypted (by checking the magic number)
+ *
+ * returns 1 if it is encrypted
+ * returns 0 otherwise
+ */
+int tox_is_data_encrypted(const uint8_t *data)
+{
+    if (memcmp(data, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0)
+        return 1;
+    else
+        return 0;
+}
+
+int tox_is_save_encrypted(const uint8_t *data)
+{
+    return tox_is_data_encrypted(data);
+}
diff --git a/toxencryptsave/toxencryptsave.h b/toxencryptsave/toxencryptsave.h
new file mode 100644
index 00000000..da13f312
--- /dev/null
+++ b/toxencryptsave/toxencryptsave.h
@@ -0,0 +1,196 @@
+/* toxencryptsave.h
+ *
+ * The Tox encrypted save functions.
+ *
+ *  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 TOXENCRYPTSAVE_H
+#define TOXENCRYPTSAVE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef TOX_DEFINED
+#define TOX_DEFINED
+typedef struct Tox Tox;
+#endif
+
+// these functions provide access to these defines in toxencryptsave.c, which
+// otherwise aren't actually available in clients...
+int tox_pass_encryption_extra_length();
+
+int tox_pass_key_length();
+
+int tox_pass_salt_length();
+
+/*  return size of the messenger data (for encrypted Messenger saving). */
+uint32_t tox_encrypted_size(const Tox *tox);
+
+/* This "module" provides functions analogous to tox_load and tox_save in toxcore,
+ * as well as functions for encryption of arbitrary client data (e.g. chat logs).
+ *
+ * It is conceptually organized into two parts. The first part are the functions
+ * with "key" in the name. To use these functions, first derive an encryption key
+ * from a password with tox_derive_key_from_pass, and use the returned key to
+ * encrypt the data. The second part takes the password itself instead of the key,
+ * and then delegates to the first part to derive the key before de/encryption,
+ * which can simplify client code; however, key derivation is very expensive
+ * compared to the actual encryption, so clients that do a lot of encryption should
+ * favor using the first part intead of the second part.
+ *
+ * The encrypted data is prepended with a magic number, to aid validity checking
+ * (no guarantees are made of course).
+ *
+ * Clients should consider alerting their users that, unlike plain data, if even one bit
+ * becomes corrupted, the data will be entirely unrecoverable.
+ * Ditto if they forget their password, there is no way to recover the data.
+ */
+
+
+/******************************* BEGIN PART 2 *******************************
+ * For simplicty, the second part of the module is presented first. The API for
+ * the first part is analgous, with some extra functions for key handling. If
+ * your code spends too much time using these functions, consider using the part
+ * 1 functions instead.
+ */
+
+/* Encrypts the given data with the given passphrase. The output array must be
+ * at least data_len + tox_pass_encryption_extra_length() bytes long. This delegates
+ * to tox_derive_key_from_pass and tox_pass_key_encrypt.
+ *
+ * tox_encrypted_save() is a good example of how to use this function.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_pass_encrypt(const uint8_t *data, uint32_t data_len, uint8_t *passphrase, uint32_t pplength, uint8_t *out);
+
+/* Save the messenger data encrypted with the given password.
+ * data must be at least tox_encrypted_size().
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_save(const Tox *tox, uint8_t *data, uint8_t *passphrase, uint32_t pplength);
+
+/* Decrypts the given data with the given passphrase. The output array must be
+ * at least data_len - tox_pass_encryption_extra_length() bytes long. This delegates
+ * to tox_pass_key_decrypt.
+ *
+ * tox_encrypted_load() is a good example of how to use this function.
+ *
+ * returns the length of the output data (== data_len - tox_pass_encryption_extra_length()) on success
+ * returns -1 on failure
+ */
+int tox_pass_decrypt(const uint8_t *data, uint32_t length, uint8_t *passphrase, uint32_t pplength, uint8_t *out);
+
+/* Load the messenger from encrypted data of size length.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_load(Tox *tox, const uint8_t *data, uint32_t length, uint8_t *passphrase, uint32_t pplength);
+
+
+/******************************* BEGIN PART 1 *******************************
+ * And now part "1", which does the actual encryption, and is rather less cpu
+ * intensive than part one. The first 3 functions are for key handling.
+ */
+
+/* Generates a secret symmetric key from the given passphrase. out_key must be at least
+ * tox_pass_key_length() bytes long.
+ * Be sure to not compromise the key! Only keep it in memory, do not write to disk.
+ * The password is zeroed after key derivation.
+ * The key should only be used with the other functions in this module, as it
+ * includes a salt.
+ * Note that this function is not deterministic; to derive the same key from a
+ * password, you also must know the random salt that was used. See below.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_derive_key_from_pass(uint8_t *passphrase, uint32_t pplength, uint8_t *out_key);
+
+/* Same as above, except with use the given salt for deterministic key derivation.
+ * The salt must be tox_salt_length() bytes in length.
+ */
+int tox_derive_key_with_salt(uint8_t *passphrase, uint32_t pplength, uint8_t *salt, uint8_t *out_key);
+
+/* This retrieves the salt used to encrypt the given data, which can then be passed to
+ * derive_key_with_salt to produce the same key as was previously used. Any encrpyted
+ * data with this module can be used as input.
+ *
+ * returns -1 if the magic number is wrong
+ * returns 0 otherwise (no guarantee about validity of data)
+ */
+int tox_get_salt(uint8_t *data, uint8_t *salt);
+
+/* Now come the functions that are analogous to the part 2 functions. */
+
+/* Encrypt arbitrary with a key produced by tox_derive_key_. The output
+ * array must be at least data_len + tox_pass_encryption_extra_length() bytes long.
+ * key must be tox_pass_key_length() bytes.
+ * If you already have a symmetric key from somewhere besides this module, simply
+ * call encrypt_data_symmetric in toxcore/crypto_core directly.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_pass_key_encrypt(const uint8_t *data, uint32_t data_len, const uint8_t *key, uint8_t *out);
+
+/* Save the messenger data encrypted with the given key from tox_derive_key.
+ * data must be at least tox_encrypted_size().
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_key_save(const Tox *tox, uint8_t *data, uint8_t *key);
+
+/* This is the inverse of tox_pass_key_encrypt, also using only keys produced by
+ * tox_derive_key_from_pass.
+ *
+ * returns the length of the output data (== data_len - tox_pass_encryption_extra_length()) on success
+ * returns -1 on failure
+ */
+int tox_pass_key_decrypt(const uint8_t *data, uint32_t length, const uint8_t *key, uint8_t *out);
+
+/* Load the messenger from encrypted data of size length, with key from tox_derive_key.
+ *
+ * returns 0 on success
+ * returns -1 on failure
+ */
+int tox_encrypted_key_load(Tox *tox, const uint8_t *data, uint32_t length, uint8_t *key);
+
+/* Determines whether or not the given data is encrypted (by checking the magic number)
+ *
+ * returns 1 if it is encrypted
+ * returns 0 otherwise
+ */
+int tox_is_data_encrypted(const uint8_t *data);
+int tox_is_save_encrypted(const uint8_t *data); // poorly-named alias for backwards compat (oh irony...)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif