51 files changed, 2476 insertions, 2106 deletions
diff --git a/INSTALL.md b/INSTALL.md
index 78c3d688..41aa5afd 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,18 +1,22 @@
 #Install Instructions
 - [Installation](#installation)
-    - [Unix like](#unix)
+  - [Unix like](#unix)
-    - [OS X](#osx)
+  - [OS X](#osx)
-      - [Homebrew](#homebrew)
+    - [Homebrew](#homebrew)
-      - [Non-Homebrew](#non-homebrew)
+    - [Non-Homebrew](#non-homebrew)
-    - [Windows](#windows)
+  - [Windows](#windows)
+    - [Cross-Compile](#windows-cross-compile)
+      - [Setting up a VM](#windows-cross-compile-vm)
+      - [Setting up the environment](#windows-cross-compile-environment)
+      - [Compiling](#windows-cross-compile-compiling)
+    - [Native](#windows-native)
 - [Additional](#additional)
-    - [Advanced configure options] (#aconf)
+  - [Advanced configure options](#aconf)
-    - [A/V support](#av)
+  - [A/V support](#av)
-      - [libtoxav] (#libtoxav)
+    - [libtoxav](#libtoxav)
-    - [Bootstrap daemon] (#bootstrapd)
+  - [Bootstrap daemon](#bootstrapd)
-    - [nTox] (#ntox)
+  - [nTox](#ntox)
 <a name="installation" />
 ##Installation
@@ -45,17 +49,18 @@ pkg install autoconf automake gcc-47
 On FreeBSD 10+:
 ```tcsh
-pkg install automake autoconf
+pkg install net-im/tox
 ```
+Note, if you install from ports select NaCl for performance, and sodium if you want it to be portable.
 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.4.2
+git checkout tags/0.5.0
 ./autogen.sh
 ./configure && make check
-sudo checkinstall --install --pkgname libsodium --pkgversion 0.4.2 --nodoc
+sudo checkinstall --install --pkgname libsodium --pkgversion 0.5.0 --nodoc
 sudo ldconfig
 cd ..
 ```
@@ -67,7 +72,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.4.2
+git checkout tags/0.5.0
 ./autogen.sh
 ./configure
 make check
@@ -145,6 +150,14 @@ Grab the following packages:
  * https://gnu.org/software/automake/
  * https://github.com/jedisct1/libsodium
  * http://check.sourceforge.net/
+  * http://yasm.tortall.net/Download.html
+  * 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.
+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).
 Uncompress and install them all. Make sure to follow the README as the instructions change, but they all follow the same pattern below:
@@ -154,9 +167,8 @@ make
 sudo make install
 ```
-In your local TOX repository:
+Compiling and installing Tox Core
-Then generate makefile, build and install tox:
 ```bash
 cd ProjectTox-Core
 autoreconf -i
@@ -165,36 +177,210 @@ make
 make install
 ```
-Do not install them from macports (or any dependencies for that matter) as they get shoved in the wrong directory
+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;
-(or the wrong version gets installed) and make your life more annoying.
+./configure --with-libsodium-headers=/usr/local/include/ --with-libsodium-libs=/usr/local/lib
+Ensure you set the locations correctly depending on where you installed libsodium on your computer.
+If there is a problem with opus (for A/V) and you don't get a libtoxav, then try to set the pkg-config environment variable beforehand:
-Another thing: you may want to install is the latest gcc. This caused me a few problems as XCode from 4.3
+```
-no longer includes gcc and instead uses LLVM-GCC, a nice install guide can be found at
+export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
-http://caiustheory.com/install-gcc-421-apple-build-56663-with-xcode-42
+```
 <a name="windows" />
 ###Windows:
+<a name="windows-cross-compile" />
+####Cross-compile
+It's a bit challenging to build Tox and all of its dependencies nativly on Windows, so we will show an easier, less error and headache prone method of building it -- cross-compiling.
+<a name="windows-cross-compile-vm" />
+#####Setting up a VM
+We will assume that you don't have any VM running Linux around and will guide you from the ground up.
+First, you would need to get a virtual machine and a Linux distribution image file.
+For a virtual machine we will use VirtualBox. You can get it [here](https://www.virtualbox.org/wiki/Downloads).
+For a Linux distribution we will use Lubuntu 14.04 32-bit, which you can get [here](https://help.ubuntu.com/community/Lubuntu/GetLubuntu).
+After you have those downloaded, install the VirtualBox and create a VM in it. The default of 512mb of RAM and 8gb of dynamically-allocated virtual hard drive would be enough.
+When you have created the VM, go into its **Settings** -> **System** -> **Processor** and add some cores, if you have any additional available, for faster builds.
+Then, go to **Settings** -> **Storage**, click on **Empty** under **Controller: IDE**, click on the little disc icon on the right side of the window, click on **Choose a virtual CD/DVD disk file** and select the downloaded Lubuntu image file.
+Start the VM and follow the installation instructions.
+After Lubuntu is installed and you have booted into it, in VirtualBox menu on top of the window select **Devices** -> **Insert Guest Additions CD image...**.
+Open terminal from **Lubuntu's menu** -> **Accessories**.
+Execute:
+```bash
+sudo apt-get update
+sudo apt-get install build-essential -y
+cd /media/*/*/
+sudo ./VBoxLinuxAdditions.run
+```
+After that, create a folder called `toxbuild` somewhere on your Windows system. The go to **Devices** -> **Shared Folders Settings...** in the VirtualBox menu, add the `toxbuild` folder there and set **Auto-mount** and **Make Permanent** options.
+Execute:
+```bash
+sudo adduser `whoami` vboxsf
+```
+Note the use of a [grave accent](http://en.wikipedia.org/wiki/Grave_accent) instead of an apostrophe.
+Then just reboot the system with:
+```bash
+sudo reboot
+```
+After the system is booted, go to **Devices** -> **Shared Clipboard** and select **Bidirectional**. Now you will be able to copy-paste text between the host and the guest systems.
+Now that the virtual machine is all set up, let's move to getting build dependencies and setting up environment variables.
+<a name="windows-cross-compile-environment" />
+#####Setting up the environment
+First we will install all tools that we would need for building:
+```bash
+sudo apt-get install build-essential libtool autotools-dev automake checkinstall check git yasm pkg-config mingw-w64 -y
+```
+Then we will define a few variables, **depending on which you will build either 32-bit or 64-bit Tox**.
+For 32-bit Tox build, do:
+```bash
+WINDOWS_TOOLCHAIN=i686-w64-mingw32
+LIB_VPX_TARGET=x86-win32-gcc
+```
+For 64-bit Tox build, do:
+```bash
+WINDOWS_TOOLCHAIN=x86_64-w64-mingw32
+LIB_VPX_TARGET=x86_64-win64-gcc
+```
+This is the only difference between 32-bit and 64-bit build procedures.
+For speeding up the build process do:
+```
+MAKEFLAGS=j$(nproc)
+export MAKEFLAGS
+```
+And let's make a folder where we will be building everything at
+```bash
+cd ~
+mkdir prefix
+cd prefix
+PREFIX_DIR=$(pwd)
+cd ..
+mkdir build
+cd build
+```
+<a name="windows-cross-compile-compiling" />
+#####Compiling
+Now we will build libraries needed for audio/video: VPX and Opus.
+VPX:
+```bash
+git clone http://git.chromium.org/webm/libvpx.git
+cd libvpx
+git checkout tags/v1.3.0
+CROSS="$WINDOWS_TOOLCHAIN"- ./configure --target="$LIB_VPX_TARGET" --prefix="$PREFIX_DIR" --disable-examples --disable-unit-tests --disable-shared --enable-static
+make
+make install
+cd ..
+```
+Opus:
+```bash
+wget http://downloads.xiph.org/releases/opus/opus-1.1.tar.gz
+tar -xf opus-1.1.tar.gz
+cd opus-1.1
+./configure --host="$WINDOWS_TOOLCHAIN" --prefix="$PREFIX_DIR" --disable-extra-programs --disable-doc --disable-shared --enable-static
+make
+make install
+cd ..
+```
+Now we will build sodium crypto library:
+```bash
+git clone https://github.com/jedisct1/libsodium/
+cd libsodium
+git checkout tags/0.4.5
+./autogen.sh
+./configure --host="$WINDOWS_TOOLCHAIN" --prefix="$PREFIX_DIR" --disable-shared --enable-static
+make
+make install
+cd ..
+```
+And finally we will build Tox:
+```bash
+git clone https://github.com/irungentoo/toxcore
+cd toxcore
+./autogen.sh
+./configure --host="$WINDOWS_TOOLCHAIN" --prefix="$PREFIX_DIR" --disable-ntox --disable-tests --disable-testing --with-dependency-search="$PREFIX_DIR" --disable-shared --enable-static
+make
+make install
+cd ..
+```
+Then we make Tox shared library:
+```bash
+cd "$PREFIX_DIR"
+mkdir tmp
+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-gcc -Wl,--export-all-symbols -Wl,--out-implib=libtox.dll.a -shared -o libtox.dll *.o ../lib/*.a /usr/$WINDOWS_TOOLCHAIN/lib/libwinpthread.a -lws2_32 -static-libgcc
+```
+And we will copy it over to the `toxbuild` directory:
+```bash
+mkdir -p /media/sf_toxbuild/release/lib
+mv libtox.dll* /media/sf_toxbuild/release/lib
+mkdir -p /media/sf_toxbuild/release/include
+mv ../include/tox /media/sf_toxbuild/release/include
+```
+That's it. Now you should have `release/lib/libtox.dll` and `release/include/tox/<headers>` in your `toxbuild` directory on the Windows system.
+<a name="windows-native" />
+####Native
+Note that the Native instructions are incomplete, in a sense that they miss instructions needed for adding audio/video support to Tox. You also might stumble upon some unknown MinGW+msys issues while trying to build it.
 You should install:
  - [MinGW](http://sourceforge.net/projects/mingw/)
 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
+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.
-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.4.2.tar.gz release:
+Assuming that you got the libsodium-0.5.0.tar.gz release:
 ```cmd
-tar -zxvf libsodium-0.4.2.tar.gz
+tar -zxvf libsodium-0.5.0.tar.gz
-cd libsodium-0.4.2
+cd libsodium-0.5.0
 ./configure
 make
 make install
 cd ..
 ```
-You can also use a precompiled win32 binary of libsodium, however you will have
+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.
-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.
@@ -334,4 +520,3 @@ Install on ubuntu:
 ```bash
 sudo apt-get install ncurses-dev
 ```
diff --git a/README.md b/README.md
index 853a747d..ff3a6bba 100644
--- a/README.md
+++ b/README.md
@@ -1,21 +1,21 @@
-![Project Tox](https://raw.github.com/irungentoo/ProjectTox-Core/master/other/tox.png "Project Tox")
+![Project Tox](https://raw.github.com/irungentoo/toxcore/master/other/tox.png "Project Tox")
 ***
 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) **|** [**Wiki**](http://wiki.tox.im/) **|** [**Blog**](https://blog.libtoxcore.so/) **|** [**FAQ**](http://wiki.tox.im/FAQ) **|** [**Binaries**](http://download.tox.im/) **|** [**Clients**](http://wiki.tox.im/Client) **|** [**Compiling**](http://wiki.tox.im/Installing) **|** [**API**](http://api.libtoxcore.so/) **|** [**Qt-GUI**](https://github.com/nurupo/ProjectTox-Qt-GUI) **|** **IRC:** #tox@freenode
+[**Website**](https://tox.im) **|** [**Download**](https://wiki.tox.im/Binaries) **|** [**Wiki**](https://wiki.tox.im/) **|** [**Blog**](https://blog.libtoxcore.so/) **|** [**FAQ**](http://wiki.tox.im/FAQ) **|** [**Binaries**](https://wiki.tox.im/Binaries) **|** [**Clients**](https://wiki.tox.im/Client) **|** [**Compiling**](https://wiki.tox.im/Installing) **|** [**API**](https://libtoxcore.so/)  **|** **IRC:** #tox@freenode
 ## The Complex Stuff:
 ### UDP vs. TCP
-Tox must use UDP simply because [hole punching](http://en.wikipedia.org/wiki/UDP_hole_punching) with TCP is not as reliable.
+Tox must use UDP simply because [hole punching](https://en.wikipedia.org/wiki/UDP_hole_punching) with TCP is not as reliable.
 However, Tox does use [TCP relays](https://github.com/irungentoo/ProjectTox-Core/blob/master/docs/TCP_Network.txt) as a fallback if it encounters a firewall that prevents UDP hole punching.
 ### Connecting & Communicating
-Every peer is represented as a [byte string][String] (the public key [Tox ID] of the peer). By using torrent-style DHT, peers can find the IP of other peers by using their Tox ID. Once the IP is obtained, peers can initiate a [secure](https://github.com/irungentoo/ProjectTox-Core/wiki/Crypto) connection with each other. Once the connection is made, peers can exchange messages, send files, start video chats, etc. using encrypted communications.
+Every peer is represented as a [byte string][String] (the public key [Tox ID] of the peer). By using torrent-style DHT, peers can find the IP of other peers by using their Tox ID. Once the IP is obtained, peers can initiate a [secure](https://github.com/irungentoo/toxcore/wiki/Crypto) connection with each other. Once the connection is made, peers can exchange messages, send files, start video chats, etc. using encrypted communications.
-**Current build status:** [![Build Status](https://travis-ci.org/irungentoo/ProjectTox-Core.png?branch=master)](https://travis-ci.org/irungentoo/ProjectTox-Core)
+**Current build status:** [![Build Status](https://travis-ci.org/irungentoo/toxcore.png?branch=master)](https://travis-ci.org/irungentoo/toxcore)
 ## Q&A:
@@ -33,10 +33,10 @@ The goal of this project is to create a configuration-free P2P Skype replacement
 ## Documentation:
- [Installation](/INSTALL.md)
+- [Compiling](/INSTALL.md)
- [DHT Protocol](http://wiki.tox.im/index.php/DHT)<br />
+- [DHT Protocol](https://wiki.tox.im/index.php/DHT)<br />
- [Lossless UDP Protocol](http://wiki.tox.im/index.php/Lossless_UDP)<br />
+- [Lossless UDP Protocol](https://wiki.tox.im/index.php/Lossless_UDP)<br />
- [Crypto](http://wiki.tox.im/index.php/Crypto)<br />
+- [Crypto](https://wiki.tox.im/index.php/Crypto)<br />
- [Ideas](http://wiki.tox.im/index.php/Ideas)
+- [Ideas](https://wiki.tox.im/index.php/Ideas)
 [String]: https://en.wikipedia.org/wiki/String_(computer_science)
diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index ca5afd9a..8e75fae0 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -294,7 +294,7 @@ END_TEST
 static int response_callback_good;
 static uint8_t response_callback_connection_id;
 static uint8_t response_callback_public_key[crypto_box_PUBLICKEYBYTES];
-static int response_callback(void *object, uint8_t connection_id, uint8_t *public_key)
+static int response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
 {
    if (set_tcp_connection_number(object - 2, connection_id, 7) != 0)
        return 1;
@@ -321,7 +321,7 @@ static int status_callback(void *object, uint32_t number, uint8_t connection_id,
    return 0;
 }
 static int data_callback_good;
-static int data_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t *data, uint16_t length)
+static int data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length)
 {
    if (object != (void *)3)
        return 1;
@@ -342,7 +342,7 @@ static int data_callback(void *object, uint32_t number, uint8_t connection_id, u
 static int oob_data_callback_good;
 static uint8_t oob_pubkey[crypto_box_PUBLICKEYBYTES];
-static int oob_data_callback(void *object, uint8_t *public_key, uint8_t *data, uint16_t length)
+static int oob_data_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length)
 {
    if (object != (void *)4)
        return 1;
diff --git a/auto_tests/tox_test.c b/auto_tests/tox_test.c
index f8da8560..1a3c5868 100644
--- a/auto_tests/tox_test.c
+++ b/auto_tests/tox_test.c
@@ -30,7 +30,7 @@ void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *dat
 }
 uint32_t messages_received;
-void print_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_message(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    if (*((uint32_t *)userdata) != 974536)
        return;
@@ -44,7 +44,7 @@ void print_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, v
 uint32_t name_changes;
-void print_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_nickchange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    if (*((uint32_t *)userdata) != 974536)
        return;
@@ -69,7 +69,7 @@ void print_typingchange(Tox *m, int friendnumber, uint8_t typing, void *userdata
 uint8_t filenum;
 uint32_t file_accepted;
 uint64_t file_size;
-void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename,
+void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, const uint8_t *filename,
                         uint16_t filename_length, void *userdata)
 {
    if (*((uint32_t *)userdata) != 974536)
@@ -85,7 +85,7 @@ void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t
 uint32_t file_sent;
 uint32_t sendf_ok;
 void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t filenumber, uint8_t control_type,
-                        uint8_t *data, uint16_t length, void *userdata)
+                        const uint8_t *data, uint16_t length, void *userdata)
 {
    if (*((uint32_t *)userdata) != 974536)
        return;
@@ -100,7 +100,7 @@ void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t
 uint64_t size_recv;
 uint8_t num;
-void write_file(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length, void *userdata)
 {
    if (*((uint32_t *)userdata) != 974536)
        return;
diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index ce3185de..bf130ecb 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -138,6 +138,15 @@ void callback_requ_timeout ( int32_t call_index, void *_arg )
 {
    ck_assert_msg(0, "No answer!");
 }
+static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length)
+{
+}
+static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img)
+{
+}
 /*************************************************************************************************/
 /* Alice calls bob and the call starts.
@@ -199,7 +208,7 @@ START_TEST(test_AV_flows)
    printf("All set after %llu seconds! Starting call...\n", time(NULL) - cur_time);
    muhcaps = av_DefaultSettings;
-    muhcaps.video_height = muhcaps.video_width = 128;
+    muhcaps.max_video_height = muhcaps.max_video_width = 128;
    Status status_control = {
        {none, toxav_new(Alice, 1), NULL, -1},
@@ -222,6 +231,10 @@ START_TEST(test_AV_flows)
    toxav_register_callstate_callback(callback_recv_error, av_OnError, &status_control);
    toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, &status_control);
+    toxav_register_audio_recv_callback(status_control.Alice.av, callback_audio);
+    toxav_register_video_recv_callback(status_control.Alice.av, callback_video);
+    toxav_register_audio_recv_callback(status_control.Bob.av, callback_audio);
+    toxav_register_video_recv_callback(status_control.Bob.av, callback_video);
    const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
    int16_t sample_payload[frame_size];
@@ -267,21 +280,22 @@ START_TEST(test_AV_flows)
        toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
        /* Both receive */
-        int16_t storage[frame_size];
+        /*int16_t storage[frame_size];
        int recved;
        /* Payload from Bob */
-        recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
+        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");*/
+            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
        }
        recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");*/
+            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }
+        }*/
        if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
            step++; /* This terminates the loop */
@@ -317,6 +331,7 @@ START_TEST(test_AV_flows)
        }
        toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
 //         toxav_send_video(status_control.Bob.av, status_control.Bob.call_index, sample_image);
        /* Both receive */
@@ -325,11 +340,11 @@ START_TEST(test_AV_flows)
        int recved;
        /* Payload from Bob */
-        recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
+        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");*/
+            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
-        }
+        }*/
        /* Video payload */
 //         toxav_recv_video(status_control.Alice.av, status_control.Alice.call_index, &video_storage);
@@ -345,11 +360,11 @@ START_TEST(test_AV_flows)
        /* Payload from Alice */
-        recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
+        /*recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");*/
+            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }
+        }*/
        if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
            step++; /* This terminates the loop */
@@ -396,11 +411,11 @@ START_TEST(test_AV_flows)
        int recved;
        /* Payload from Bob */
-        recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
+        /*recved = toxav_recv_audio(status_control.Alice.av, status_control.Alice.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");*/
+            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Bob is invalid");
-        }
+        }*/
        /* Video payload */
 //         toxav_recv_video(status_control.Alice.av, status_control.Alice.call_index, &video_storage);
@@ -416,11 +431,11 @@ START_TEST(test_AV_flows)
        /* Payload from Alice */
-        recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
+        /*recved = toxav_recv_audio(status_control.Bob.av, status_control.Bob.call_index, frame_size, storage);
        if ( recved ) {
-            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");*/
+            ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from Alice is invalid");
-        }
+        }*/
        /* Video payload */
 //         toxav_recv_video(status_control.Bob.av, status_control.Bob.call_index, &video_storage);
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index 2a931cb0..3195d1ed 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -24,6 +24,7 @@
 #define c_sleep(x) usleep(1000*x)
 #endif
+pthread_mutex_t muhmutex;
 typedef enum _CallStatus {
    none,
@@ -124,6 +125,14 @@ void callback_requ_timeout ( int32_t call_index, void *_arg )
 {
    ck_assert_msg(0, "No answer!");
 }
+static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int length)
+{
+}
+static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img)
+{
+}
 /*************************************************************************************************/
@@ -142,6 +151,11 @@ void *in_thread_call (void *arg)
    uint8_t prepared_payload[RTP_PAYLOAD_SIZE];
+    toxav_register_audio_recv_callback(this_call->Caller.av, callback_audio);
+    toxav_register_video_recv_callback(this_call->Caller.av, callback_video);
+    toxav_register_audio_recv_callback(this_call->Callee.av, callback_audio);
+    toxav_register_video_recv_callback(this_call->Callee.av, callback_video);
    /* NOTE: CALLEE WILL ALWAHYS NEED CALL_IDX == 0 */
    while (running) {
@@ -192,26 +206,28 @@ void *in_thread_call (void *arg)
                        int recved;
                        /* Payload from CALLER */
-                        recved = toxav_recv_audio(this_call->Callee.av, 0, frame_size, storage);
+                        /*recved = toxav_recv_audio(this_call->Callee.av, 0, frame_size, storage);
                        if ( recved ) {
-                            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLER is invalid");*/
+                            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLER is invalid");
-                        }
+                        }*/
                        /* Payload from CALLEE */
-                        recved = toxav_recv_audio(this_call->Caller.av, call_idx, frame_size, storage);
+                        /*recved = toxav_recv_audio(this_call->Caller.av, call_idx, frame_size, storage);
                        if ( recved ) {
-                            /*ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLEE is invalid");*/
+                            //ck_assert_msg(recved == 10 && memcmp(storage, sample_payload, 10) == 0, "Payload from CALLEE is invalid");
-                        }
+                        }*/
                        c_sleep(20);
                    }
                    step++; /* This terminates the loop */
+                    pthread_mutex_lock(&muhmutex);
                    toxav_kill_transmission(this_call->Callee.av, 0);
                    toxav_kill_transmission(this_call->Caller.av, call_idx);
+                    pthread_mutex_unlock(&muhmutex);
                    /* Call over CALLER hangs up */
                    toxav_hangup(this_call->Caller.av, call_idx);
@@ -335,6 +351,8 @@ START_TEST(test_AV_three_calls)
    toxav_register_callstate_callback(callback_requ_timeout, av_OnRequestTimeout, &status_control);
+    pthread_mutex_init(&muhmutex, NULL);
    for ( i = 0; i < 3; i++ )
        pthread_create(&status_control.calls[i].tid, NULL, in_thread_call, &status_control.calls[i]);
@@ -350,11 +368,15 @@ START_TEST(test_AV_three_calls)
        status_control.calls[1].Callee.status != Ended && status_control.calls[1].Caller.status != Ended &&
        status_control.calls[2].Callee.status != Ended && status_control.calls[2].Caller.status != Ended
    ) {
+        pthread_mutex_lock(&muhmutex);
        tox_do(bootstrap_node);
        tox_do(caller);
        tox_do(callees[0]);
        tox_do(callees[1]);
        tox_do(callees[2]);
+        pthread_mutex_unlock(&muhmutex);
        c_sleep(20);
    }
@@ -403,4 +425,4 @@ int main(int argc, char *argv[])
 //     test_AV_three_calls();
 //
 //     return 0;
-}
-\ No newline at end of file
+}
diff --git a/docs/TODO b/docs/TODO
index fc50d566..966a1b5f 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -24,8 +24,8 @@ Lossless UDP:
    [DONE] Call initiation
    [DONE] Encryption
    [IN PROGRESS] Auditing.
-    [NOT STARTED] Video packet splitting.
+    [NEEDS TESTING] Video packet splitting.
-    [NOT STARTED] Prevent audio skew.
+    [IN PROGRESS] Prevent audio skew (seems to be easily solvable client side.)
    [IN PROGRESS] Group chats.
 Friend_requests.c:
diff --git a/other/bootstrap_daemon/tox_bootstrap_daemon.c b/other/bootstrap_daemon/tox_bootstrap_daemon.c
index ceb4fded..5f8f9f76 100644
--- a/other/bootstrap_daemon/tox_bootstrap_daemon.c
+++ b/other/bootstrap_daemon/tox_bootstrap_daemon.c
@@ -91,6 +91,7 @@ int manage_keys(DHT *dht, char *keys_file_path)
        size_t read_size = fread(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
        if (read_size != KEYS_SIZE) {
+            fclose(keys_file);
            return 0;
        }
@@ -106,6 +107,7 @@ int manage_keys(DHT *dht, char *keys_file_path)
        size_t write_size = fwrite(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
        if (write_size != KEYS_SIZE) {
+            fclose(keys_file);
            return 0;
        }
    }
@@ -147,8 +149,11 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
        for (i = 0; i < DEFAULT_TCP_RELAY_PORTS_COUNT; i ++) {
            (*tcp_relay_ports)[*tcp_relay_port_count] = default_ports[i];
-            if ((*tcp_relay_ports)[*tcp_relay_port_count] < MIN_ALLOWED_PORT || (*tcp_relay_ports)[*tcp_relay_port_count] > MAX_ALLOWED_PORT) {
-                syslog(LOG_WARNING, "Port #%d: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i, (*tcp_relay_ports)[*tcp_relay_port_count], MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
+            if ((*tcp_relay_ports)[*tcp_relay_port_count] < MIN_ALLOWED_PORT
+                    || (*tcp_relay_ports)[*tcp_relay_port_count] > MAX_ALLOWED_PORT) {
+                syslog(LOG_WARNING, "Port #%d: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i,
+                       (*tcp_relay_ports)[*tcp_relay_port_count], MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
                continue;
            }
@@ -162,11 +167,13 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
    }
    if (config_setting_is_array(ports_array) == CONFIG_FALSE) {
-        syslog(LOG_WARNING, "'%s' setting should be an array. Array syntax: 'setting = [value1, value2, ...]'.\n", NAME_TCP_RELAY_PORTS);
+        syslog(LOG_WARNING, "'%s' setting should be an array. Array syntax: 'setting = [value1, value2, ...]'.\n",
+               NAME_TCP_RELAY_PORTS);
        return;
    }
    int config_port_count = config_setting_length(ports_array);
    if (config_port_count == 0) {
        syslog(LOG_WARNING, "'%s' is empty.\n", NAME_TCP_RELAY_PORTS);
        return;
@@ -174,12 +181,10 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
    *tcp_relay_ports = malloc(config_port_count * sizeof(uint16_t));
-    config_setting_t *elem;
    int i;
    for (i = 0; i < config_port_count; i ++) {
+        config_setting_t *elem = config_setting_get_elem(ports_array, i);
-        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
@@ -193,8 +198,11 @@ void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int
        }
        (*tcp_relay_ports)[*tcp_relay_port_count] = config_setting_get_int(elem);
-        if ((*tcp_relay_ports)[*tcp_relay_port_count] < MIN_ALLOWED_PORT || (*tcp_relay_ports)[*tcp_relay_port_count] > MAX_ALLOWED_PORT) {
-            syslog(LOG_WARNING, "Port #%d: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i, (*tcp_relay_ports)[*tcp_relay_port_count], MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
+        if ((*tcp_relay_ports)[*tcp_relay_port_count] < MIN_ALLOWED_PORT
+                || (*tcp_relay_ports)[*tcp_relay_port_count] > MAX_ALLOWED_PORT) {
+            syslog(LOG_WARNING, "Port #%d: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i,
+                   (*tcp_relay_ports)[*tcp_relay_port_count], MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
            continue;
        }
@@ -315,6 +323,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
            syslog(LOG_WARNING, "Using default '%s': %s\n", NAME_MOTD, DEFAULT_MOTD);
            tmp_motd = DEFAULT_MOTD;
        }
        size_t tmp_motd_length = strlen(tmp_motd) + 1;
        size_t motd_length = tmp_motd_length > MAX_MOTD_LENGTH ? MAX_MOTD_LENGTH : tmp_motd_length;
        *motd = malloc(motd_length);
@@ -332,6 +341,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
    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");
    // show info about tcp ports only if tcp relay is enabled
    if (*enable_tcp_relay) {
        if (*tcp_relay_port_count == 0) {
@@ -339,6 +349,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
        } else {
            syslog(LOG_DEBUG, "Read %d TCP ports:\n", *tcp_relay_port_count);
            int i;
            for (i = 0; i < *tcp_relay_port_count; i ++) {
                syslog(LOG_DEBUG, "Port #%d: %u\n", i, (*tcp_relay_ports)[i]);
            }
@@ -346,6 +357,7 @@ int get_general_config(char *cfg_file_path, char **pid_file_path, char **keys_fi
    }
    syslog(LOG_DEBUG, "'%s': %s\n", NAME_ENABLE_MOTD,          *enable_motd          ? "true" : "false");
    if (*enable_motd) {
        syslog(LOG_DEBUG, "'%s': %s\n", NAME_MOTD, *motd);
    }
@@ -424,14 +436,15 @@ int bootstrap_from_config(char *cfg_file_path, DHT *dht, int enable_ipv6)
        }
        // Process settings
-        if (strlen(bs_public_key) != crypto_box_PUBLICKEYBYTES*2) {
+        if (strlen(bs_public_key) != crypto_box_PUBLICKEYBYTES * 2) {
            syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %s. Skipping the node.\n", i, NAME_PUBLIC_KEY,
                   bs_public_key);
            goto next;
        }
        if (bs_port < MIN_ALLOWED_PORT || bs_port > MAX_ALLOWED_PORT) {
-            syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %d, should be in [%d, %d]. Skipping the node.\n", i, NAME_PORT, bs_port, MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
+            syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %d, should be in [%d, %d]. Skipping the node.\n", i, NAME_PORT,
+                   bs_port, MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
            goto next;
        }
@@ -464,7 +477,7 @@ next:
 void print_public_key(uint8_t *public_key)
 {
-    char buffer[2*crypto_box_PUBLICKEYBYTES + 1];
+    char buffer[2 * crypto_box_PUBLICKEYBYTES + 1];
    int index = 0;
    int i;
@@ -500,7 +513,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_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);
@@ -513,8 +527,11 @@ int main(int argc, char *argv[])
    }
    // Check if the PID file exists
-    if (fopen(pid_file_path, "r")) {
+    FILE *pid_file;
+    if (pid_file = fopen(pid_file_path, "r")) {
        syslog(LOG_ERR, "Another instance of the daemon is already running, PID file %s exists.\n", pid_file_path);
+        fclose(pid_file);
    }
    IP ip;
@@ -536,12 +553,13 @@ int main(int argc, char *argv[])
    }
    if (enable_motd) {
-        if (bootstrap_set_callbacks(dht->net, DAEMON_VERSION_NUMBER, (uint8_t*)motd, strlen(motd) + 1) == 0) {
+        if (bootstrap_set_callbacks(dht->net, DAEMON_VERSION_NUMBER, (uint8_t *)motd, strlen(motd) + 1) == 0) {
            syslog(LOG_DEBUG, "Set MOTD successfully.\n");
        } else {
            syslog(LOG_ERR, "Couldn't set MOTD: %s. Exiting.\n", motd);
            return 1;
        }
        free(motd);
    }
@@ -560,7 +578,8 @@ int main(int argc, char *argv[])
            return 1;
        }
-        tcp_server = new_TCP_server(enable_ipv6, tcp_relay_port_count, tcp_relay_ports, dht->self_public_key, dht->self_secret_key, onion);
+        tcp_server = new_TCP_server(enable_ipv6, tcp_relay_port_count, tcp_relay_ports, dht->self_public_key,
+                                    dht->self_secret_key, onion);
        // tcp_relay_port_count != 0 at this point
        free(tcp_relay_ports);
@@ -596,17 +615,18 @@ int main(int argc, char *argv[])
    // Fork off from the parent process
    pid_t pid = fork();
-    if (pid < 0) {
-        fclose(pidf);
-        syslog(LOG_ERR, "Forking failed. Exiting.\n");
-        return 1;
-    }
    if (pid > 0) {
        fprintf(pidf, "%d ", pid);
        fclose(pidf);
        syslog(LOG_DEBUG, "Forked successfully: PID: %d.\n", pid);
        return 0;
+    } else {
+        fclose(pidf);
+    }
+    if (pid < 0) {
+        syslog(LOG_ERR, "Forking failed. Exiting.\n");
+        return 1;
    }
    // Change the file mode mask
diff --git a/other/fun/cracker.c b/other/fun/cracker.c
index 7b7000de..843b9359 100644
--- a/other/fun/cracker.c
+++ b/other/fun/cracker.c
@@ -17,7 +17,7 @@
 #include <randombytes.h>
 /* Sodium include*/
-//#include <libsodium.h>
+//#include <sodium.h>
 void print_key(uint8_t *client_id)
 {
diff --git a/other/fun/sign.c b/other/fun/sign.c
index eaea9d6a..56a9d1e2 100644
--- a/other/fun/sign.c
+++ b/other/fun/sign.c
@@ -36,6 +36,7 @@ int load_file(char *filename, char **result)
    if (size != fread(*result, sizeof(char), size, f)) {
        free(*result);
+        fclose(f);
        return -2; // -2 means file reading fail
    }
diff --git a/other/fun/strkey.c b/other/fun/strkey.c
new file mode 100644
index 00000000..7e5a1e1c
--- /dev/null
+++ b/other/fun/strkey.c
@@ -0,0 +1,137 @@
+/* strkey -- String in Public Key
+ *
+ * Generates Tox's key pairs, checking if a certain string is in the public key.
+ *
+ * Requires sodium or nacl library.
+ *
+ * There seem to be some problems with the code working on Windows -- it works
+ * when built in debug mode with MinGW 4.8, but it doesn't work correctly when
+ * built in release.
+ *
+ * Usage: strkey <offset> <string>
+ *
+ * Offset - an integer specifying exact byte offset position of the string you
+ * are looking for within a public key. When offset is negative, the program
+ * just looks for the desired string being somewhere, doesn't matter where, in
+ * the public key.
+ *
+ * String - a hex string that you want to have in your public key. It must have
+ * an even number of letters, since every two hexes map to a single byte of
+ * the public key.
+ *
+ * Examples:
+ *   strkey 0 0123
+ *   Looks for a public key that begins with "0123".
+ *
+ *   strkey 1 0123
+ *   Looks for a public key that has "0123" starting at its second byte, i.e. "XX0123...".
+ *
+ *   strkey 2 0123
+ *   Looks for a public key that has "0123" starting at its third byte, i.e. "XXXX0123...".
+ *   (each two hexes represent a single byte of a public key)
+ *
+ *   strkey -1 AF57CC
+ *   Looks for a public key that contains "AF57CC", regardless of its position.
+ *
+ * To compile with gcc and sodium: gcc strkey.c -o strkey -lsodium
+*/
+#include <stdio.h>
+#include <string.h>
+#include <sodium.h>
+#define PRINT_TRIES_COUNT
+void print_key(unsigned char *key)
+{
+    size_t i;
+    for (i = 0; i < crypto_box_PUBLICKEYBYTES; i++) {
+        if (key[i] < 16) {
+            fprintf(stdout, "0");
+        }
+        fprintf(stdout, "%hhX", key[i]);
+    }
+}
+int main(int argc, char *argv[])
+{
+    unsigned char public_key[crypto_box_PUBLICKEYBYTES]; // null terminator
+    unsigned char secret_key[crypto_box_SECRETKEYBYTES];
+    int offset = 0;
+    size_t len;
+    unsigned char desired_bin[crypto_box_PUBLICKEYBYTES]; // null terminator
+    if (argc == 3) {
+        offset = atoi(argv[1]);
+        char *desired_hex = argv[2];
+        len = strlen(desired_hex);
+        if (len % 2 != 0) {
+            fprintf(stderr, "Desired key should have an even number of letters\n");
+            exit(1);
+        }
+        size_t block_length = (offset < 0 ? 0 : offset) + len/2;
+        if (block_length > crypto_box_PUBLICKEYBYTES) {
+            fprintf(stderr, "The given key with the given offset exceed public key's length\n");
+            exit(1);
+        }
+        // convert hex to bin
+        char *pos = desired_hex;
+        size_t i;
+        for (i = 0; i < len; pos += 2) {
+            sscanf(pos, "%2hhx", &desired_bin[i]);
+            ++i;
+        }
+    } else {
+        fprintf(stdout, "Usage: executable <byte offset> <desired hex string with even number of letters>\n");
+        exit(1);
+    }
+    len /= 2;
+#ifdef PRINT_TRIES_COUNT
+    long long unsigned int tries = 0;
+#endif
+    if (offset < 0) {
+        int found = 0;
+        do {
+#ifdef PRINT_TRIES_COUNT
+            tries ++;
+#endif
+            crypto_box_keypair(public_key, secret_key);
+            int i;
+            for (i = 0; i <= crypto_box_PUBLICKEYBYTES - len; i ++) {
+                if (memcmp(public_key + i, desired_bin, len) == 0) {
+                    found = 1;
+                    break;
+                }
+            }
+        } while (!found);
+    } else {
+        unsigned char *p = public_key + offset;
+        do {
+#ifdef PRINT_TRIES_COUNT
+            tries ++;
+#endif
+            crypto_box_keypair(public_key, secret_key);
+        } while (memcmp(p, desired_bin, len) != 0);
+    }
+    fprintf(stdout, "Public key:  ");
+    print_key(public_key);
+    fprintf(stdout, "\n");
+    fprintf(stdout, "Private key: ");
+    print_key(secret_key);
+    fprintf(stdout, "\n");
+#ifdef PRINT_TRIES_COUNT
+        fprintf(stdout, "Found the key pair on %llu try.\n", tries);
+#endif
+    return 0;
+}
diff --git a/testing/Messenger_test.c b/testing/Messenger_test.c
index 7c1d64e7..905bcef4 100644
--- a/testing/Messenger_test.c
+++ b/testing/Messenger_test.c
@@ -56,7 +56,7 @@
 #endif
-void print_message(Messenger *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_message(Messenger *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    printf("Message with length %u received from %u: %s \n", length, friendnumber, string);
    m_sendmessage(m, friendnumber, (uint8_t *)"Test1", 6);
diff --git a/testing/dns3_test.c b/testing/dns3_test.c
index 69649f50..7052aae7 100644
--- a/testing/dns3_test.c
+++ b/testing/dns3_test.c
@@ -2,8 +2,45 @@
 #include "../toxdns/toxdns.h"
 #include "../toxcore/tox.h"
+#include "../toxcore/network.h"
 #include "misc_tools.c"
+#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
+#define c_sleep(x) Sleep(1*x)
+#else
+#define c_sleep(x) usleep(1000*x)
+#endif
+uint32_t create_packet(uint8_t *packet, uint8_t *string, uint8_t str_len, uint8_t id)
+{
+    memset(packet, 0, str_len + 13 + 16);
+    packet[0] = id;
+    packet[1] = rand();
+    packet[5] = 1;
+    packet[11] = 1;
+    packet[12] = '.';
+    memcpy(packet + 13, string, str_len);
+    uint32_t i, c = 0;
+    for (i = str_len + 12; i != 11; --i) {
+        if (packet[i] == '.') {
+            packet[i] = c;
+            c = 0;
+        } else {
+            ++c;
+        }
+    }
+    packet[str_len + 13 + 2] = 16;
+    packet[str_len + 13 + 4] = 1;
+    packet[str_len + 13 + 7] = 0x29;
+    packet[str_len + 13 + 8] = 16;
+    packet[str_len + 13 + 12] = 0x80;
+    return str_len + 13 + 16;
+}
 int main(int argc, char *argv[])
 {
@@ -13,6 +50,22 @@ int main(int argc, char *argv[])
        exit(0);
    }
+    IP ip = {0};
+    ip.family = AF_INET;
+    sock_t sock = socket(ip.family, SOCK_DGRAM, IPPROTO_UDP);
+    if (!sock_valid(sock))
+        return -1;
+    if (!addr_resolve_or_parse_ip(argv[1], &ip, 0))
+        return -1;
+    struct sockaddr_in target;
+    size_t addrsize = sizeof(struct sockaddr_in);
+    target.sin_family = AF_INET;
+    target.sin_addr = ip.ip4.in_addr;
+    target.sin_port = htons(53);
    uint8_t string[1024] = {0};
    void *d = tox_dns3_new(hex_string_to_bin(argv[2]));
    unsigned int i;
@@ -30,13 +83,24 @@ int main(int argc, char *argv[])
    string[0] = '_';
    memcpy(string + len + 1, "._tox.", sizeof("._tox."));
    memcpy((char *)(string + len + 1 + sizeof("._tox.") - 1), argv[1], strlen(argv[1]));
-    printf("Do a DNS request and find the TXT record for:\n%s\nThen paste the contents of the data contained in the id field here:\n",
+    uint8_t packet[512];
-           string);
+    uint8_t id = rand();
+    uint32_t p_len = create_packet(packet, string, strlen((char *)string), id);
+    if (sendto(sock, (char *) packet, p_len, 0, (struct sockaddr *)&target, addrsize) != p_len)
+        return -1;
+    uint8_t buffer[512] = {};
+    int r_len = recv(sock, buffer, sizeof(buffer), 0);
+    if (r_len < (int)p_len)
+        return -1;
+    for (i = r_len - 1; i != 0 && buffer[i] != '='; --i);
-    scanf("%s", string);
    uint8_t tox_id[TOX_FRIEND_ADDRESS_SIZE];
-    if (tox_decrypt_dns3_TXT(d, tox_id, string, strlen((char *)string), request_id) != 0)
+    if (tox_decrypt_dns3_TXT(d, tox_id, buffer + i + 1, r_len - (i + 1), request_id) != 0)
        return -1;
    printf("The Tox id for username %s is:\n", argv[3]);
diff --git a/testing/nTox.c b/testing/nTox.c
index 0145c6ee..971a2571 100644
--- a/testing/nTox.c
+++ b/testing/nTox.c
@@ -531,11 +531,11 @@ void line_eval(Tox *m, char *line)
                }
            }
        } else if (inpt_command == 't') {
-            char msg[512];
            char *posi[1];
            int friendnum = strtoul(line + prompt_offset, posi, 0);
            if (**posi != 0) {
+                char msg[512];
                sprintf(msg, "[t] Sending file %s to friendnum %u filenumber is %i (-1 means failure)", *posi + 1, friendnum,
                        add_filesender(m, friendnum, *posi + 1));
                new_lines(msg);
@@ -634,7 +634,7 @@ void line_eval(Tox *m, char *line)
 * otherwise turns spaces into newlines if possible */
 void wrap(char output[STRING_LENGTH_WRAPPED], char input[STRING_LENGTH], int line_width)
 {
-    size_t i, k, m, len = strlen(input);
+    size_t i, len = strlen(input);
    if ((line_width < 4) || (len < (size_t)line_width)) {
        /* if line_width ridiculously tiny, it's not worth the effort */
@@ -652,8 +652,8 @@ void wrap(char output[STRING_LENGTH_WRAPPED], char input[STRING_LENGTH], int lin
    for (i = line_width; i < len; i += line_width) {
        /* look backward for a space to expand/turn into a new line */
-        k = i;
+        size_t k = i;
-        m = i - line_width;
+        size_t m = i - line_width;
        while (input[k] != ' ' && k > m) {
            k--;
@@ -837,7 +837,6 @@ void do_refresh()
 {
    int count = 0;
    char wrap_output[STRING_LENGTH_WRAPPED];
-    int L;
    int i;
    for (i = 0; i < HISTORY; i++) {
@@ -846,7 +845,7 @@ void do_refresh()
        else
            wrap(wrap_output, lines[i], x);
-        L = count_lines(wrap_output);
+        int L = count_lines(wrap_output);
        count = count + L;
        if (count < y) {
@@ -877,14 +876,16 @@ void print_request(Tox *m, const uint8_t *public_key, const uint8_t *data, uint1
    do_refresh();
 }
-void print_message(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_message(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    /* ensure null termination */
-    string[length - 1] = 0;
+    uint8_t null_string[length + 1];
-    print_formatted_message(m, (char *)string, friendnumber, 0);
+    memcpy(null_string, string, length);
+    null_string[length] = 0;
+    print_formatted_message(m, (char *)null_string, friendnumber, 0);
 }
-void print_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_nickchange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    char name[TOX_MAX_NAME_LENGTH + 1];
@@ -900,7 +901,7 @@ void print_nickchange(Tox *m, int friendnumber, uint8_t *string, uint16_t length
    }
 }
-void print_statuschange(Tox *m, int friendnumber, uint8_t *string, uint16_t length, void *userdata)
+void print_statuschange(Tox *m, int friendnumber, const uint8_t *string, uint16_t length, void *userdata)
 {
    char name[TOX_MAX_NAME_LENGTH + 1];
@@ -921,11 +922,10 @@ static char *data_file_name = NULL;
 static int load_data(Tox *m)
 {
    FILE *data_file = fopen(data_file_name, "r");
-    size_t size = 0;
    if (data_file) {
        fseek(data_file, 0, SEEK_END);
-        size = ftell(data_file);
+        size_t size = ftell(data_file);
        rewind(data_file);
        uint8_t data[size];
@@ -1001,7 +1001,7 @@ 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, uint8_t *group_public_key, void *userdata)
+void print_invite(Tox *m, int friendnumber, const uint8_t *group_public_key, void *userdata)
 {
    char msg[256];
    sprintf(msg, "[i] received group chat invite from: %u, auto accepting and joining. group number: %u", friendnumber,
@@ -1057,7 +1057,8 @@ void print_groupchatpeers(Tox *m, int groupnumber)
    new_lines_mark(msg, 1);
 }
-void print_groupmessage(Tox *m, int groupnumber, int peernumber, uint8_t *message, uint16_t length, void *userdata)
+void print_groupmessage(Tox *m, int groupnumber, int peernumber, const uint8_t *message, uint16_t length,
+                        void *userdata)
 {
    char msg[256 + length];
    uint8_t name[TOX_MAX_NAME_LENGTH] = {0};
@@ -1118,7 +1119,7 @@ void print_groupnamelistchange(Tox *m, int groupnumber, int peernumber, uint8_t
        print_groupchatpeers(m, groupnumber);
    }
 }
-void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename,
+void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, const uint8_t *filename,
                         uint16_t filename_length, void *userdata)
 {
    char msg[512];
@@ -1133,8 +1134,7 @@ void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t
 }
 void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t filenumber, uint8_t control_type,
-                        uint8_t *data,
+                        const uint8_t *data, uint16_t length, void *userdata)
-                        uint16_t length, void *userdata)
 {
    char msg[512] = {0};
@@ -1148,7 +1148,7 @@ void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t
    new_lines(msg);
 }
-void write_file(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length, void *userdata)
 {
    char filename[256];
    sprintf(filename, "%u.%u.bin", friendnumber, filenumber);
@@ -1215,7 +1215,6 @@ int main(int argc, char *argv[])
        exit(1);
    int on = 0;
-    int c = 0;
    char *filename = "data";
    char idstring[200] = {0};
    Tox *m;
@@ -1282,8 +1281,6 @@ int main(int argc, char *argv[])
    time_t timestamp0 = time(NULL);
-    uint8_t pollok = 0;
    while (1) {
        if (on == 0) {
            if (tox_isconnected(m)) {
@@ -1305,7 +1302,7 @@ int main(int argc, char *argv[])
        tox_do(m);
        do_refresh();
-        c = timeout_getch(m);
+        int c = timeout_getch(m);
        if (c == ERR || c == 27)
            continue;
diff --git a/testing/tox_sync.c b/testing/tox_sync.c
index 68cad9f4..523f2c56 100644
--- a/testing/tox_sync.c
+++ b/testing/tox_sync.c
@@ -130,7 +130,7 @@ int not_sending()
 static char path[1024];
-void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename,
+void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t filesize, const uint8_t *filename,
                         uint16_t filename_length, void *userdata)
 {
    char fullpath[1024];
@@ -169,7 +169,7 @@ void file_request_accept(Tox *m, int friendnumber, uint8_t filenumber, uint64_t
 }
 void file_print_control(Tox *m, int friendnumber, uint8_t recieve_send, uint8_t filenumber, uint8_t control_type,
-                        uint8_t *data,
+                        const uint8_t *data,
                        uint16_t length, void *userdata)
 {
    if (recieve_send == 1 && (control_type == TOX_FILECONTROL_KILL || control_type == TOX_FILECONTROL_FINISHED)) {
@@ -185,7 +185,7 @@ void file_print_control(Tox *m, int friendnumber, uint8_t recieve_send, uint8_t
    }
 }
-void write_file(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
+void write_file(Tox *m, int friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length, void *userdata)
 {
    if (file_recv[filenumber].file != 0)
        if (fwrite(data, length, 1, file_recv[filenumber].file) != 1)
diff --git a/toxav/Makefile.inc b/toxav/Makefile.inc
index 50e2564c..de8ef8ff 100644
--- a/toxav/Makefile.inc
+++ b/toxav/Makefile.inc
@@ -4,14 +4,12 @@ lib_LTLIBRARIES += libtoxav.la
 libtoxav_la_include_HEADERS = ../toxav/toxav.h
 libtoxav_la_includedir = $(includedir)/tox
-libtoxav_la_SOURCES = ../toxav/event.h \
+libtoxav_la_SOURCES = ../toxav/rtp.h \
-                      ../toxav/event.c \
-                      ../toxav/rtp.h \
                      ../toxav/rtp.c \
                      ../toxav/msi.h \
                      ../toxav/msi.c \
-                      ../toxav/media.h \
+                      ../toxav/codec.h \
-                      ../toxav/media.c \
+                      ../toxav/codec.c \
                      ../toxav/toxav.h \
                      ../toxav/toxav.c
diff --git a/toxav/media.c b/toxav/codec.c
index 8b50e301..ae24a976 100644
--- a/toxav/media.c
+++ b/toxav/codec.c
@@ -1,4 +1,4 @@
-/**  media.c
+/**  codec.c
 *
 *   Audio and video codec intitialization, encoding/decoding and playback
 *
@@ -34,7 +34,10 @@
 #include <assert.h>
 #include "rtp.h"
-#include "media.h"
+#include "codec.h"
+const uint16_t min_jbuf_size = 4;
+const uint16_t min_readiness_idx = 2; /* when is buffer ready to dqq */
 int empty_queue(JitterBuffer *q)
 {
@@ -65,7 +68,7 @@ JitterBuffer *create_queue(int capacity)
    }
    q->size = 0;
-    q->capacity = capacity;
+    q->capacity = capacity >= min_jbuf_size ? capacity : min_jbuf_size;
    q->front = 0;
    q->rear = -1;
    q->queue_ready = 0;
@@ -77,8 +80,12 @@ JitterBuffer *create_queue(int capacity)
 void terminate_queue(JitterBuffer *q)
 {
+    if (!q) return;
    empty_queue(q);
    free(q->queue);
+    LOGGER_DEBUG("Terminated jitter buffer: %p", q);
    free(q);
 }
@@ -141,24 +148,21 @@ void queue(JitterBuffer *q, RTPMessage *pk)
        empty_queue(q);
    }
-    if (q->size > 8)
+    if (q->size >= min_readiness_idx) q->queue_ready = 1;
-        q->queue_ready = 1;
    ++q->size;
    ++q->rear;
-    if (q->rear == q->capacity)
+    if (q->rear == q->capacity) q->rear = 0;
-        q->rear = 0;
    q->queue[q->rear] = pk;
    int a;
-    int b;
    int j;
    a = q->rear;
    for (j = 0; j < q->size - 1; ++j) {
-        b = a - 1;
+        int b = a - 1;
        if (b < 0)
            b += q->capacity;
@@ -176,8 +180,7 @@ void queue(JitterBuffer *q, RTPMessage *pk)
        a -= 1;
-        if (a < 0)
+        if (a < 0) a += q->capacity;
-            a += q->capacity;
    }
 }
@@ -207,20 +210,71 @@ int init_audio_decoder(CodecState *cs, uint32_t 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 init_video_encoder(CodecState *cs, uint16_t width, uint16_t height, uint32_t video_bitrate)
+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)
 {
    vpx_codec_enc_cfg_t  cfg;
    int rc = vpx_codec_enc_config_default(VIDEO_CODEC_ENCODER_INTERFACE, &cfg, 0);
-    if (rc) {
+    if (rc != VPX_CODEC_OK) {
        LOGGER_ERROR("Failed to get config: %s", vpx_codec_err_to_string(rc));
        return -1;
    }
    cfg.rc_target_bitrate = video_bitrate;
-    cfg.g_w = width;
+    cfg.g_w = max_width;
-    cfg.g_h = height;
+    cfg.g_h = max_height;
+    cfg.g_pass = VPX_RC_ONE_PASS;
+    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_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);
@@ -229,6 +283,13 @@ int init_video_encoder(CodecState *cs, uint16_t width, uint16_t height, uint32_t
        return -1;
    }
+    rc = vpx_codec_control(&cs->v_encoder, VP8E_SET_CPUUSED, 7);
+    if ( rc != VPX_CODEC_OK) {
+        LOGGER_ERROR("Failed to set encoder control setting: %s", vpx_codec_err_to_string(rc));
+        return -1;
+    }
    return 0;
 }
@@ -265,8 +326,9 @@ CodecState *codec_init_session ( uint32_t audio_bitrate,
                                 uint16_t audio_frame_duration,
                                 uint32_t audio_sample_rate,
                                 uint32_t audio_channels,
-                                 uint16_t video_width,
+                                 uint32_t audio_VAD_tolerance_ms,
-                                 uint16_t video_height,
+                                 uint16_t max_video_width,
+                                 uint16_t max_video_height,
                                 uint32_t video_bitrate )
 {
    CodecState *retu = calloc(sizeof(CodecState), 1);
@@ -277,11 +339,12 @@ CodecState *codec_init_session ( uint32_t audio_bitrate,
    retu->audio_sample_rate = audio_sample_rate;
    /* Encoders */
-    if (!video_width || !video_height) { /* Disable video */
+    if (!max_video_width || !max_video_height) { /* Disable video */
        /*video_width = 320;
        video_height = 240; */
    } else {
-        retu->capabilities |= ( 0 == init_video_encoder(retu, video_width, video_height, video_bitrate) ) ? v_encoding : 0;
+        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;
    }
@@ -293,24 +356,56 @@ CodecState *codec_init_session ( uint32_t audio_bitrate,
        return NULL;
    }
+    retu->EVAD_tolerance = audio_VAD_tolerance_ms > audio_frame_duration ?
+                           audio_VAD_tolerance_ms / audio_frame_duration : audio_frame_duration;
    return retu;
 }
 void codec_terminate_session ( CodecState *cs )
 {
+    if (!cs) return;
    if ( cs->audio_encoder )
        opus_encoder_destroy(cs->audio_encoder);
    if ( cs->audio_decoder )
        opus_decoder_destroy(cs->audio_decoder);
-    /* TODO: Terminate video
-     *           Do what?
-     */
    if ( cs->capabilities & v_decoding )
        vpx_codec_destroy(&cs->v_decoder);
    if ( cs->capabilities & v_encoding )
        vpx_codec_destroy(&cs->v_encoder);
+    LOGGER_DEBUG("Terminated codec state: %p", cs);
+    free(cs);
+}
+inline 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)
+{
+    float frame_energy = sqrt(calculate_sum_sq(PCM, frame_size)) / frame_size;
+    if ( frame_energy > energy) {
+        cs->EVAD_tolerance_cr = cs->EVAD_tolerance; /* Reset counter */
+        return 1;
+    }
+    if ( cs->EVAD_tolerance_cr ) {
+        cs->EVAD_tolerance_cr --;
+        return 1;
+    }
+    return 0;
 }
diff --git a/toxav/media.h b/toxav/codec.h
index 66798351..a464ec8f 100644
--- a/toxav/media.h
+++ b/toxav/codec.h
@@ -1,4 +1,4 @@
-/**  media.h
+/**  codec.h
 *
 *   Audio and video codec intitialization, encoding/decoding and playback
 *
@@ -21,8 +21,8 @@
 *
 */
-#ifndef _AVCODEC_H_
+#ifndef _CODEC_H_
-#define _AVCODEC_H_
+#define _CODEC_H_
 #include <stdio.h>
 #include <math.h>
@@ -46,6 +46,8 @@ typedef enum _Capabilities {
    v_decoding = 1 << 3
 } Capabilities;
+extern const uint16_t min_jbuf_size;
 typedef struct _CodecState {
    /* video encoding */
@@ -54,6 +56,9 @@ typedef struct _CodecState {
    /* video decoding */
    vpx_codec_ctx_t  v_decoder;
+    int bitrate;
+    int max_width;
+    int max_height;
    /* audio encoding */
    OpusEncoder *audio_encoder;
@@ -65,6 +70,9 @@ typedef struct _CodecState {
    uint64_t capabilities; /* supports*/
+    /* Voice activity detection */
+    uint32_t EVAD_tolerance; /* In frames */
+    uint32_t EVAD_tolerance_cr;
 } CodecState;
@@ -90,10 +98,20 @@ CodecState *codec_init_session ( uint32_t audio_bitrate,
                                 uint16_t audio_frame_duration,
                                 uint32_t audio_sample_rate,
                                 uint32_t audio_channels,
+                                 uint32_t audio_VAD_tolerance_ms,
                                 uint16_t video_width,
                                 uint16_t video_height,
-                                 uint32_t video_bitrate );
+                                 uint32_t video_bitrate);
 void codec_terminate_session(CodecState *cs);
-#endif
+/* 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);
+/* 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);
+#endif /* _CODEC_H_ */
diff --git a/toxav/event.c b/toxav/event.c
deleted file mode 100644
index 870abf2a..00000000
--- a/toxav/event.c
+++ /dev/null
@@ -1,382 +0,0 @@
-/**  event.c
- *
- *   Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *   This file is part of Tox.
- *
- *   Tox is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   Tox is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
- *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
- */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
-#include <stdlib.h>
-#include "../toxcore/network.h" /* current_time_monotonic() */
-#include "event.h"
-#define _GNU_SOURCE
-#include <assert.h>
-#include <unistd.h>
-#include <stddef.h>
-#include <inttypes.h>
-#include <pthread.h>
-#include <stdio.h>
-#define RUN_IN_THREAD(func, args) { pthread_t _tid; \
-pthread_create(&_tid, NULL, func, args); assert( pthread_detach(_tid) == 0 ); }
-#define LOCK(event_handler) pthread_mutex_lock (&event_handler->mutex)
-#define UNLOCK(event_handler) pthread_mutex_unlock(&event_handler->mutex)
-#define FREQUENCY 10000
-#define inline__ inline __attribute__((always_inline))
-typedef struct _EventContainer {
-    void *(*func)(void *);
-    void *func_args;
-    unsigned timeout;
-    long long id;
-} EventContainer;
-typedef struct _EventHandler {
-    EventContainer *timed_events;
-    size_t timed_events_count;
-    int running;
-    pthread_mutex_t mutex;
-} EventHandler;
-int throw_event( void *(func)(void *), void *arg );
-int reset_timer_event ( int id, uint32_t timeout );
-int throw_timer_event ( void *(func)(void *), void *arg, unsigned timeout);
-int cancel_timer_event ( int id );
-int execute_timer_event ( int id );
-struct _Event event = {
-    throw_event,
-    /* reset_timer_event */ NULL,
-    throw_timer_event,
-    cancel_timer_event,
-    /*execute_timer_event*/ NULL
-};
-/*
- * Random functions used by this file
- */
-void clear_events (EventContainer **event_container, size_t *counter)
-{
-    free(*event_container );
-    *event_container = NULL;
-    *counter = 0;
-}
-int pop_id ( EventContainer **event_container, size_t *counter, int id )
-{
-    if ( !*event_container || !*counter || !id )
-        return -1;
-    EventContainer *_it = *event_container;
-    int i;
-    for ( i = *counter; i; -- i ) {
-        if ( _it->id == id ) { /* Hit! */
-            break;
-        }
-        ++_it;
-    }
-    if ( i ) {
-        for ( ; i; -- i ) {
-            *_it = *(_it + 1);
-            ++_it;
-        }
-        -- (*counter );
-        if ( !(*counter)) { /* Free and set to NULL */
-            free(*event_container);
-            *event_container = NULL;
-        } else {
-            void *_result = realloc(*event_container, sizeof(EventContainer) * (*counter )); /* resize */
-            if ( _result != NULL ) {
-                *event_container = _result;
-                return 0;
-            } else {
-                /* Not sure what would happen next so abort execution.
-                 */
-                fprintf(stderr, "CRITICAL! Failed to reallocate memory in %s():%d, aborting...", __func__, __LINE__);
-                abort();
-                return -1;
-            }
-        }
-    }
-    /* not found here */
-    return -1;
-}
-void push_event ( EventContainer **container, size_t *counter, void *(func)(void *), void *arg )
-{
-    EventContainer *_new = realloc((*container ), sizeof(EventContainer) * ((*counter ) + 1));
-    if ( _new == NULL ) {
-        /* Not sure what would happen next so abort execution.
-         * TODO: This could notice the calling function
-         *       about realloc failing.
-         */
-        fprintf(stderr, "CRITICAL! Failed to reallocate memory in %s():%d, aborting...", __func__, __LINE__);
-        abort();
-    }
-    _new[*counter].func = func;
-    _new[*counter].func_args = arg;
-    _new[*counter].timeout = 0;
-    _new[*counter].id = 0;
-    (*container) = _new;
-    (*counter )++;
-}
-void reorder_events ( size_t counter, EventContainer *container, unsigned timeout )
-{
-    if ( counter > 1 ) {
-        int i = counter - 1;
-        /* start from behind excluding last added member */
-        EventContainer *_it = &container[i - 1];
-        EventContainer _last_added = container[i];
-        for ( ; i; --i ) {
-            if ( _it->timeout > timeout ) {
-                *(_it + 1) = *_it;
-                *_it = _last_added;
-                -- _it;
-            }
-        }
-    }
-}
-/* ============================================= */
-/* main poll for event execution */
-void *event_poll( void *arg )
-{
-    EventHandler *_event_handler = arg;
-    while ( _event_handler->running ) {
-        LOCK( _event_handler );
-        if ( _event_handler->timed_events ) {
-            uint32_t _time = ((uint32_t)current_time_monotonic());
-            if ( _event_handler->timed_events[0].timeout < _time ) {
-                RUN_IN_THREAD ( _event_handler->timed_events[0].func,
-                                _event_handler->timed_events[0].func_args );
-                pop_id(&_event_handler->timed_events,
-                       &_event_handler->timed_events_count,
-                       _event_handler->timed_events[0].id);
-            }
-        }
-        UNLOCK( _event_handler );
-        usleep(FREQUENCY);
-    }
-    LOCK( _event_handler );
-    clear_events(&_event_handler->timed_events, &_event_handler->timed_events_count);
-    UNLOCK( _event_handler );
-    _event_handler->running = -1;
-    pthread_exit(NULL);
-}
-int throw_event( void *(func)(void *), void *arg )
-{
-    pthread_t _tid;
-    int _rc =
-        pthread_create(&_tid, NULL, func, arg );
-    return (0 != _rc ) ? _rc : pthread_detach(_tid);
-}
-EventHandler event_handler;
-/* Place and order array of timers */
-int throw_timer_event ( void *(func)(void *), void *arg, unsigned timeout)
-{
-    static int _unique_id = 1;
-    push_event(&event_handler.timed_events, &(event_handler.timed_events_count), func, arg );
-    size_t _counter = event_handler.timed_events_count;
-    event_handler.timed_events[_counter - 1].timeout = timeout + ((uint32_t)current_time_monotonic());
-    event_handler.timed_events[_counter - 1].id = _unique_id;
-    ++_unique_id;
-    /* reorder */
-    reorder_events(_counter, event_handler.timed_events, timeout );
-    return _unique_id - 1;
-}
-int execute_timer_event ( int id )
-{
-    int _status;
-    LOCK((&event_handler));
-    EventContainer *_it = event_handler.timed_events;
-    int _i = event_handler.timed_events_count;
-    /* Find it and execute */
-    for ( ; _i; _i-- ) {
-        if ( _it->id == id ) {
-            RUN_IN_THREAD ( _it->func, _it->func_args );
-            break;
-        }
-        ++_it;
-    }
-    /* Now remove it from the queue */
-    if ( _i ) {
-        for ( ; _i; -- _i ) {
-            *_it = *(_it + 1);
-            ++_it;
-        }
-        -- event_handler.timed_events_count;
-        if ( !event_handler.timed_events_count ) { /* Free and set to null */
-            free(event_handler.timed_events);
-            event_handler.timed_events = NULL;
-        } else {
-            void *_result = realloc(event_handler.timed_events,
-                                    sizeof(EventContainer) * event_handler.timed_events_count); /* resize */
-            if ( _result != NULL ) {
-                event_handler.timed_events = _result;
-            } else {
-                /* Not sure what would happen next so abort execution.
-                */
-                fprintf(stderr, "CRITICAL! Failed to reallocate memory in %s():%d, aborting...", __func__, __LINE__);
-                abort();
-                return -1;
-            }
-        }
-        _status = 0;
-    } else _status = -1;
-    UNLOCK((&event_handler));
-    return _status;
-}
-int reset_timer_event ( int id, uint32_t timeout )
-{
-    int _status;
-    LOCK((&event_handler));
-    EventContainer *_it = event_handler.timed_events;
-    int _i = event_handler.timed_events_count;
-    /* Find it and change */
-    for ( ; _i; _i-- ) {
-        if ( _it->id == id ) {
-            _it->timeout = timeout + ((uint32_t)current_time_monotonic());
-            break;
-        }
-        ++_it;
-    }
-    _status = _i ? -1 : 0;
-    UNLOCK((&event_handler));
-    return _status;
-}
-/* Remove timer from array */
-inline__ int cancel_timer_event ( int id )
-{
-    return pop_id (&event_handler.timed_events, &event_handler.timed_events_count, id );
-}
-/* Initialization and termination of event polls
- * This will be run at the beginning and the end of the program execution.
- * I think that's the best way to do it.
- */
-void __attribute__((constructor)) init_event_poll ()
-{
-    event_handler.timed_events = NULL;
-    event_handler.timed_events_count = 0;
-    event_handler.running = 1;
-    pthread_mutex_init(&event_handler.mutex, NULL);
-    RUN_IN_THREAD(event_poll, &event_handler);
-}
-/* NOTE: Do we need this? */
-void __attribute__((destructor)) terminate_event_poll()
-{
-    /* Exit thread */
-    event_handler.running = 0;
-    /* Give it enought time to exit */
-    usleep(FREQUENCY * 2);
-    pthread_mutex_destroy( &event_handler.mutex );
-}
-\ No newline at end of file
diff --git a/toxav/event.h b/toxav/event.h
deleted file mode 100644
index f9e67543..00000000
--- a/toxav/event.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/**  event.h
- *
- *   Copyright (C) 2013 Tox project All Rights Reserved.
- *
- *   This file is part of Tox.
- *
- *   Tox is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   Tox is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
- *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
- */
-#ifndef __TOXEVENT
-#define __TOXEVENT
-/**
- * - Events are, in fact, ran in their own threads upon execution.
- * - Event handler is initialized at the start, before the main() function
- *      and terminated after it's execution.
- * - Timers are checked for timeout every ~10000 ns.
- * - Timers can be canceled or ran immediately via
- *      timer_release() or timer_now() functions.
- * - Timeout is measured in milliseconds.
- *
- * NOTE: timer_reset () and timer_now() are not tested nor usable atm
- *
- */
-extern struct _Event {
-    int (*rise) (void *( func ) ( void *), void *arg);
-    int (*timer_reset ) ( int id, unsigned timeout );
-    int (*timer_alloc) (void *( func ) ( void *), void *arg, unsigned timeout);
-    int (*timer_release) (int id);
-    int (*timer_now) ( int id );
-} event;
-#endif /* _MSI__EVENT_H_ */
diff --git a/toxav/msi.c b/toxav/msi.c
index 8476c5be..88f62ebd 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
@@ -30,13 +28,11 @@
 #include "../toxcore/util.h"
 #include "msi.h"
-#include "event.h"
-#include <assert.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #define same(x, y) strcmp((const char*) x, (const char*) y) == 0
@@ -86,8 +82,6 @@ GENERIC_HEADER ( CallType )
 GENERIC_HEADER ( CallId )
 GENERIC_HEADER ( Info )
 GENERIC_HEADER ( Reason )
-GENERIC_HEADER ( CryptoKey )
-GENERIC_HEADER ( Nonce )
 /**
@@ -104,8 +98,6 @@ typedef struct _MSIMessage {
    MSIHeaderInfo      info;
    MSIHeaderReason    reason;
    MSIHeaderCallId    callid;
-    MSIHeaderCryptoKey cryptokey;
-    MSIHeaderNonce     nonce;
    struct _MSIMessage *next;
@@ -117,11 +109,10 @@ typedef struct _MSIMessage {
 static struct _Callbacks {
    MSICallback function;
    void *data;
-} callbacks[11] = {0};
+} callbacks[11] = {{0}};
 inline__ void invoke_callback(int32_t call_index, MSICallbackID id)
 {
-    /*if ( callbacks[id].function ) event.rise ( callbacks[id].function, callbacks[id].data );*/
    if ( callbacks[id].function ) {
        LOGGER_DEBUG("Invoking callback function: %d", id);
        callbacks[id].function ( call_index, callbacks[id].data );
@@ -139,8 +130,6 @@ inline__ void invoke_callback(int32_t call_index, MSICallbackID id)
 #define REASON_FIELD       "Reason"
 #define CALLTYPE_FIELD     "Call-type"
 #define CALLID_FIELD       "Call-id"
-#define CRYPTOKEY_FIELD    "Crypto-key"
-#define NONCE_FIELD        "Nonce"
 /* protocol descriptors */
 #define end_byte    0x0
@@ -228,7 +217,8 @@ if ( *iterator != value_byte || size_con <= type_size_const) { return -1; } size
 iterator ++; if(size_con <= 3) {return -1;} size_con -= 3; \
 uint16_t _value_size; memcpy(&_value_size, iterator, sizeof(_value_size)); _value_size = ntohs(_value_size);\
 if(size_con < _value_size) { return -1; } size_con -= _value_size; \
-header.header_value = calloc(sizeof(uint8_t), _value_size); \
+if ( !(header.header_value = calloc(sizeof(uint8_t), _value_size)) ) \
+LOGGER_ERROR("Allocation failed! Program might misbehave!"); \
 header.size = _value_size; \
 memcpy(header.header_value, iterator + 2, _value_size);\
 iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte */ }
@@ -259,18 +249,13 @@ iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte
            _it += 3; /* place it at the field value beginning */
            size_max -= 3;
-            switch ( _size ) { /* Compare the size of the hardcoded values ( vary fast and convenient ) */
+            switch ( _size ) { /* Compare the size of the hardcoded values ( very convenient ) */
                case 4: { /* INFO header */
                    if ON_HEADER ( _it, size_max, msg->info, INFO_FIELD, 4 )
                    }
                break;
-                case 5: { /* NONCE header */
-                    if ON_HEADER ( _it, size_max, msg->nonce, NONCE_FIELD, 5 )
-                    }
-                break;
                case 6: { /* Reason header */
                    if ON_HEADER ( _it, size_max, msg->reason, REASON_FIELD, 6 )
                    }
@@ -293,11 +278,6 @@ iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte
                    }
                break;
-                case 10: { /* Crypto-key headers */
-                    if ON_HEADER ( _it, size_max, msg->cryptokey, CRYPTOKEY_FIELD, 10 )
-                    }
-                break;
                default:
                    LOGGER_ERROR("Unkown field value");
                    return -1;
@@ -316,8 +296,8 @@ iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte
 #define ALLOCATE_HEADER( var, mheader_value, t_size) \
-var.header_value = calloc(sizeof *mheader_value, t_size); \
+if (!(var.header_value = calloc(sizeof *mheader_value, t_size))) \
-if (var.header_value == NULL) { LOGGER_WARNING("Header allocation failed!"); } \
+{ LOGGER_WARNING("Header allocation failed! Program might misbehave!"); } \
 else { memcpy(var.header_value, mheader_value, t_size); \
 var.size = t_size; }
@@ -340,8 +320,6 @@ void free_message ( MSIMessage *msg )
    free ( msg->response.header_value );
    free ( msg->version.header_value );
    free ( msg->info.header_value );
-    free ( msg->cryptokey.header_value );
-    free ( msg->nonce.header_value );
    free ( msg->reason.header_value );
    free ( msg->callid.header_value );
@@ -362,7 +340,7 @@ MSIMessage *msi_new_message ( uint8_t type, const uint8_t *type_id )
    MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
    if ( _retu == NULL ) {
-        LOGGER_WARNING("Allocation failed!");
+        LOGGER_WARNING("Allocation failed! Program might misbehave!");
        return NULL;
    }
@@ -400,7 +378,7 @@ MSIMessage *parse_message ( const uint8_t *data, uint16_t length )
    MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
    if ( _retu == NULL ) {
-        LOGGER_WARNING("Allocation failed!");
+        LOGGER_WARNING("Allocation failed! Program might misbehave!");
        return NULL;
    }
@@ -423,43 +401,6 @@ MSIMessage *parse_message ( const uint8_t *data, uint16_t length )
 }
-/**
- * @brief Makes clear message presentation
- *
- * @param msg Message
- * @param dest Dest string
- * @return int
- */
-int stringify_message(MSIMessage *msg, char *dest)
-{
-#define HDR_TO_STR(__dest, __hdr) if (__hdr.header_value) {\
-    char nltstr[MSI_MAXMSG_SIZE]; memset(nltstr, '\0', MSI_MAXMSG_SIZE); int i = 0; \
-    for ( ; i < __hdr.size; i ++) nltstr[i] = (char)__hdr.header_value[i]; \
-    }
-    if ( !msg || !dest )
-        return -1;
-    HDR_TO_STR(dest, msg->version);
-    HDR_TO_STR(dest, msg->request);
-    HDR_TO_STR(dest, msg->response);
-    HDR_TO_STR(dest, msg->reason);
-    HDR_TO_STR(dest, msg->callid);
-    HDR_TO_STR(dest, msg->calltype);
-    HDR_TO_STR(dest, msg->cryptokey);
-    HDR_TO_STR(dest, msg->nonce);
-//     if (msg->version.header_value) {
-//         U8_TO_NLTCHAR(msg->version.header_value, msg->version.size, nltstr, MSI_MAXMSG_SIZE);
-//         sprintf(dest, "Version: %s\n", nltstr);
-//     }
-    return 0;
-}
 /**
 * @brief Speaks for it self.
 *
@@ -479,7 +420,7 @@ uint8_t *append_header_to_string (
 {
    if ( dest == NULL ) {
        LOGGER_ERROR("No destination space!");
-        assert(dest);
+        return NULL;
    }
    if (header_value == NULL) {
@@ -574,8 +515,6 @@ uint16_t message_to_send ( MSIMessage *msg, uint8_t *dest )
    CLEAN_ASSIGN ( _size, _iterated, INFO_FIELD, msg->info );
    CLEAN_ASSIGN ( _size, _iterated, CALLID_FIELD, msg->callid );
    CLEAN_ASSIGN ( _size, _iterated, REASON_FIELD, msg->reason );
-    CLEAN_ASSIGN ( _size, _iterated, CRYPTOKEY_FIELD, msg->cryptokey );
-    CLEAN_ASSIGN ( _size, _iterated, NONCE_FIELD, msg->nonce );
    *_iterated = end_byte;
    _size ++;
@@ -586,7 +525,7 @@ uint16_t message_to_send ( MSIMessage *msg, uint8_t *dest )
 #define GENERIC_SETTER_DEFINITION(header) \
 void msi_msg_set_##header ( MSIMessage* _msg, const uint8_t* header_value, uint16_t _size ) \
-{ assert(_msg); assert(header_value); \
+{ if ( !_msg || !header_value) { LOGGER_WARNING("No setter values!"); return; } \
  free(_msg->header.header_value); \
  ALLOCATE_HEADER( _msg->header, header_value, _size )}
@@ -594,10 +533,259 @@ GENERIC_SETTER_DEFINITION ( calltype )
 GENERIC_SETTER_DEFINITION ( reason )
 GENERIC_SETTER_DEFINITION ( info )
 GENERIC_SETTER_DEFINITION ( callid )
-GENERIC_SETTER_DEFINITION ( cryptokey )
-GENERIC_SETTER_DEFINITION ( nonce )
+typedef struct _Timer {
+    void *(*func)(void *);
+    void *func_arg1;
+    int func_arg2;
+    uint64_t timeout;
+    size_t idx;
+} Timer;
+typedef struct _TimerHandler {
+    Timer **timers;
+    pthread_mutex_t mutex;
+    size_t max_capacity;
+    size_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
+ */
+int timer_alloc ( TimerHandler *timers_container, void *(func)(void *), void *arg1, int arg2, unsigned timeout)
+{
+    static int timer_id;
+    pthread_mutex_lock(&timers_container->mutex);
+    int i = 0;
+    for (; i < timers_container->max_capacity && timers_container->timers[i]; i ++);
+    if (i == timers_container->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);
+    if (timer == NULL) {
+        LOGGER_ERROR("Failed to allocate timer!");
+        pthread_mutex_unlock(&timers_container->mutex);
+        return -1;
+    }
+    timers_container->size ++;
+    timer->func = func;
+    timer->func_arg1 = arg1;
+    timer->func_arg2 = arg2;
+    timer->timeout = timeout + current_time_monotonic(); /* In ms */
+    ++timer_id;
+    timer->idx = timer_id;
+    /* reorder */
+    if (i) {
+        int 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;
+        }
+    }
+    pthread_mutex_unlock(&timers_container->mutex);
+    LOGGER_DEBUG("Allocated timer index: %d timeout: %d, current size: %d", i, timeout, timers_container->size);
+    return timer->idx;
+}
+/**
+ * @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
+ */
+int timer_release ( TimerHandler *timers_container, int idx , int lock_mutex)
+{
+    if (lock_mutex)
+        pthread_mutex_lock(&timers_container->mutex);
+    Timer **timed_events = timers_container->timers;
+    int i, res = -1;
+    for (i = 0; i < timers_container->max_capacity; ++i) {
+        if (timed_events[i] && timed_events[i]->idx == idx) {
+            res = i;
+            break;
+        }
+    }
+    if (res == -1) {
+        LOGGER_WARNING("No event with id: %d", idx);
+        if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
+        return -1;
+    }
+    free(timed_events[res]);
+    timed_events[res] = NULL;
+    i = res + 1;
+    for (; i < timers_container->max_capacity && timed_events[i]; i ++) {
+        timed_events[i - 1] = timed_events[i];
+        timed_events[i] = NULL;
+    }
+    timers_container->size--;
+    LOGGER_DEBUG("Popped index: %d, current size: %d ", idx, timers_container->size);
+    if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
+    return 0;
+}
+/**
+ * @brief Main poll for timer execution
+ *
+ * @param arg ...
+ * @return void*
+ */
+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();
+            if ( 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*
+ */
+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
+ */
+void timer_terminate_session(TimerHandler *handler)
+{
+    pthread_mutex_lock(&handler->mutex);
+    handler->running = 0;
+    pthread_mutex_unlock(&handler->mutex);
+    int 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.
 *
@@ -605,7 +793,7 @@ GENERIC_SETTER_DEFINITION ( nonce )
 * @param size Size of string.
 * @return void
 */
-void t_randomstr ( uint8_t *str, size_t size )
+void t_randomstr ( uint8_t *str, uint32_t size )
 {
    if (str == NULL) {
        LOGGER_DEBUG("Empty destination!");
@@ -617,7 +805,7 @@ void t_randomstr ( uint8_t *str, size_t size )
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
-    size_t _it = 0;
+    uint32_t _it = 0;
    for ( ; _it < size; _it++ ) {
        str[_it] = _bytes[ random_int() % 61 ];
@@ -626,7 +814,8 @@ void t_randomstr ( uint8_t *str, size_t size )
 typedef enum {
-    error_deadcall = 1,  /* has call id but it's from old call */
+    error_none,
+    error_deadcall,      /* has call id but it's from old call */
    error_id_mismatch,   /* non-existing call */
    error_no_callid,     /* not having call id */
@@ -704,14 +893,6 @@ int send_message ( MSISession *session, MSICall *call, MSIMessage *msg, uint32_t
        return -1;
    }
-    /*
-    LOGGER_SCOPE(
-        char cast[MSI_MAXMSG_SIZE];
-        stringify_message(msg, cast);
-        LOGGER_DEBUG("[Call: %s] [to: %u] Sending message: len: %d\n%s", call->id, to, _length, cast);
-    );*/
    if ( m_msi_packet(session->messenger_handle, to, _msg_string_final, _length) ) {
        LOGGER_DEBUG("Sent message");
        return 0;
@@ -732,13 +913,7 @@ int send_message ( MSISession *session, MSICall *call, MSIMessage *msg, uint32_t
 */
 int call_id_bigger( const uint8_t *first, const uint8_t *second)
 {
-    int i = 0;
+    return (memcmp(first, second, CALL_ID_LEN) < 0);
-    for (; i < CALL_ID_LEN; i ++) {
-        if ( first[i] != second[i] )
-            return first[i] > second [i] ? 0 : 1;
-    }
 }
@@ -804,7 +979,11 @@ MSICall *find_call ( MSISession *session, uint8_t *call_id )
    for (; i < session->max_calls; i ++ )
        if ( session->calls[i] && memcmp(session->calls[i]->id, call_id, CALL_ID_LEN) == 0 ) {
-            LOGGER_DEBUG("Found call id: %s", session->calls[i]->id);
+            LOGGER_SCOPE(
+                char tmp[CALL_ID_LEN + 1] = {'\0'};
+                memcpy(tmp, session->calls[i]->id, CALL_ID_LEN);
+                LOGGER_DEBUG("Found call id: %s", tmp);
+            );
            return session->calls[i];
        }
@@ -818,9 +997,9 @@ MSICall *find_call ( MSISession *session, uint8_t *call_id )
 * @param errid The id.
 * @param to Where to?
 * @return int
- * @retval 0 It's always success.
+ * @retval -1/0 It's usually always success.
 */
-int handle_error ( MSISession *session, MSICall *call, MSICallError errid, uint32_t to )
+int send_error ( MSISession *session, MSICall *call, MSICallError errid, uint32_t to )
 {
    if (!call) {
        LOGGER_WARNING("Cannot handle error on 'null' call");
@@ -840,38 +1019,12 @@ int handle_error ( MSISession *session, MSICall *call, MSICallError errid, uint3
    session->last_error_id = errid;
    session->last_error_str = stringify_error ( errid );
-    invoke_callback(call->call_idx, MSI_OnError);
+    /* invoke_callback(call->call_idx, MSI_OnError); */
    return 0;
 }
-/**
- * @brief Determine the error if any.
- *
- * @param session Control session.
- * @param msg The message.
- * @return int
- * @retval -1 No error.
- * @retval 0 Error occurred and response sent.
- */
-int has_call_error ( MSISession *session, MSICall *call, MSIMessage *msg )
-{
-    if ( !msg->callid.header_value ) {
-        return handle_error ( session, call, error_no_callid, msg->friend_id );
-    } else if ( !call ) {
-        LOGGER_WARNING("Handling message while no call!");
-        return 0;
-    } else if ( memcmp ( call->id, msg->callid.header_value, CALL_ID_LEN ) != 0 ) {
-        return handle_error ( session, call, error_id_mismatch, msg->friend_id );
-    }
-    return -1;
-}
 /**
 * @brief Add peer to peer list.
@@ -882,14 +1035,16 @@ int has_call_error ( MSISession *session, MSICall *call, MSIMessage *msg )
 */
 void add_peer( MSICall *call, int peer_id )
 {
-    if ( !call->peers ) {
+    uint32_t *peers = !call->peers ? peers = calloc(sizeof(uint32_t), 1) :
-        call->peers = calloc(sizeof(uint32_t), 1);
+                      realloc( call->peers, sizeof(uint32_t) * call->peer_count);
-        call->peer_count = 1;
-    } else {
+    if (!peers) {
-        call->peer_count ++;
+        LOGGER_WARNING("Allocation failed! Program might misbehave!");
-        call->peers = realloc( call->peers, sizeof(uint32_t) * call->peer_count);
+        return;
    }
+    call->peer_count ++;
+    call->peers = peers;
    call->peers[call->peer_count - 1] = peer_id;
    LOGGER_DEBUG("Added peer: %d", peer_id);
@@ -912,54 +1067,49 @@ MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
        return NULL;
    }
-    int32_t _call_idx = 0;
+    int32_t call_idx = 0;
+    for (; call_idx < session->max_calls; call_idx ++) {
+        if ( !session->calls[call_idx] ) {
+            if (!(session->calls[call_idx] = calloc ( sizeof ( MSICall ), 1 ))) {
+                LOGGER_WARNING("Allocation failed! Program might misbehave!");
+                return NULL;
+            }
-    for (; _call_idx < session->max_calls; _call_idx ++) {
-        if ( !session->calls[_call_idx] ) {
-            session->calls[_call_idx] = calloc ( sizeof ( MSICall ), 1 );
            break;
        }
    }
-    if ( _call_idx == session->max_calls ) {
+    if ( call_idx == session->max_calls ) {
        LOGGER_WARNING("Reached maximum amount of calls!");
        return NULL;
    }
-    MSICall *_call = session->calls[_call_idx];
+    MSICall *call = session->calls[call_idx];
-    if ( _call == NULL ) {
+    call->call_idx = call_idx;
-        LOGGER_WARNING("Allocation failed!");
-        return NULL;
-    }
-    
-    _call->call_idx = _call_idx;
-    _call->type_peer = calloc ( sizeof ( MSICallType ), peers );
-    if ( _call->type_peer == NULL ) {
+    if ( !(call->type_peer = calloc ( sizeof ( MSICallType ), peers )) ) {
-        LOGGER_WARNING("Allocation failed!");
+        LOGGER_WARNING("Allocation failed! Program might misbehave!");
+        free(call);
        return NULL;
    }
-    _call->session = session;
+    call->session = session;
    /*_call->_participant_count = _peers;*/
-    _call->request_timer_id = 0;
+    call->request_timer_id = 0;
-    _call->ringing_timer_id = 0;
+    call->ringing_timer_id = 0;
-    _call->key_local = NULL;
+    call->ringing_tout_ms = ringing_timeout;
-    _call->key_peer = NULL;
-    _call->nonce_local = NULL;
-    _call->nonce_peer = NULL;
-    _call->ringing_tout_ms = ringing_timeout;
+    pthread_mutex_init ( &call->mutex, NULL );
-    pthread_mutex_init ( &_call->mutex, NULL );
+    LOGGER_DEBUG("Started new call with index: %u", call_idx);
+    return call;
-    LOGGER_DEBUG("Started new call with index: %u", _call_idx);
-    return _call;
 }
@@ -985,8 +1135,8 @@ int terminate_call ( MSISession *session, MSICall *call )
     * NOTE: This has to be done before possibly
     * locking the mutex the second time
     */
-    event.timer_release ( call->request_timer_id );
+    timer_release ( session->timer_handler, call->request_timer_id, 1);
-    event.timer_release ( call->ringing_timer_id );
+    timer_release ( session->timer_handler, call->ringing_timer_id, 1);
    /* Get a handle */
    pthread_mutex_lock ( &call->mutex );
@@ -994,8 +1144,6 @@ int terminate_call ( MSISession *session, MSICall *call )
    session->calls[call->call_idx] = NULL;
    free ( call->type_peer );
-    free ( call->key_local );
-    free ( call->key_peer );
    free ( call->peers);
    /* Release handle */
@@ -1024,12 +1172,15 @@ void *handle_timeout ( void *arg )
     * timers on these cancels and terminate call on
     * their timeout
     */
-    MSICall *_call = arg;
+    struct timer_function_args *args = arg;
+    int call_index = args->arg2;
+    MSISession *session = args->arg1;
+    MSICall *_call = session->calls[call_index];
    if (_call) {
        LOGGER_DEBUG("[Call: %s] Request timed out!", _call->id);
-    
-        invoke_callback(_call->call_idx, MSI_OnRequestTimeout);
+        invoke_callback(call_index, MSI_OnRequestTimeout);
    }
    if ( _call && _call->session ) {
@@ -1041,6 +1192,7 @@ void *handle_timeout ( void *arg )
        /*terminate_call(_call->session, _call);*/
    }
+    free(arg);
    pthread_exit(NULL);
 }
@@ -1081,7 +1233,8 @@ int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *msg )
            }
        } else {
-            handle_error ( session, call, error_busy, msg->friend_id ); /* TODO: Ugh*/
+            send_error ( session, call, error_busy, msg->friend_id ); /* TODO: Ugh*/
+            terminate_call(session, call);
            pthread_mutex_unlock(&session->mutex);
            return 0;
        }
@@ -1096,7 +1249,8 @@ int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *msg )
    }
    if ( !msg->callid.header_value ) {
-        handle_error ( session, call, error_no_callid, msg->friend_id );
+        send_error ( session, call, error_no_callid, msg->friend_id );
+        terminate_call(session, call);
        pthread_mutex_unlock(&session->mutex);
        return 0;
    }
@@ -1120,29 +1274,17 @@ int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *msg )
 }
 int handle_recv_start ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
+        return 0;
+    }
    LOGGER_DEBUG("Session: %p Handling 'start' on call: %s, friend id: %d", session, call->id, msg->friend_id );
    pthread_mutex_lock(&session->mutex);
-    if ( has_call_error ( session, call, msg ) == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
-        return -1;
-    }
-    if ( !msg->cryptokey.header_value ) {
-        int rc = handle_error ( session, call, error_no_crypto_key, msg->friend_id );
-        pthread_mutex_unlock(&session->mutex);
-        return rc;
-    }
    call->state = call_active;
-    call->key_peer = calloc ( sizeof ( uint8_t ), crypto_box_KEYBYTES );
-    memcpy ( call->key_peer, msg->cryptokey.header_value, crypto_box_KEYBYTES );
-    call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
-    memcpy ( call->nonce_peer, msg->nonce.header_value,  crypto_box_NONCEBYTES );
    flush_peer_type ( call, msg, 0 );
    pthread_mutex_unlock(&session->mutex);
@@ -1152,15 +1294,14 @@ int handle_recv_start ( MSISession *session, MSICall *call, MSIMessage *msg )
 }
 int handle_recv_reject ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
-    LOGGER_DEBUG("Session: %p Handling 'reject' on call: %s", session, call->id);
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-    pthread_mutex_lock(&session->mutex);
-    if ( has_call_error ( session, call, msg ) == 0 )  {
-        pthread_mutex_unlock(&session->mutex);
        return 0;
    }
+    LOGGER_DEBUG("Session: %p Handling 'reject' on call: %s", session, call->id);
+    pthread_mutex_lock(&session->mutex);
    MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
    send_message ( session, call, _msg_ending, msg->friend_id );
@@ -1170,30 +1311,22 @@ int handle_recv_reject ( MSISession *session, MSICall *call, MSIMessage *msg )
    pthread_mutex_unlock(&session->mutex);
    invoke_callback(call->call_idx, MSI_OnReject);
-    /*
-    event.timer_release ( session->call->request_timer_id );
-    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
-    */
    terminate_call(session, call);
    return 1;
 }
 int handle_recv_cancel ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
+        return 0;
+    }
    LOGGER_DEBUG("Session: %p Handling 'cancel' on call: %s", session, call->id );
    pthread_mutex_lock(&session->mutex);
-    if ( has_call_error ( session, call, msg ) == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
-        return 0;
-    }
    /* Act as end message */
-    /*
-    MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
-    send_message ( session, call, _msg_ending, msg->friend_id );
-    free_message ( _msg_ending );*/
    pthread_mutex_unlock(&session->mutex);
    invoke_callback(call->call_idx, MSI_OnCancel);
@@ -1203,15 +1336,15 @@ int handle_recv_cancel ( MSISession *session, MSICall *call, MSIMessage *msg )
 }
 int handle_recv_end ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
+        return 0;
+    }
    LOGGER_DEBUG("Session: %p Handling 'end' on call: %s", session, call->id );
    pthread_mutex_lock(&session->mutex);
-    if ( has_call_error ( session, call, msg ) == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
-        return 0;
-    }
    MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
    send_message ( session, call, _msg_ending, msg->friend_id );
    free_message ( _msg_ending );
@@ -1227,16 +1360,23 @@ int handle_recv_end ( MSISession *session, MSICall *call, MSIMessage *msg )
 /********** Response handlers **********/
 int handle_recv_ringing ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
+        return 0;
+    }
    pthread_mutex_lock(&session->mutex);
-    if ( has_call_error ( session, call, msg ) == 0 ) {
+    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: %s", session, call->id );
-    call->ringing_timer_id = event.timer_alloc ( handle_timeout, call, call->ringing_tout_ms );
+    call->ringing_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, call->call_idx,
+                                           call->ringing_tout_ms );
    pthread_mutex_unlock(&session->mutex);
@@ -1245,48 +1385,25 @@ int handle_recv_ringing ( MSISession *session, MSICall *call, MSIMessage *msg )
 }
 int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
-    pthread_mutex_lock(&session->mutex);
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-    if ( has_call_error ( session, call, msg ) == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
        return 0;
    }
-    LOGGER_DEBUG("Session: %p Handling 'starting' on call: %s", session, call->id );
+    pthread_mutex_lock(&session->mutex);
-    if ( !msg->cryptokey.header_value ) {
-        int rc = handle_error ( session, call, error_no_crypto_key, msg->friend_id );
-        pthread_mutex_unlock(&session->mutex);
-        return rc;
-    }
-    /* Generate local key/nonce to send */
-    call->key_local = calloc ( sizeof ( uint8_t ), crypto_box_KEYBYTES );
-    new_symmetric_key ( call->key_local );
-    call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
-    new_nonce ( call->nonce_local );
-    /* Save peer key/nonce */
-    call->key_peer = calloc ( sizeof ( uint8_t ), crypto_box_KEYBYTES );
-    memcpy ( call->key_peer, msg->cryptokey.header_value, crypto_box_KEYBYTES );
-    call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
+    LOGGER_DEBUG("Session: %p Handling 'starting' on call: %s", session, call->id );
-    memcpy ( call->nonce_peer, msg->nonce.header_value,  crypto_box_NONCEBYTES );
    call->state = call_active;
    MSIMessage *_msg_start = msi_new_message ( TYPE_REQUEST, stringify_request ( start ) );
-    msi_msg_set_cryptokey ( _msg_start, call->key_local, crypto_box_KEYBYTES );
-    msi_msg_set_nonce ( _msg_start, call->nonce_local, crypto_box_NONCEBYTES );
    send_message ( session, call, _msg_start, msg->friend_id );
    free_message ( _msg_start );
    flush_peer_type ( call, msg, 0 );
-    event.timer_release ( call->ringing_timer_id );
+    timer_release ( session->timer_handler, call->ringing_timer_id, 1 );
    pthread_mutex_unlock(&session->mutex);
    invoke_callback(call->call_idx, MSI_OnStarting);
@@ -1294,17 +1411,17 @@ int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage *msg )
 }
 int handle_recv_ending ( MSISession *session, MSICall *call, MSIMessage *msg )
 {
-    pthread_mutex_lock(&session->mutex);
+    if ( !call ) {
+        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-    if ( has_call_error ( session, call, msg ) == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
        return 0;
    }
+    pthread_mutex_lock(&session->mutex);
    LOGGER_DEBUG("Session: %p Handling 'ending' on call: %s", session, call->id );
    /* Stop timer */
-    event.timer_release ( call->request_timer_id );
+    timer_release ( session->timer_handler, call->request_timer_id, 1 );
    pthread_mutex_unlock(&session->mutex);
@@ -1376,95 +1493,94 @@ int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *msg )
 *
 *
 */
-void msi_handle_packet ( Messenger *messenger, int source, uint8_t *data, uint16_t length, void *object )
+void msi_handle_packet ( Messenger *messenger, int source, const uint8_t *data, uint16_t length, void *object )
 {
    LOGGER_DEBUG("Got msi message");
    /* Unused */
    (void)messenger;
-    MSISession *_session = object;
+    MSISession *session = object;
-    MSIMessage *_msg;
+    MSIMessage *msg;
    if ( !length ) {
        LOGGER_WARNING("Lenght param negative");
        return;
    }
-    _msg = parse_message ( data, length );
+    msg = parse_message ( data, length );
-    if ( !_msg ) {
+    if ( !msg ) {
        LOGGER_WARNING("Error parsing message");
        return;
    } else {
        LOGGER_DEBUG("Successfully parsed message");
    }
-    _msg->friend_id = source;
+    msg->friend_id = source;
    /* Find what call */
-    MSICall *_call = _msg->callid.header_value ? find_call(_session, _msg->callid.header_value ) : NULL;
+    MSICall *call = msg->callid.header_value ? find_call(session, msg->callid.header_value ) : NULL;
    /* Now handle message */
-    if ( _msg->request.header_value ) { /* Handle request */
+    if ( msg->request.header_value ) { /* Handle request */
-        if ( _msg->response.size > 32 ) {
+        if ( msg->response.size > 32 ) {
            LOGGER_WARNING("Header size too big");
            goto free_end;
        }
        uint8_t _request_value[32];
-        memcpy(_request_value, _msg->request.header_value, _msg->request.size);
+        memcpy(_request_value, msg->request.header_value, msg->request.size);
-        _request_value[_msg->request.size] = '\0';
+        _request_value[msg->request.size] = '\0';
        if ( same ( _request_value, stringify_request ( invite ) ) ) {
-            handle_recv_invite ( _session, _call, _msg );
+            handle_recv_invite ( session, call, msg );
        } else if ( same ( _request_value, stringify_request ( start ) ) ) {
-            handle_recv_start ( _session, _call, _msg );
+            handle_recv_start ( session, call, msg );
        } else if ( same ( _request_value, stringify_request ( cancel ) ) ) {
-            handle_recv_cancel ( _session, _call, _msg );
+            handle_recv_cancel ( session, call, msg );
        } else if ( same ( _request_value, stringify_request ( reject ) ) ) {
-            handle_recv_reject ( _session, _call, _msg );
+            handle_recv_reject ( session, call, msg );
        } else if ( same ( _request_value, stringify_request ( end ) ) ) {
-            handle_recv_end ( _session, _call, _msg );
+            handle_recv_end ( session, call, msg );
        } else {
            LOGGER_WARNING("Uknown request");
            goto free_end;
        }
-    } else if ( _msg->response.header_value ) { /* Handle response */
+    } else if ( msg->response.header_value ) { /* Handle response */
-        if ( _msg->response.size > 32 ) {
+        if ( msg->response.size > 32 ) {
            LOGGER_WARNING("Header size too big");
            goto free_end;
        }
        /* Got response so cancel timer */
-        if ( _call )
+        if ( call ) timer_release ( session->timer_handler, call->request_timer_id, 1 );
-            event.timer_release ( _call->request_timer_id );
        uint8_t _response_value[32];
-        memcpy(_response_value, _msg->response.header_value, _msg->response.size);
+        memcpy(_response_value, msg->response.header_value, msg->response.size);
-        _response_value[_msg->response.size] = '\0';
+        _response_value[msg->response.size] = '\0';
        if ( same ( _response_value, stringify_response ( ringing ) ) ) {
-            handle_recv_ringing ( _session, _call, _msg );
+            handle_recv_ringing ( session, call, msg );
        } else if ( same ( _response_value, stringify_response ( starting ) ) ) {
-            handle_recv_starting ( _session, _call, _msg );
+            handle_recv_starting ( session, call, msg );
        } else if ( same ( _response_value, stringify_response ( ending ) ) ) {
-            handle_recv_ending ( _session, _call, _msg );
+            handle_recv_ending ( session, call, msg );
        } else if ( same ( _response_value, stringify_response ( error ) ) ) {
-            handle_recv_error ( _session, _call, _msg );
+            handle_recv_error ( session, call, msg );
        } else {
            LOGGER_WARNING("Uknown response");
@@ -1476,7 +1592,7 @@ void msi_handle_packet ( Messenger *messenger, int source, uint8_t *data, uint16
    }
 free_end:
-    free_message ( _msg );
+    free_message ( msg );
 }
@@ -1509,34 +1625,45 @@ MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls )
        return NULL;
    }
-    if ( !max_calls) return NULL;
+    TimerHandler *handler = timer_init_session(max_calls * 10, 10000);
-    MSISession *_retu = calloc ( sizeof ( MSISession ), 1 );
+    if ( !max_calls || !handler ) {
+        LOGGER_WARNING("Invalid max call treshold or timer handler initialization failed!");
+        return NULL;
+    }
-    if (_retu == NULL) {
+    MSISession *retu = calloc ( sizeof ( MSISession ), 1 );
-        LOGGER_ERROR("Allocation failed!");
+    if (retu == NULL) {
+        LOGGER_ERROR("Allocation failed! Program might misbehave!");
        return NULL;
    }
-    _retu->messenger_handle = messenger;
+    retu->messenger_handle = messenger;
-    _retu->agent_handler = NULL;
+    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;
+    }
-    _retu->calls = calloc( sizeof (MSICall *), max_calls );
+    retu->max_calls = max_calls;
-    _retu->max_calls = max_calls;
-    _retu->frequ = 10000; /* default value? */
+    retu->frequ = 10000; /* default value? */
-    _retu->call_timeout = 30000; /* default value? */
+    retu->call_timeout = 30000; /* default value? */
-    m_callback_msi_packet(messenger, msi_handle_packet, _retu );
+    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);
+    m_callback_connectionstatus_internal_av(messenger, handle_remote_connection_change, retu);
-    pthread_mutex_init(&_retu->mutex, NULL);
+    pthread_mutex_init(&retu->mutex, NULL);
-    LOGGER_DEBUG("New msi session: %p max calls: %u", _retu, max_calls);
+    LOGGER_DEBUG("New msi session: %p max calls: %u", retu, max_calls);
-    return _retu;
+    return retu;
 }
@@ -1571,6 +1698,7 @@ int msi_terminate_session ( MSISession *session )
            msi_cancel ( session, idx, session->calls[idx]->peers [_it], "MSI session terminated!" );
        }
+    timer_terminate_session(session->timer_handler);
    pthread_mutex_destroy(&session->mutex);
@@ -1626,7 +1754,7 @@ int msi_invite ( MSISession *session, int32_t *call_index, MSICallType call_type
    _call->state = call_inviting;
-    _call->request_timer_id = event.timer_alloc ( handle_timeout, _call, m_deftout );
+    _call->request_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, _call->call_idx, m_deftout );
    LOGGER_DEBUG("Invite sent");
@@ -1670,11 +1798,12 @@ 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;
    free_message ( _msg_end );
-    session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index],
+    session->calls[call_index]->request_timer_id =
-            m_deftout );
+        timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
    pthread_mutex_unlock(&session->mutex);
    return 0;
@@ -1712,17 +1841,6 @@ int msi_answer ( MSISession *session, int32_t call_index, MSICallType call_type
        ( _msg_starting, ( const uint8_t *) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
    }
-    /* Now set the local encryption key and pass it with STARTING message */
-    session->calls[call_index]->key_local = calloc ( sizeof ( uint8_t ), crypto_box_KEYBYTES );
-    new_symmetric_key ( session->calls[call_index]->key_local );
-    session->calls[call_index]->nonce_local = calloc ( sizeof ( uint8_t ), crypto_box_NONCEBYTES );
-    new_nonce ( session->calls[call_index]->nonce_local );
-    msi_msg_set_cryptokey ( _msg_starting, session->calls[call_index]->key_local, crypto_box_KEYBYTES );
-    msi_msg_set_nonce ( _msg_starting, session->calls[call_index]->nonce_local, crypto_box_NONCEBYTES );
    send_message ( session, session->calls[call_index], _msg_starting,
                   session->calls[call_index]->peers[session->calls[call_index]->peer_count - 1] );
    free_message ( _msg_starting );
@@ -1760,7 +1878,8 @@ int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const c
    send_message ( session, session->calls[call_index], _msg_cancel, peer );
    free_message ( _msg_cancel );
-    /*session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index], m_deftout );*/
+    /*session->calls[call_index]->state = call_hanged_up;
+      session->calls[call_index]->request_timer_id = timer_alloc ( handle_timeout, session, call_index, m_deftout );*/
    terminate_call ( session, session->calls[call_index] );
    pthread_mutex_unlock(&session->mutex);
@@ -1794,8 +1913,10 @@ int msi_reject ( MSISession *session, int32_t call_index, const uint8_t *reason
                   session->calls[call_index]->peers[session->calls[call_index]->peer_count - 1] );
    free_message ( _msg_reject );
-    session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index],
+    session->calls[call_index]->state = call_hanged_up;
-            m_deftout );
+    session->calls[call_index]->request_timer_id =
+        timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
    pthread_mutex_unlock(&session->mutex);
    return 0;
diff --git a/toxav/msi.h b/toxav/msi.h
index 042f3f0f..0020df4c 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
 #ifndef __TOXMSI
@@ -52,7 +50,8 @@ typedef enum {
    call_inviting, /* when sending call invite */
    call_starting, /* when getting call invite */
    call_active,
-    call_hold
+    call_hold,
+    call_hanged_up
 } MSICallState;
@@ -72,12 +71,6 @@ typedef struct _MSICall {                  /* Call info structure */
    uint8_t             id[CALL_ID_LEN];   /* Random value identifying the call */
-    uint8_t            *key_local;         /* The key for encryption */
-    uint8_t            *key_peer;          /* The key for decryption */
-    uint8_t            *nonce_local;       /* Local nonce */
-    uint8_t            *nonce_peer;        /* Peer nonce  */
    int                 ringing_tout_ms;   /* Ringing timeout in ms */
    int                 request_timer_id;  /* Timer id for outgoing request/action */
@@ -112,6 +105,8 @@ typedef struct _MSISession {
    uint32_t call_timeout; /* Time of the timeout for some action to end; 0 if infinite */
    pthread_mutex_t mutex;
+    void *timer_handler;
 } MSISession;
diff --git a/toxav/rtp.c b/toxav/rtp.c
index d4fdf656..a6bcaf18 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
 #ifdef HAVE_CONFIG_H
@@ -29,12 +27,8 @@
 #include "../toxcore/util.h"
 #include "rtp.h"
-#include <assert.h>
 #include <stdlib.h>
+void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg);
-#define PAYLOAD_ID_VALUE_OPUS 1
-#define PAYLOAD_ID_VALUE_VP8  2
 #define size_32 4
@@ -52,7 +46,6 @@
 #define GET_SETTING_MARKER(_h) (( _h->marker_payloadt ) >> 7)
 #define GET_SETTING_PAYLOAD(_h) ((_h->marker_payloadt) & 0x7f)
 /**
 * @brief Checks if message came in late.
 *
@@ -74,66 +67,6 @@ inline__ int check_late_message (RTPSession *session, RTPMessage *msg)
 /**
- * @brief Increases nonce value by 'target'
- *
- * @param nonce The nonce
- * @param target The target
- * @return void
- */
-inline__ void increase_nonce(uint8_t *nonce, uint16_t target)
-{
-    uint16_t _nonce_counter;
-    uint8_t _reverse_bytes[2];
-    _reverse_bytes[0] = nonce[crypto_box_NONCEBYTES - 1];
-    _reverse_bytes[1] = nonce[crypto_box_NONCEBYTES - 2];
-    bytes_to_U16(&_nonce_counter, _reverse_bytes );
-    /* Check overflow */
-    if (_nonce_counter > UINT16_MAX - target ) { /* 2 bytes are not long enough */
-        uint8_t _it = 3;
-        while ( _it <= crypto_box_NONCEBYTES ) _it += ++nonce[crypto_box_NONCEBYTES - _it] ?
-                    crypto_box_NONCEBYTES : 1;
-        _nonce_counter = _nonce_counter - (UINT16_MAX - target ); /* Assign the rest of it */
-    } else { /* Increase nonce */
-        _nonce_counter += target;
-    }
-    /* Assign the last bytes */
-    U16_to_bytes( _reverse_bytes, _nonce_counter);
-    nonce [crypto_box_NONCEBYTES - 1] = _reverse_bytes[0];
-    nonce [crypto_box_NONCEBYTES - 2] = _reverse_bytes[1];
-}
-/**
- * @brief Speaks for it self.
- *
- */
-static const uint32_t payload_table[] = {
-    8000, 8000, 8000, 8000, 8000, 8000, 16000, 8000, 8000, 8000,        /*    0-9    */
-    44100, 44100, 0, 0, 90000, 8000, 11025, 22050, 0, 0,                /*   10-19   */
-    0, 0, 0, 0, 0, 90000, 90000, 0, 90000, 0,                           /*   20-29   */
-    0, 90000, 90000, 90000, 90000, 0, 0, 0, 0, 0,                       /*   30-39   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   40-49   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   50-59   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   60-69   */
-    PAYLOAD_ID_VALUE_OPUS, PAYLOAD_ID_VALUE_VP8, 0, 0, 0, 0, 0, 0, 0, 0,/*   70-79   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   80-89   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*   90-99   */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*  100-109  */
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                                       /*  110-119  */
-    0, 0, 0, 0, 0, 0, 0, 0                                              /*  120-127  */
-};
-/**
 * @brief Extracts header from payload.
 *
 * @param payload The payload.
@@ -148,10 +81,16 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
        return NULL;
    }
-    const uint8_t *_it = payload;
    RTPHeader *_retu = calloc(1, sizeof (RTPHeader));
-    assert(_retu);
+    if ( !_retu ) {
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
+        return NULL;
+    }
+    bytes_to_U16(&_retu->sequnum, payload);
+    const uint8_t *_it = payload + 2;
    _retu->flags = *_it;
    ++_it;
@@ -216,7 +155,11 @@ RTPExtHeader *extract_ext_header ( const uint8_t *payload, uint16_t length )
    const uint8_t *_it = payload;
    RTPExtHeader *_retu = calloc(1, sizeof (RTPExtHeader));
-    assert(_retu);
+    if ( !_retu ) {
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
+        return NULL;
+    }
    uint16_t _ext_length;
    bytes_to_U16(&_ext_length, _it);
@@ -233,8 +176,11 @@ RTPExtHeader *extract_ext_header ( const uint8_t *payload, uint16_t length )
    bytes_to_U16(&_retu->type, _it);
    _it += 2;
-    _retu->table = calloc(_ext_length, sizeof (uint32_t));
+    if ( !(_retu->table = calloc(_ext_length, sizeof (uint32_t))) ) {
-    assert(_retu->table);
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
+        free(_retu);
+        return NULL;
+    }
    uint16_t _x;
@@ -321,7 +267,11 @@ uint8_t *add_ext_header ( RTPExtHeader *header, uint8_t *payload )
 RTPHeader *build_header ( RTPSession *session )
 {
    RTPHeader *_retu = calloc ( 1, sizeof (RTPHeader) );
-    assert(_retu);
+    if ( !_retu ) {
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
+        return NULL;
+    }
    ADD_FLAG_VERSION ( _retu, session->version );
    ADD_FLAG_PADDING ( _retu, session->padding );
@@ -357,7 +307,7 @@ RTPHeader *build_header ( RTPSession *session )
 * @return RTPMessage*
 * @retval NULL Error occurred.
 */
-RTPMessage *msg_parse ( uint16_t sequnum, const uint8_t *data, int length )
+RTPMessage *msg_parse ( const uint8_t *data, int length )
 {
    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
@@ -369,11 +319,9 @@ RTPMessage *msg_parse ( uint16_t sequnum, const uint8_t *data, int length )
        return NULL;
    }
-    _retu->header->sequnum = sequnum;
+    uint16_t _from_pos = _retu->header->length;
+    _retu->length = length - _from_pos;
-    _retu->length = length - _retu->header->length;
-    uint16_t _from_pos = _retu->header->length - 2 /* Since sequ num is excluded */ ;
    if ( GET_FLAG_EXTENSION ( _retu->header ) ) {
@@ -415,70 +363,17 @@ RTPMessage *msg_parse ( uint16_t sequnum, const uint8_t *data, int length )
 * @retval -1 Error occurred.
 * @retval 0 Success.
 */
-int rtp_handle_packet ( void *object, uint8_t *data, uint32_t length )
+int rtp_handle_packet ( void *object, const uint8_t *data, uint32_t length )
 {
    RTPSession *_session = object;
    RTPMessage *_msg;
-    if ( !_session || length < 13 + crypto_box_MACBYTES) { /* 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;
    }
-    if ( _session->queue_limit <= _session->queue_size ) {
+    _msg = msg_parse ( data + 1, length - 1 );
-        LOGGER_WARNING("Queue limit reached!");
-        return -1;
-    }
-    uint8_t _plain[MAX_UDP_PACKET_SIZE];
-    uint16_t _sequnum;
-    bytes_to_U16(&_sequnum, data + 1);
-    /* Clculate the right nonce */
-    uint8_t _calculated[crypto_box_NONCEBYTES];
-    memcpy(_calculated, _session->decrypt_nonce, crypto_box_NONCEBYTES);
-    increase_nonce ( _calculated, _sequnum );
-    /* Decrypt message */
-    int _decrypted_length = decrypt_data_symmetric(
-                                (uint8_t *)_session->decrypt_key, _calculated, data + 3, length - 3, _plain );
-    /* This packet is either not encrypted properly or late
-     */
-    if ( -1 == _decrypted_length ) {
-        /* If this is the case, then the packet is most likely late.
-         * Try with old nonce cycle.
-         */
-        if ( _session->rsequnum < _sequnum ) {
-            _decrypted_length = decrypt_data_symmetric(
-                                    (uint8_t *)_session->decrypt_key, _session->nonce_cycle, data + 3, length - 3, _plain );
-            if ( _decrypted_length == -1 ) {
-                LOGGER_WARNING("Packet not ecrypted properly!");
-                return -1; /* This packet is not encrypted properly */
-            }
-            /* Otherwise, if decryption is ok with new cycle, set new cycle
-             */
-        } else {
-            increase_nonce ( _calculated, MAX_SEQU_NUM );
-            _decrypted_length = decrypt_data_symmetric(
-                                    (uint8_t *)_session->decrypt_key, _calculated, data + 3, length - 3, _plain );
-            if ( _decrypted_length == -1 ) {
-                LOGGER_WARNING("Error decrypting!");
-                return -1; /* This is just an error */
-            }
-            /* A new cycle setting. */
-            memcpy(_session->nonce_cycle, _session->decrypt_nonce, crypto_box_NONCEBYTES);
-            memcpy(_session->decrypt_nonce, _calculated, crypto_box_NONCEBYTES);
-        }
-    }
-    _msg = msg_parse ( _sequnum, _plain, _decrypted_length );
    if ( !_msg ) {
        LOGGER_WARNING("Could not parse message!");
@@ -491,18 +386,7 @@ int rtp_handle_packet ( void *object, uint8_t *data, uint32_t length )
        _session->timestamp = _msg->header->timestamp;
    }
-    pthread_mutex_lock(&_session->mutex);
+    toxav_handle_packet(_session, _msg);
-    if ( _session->last_msg ) {
-        _session->last_msg->next = _msg;
-        _session->last_msg = _msg;
-    } else {
-        _session->last_msg = _session->oldest_msg = _msg;
-    }
-    _session->queue_size++;
-    pthread_mutex_unlock(&_session->mutex);
    return 0;
 }
@@ -528,22 +412,28 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
    uint8_t *_from_pos;
    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
-    assert(_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;
-    uint32_t _total_length = length + _retu->header->length;
+    uint32_t _total_length = length + _retu->header->length + 1;
+    _retu->data[0] = session->prefix;
    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 );
+        _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 );
+        _from_pos = add_header ( _retu->header, _retu->data + 1 );
    }
    /*
@@ -562,104 +452,6 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
 }
-/**
- * @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 )
-{
-    if ( !session ) {
-        LOGGER_WARNING("No session!");
-        return -1;
-    }
-    RTPMessage *_tmp, * _it;
-    pthread_mutex_lock(&session->mutex);
-    for ( _it = session->oldest_msg; _it; _it = _tmp ) {
-        _tmp = _it->next;
-        rtp_free_msg( session, _it);
-    }
-    session->last_msg = session->oldest_msg = NULL;
-    session->queue_size = 0;
-    pthread_mutex_unlock(&session->mutex);
-    return 0;
-}
-/**
- * @brief Call this to change queue limit
- *
- * @param session The session
- * @param limit new limit
- * @return void
- */
-void rtp_queue_adjust_limit(RTPSession *session, uint64_t limit)
-{
-    RTPMessage *_tmp, * _it;
-    pthread_mutex_lock(&session->mutex);
-    for ( _it = session->oldest_msg; session->queue_size > limit; _it = _tmp ) {
-        _tmp = _it->next;
-        rtp_free_msg( session, _it);
-        session->queue_size --;
-    }
-    session->oldest_msg = _it;
-    session->queue_limit = limit;
-    pthread_mutex_unlock(&session->mutex);
-}
-/**
- * @brief Gets oldest message in the list.
- *
- * @param session Where the list is.
- * @return RTPMessage* The message. You _must_ call rtp_msg_free() to free it.
- * @retval NULL No messages in the list, or no list.
- */
-RTPMessage *rtp_recv_msg ( RTPSession *session )
-{
-    if ( !session ) {
-        LOGGER_WARNING("No session!");
-        return NULL;
-    }
-    pthread_mutex_lock(&session->mutex);
-    if ( session->queue_size == 0 ) {
-        pthread_mutex_unlock(&session->mutex);
-        return NULL;
-    }
-    RTPMessage *_retu = session->oldest_msg;
-    /*if (_retu)*/
-    session->oldest_msg = _retu->next;
-    if ( !session->oldest_msg )
-        session->last_msg = NULL;
-    session->queue_size --;
-    pthread_mutex_unlock(&session->mutex);
-    return _retu;
-}
 /**
 * @brief Sends data to _RTPSession::dest
 *
@@ -680,25 +472,7 @@ int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *dat
        return -1;
    }
-    uint8_t _send_data [ MAX_UDP_PACKET_SIZE ];
+    if ( -1 == send_custom_lossy_packet(messenger, session->dest, msg->data, msg->length) ) {
-    _send_data[0] = session->prefix;
-    /* Generate the right nonce */
-    uint8_t _calculated[crypto_box_NONCEBYTES];
-    memcpy(_calculated, session->encrypt_nonce, crypto_box_NONCEBYTES);
-    increase_nonce ( _calculated, msg->header->sequnum );
-    /* Need to skip 2 bytes that are for sequnum */
-    int encrypted_length = encrypt_data_symmetric( /* TODO: msg->length - 2 (fix this properly)*/
-                               (uint8_t *) session->encrypt_key, _calculated, msg->data + 2, msg->length, _send_data + 3 );
-    _send_data[1] = msg->data[0];
-    _send_data[2] = msg->data[1];
-    if ( -1 == send_custom_lossy_packet(messenger, session->dest, _send_data, encrypted_length + 3) ) {
        LOGGER_WARNING("Failed to send full packet! std error: %s", strerror(errno));
        rtp_free_msg ( session, msg );
        return -1;
@@ -706,13 +480,7 @@ int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *dat
    /* Set sequ number */
-    if ( session->sequnum >= MAX_SEQU_NUM ) {
+    session->sequnum = session->sequnum >= MAX_SEQU_NUM ? 0 : session->sequnum + 1;
-        session->sequnum = 0;
-        memcpy(session->encrypt_nonce, _calculated, crypto_box_NONCEBYTES);
-    } else {
-        session->sequnum++;
-    }
    rtp_free_msg ( session, msg );
    return 0;
@@ -745,7 +513,6 @@ 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.
@@ -753,26 +520,19 @@ void rtp_free_msg ( RTPSession *session, RTPMessage *msg )
 * @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.
- * @param encrypt_key Speaks for it self.
- * @param decrypt_key Speaks for it self.
- * @param encrypt_nonce Speaks for it self.
- * @param decrypt_nonce Speaks for it self.
 * @return RTPSession* Created control session.
 * @retval NULL Error occurred.
 */
-RTPSession *rtp_init_session ( int            payload_type,
+RTPSession *rtp_init_session ( int payload_type, Messenger *messenger, int friend_num )
-                               Messenger     *messenger,
-                               int            friend_num,
-                               const uint8_t *encrypt_key,
-                               const uint8_t *decrypt_key,
-                               const uint8_t *encrypt_nonce,
-                               const uint8_t *decrypt_nonce )
 {
    RTPSession *_retu = calloc(1, sizeof(RTPSession));
-    assert(_retu);
-    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, _retu) ||
+    if ( !_retu ) {
-            !encrypt_key || !decrypt_key || !encrypt_nonce || !decrypt_nonce) {
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
+        return NULL;
+    }
+    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);
        return NULL;
@@ -787,7 +547,7 @@ RTPSession *rtp_init_session ( int            payload_type,
    _retu->csrc      = NULL;        /* Container */
    _retu->ssrc      = random_int();
    _retu->marker    = 0;
-    _retu->payload_type = payload_table[payload_type];
+    _retu->payload_type = payload_type % 128;
    _retu->dest = friend_num;
@@ -795,34 +555,18 @@ RTPSession *rtp_init_session ( int            payload_type,
    _retu->ext_header = NULL; /* When needed allocate */
-    _retu->encrypt_key = encrypt_key;
-    _retu->decrypt_key = decrypt_key;
-    /* Need to allocate new memory */
+    if ( !(_retu->csrc = calloc(1, sizeof (uint32_t))) ) {
-    _retu->encrypt_nonce = calloc ( crypto_box_NONCEBYTES, sizeof (uint8_t) );
+        LOGGER_WARNING("Alloc failed! Program might misbehave!");
-    assert(_retu->encrypt_nonce);
+        free(_retu);
-    _retu->decrypt_nonce = calloc ( crypto_box_NONCEBYTES, sizeof (uint8_t) );
+        return NULL;
-    assert(_retu->decrypt_nonce);
+    }
-    _retu->nonce_cycle   = calloc ( crypto_box_NONCEBYTES, sizeof (uint8_t) );
-    assert(_retu->nonce_cycle);
-    memcpy(_retu->encrypt_nonce, encrypt_nonce, crypto_box_NONCEBYTES);
-    memcpy(_retu->decrypt_nonce, decrypt_nonce, crypto_box_NONCEBYTES);
-    memcpy(_retu->nonce_cycle  , decrypt_nonce, crypto_box_NONCEBYTES);
-    _retu->csrc = calloc(1, sizeof (uint32_t));
-    assert(_retu->csrc);
    _retu->csrc[0] = _retu->ssrc; /* Set my ssrc to the list receive */
    /* Also set payload type as prefix */
    _retu->prefix = payload_type;
-    _retu->oldest_msg = _retu->last_msg = NULL;
-    _retu->queue_limit = 100; /* Default */
-    _retu->queue_size = 0;
-    pthread_mutex_init(&_retu->mutex, NULL);
    /*
     *
     */
@@ -839,31 +583,18 @@ RTPSession *rtp_init_session ( int            payload_type,
 * @retval -1 Error occurred.
 * @retval 0 Success.
 */
-int rtp_terminate_session ( RTPSession *session, Messenger *messenger )
+void rtp_terminate_session ( RTPSession *session, Messenger *messenger )
 {
-    if ( !session ) {
+    if ( !session ) return;
-        LOGGER_WARNING("No session!");
-        return -1;
-    }
    custom_lossy_packet_registerhandler(messenger, session->dest, session->prefix, NULL, NULL);
-    rtp_release_session_recv(session);
-    pthread_mutex_lock(&session->mutex);
    free ( session->ext_header );
    free ( session->csrc );
-    free ( session->decrypt_nonce );
-    free ( session->encrypt_nonce );
-    free ( session->nonce_cycle );
-    pthread_mutex_unlock(&session->mutex);
+    LOGGER_DEBUG("Terminated RTP session: %p", session);
-    pthread_mutex_destroy(&session->mutex);
    /* And finally free session */
    free ( session );
-    return 0;
 }
diff --git a/toxav/rtp.h b/toxav/rtp.h
index 45cf83b6..45128285 100644
--- a/toxav/rtp.h
+++ b/toxav/rtp.h
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
 #ifndef __TOXRTP
@@ -107,29 +105,12 @@ typedef struct _RTPSession {
     */
    RTPExtHeader   *ext_header;
-    /* Since these are only references of the
-     * call structure don't allocate or free
-     */
-    const uint8_t  *encrypt_key;
-    const uint8_t  *decrypt_key;
-    uint8_t        *encrypt_nonce;
-    uint8_t        *decrypt_nonce;
-    uint8_t        *nonce_cycle;
-    RTPMessage     *oldest_msg;
-    RTPMessage     *last_msg; /* tail */
-    uint64_t        queue_limit;/* Default 100; modify per thy liking */
-    uint64_t        queue_size; /* currently holding << messages */
    /* Msg prefix for core to know when recving */
    uint8_t         prefix;
-    pthread_mutex_t mutex;
    int             dest;
+    int32_t         call_index;
+    struct _ToxAv *av;
 } RTPSession;
@@ -186,7 +167,6 @@ int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *dat
 */
 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.
@@ -194,20 +174,10 @@ void rtp_free_msg ( RTPSession *session, RTPMessage *msg );
 * @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.
- * @param encrypt_key Speaks for it self.
- * @param decrypt_key Speaks for it self.
- * @param encrypt_nonce Speaks for it self.
- * @param decrypt_nonce Speaks for it self.
 * @return RTPSession* Created control session.
 * @retval NULL Error occurred.
 */
-RTPSession *rtp_init_session ( int            payload_type,
+RTPSession *rtp_init_session ( int payload_type, Messenger *messenger, int friend_num );
-                               Messenger     *messenger,
-                               int            friend_num,
-                               const uint8_t *encrypt_key,
-                               const uint8_t *decrypt_key,
-                               const uint8_t *encrypt_nonce,
-                               const uint8_t *decrypt_nonce );
 /**
@@ -219,7 +189,7 @@ RTPSession *rtp_init_session ( int            payload_type,
 * @retval -1 Error occurred.
 * @retval 0 Success.
 */
-int rtp_terminate_session ( RTPSession *session, Messenger *messenger );
+void rtp_terminate_session ( RTPSession *session, Messenger *messenger );
diff --git a/toxav/toxav.c b/toxav/toxav.c
index a042b9dd..a301e007 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
 #ifdef HAVE_CONFIG_H
@@ -29,19 +27,22 @@
 #define _GNU_SOURCE /* implicit declaration warning */
 #include "rtp.h"
-#include "media.h"
+#include "codec.h"
 #include "msi.h"
 #include "toxav.h"
 #include "../toxcore/logger.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 /* Assume 60 fps*/
-#define MAX_ENCODE_TIME_US ((1000 / 60) * 1000)
+#define MAX_ENCODE_TIME_US ((1000 / 24) * 1000)
+#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))
@@ -61,6 +62,13 @@ typedef struct _CallSpecific {
                     * 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;
 } CallSpecific;
@@ -68,19 +76,25 @@ 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 (*video_callback)(ToxAv *, int32_t, vpx_image_t *);
    uint32_t max_calls;
 };
 const ToxAvCodecSettings av_DefaultSettings = {
-    1000000,
+    500,
-    800,
+    1280,
-    600,
+    720,
    64000,
    20,
    48000,
    1,
-    20
+    600,
+    6
 };
@@ -123,8 +137,6 @@ ToxAv *toxav_new( Tox *messenger, int32_t max_calls)
 */
 void toxav_kill ( ToxAv *av )
 {
-    msi_terminate_session(av->msi_session);
    int i = 0;
    for (; i < av->max_calls; i ++) {
@@ -142,6 +154,8 @@ void toxav_kill ( ToxAv *av )
        if ( av->calls[i].cs ) codec_terminate_session(av->calls[i].cs);
    }
+    msi_terminate_session(av->msi_session);
    free(av->calls);
    free(av);
 }
@@ -159,6 +173,28 @@ void toxav_register_callstate_callback ( ToxAVCallback callback, ToxAvCallbackID
 }
 /**
+ * @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))
+{
+    av->audio_callback = callback;
+}
+/**
+ * @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 *))
+{
+    av->video_callback = callback;
+}
+/**
 * @brief Call user. Use its friend_id.
 *
 * @param av Handler.
@@ -255,6 +291,10 @@ int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reaso
        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);
 }
@@ -285,59 +325,80 @@ int toxav_stop_call ( ToxAv *av, int32_t call_index )
 */
 int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettings *codec_settings, int support_video )
 {
-    if ( !av->msi_session || cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
+    if ( !av->msi_session || cii(call_index, av->msi_session) ||
-        LOGGER_ERROR("Error while starting audio RTP session: invalid call!\n");
+            !av->msi_session->calls[call_index] || av->calls[call_index].call_active) {
+        LOGGER_ERROR("Error while starting RTP session: invalid call!\n");
        return ErrorInternal;
    }
    CallSpecific *call = &av->calls[call_index];
    call->crtps[audio_index] =
-        rtp_init_session(
+        rtp_init_session(type_audio, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-            type_audio,
-            av->messenger,
-            av->msi_session->calls[call_index]->peers[0],
-            av->msi_session->calls[call_index]->key_peer,
-            av->msi_session->calls[call_index]->key_local,
-            av->msi_session->calls[call_index]->nonce_peer,
-            av->msi_session->calls[call_index]->nonce_local);
    if ( !call->crtps[audio_index] ) {
        LOGGER_ERROR("Error while starting audio RTP session!\n");
-        return ErrorStartingAudioRtp;
+        return ErrorInternal;
    }
+    call->crtps[audio_index]->call_index = call_index;
+    call->crtps[audio_index]->av = av;
    if ( support_video ) {
        call->crtps[video_index] =
-            rtp_init_session (
+            rtp_init_session(type_video, av->messenger, av->msi_session->calls[call_index]->peers[0]);
-                type_video,
-                av->messenger,
-                av->msi_session->calls[call_index]->peers[0],
-                av->msi_session->calls[call_index]->key_peer,
-                av->msi_session->calls[call_index]->key_local,
-                av->msi_session->calls[call_index]->nonce_peer,
-                av->msi_session->calls[call_index]->nonce_local);
        if ( !call->crtps[video_index] ) {
            LOGGER_ERROR("Error while starting video RTP session!\n");
-            return ErrorStartingVideoRtp;
+            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(codec_settings->jbuf_capacity)) ) {
+        LOGGER_WARNING("Jitter buffer creaton failed!");
+        goto error;
    }
-    if ( !(call->j_buf = create_queue(codec_settings->jbuf_capacity)) ) return ErrorInternal;
+    if ( (call->cs = codec_init_session(codec_settings->audio_bitrate,
+                                        codec_settings->audio_frame_duration,
+                                        codec_settings->audio_sample_rate,
+                                        codec_settings->audio_channels,
+                                        codec_settings->audio_VAD_tolerance,
+                                        codec_settings->max_video_width,
+                                        codec_settings->max_video_height,
+                                        codec_settings->video_bitrate) )) {
-    call->cs = codec_init_session(codec_settings->audio_bitrate,
+        if ( pthread_mutex_init(&call->mutex, NULL) != 0 ) goto error;
-                                  codec_settings->audio_frame_duration,
-                                  codec_settings->audio_sample_rate,
+        call->call_active = 1;
-                                  codec_settings->audio_channels,
-                                  codec_settings->video_width,
+        return ErrorNone;
-                                  codec_settings->video_height,
+    }
-                                  codec_settings->video_bitrate);
-    return call->cs ? ErrorNone : ErrorInternal;
+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);
+    return ErrorInternal;
 }
 /**
@@ -350,34 +411,35 @@ int toxav_prepare_transmission ( ToxAv *av, int32_t call_index, ToxAvCodecSettin
 */
 int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
+        return ErrorNoCall;
+    }
    CallSpecific *call = &av->calls[call_index];
-    if ( call->crtps[audio_index] && -1 == rtp_terminate_session(call->crtps[audio_index], av->messenger) ) {
+    pthread_mutex_lock(&call->mutex);
-        LOGGER_ERROR("Error while terminating audio RTP session!\n");
-        return ErrorTerminatingAudioRtp;
-    }
-    if ( call->crtps[video_index] && -1 == rtp_terminate_session(call->crtps[video_index], av->messenger) ) {
+    if (!call->call_active) {
-        LOGGER_ERROR("Error while terminating video RTP session!\n");
+        pthread_mutex_unlock(&call->mutex);
-        return ErrorTerminatingVideoRtp;
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
    }
+    call->call_active = 0;
+    rtp_terminate_session(call->crtps[audio_index], av->messenger);
    call->crtps[audio_index] = NULL;
+    rtp_terminate_session(call->crtps[video_index], av->messenger);
    call->crtps[video_index] = NULL;
+    terminate_queue(call->j_buf);
+    call->j_buf = NULL;
+    codec_terminate_session(call->cs);
+    call->cs = NULL;
-    if ( call->j_buf ) {
+    pthread_mutex_unlock(&call->mutex);
-        terminate_queue(call->j_buf);
+    pthread_mutex_destroy(&call->mutex);
-        call->j_buf = NULL;
-        LOGGER_DEBUG("Terminated j queue");
-    } else LOGGER_DEBUG("No j queue");
-    if ( call->cs ) {
-        codec_terminate_session(call->cs);
-        call->cs = NULL;
-        LOGGER_DEBUG("Terminated codec session");
-    } else LOGGER_DEBUG("No codec session");
    return ErrorNone;
 }
@@ -395,122 +457,83 @@ int toxav_kill_transmission ( ToxAv *av, int32_t call_index )
 * @retval -1 Failure.
 */
 inline__ int toxav_send_rtp_payload ( ToxAv *av, int32_t call_index, ToxAvCallType type, const uint8_t *payload,
-                                      uint16_t length )
+                                      unsigned int length )
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    CallSpecific *call = &av->calls[call_index];
-    if ( av->calls[call_index].crtps[type - TypeAudio] )
+    if (call->crtps[type - TypeAudio]) {
-        return rtp_send_msg ( av->calls[call_index].crtps[type - TypeAudio], av->msi_session->messenger_handle, payload,
-                              length );
-    else return -1;
-}
-/**
+        if (type == TypeAudio) {
- * @brief Receive RTP payload.
+            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, payload, length);
- *
+        } else {
- * @param av Handler.
+            if (length == 0 || length > MAX_VIDEOFRAME_SIZE) {
- * @param type Type of the payload.
+                LOGGER_ERROR("Invalid video frame size: %u\n", length);
- * @param dest Storage.
+                return ErrorInternal;
- * @return int
+            }
- * @retval ToxAvError On Error.
- * @retval >=0 Size of received payload.
- */
-inline__ int toxav_recv_rtp_payload ( ToxAv *av, int32_t call_index, ToxAvCallType type, uint8_t *dest )
-{
-    if ( !dest ) return ErrorInternal;
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+            /* number of pieces - 1*/
+            uint8_t numparts = (length - 1) / VIDEOFRAME_PIECE_SIZE;
-    CallSpecific *call = &av->calls[call_index];
+            uint8_t load[2 + VIDEOFRAME_PIECE_SIZE];
+            load[0] = call->frame_outid++;
+            load[1] = 0;
-    if ( !call->crtps[type - TypeAudio] ) return ErrorNoRtpSession;
+            int i;
-    RTPMessage *message;
+            for (i = 0; i < numparts; i++) {
+                memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, VIDEOFRAME_PIECE_SIZE);
+                payload += VIDEOFRAME_PIECE_SIZE;
-    if ( type == TypeAudio ) {
+                if (rtp_send_msg(call->crtps[type - TypeAudio], av->messenger,
+                                 load, VIDEOFRAME_HEADER_SIZE + VIDEOFRAME_PIECE_SIZE) != 0) {
-        do {
+                    return ErrorInternal;
-            message = rtp_recv_msg(call->crtps[audio_index]);
+                }
-            if (message) {
+                load[1]++;
-                /* push the packet into the queue */
-                queue(call->j_buf, message);
            }
-        } while (message);
-        int success = 0;
+            /* remainder = length % VIDEOFRAME_PIECE_SIZE, VIDEOFRAME_PIECE_SIZE if = 0 */
-        message = dequeue(call->j_buf, &success);
+            length = ((length - 1) % VIDEOFRAME_PIECE_SIZE) + 1;
+            memcpy(load + VIDEOFRAME_HEADER_SIZE, payload, length);
-        if ( success == 2) return ErrorAudioPacketLost;
+            return rtp_send_msg(call->crtps[type - TypeAudio], av->messenger, load, VIDEOFRAME_HEADER_SIZE + length);
+        }
    } else {
-        message = rtp_recv_msg(call->crtps[video_index]);
+        return ErrorNoRtpSession;
-    }
-    if ( message ) {
-        memcpy(dest, message->data, message->length);
-        int length = message->length;
-        rtp_free_msg(NULL, message);
-        return length;
    }
-    return 0;
 }
 /**
- * @brief Receive decoded video packet.
+ * @brief Encode and send video packet.
 *
 * @param av Handler.
- * @param output Storage.
+ * @param input The packet.
 * @return int
 * @retval 0 Success.
- * @retval ToxAvError On Error.
+ * @retval ToxAvError On error.
 */
-inline__ int toxav_recv_video ( ToxAv *av, int32_t call_index, vpx_image_t **output)
+inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
 {
-    if ( !output ) return ErrorInternal;
+    if (cii(call_index, av->msi_session)) {
+        LOGGER_WARNING("Invalid call index: %d", call_index);
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+        return ErrorNoCall;
+    }
-    uint8_t packet [RTP_PAYLOAD_SIZE];
-    int recved_size = 0;
-    int rc;
    CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
-    do {
-        recved_size = toxav_recv_rtp_payload(av, call_index, TypeVideo, packet);
-        if (recved_size > 0 && ( rc = vpx_codec_decode(&call->cs->v_decoder, packet, recved_size, NULL, 0) ) != VPX_CODEC_OK) {
-            LOGGER_ERROR("Error decoding video: %s\n", vpx_codec_err_to_string(rc));
-            return ErrorInternal;
-        }
-    } while (recved_size > 0);
-    vpx_codec_iter_t iter = NULL;
+    if (!call->call_active) {
-    vpx_image_t *img;
+        pthread_mutex_unlock(&call->mutex);
-    img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
-    *output = img;
+    }
-    return 0;
-}
-/**
+    int rc = toxav_send_rtp_payload(av, call_index, TypeVideo, frame, frame_size);
- * @brief Encode and send video packet.
+    pthread_mutex_unlock(&call->mutex);
- *
- * @param av Handler.
- * @param input The packet.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On error.
- */
-inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
-{
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
-    return toxav_send_rtp_payload(av, call_index, TypeVideo, frame, frame_size);
+    return rc;
 }
 /**
@@ -526,14 +549,31 @@ inline__ int toxav_send_video ( ToxAv *av, int32_t call_index, const uint8_t *fr
 */
 inline__ 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)) return ErrorNoCall;
+    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);
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+    if (reconfigure_video_encoder_resolution(call->cs, input->d_w, input->d_h) != 0) {
+        pthread_mutex_unlock(&call->mutex);
+        return ErrorInternal;
+    }
    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;
    }
@@ -545,61 +585,21 @@ inline__ int toxav_prepare_video_frame(ToxAv *av, int32_t call_index, uint8_t *d
    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 ) return ErrorPacketTooLarge;
+            if ( copied + pkt->data.frame.sz > dest_max ) {
+                pthread_mutex_unlock(&call->mutex);
+                return ErrorPacketTooLarge;
+            }
            memcpy(dest + copied, pkt->data.frame.buf, pkt->data.frame.sz);
            copied += pkt->data.frame.sz;
        }
    }
+    pthread_mutex_unlock(&call->mutex);
    return copied;
 }
 /**
- * @brief Receive decoded audio frame.
- *
- * @param av Handler.
- * @param frame_size The size of dest in frames/samples (one frame/sample is 16 bits or 2 bytes
- *                   and corresponds to one sample of audio.)
- * @param dest Destination of the raw audio (16 bit signed pcm with AUDIO_CHANNELS channels).
- *             Make sure it has enough space for frame_size frames/samples.
- * @return int
- * @retval >=0 Size of received data in frames/samples.
- * @retval ToxAvError On error.
- */
-inline__ int toxav_recv_audio ( ToxAv *av, int32_t call_index, int frame_size, int16_t *dest )
-{
-    if ( !dest ) return ErrorInternal;
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
-    CallSpecific *call = &av->calls[call_index];
-    uint8_t packet [RTP_PAYLOAD_SIZE];
-    int recved_size = toxav_recv_rtp_payload(av, call_index, TypeAudio, packet);
-    if ( recved_size == ErrorAudioPacketLost ) {
-        int dec_size = opus_decode(call->cs->audio_decoder, NULL, 0, dest, frame_size, 1);
-        if ( dec_size < 0 ) {
-            LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
-            return ErrorInternal;
-        } else return dec_size;
-    } else if ( recved_size ) {
-        int dec_size = opus_decode(call->cs->audio_decoder, packet, recved_size, dest, frame_size, 0);
-        if ( dec_size < 0 ) {
-            LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
-            return ErrorInternal;
-        } else return dec_size;
-    } else {
-        return 0; /* Nothing received */
-    }
-}
-/**
 * @brief Send audio frame.
 *
 * @param av Handler.
@@ -612,9 +612,25 @@ inline__ int toxav_recv_audio ( ToxAv *av, int32_t call_index, int frame_size, i
 */
 inline__ int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *frame, int frame_size)
 {
-    if (cii(call_index, av->msi_session)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+    CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
-    return toxav_send_rtp_payload(av, call_index, TypeAudio, frame, frame_size);
+    int rc = toxav_send_rtp_payload(av, call_index, TypeAudio, frame, frame_size);
+    pthread_mutex_unlock(&call->mutex);
+    return rc;
 }
 /**
@@ -632,9 +648,23 @@ inline__ int toxav_send_audio ( ToxAv *av, int32_t call_index, const uint8_t *fr
 inline__ 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)) return ErrorNoCall;
+    if (cii(call_index, av->msi_session) || !av->calls[call_index].call_active) {
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+    CallSpecific *call = &av->calls[call_index];
+    pthread_mutex_lock(&call->mutex);
-    int32_t rc = opus_encode(av->calls[call_index].cs->audio_encoder, frame, frame_size, dest, dest_max);
+    if (!call->call_active) {
+        pthread_mutex_unlock(&call->mutex);
+        LOGGER_WARNING("Action on inactive call: %d", call_index);
+        return ErrorNoCall;
+    }
+    int32_t rc = opus_encode(call->cs->audio_encoder, frame, frame_size, dest, dest_max);
+    pthread_mutex_unlock(&call->mutex);
    if (rc < 0) {
        LOGGER_ERROR("Failed to encode payload: %s\n", opus_strerror(rc));
@@ -672,8 +702,6 @@ int toxav_get_peer_transmission_type ( ToxAv *av, int32_t call_index, int peer )
 */
 int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int peer )
 {
-    assert(av->msi_session);
    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;
@@ -682,6 +710,23 @@ int toxav_get_peer_id ( ToxAv *av, int32_t call_index, int 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;
+    return av->msi_session->calls[call_index]->state;
+}
+/**
 * @brief Is certain capability supported
 *
 * @param av Handler
@@ -695,43 +740,100 @@ inline__ int toxav_capability_supported ( ToxAv *av, int32_t call_index, ToxAvCa
    /* 0 is error here */
 }
-/**
+inline__ Tox *toxav_get_tox(ToxAv *av)
- * @brief Set queue limit
- *
- * @param av Handler
- * @param call_index index
- * @param limit the limit
- * @return void
- */
-inline__ int toxav_set_audio_queue_limit(ToxAv *av, int32_t call_index, uint64_t limit)
 {
-    if ( av->calls[call_index].crtps[audio_index] )
+    return (Tox *)av->messenger;
-        rtp_queue_adjust_limit(av->calls[call_index].crtps[audio_index], limit);
-    else
-        return ErrorNoRtpSession;
-    return ErrorNone;
 }
-/**
+int toxav_has_activity(ToxAv *av, int32_t call_index, int16_t *PCM, uint16_t frame_size, float ref_energy)
- * @brief Set queue limit
- *
- * @param av Handler
- * @param call_index index
- * @param limit the limit
- * @return void
- */
-inline__ int toxav_set_video_queue_limit(ToxAv *av, int32_t call_index, uint64_t limit)
 {
-    if ( av->calls[call_index].crtps[video_index] )
+    if ( !av->calls[call_index].cs ) return ErrorInvalidCodecState;
-        rtp_queue_adjust_limit(av->calls[call_index].crtps[video_index], limit);
-    else
-        return ErrorNoRtpSession;
-    return ErrorNone;
+    return energy_VAD(av->calls[call_index].cs, PCM, frame_size, ref_energy);
 }
-inline__ Tox *toxav_get_tox(ToxAv *av)
+void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
 {
-    return (Tox *)av->messenger;
+    ToxAv *av = _session->av;
-}
-\ No newline at end of file
+    int32_t call_index = _session->call_index;
+    CallSpecific *call = &av->calls[call_index];
+    if (_session->payload_type == type_audio % 128) {
+        queue(call->j_buf, _msg);
+        int success = 0, dec_size;
+        int frame_size = 960;
+        int16_t dest[frame_size];
+        while ((_msg = dequeue(call->j_buf, &success)) || success == 2) {
+            if (success == 2) {
+                dec_size = opus_decode(call->cs->audio_decoder, NULL, 0, dest, frame_size, 1);
+            } else {
+                dec_size = opus_decode(call->cs->audio_decoder, _msg->data, _msg->length, dest, frame_size, 0);
+                rtp_free_msg(NULL, _msg);
+            }
+            if (dec_size < 0) {
+                LOGGER_WARNING("Decoding error: %s", opus_strerror(dec_size));
+                continue;
+            }
+            av->audio_callback(av, call_index, dest, frame_size);
+        }
+    } 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 */
+            int rc = vpx_codec_decode(&call->cs->v_decoder, call->frame_buf, call->frame_limit, NULL, 0);
+            call->frame_id = packet[0];
+            memset(call->frame_buf, 0, call->frame_limit);
+            call->frame_limit = 0;
+            if (rc != VPX_CODEC_OK) {
+                LOGGER_ERROR("Error decoding video: %u %s\n", i, vpx_codec_err_to_string(rc));
+            }
+        } 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:
+        ;
+        vpx_codec_iter_t iter = NULL;
+        vpx_image_t *img;
+        img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
+        if (img) {
+            av->video_callback(av, call_index, img);
+        }
+        rtp_free_msg(NULL, _msg);
+    }
+}
diff --git a/toxav/toxav.h b/toxav/toxav.h
index 4d988962..0ded42bd 100644
--- a/toxav/toxav.h
+++ b/toxav/toxav.h
@@ -17,8 +17,6 @@
 *   You should have received a copy of the GNU General Public License
 *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
 *
- *
- *   Report bugs/suggestions at #tox-dev @ freenode.net:6667
 */
@@ -26,6 +24,10 @@
 #define __TOXAV
 #include <inttypes.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
 /* vpx_image_t */
 #include <vpx/vpx_image.h>
@@ -72,6 +74,15 @@ typedef enum {
 } ToxAvCallType;
+typedef enum {
+    av_CallNonExistant = -1,
+    av_CallInviting, /* when sending call invite */
+    av_CallStarting, /* when getting call invite */
+    av_CallActive,
+    av_CallHold,
+    av_CallHanged_up
+} ToxAvCallState;
 /**
 * @brief Error indicators.
 */
@@ -88,6 +99,7 @@ typedef enum {
    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 */
 } ToxAvError;
@@ -107,14 +119,15 @@ typedef enum {
 * @brief Encoding settings.
 */
 typedef struct _ToxAvCodecSettings {
-    uint32_t video_bitrate; /* In bits/s */
+    uint32_t video_bitrate; /* In kbits/s */
-    uint16_t video_width; /* In px */
+    uint16_t max_video_width; /* In px */
-    uint16_t video_height; /* In px */
+    uint16_t max_video_height; /* In px */
    uint32_t audio_bitrate; /* In bits/s */
    uint16_t audio_frame_duration; /* In ms */
    uint32_t audio_sample_rate; /* In Hz */
    uint32_t audio_channels;
+    uint32_t audio_VAD_tolerance; /* In ms */
    uint32_t jbuf_capacity; /* Size of jitter buffer */
 } ToxAvCodecSettings;
@@ -152,6 +165,22 @@ void toxav_kill(ToxAv *av);
 void toxav_register_callstate_callback (ToxAVCallback callback, ToxAvCallbackID id, void *userdata);
 /**
+ * @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));
+/**
+ * @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 *));
+/**
 * @brief Call user. Use its friend_id.
 *
 * @param av Handler.
@@ -240,31 +269,6 @@ int toxav_prepare_transmission(ToxAv *av, int32_t call_index, ToxAvCodecSettings
 int toxav_kill_transmission(ToxAv *av, int32_t call_index);
 /**
- * @brief Receive decoded video packet.
- *
- * @param av Handler.
- * @param output Storage.
- * @return int
- * @retval 0 Success.
- * @retval ToxAvError On Error.
- */
-int toxav_recv_video ( ToxAv *av, int32_t call_index, vpx_image_t **output);
-/**
- * @brief Receive decoded audio frame.
- *
- * @param av Handler.
- * @param frame_size The size of dest in frames/samples (one frame/sample is 16 bits or 2 bytes
- *                   and corresponds to one sample of audio.)
- * @param dest Destination of the raw audio (16 bit signed pcm with AUDIO_CHANNELS channels).
- *             Make sure it has enough space for frame_size frames/samples.
- * @return int
- * @retval >=0 Size of received data in frames/samples.
- * @retval ToxAvError On error.
- */
-int toxav_recv_audio( ToxAv *av, int32_t call_index, int frame_size, int16_t *dest );
-/**
 * @brief Encode and send video packet.
 *
 * @param av Handler.
@@ -339,6 +343,15 @@ int toxav_get_peer_transmission_type ( ToxAv *av, int32_t call_index, int peer )
 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
+ */
+ToxAvCallState toxav_get_call_state ( ToxAv *av, int32_t call_index );
+/**
 * @brief Is certain capability supported
 *
 * @param av Handler
@@ -370,4 +383,11 @@ int toxav_set_video_queue_limit ( ToxAv *av, int32_t call_index, uint64_t limit
 Tox *toxav_get_tox(ToxAv *av);
-#endif /* __TOXAV */
-\ No newline at end of file
+int toxav_has_activity ( ToxAv *av, int32_t call_index, int16_t *PCM, uint16_t frame_size, float ref_energy );
+#ifdef __cplusplus
+}
+#endif
+#endif /* __TOXAV */
diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index b09ea0c9..77d126c1 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -2212,7 +2212,7 @@ static int random_node_fromlist(Client_data *list, uint16_t list_size, Node_form
 *
 * TODO: remove the LAN stuff from this.
 */
-uint16_t random_nodes_path(DHT *dht, Node_format *nodes, uint16_t max_num)
+uint16_t random_nodes_path(const DHT *dht, Node_format *nodes, uint16_t max_num)
 {
    if (max_num == 0)
        return 0;
@@ -2221,11 +2221,11 @@ uint16_t random_nodes_path(DHT *dht, Node_format *nodes, uint16_t max_num)
        return 0;
    uint16_t count = 0;
-    Client_data *list = NULL;
    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;
diff --git a/toxcore/DHT.h b/toxcore/DHT.h
index c7fddb4f..ea94e4ca 100644
--- a/toxcore/DHT.h
+++ b/toxcore/DHT.h
@@ -306,7 +306,7 @@ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num);
 *
 * NOTE:this is used to pick nodes for paths.
 */
-uint16_t random_nodes_path(DHT *dht, Node_format *nodes, uint16_t max_num);
+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);
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 3f913d4c..b65f09ae 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -40,10 +40,11 @@
 static void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status);
-static int write_cryptpacket_id(Messenger *m, int32_t friendnumber, uint8_t packet_id, uint8_t *data, uint32_t length);
+static int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
+                                uint32_t length);
 // friend_not_valid determines if the friendnumber passed is valid in the Messenger object
-static uint8_t friend_not_valid(Messenger *m, int32_t friendnumber)
+static uint8_t friend_not_valid(const Messenger *m, int32_t friendnumber)
 {
    return (unsigned int)friendnumber >= m->numfriends;
 }
@@ -109,7 +110,7 @@ int32_t getfriend_id(const Messenger *m, const uint8_t *client_id)
 *  return 0 if success.
 *  return -1 if failure.
 */
-int getclient_id(Messenger *m, int32_t friendnumber, uint8_t *client_id)
+int getclient_id(const Messenger *m, int32_t friendnumber, uint8_t *client_id)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -125,7 +126,7 @@ int getclient_id(Messenger *m, int32_t friendnumber, uint8_t *client_id)
 *
 *  return a uint16_t that represents the checksum of address of length len.
 */
-static uint16_t address_checksum(uint8_t *address, uint32_t len)
+static uint16_t address_checksum(const uint8_t *address, uint32_t len)
 {
    uint8_t checksum[2] = {0};
    uint16_t check;
@@ -142,7 +143,7 @@ static uint16_t address_checksum(uint8_t *address, uint32_t len)
 *
 *  return FRIEND_ADDRESS_SIZE byte address to give to others.
 */
-void getaddress(Messenger *m, uint8_t *address)
+void getaddress(const Messenger *m, uint8_t *address)
 {
    id_copy(address, m->net_crypto->self_public_key);
    uint32_t nospam = get_nospam(&(m->fr));
@@ -152,7 +153,7 @@ void getaddress(Messenger *m, uint8_t *address)
 }
 /* callback for recv TCP relay nodes. */
-static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, uint8_t *public_key)
+static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key)
 {
    Messenger *m = object;
@@ -183,7 +184,7 @@ static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_por
 *  (the nospam for that friend was set to the new one).
 *  return FAERR_NOMEM if increasing the friend list size fails.
 */
-int32_t m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t length)
+int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, uint16_t length)
 {
    if (length > MAX_FRIEND_REQUEST_DATA_SIZE)
        return FAERR_TOOLONG;
@@ -346,7 +347,7 @@ int m_delfriend(Messenger *m, int32_t friendnumber)
    return 0;
 }
-int m_get_friend_connectionstatus(Messenger *m, int32_t friendnumber)
+int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -354,7 +355,7 @@ int m_get_friend_connectionstatus(Messenger *m, int32_t friendnumber)
    return m->friendlist[friendnumber].status == FRIEND_ONLINE;
 }
-int m_friend_exists(Messenger *m, int32_t friendnumber)
+int m_friend_exists(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return 0;
@@ -402,7 +403,7 @@ uint32_t m_sendmessage_withid(Messenger *m, int32_t friendnumber, uint32_t theid
 *  return the message id if packet was successfully put into the send queue.
 *  return 0 if it was not.
 */
-uint32_t m_sendaction(Messenger *m, int32_t friendnumber, uint8_t *action, uint32_t length)
+uint32_t m_sendaction(Messenger *m, int32_t friendnumber, const uint8_t *action, uint32_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return 0;
@@ -419,7 +420,8 @@ uint32_t m_sendaction(Messenger *m, int32_t friendnumber, uint8_t *action, uint3
    return 0;
 }
-uint32_t m_sendaction_withid(Messenger *m, int32_t friendnumber, uint32_t theid, uint8_t *action, uint32_t length)
+uint32_t m_sendaction_withid(const Messenger *m, int32_t friendnumber, uint32_t theid, const uint8_t *action,
+                             uint32_t length)
 {
    if (length >= (MAX_CRYPTO_DATA_SIZE - sizeof(theid)))
        return 0;
@@ -434,7 +436,7 @@ uint32_t m_sendaction_withid(Messenger *m, int32_t friendnumber, uint32_t theid,
 /* Send a name packet to friendnumber.
 * length is the length with the NULL terminator.
 */
-static int m_sendname(Messenger *m, int32_t friendnumber, uint8_t *name, uint16_t length)
+static int m_sendname(const Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length)
 {
    if (length > MAX_NAME_LENGTH || length == 0)
        return 0;
@@ -447,7 +449,7 @@ static int m_sendname(Messenger *m, int32_t friendnumber, uint8_t *name, uint16_
 *  return 0 if success.
 *  return -1 if failure.
 */
-int setfriendname(Messenger *m, int32_t friendnumber, uint8_t *name, uint16_t length)
+int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -492,7 +494,7 @@ int setname(Messenger *m, const uint8_t *name, uint16_t length)
 *
 *  return the length of the name.
 */
-uint16_t getself_name(Messenger *m, uint8_t *name)
+uint16_t getself_name(const Messenger *m, uint8_t *name)
 {
    if (name == NULL) {
        return 0;
@@ -509,7 +511,7 @@ uint16_t getself_name(Messenger *m, uint8_t *name)
 *  return length of name if success.
 *  return -1 if failure.
 */
-int getname(Messenger *m, int32_t friendnumber, uint8_t *name)
+int getname(const Messenger *m, int32_t friendnumber, uint8_t *name)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -518,7 +520,7 @@ int getname(Messenger *m, int32_t friendnumber, uint8_t *name)
    return m->friendlist[friendnumber].name_length;
 }
-int m_get_name_size(Messenger *m, int32_t friendnumber)
+int m_get_name_size(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -526,7 +528,7 @@ int m_get_name_size(Messenger *m, int32_t friendnumber)
    return m->friendlist[friendnumber].name_length;
 }
-int m_get_self_name_size(Messenger *m)
+int m_get_self_name_size(const Messenger *m)
 {
    return m->name_length;
 }
@@ -565,7 +567,7 @@ int m_set_userstatus(Messenger *m, uint8_t status)
 /* return the size of friendnumber's user status.
 * Guaranteed to be at most MAX_STATUSMESSAGE_LENGTH.
 */
-int m_get_statusmessage_size(Messenger *m, int32_t friendnumber)
+int m_get_statusmessage_size(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -576,32 +578,35 @@ int m_get_statusmessage_size(Messenger *m, int32_t friendnumber)
 /*  Copy the user status of friendnumber into buf, truncating if needed to maxlen
 *  bytes, use m_get_statusmessage_size to find out how much you need to allocate.
 */
-int m_copy_statusmessage(Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
+int m_copy_statusmessage(const Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
-    memset(buf, 0, maxlen);
+    int msglen = MIN(maxlen, m->friendlist[friendnumber].statusmessage_length);
-    memcpy(buf, m->friendlist[friendnumber].statusmessage, MIN(maxlen, m->friendlist[friendnumber].statusmessage_length));
-    return MIN(maxlen, m->friendlist[friendnumber].statusmessage_length);
+    memcpy(buf, m->friendlist[friendnumber].statusmessage, msglen);
+    memset(buf + msglen, 0, maxlen - msglen);
+    return msglen;
 }
 /* return the size of friendnumber's user status.
 * Guaranteed to be at most MAX_STATUSMESSAGE_LENGTH.
 */
-int m_get_self_statusmessage_size(Messenger *m)
+int m_get_self_statusmessage_size(const Messenger *m)
 {
    return m->statusmessage_length;
 }
-int m_copy_self_statusmessage(Messenger *m, uint8_t *buf, uint32_t maxlen)
+int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf, uint32_t maxlen)
 {
-    memset(buf, 0, maxlen);
+    int msglen = MIN(maxlen, m->statusmessage_length);
-    memcpy(buf, m->statusmessage, MIN(maxlen, m->statusmessage_length));
+    memcpy(buf, m->statusmessage, msglen);
-    return MIN(maxlen, m->statusmessage_length);
+    memset(buf + msglen, 0, maxlen - msglen);
+    return msglen;
 }
-uint8_t m_get_userstatus(Messenger *m, int32_t friendnumber)
+uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return USERSTATUS_INVALID;
@@ -615,12 +620,12 @@ uint8_t m_get_userstatus(Messenger *m, int32_t friendnumber)
    return status;
 }
-uint8_t m_get_self_userstatus(Messenger *m)
+uint8_t m_get_self_userstatus(const Messenger *m)
 {
    return m->userstatus;
 }
-uint64_t m_get_last_online(Messenger *m, int32_t friendnumber)
+uint64_t m_get_last_online(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -644,7 +649,7 @@ int m_set_usertyping(Messenger *m, int32_t friendnumber, uint8_t is_typing)
    return 0;
 }
-uint8_t m_get_istyping(Messenger *m, int32_t friendnumber)
+uint8_t m_get_istyping(const Messenger *m, int32_t friendnumber)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -652,23 +657,23 @@ uint8_t m_get_istyping(Messenger *m, int32_t friendnumber)
    return m->friendlist[friendnumber].is_typing;
 }
-static int send_statusmessage(Messenger *m, int32_t friendnumber, uint8_t *status, uint16_t length)
+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);
 }
-static int send_userstatus(Messenger *m, int32_t friendnumber, uint8_t status)
+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));
 }
-static int send_user_istyping(Messenger *m, int32_t friendnumber, uint8_t is_typing)
+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(Messenger *m, int32_t friendnumber)
+static int send_ping(const Messenger *m, int32_t friendnumber)
 {
    int ret = write_cryptpacket_id(m, friendnumber, PACKET_ID_ALIVE, 0, 0);
@@ -678,7 +683,7 @@ static int send_ping(Messenger *m, int32_t friendnumber)
    return ret;
 }
-static int send_relays(Messenger *m, int32_t friendnumber)
+static int send_relays(const Messenger *m, int32_t friendnumber)
 {
    Node_format nodes[MAX_SHARED_RELAYS];
    uint8_t data[1024];
@@ -697,7 +702,7 @@ static int send_relays(Messenger *m, int32_t friendnumber)
-static int set_friend_statusmessage(Messenger *m, int32_t friendnumber, uint8_t *status, uint16_t length)
+static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, const uint8_t *status, uint16_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -710,12 +715,12 @@ static int set_friend_statusmessage(Messenger *m, int32_t friendnumber, uint8_t
    return 0;
 }
-static void set_friend_userstatus(Messenger *m, int32_t friendnumber, uint8_t status)
+static void set_friend_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status)
 {
    m->friendlist[friendnumber].userstatus = status;
 }
-static void set_friend_typing(Messenger *m, int32_t friendnumber, uint8_t is_typing)
+static void set_friend_typing(const Messenger *m, int32_t friendnumber, uint8_t is_typing)
 {
    m->friendlist[friendnumber].is_typing = is_typing;
 }
@@ -742,28 +747,28 @@ void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const
 }
 /* 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, uint8_t *, uint16_t, void *),
+void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_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, uint8_t *, uint16_t, void *),
+void m_callback_action(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_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, uint8_t *, uint16_t, void *),
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_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, uint8_t *, uint16_t, void *),
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                              void *userdata)
 {
    m->friend_statusmessagechange = function;
@@ -801,7 +806,7 @@ void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Mess
    m->friend_connectionstatuschange_internal_userdata = userdata;
 }
-static void break_files(Messenger *m, int32_t friendnumber);
+static void break_files(const Messenger *m, int32_t friendnumber);
 static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, uint8_t status)
 {
    if (status == NOFRIEND)
@@ -837,7 +842,8 @@ void set_friend_status(Messenger *m, int32_t friendnumber, uint8_t status)
    m->friendlist[friendnumber].status = status;
 }
-int write_cryptpacket_id(Messenger *m, int32_t friendnumber, uint8_t packet_id, uint8_t *data, uint32_t length)
+int write_cryptpacket_id(const Messenger *m, int32_t friendnumber, uint8_t packet_id, const uint8_t *data,
+                         uint32_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return 0;
@@ -859,7 +865,7 @@ int write_cryptpacket_id(Messenger *m, int32_t friendnumber, uint8_t packet_id,
 /* return 1 if the groupnumber is not valid.
 * return 0 if the groupnumber is valid.
 */
-static uint8_t groupnumber_not_valid(Messenger *m, int groupnumber)
+static uint8_t groupnumber_not_valid(const Messenger *m, int groupnumber)
 {
    if ((unsigned int)groupnumber >= m->numchats)
        return 1;
@@ -877,7 +883,7 @@ static uint8_t groupnumber_not_valid(Messenger *m, int groupnumber)
 /* returns valid ip port of connected friend on success
 * returns zeroed out IP_Port on failure
 */
-static IP_Port get_friend_ipport(Messenger *m, int32_t friendnumber)
+static IP_Port get_friend_ipport(const Messenger *m, int32_t friendnumber)
 {
    IP_Port zero;
    memset(&zero, 0, sizeof(zero));
@@ -901,7 +907,7 @@ static IP_Port get_friend_ipport(Messenger *m, int32_t friendnumber)
 /* returns the group number of the chat with public key group_public_key.
 * returns -1 on failure.
 */
-static int group_num(Messenger *m, uint8_t *group_public_key)
+static int group_num(const Messenger *m, const uint8_t *group_public_key)
 {
    uint32_t i;
@@ -918,7 +924,8 @@ static int group_num(Messenger *m, uint8_t *group_public_key)
 *
 *  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, uint8_t *, void *), void *userdata)
+void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, void *),
+                             void *userdata)
 {
    m->group_invite = function;
    m->group_invite_userdata = userdata;
@@ -928,7 +935,7 @@ void m_callback_group_invite(Messenger *m, void (*function)(Messenger *m, int32_
 *
 *  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, uint8_t *, uint16_t, void *),
+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;
@@ -939,7 +946,7 @@ void m_callback_group_message(Messenger *m, void (*function)(Messenger *m, int,
 *
 *  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, uint8_t *, uint16_t, void *),
+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;
@@ -958,7 +965,7 @@ void m_callback_group_namelistchange(Messenger *m, void (*function)(Messenger *m
    m->group_namelistchange_userdata = userdata;
 }
-static int get_chat_num(Messenger *m, Group_Chat *chat)
+static int get_chat_num(const Messenger *m, const Group_Chat *chat)
 {
    uint32_t i;
@@ -1111,7 +1118,7 @@ int del_groupchat(Messenger *m, int groupnumber)
 * return length of name if success
 * return -1 if failure
 */
-int m_group_peername(Messenger *m, int groupnumber, int peernumber, uint8_t *name)
+int m_group_peername(const Messenger *m, int groupnumber, int peernumber, uint8_t *name)
 {
    if ((unsigned int)groupnumber >= m->numchats)
        return -1;
@@ -1138,7 +1145,7 @@ static void group_store_friendinvite(Messenger *m, int32_t friendnumber, int gro
 /* return 1 if that friend was invited to the group
 * return 0 if the friend was not or error.
 */
-static uint8_t group_invited(Messenger *m, int32_t friendnumber, int groupnumber)
+static uint8_t group_invited(const Messenger *m, int32_t friendnumber, int groupnumber)
 {
    uint32_t i;
@@ -1186,7 +1193,7 @@ int invite_friend(Messenger *m, int32_t friendnumber, int groupnumber)
 * returns group number on success
 * returns -1 on failure.
 */
-int join_groupchat(Messenger *m, int32_t friendnumber, uint8_t *friend_group_public_key)
+int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_group_public_key)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1199,8 +1206,10 @@ int join_groupchat(Messenger *m, int32_t friendnumber, uint8_t *friend_group_pub
    IP_Port friend_ip = get_friend_ipport(m, friendnumber);
-    if (friend_ip.ip.family == 0)
+    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);
@@ -1211,6 +1220,7 @@ int join_groupchat(Messenger *m, int32_t friendnumber, uint8_t *friend_group_pub
        return groupnum;
    }
+    del_groupchat(m, groupnum);
    return -1;
 }
@@ -1219,7 +1229,7 @@ int join_groupchat(Messenger *m, int32_t friendnumber, uint8_t *friend_group_pub
 * return 0 on success
 * return -1 on failure
 */
-int group_message_send(Messenger *m, int groupnumber, uint8_t *message, uint32_t length)
+int group_message_send(const Messenger *m, int groupnumber, const uint8_t *message, uint32_t length)
 {
    if (groupnumber_not_valid(m, groupnumber))
        return -1;
@@ -1234,7 +1244,7 @@ int group_message_send(Messenger *m, int groupnumber, uint8_t *message, uint32_t
 * return 0 on success
 * return -1 on failure
 */
-int group_action_send(Messenger *m, int groupnumber, uint8_t *action, uint32_t length)
+int group_action_send(const Messenger *m, int groupnumber, const uint8_t *action, uint32_t length)
 {
    if (groupnumber_not_valid(m, groupnumber))
        return -1;
@@ -1248,7 +1258,7 @@ int group_action_send(Messenger *m, int groupnumber, uint8_t *action, uint32_t l
 /* Return the number of peers in the group chat on success.
 * return -1 on failure
 */
-int group_number_peers(Messenger *m, int groupnumber)
+int group_number_peers(const Messenger *m, int groupnumber)
 {
    if (groupnumber_not_valid(m, groupnumber))
        return -1;
@@ -1266,7 +1276,8 @@ int group_number_peers(Messenger *m, int groupnumber)
 *
 * return -1 on failure.
 */
-int group_names(Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[], uint16_t length)
+int group_names(const Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
+                uint16_t length)
 {
    if (groupnumber_not_valid(m, groupnumber))
        return -1;
@@ -1312,7 +1323,7 @@ static void do_allgroupchats(Messenger *m)
 *
 *  Function(Tox *tox, int32_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, uint8_t *,
+void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint64_t, const uint8_t *,
                               uint16_t, void *), void *userdata)
 {
    m->file_sendrequest = function;
@@ -1324,8 +1335,8 @@ void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int3
 *  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 callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t, uint8_t *,
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t,
-                           uint16_t, void *), void *userdata)
+                           const uint8_t *, uint16_t, void *), void *userdata)
 {
    m->file_filecontrol = function;
    m->file_filecontrol_userdata = userdata;
@@ -1336,7 +1347,7 @@ void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t,
 *  Function(Tox *tox, int32_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, uint8_t *, uint16_t length,
+void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
                        void *), void *userdata)
 {
    m->file_filedata = function;
@@ -1350,8 +1361,8 @@ void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, ui
 *  return 1 on success
 *  return 0 on failure
 */
-int file_sendrequest(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename,
+int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize,
-                     uint16_t filename_length)
+                     const uint8_t *filename, uint16_t filename_length)
 {
    if (friend_not_valid(m, friendnumber))
        return 0;
@@ -1373,7 +1384,8 @@ int file_sendrequest(Messenger *m, int32_t friendnumber, uint8_t filenumber, uin
 *  return file number on success
 *  return -1 on failure
 */
-int new_filesender(Messenger *m, int32_t friendnumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length)
+int new_filesender(const Messenger *m, int32_t friendnumber, uint64_t filesize, const uint8_t *filename,
+                   uint16_t filename_length)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1403,8 +1415,8 @@ int new_filesender(Messenger *m, int32_t friendnumber, uint64_t filesize, uint8_
 *  return 0 on success
 *  return -1 on failure
 */
-int file_control(Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
+int file_control(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
-                 uint8_t *data, uint16_t length)
+                 const uint8_t *data, uint16_t length)
 {
    if (length > MAX_CRYPTO_DATA_SIZE - 3)
        return -1;
@@ -1485,13 +1497,13 @@ int file_control(Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8
    }
 }
-#define MIN_SLOTS_FREE 4
+#define MIN_SLOTS_FREE (CRYPTO_MIN_QUEUE_LENGTH / 2)
 /* Send file data.
 *
 *  return 0 on success
 *  return -1 on failure
 */
-int file_data(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length)
+int file_data(const Messenger *m, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length)
 {
    if (length > MAX_CRYPTO_DATA_SIZE - 1)
        return -1;
@@ -1526,7 +1538,7 @@ int file_data(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t *d
 *  return number of bytes remaining to be sent/received on success
 *  return 0 on failure
 */
-uint64_t file_dataremaining(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
+uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
 {
    if (friend_not_valid(m, friendnumber))
        return 0;
@@ -1549,7 +1561,7 @@ uint64_t file_dataremaining(Messenger *m, int32_t friendnumber, uint8_t filenumb
 /* Run this when the friend disconnects.
 *  Sets all current file transfers to broken.
 */
-static void break_files(Messenger *m, int32_t friendnumber)
+static void break_files(const Messenger *m, int32_t friendnumber)
 {
    uint32_t i;
@@ -1562,7 +1574,7 @@ static void break_files(Messenger *m, int32_t friendnumber)
    }
 }
-static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber,
+static int handle_filecontrol(const Messenger *m, int32_t friendnumber, uint8_t receive_send, uint8_t filenumber,
                              uint8_t message_id, uint8_t *data,
                              uint16_t length)
 {
@@ -1652,7 +1664,7 @@ static int handle_filecontrol(Messenger *m, int32_t friendnumber, uint8_t receiv
 *
 *  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, uint8_t *, uint16_t, void *),
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                           void *userdata)
 {
    m->msi_packet = function;
@@ -1664,12 +1676,12 @@ void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t,
 *  return 1 on success
 *  return 0 on failure
 */
-int m_msi_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint16_t length)
+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);
 }
-static int handle_custom_lossy_packet(void *object, int friend_num, uint8_t *packet, uint16_t length)
+static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
 {
    Messenger *m = object;
@@ -1684,7 +1696,7 @@ static int handle_custom_lossy_packet(void *object, int friend_num, uint8_t *pac
 }
 int custom_lossy_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-                                        int (*packet_handler_callback)(void *object, uint8_t *data, uint32_t len), void *object)
+                                        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1700,7 +1712,7 @@ int custom_lossy_packet_registerhandler(Messenger *m, int32_t friendnumber, uint
    return 0;
 }
-int send_custom_lossy_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint32_t length)
+int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1714,7 +1726,7 @@ int send_custom_lossy_packet(Messenger *m, int32_t friendnumber, uint8_t *data,
    return send_lossy_cryptpacket(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id, data, length);
 }
-static int handle_custom_lossless_packet(void *object, int friend_num, uint8_t *packet, uint16_t length)
+static int handle_custom_lossless_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length)
 {
    Messenger *m = object;
@@ -1735,7 +1747,7 @@ static int handle_custom_lossless_packet(void *object, int friend_num, uint8_t *
 }
 int custom_lossless_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-        int (*packet_handler_callback)(void *object, uint8_t *data, uint32_t len), void *object)
+        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1752,7 +1764,7 @@ int custom_lossless_packet_registerhandler(Messenger *m, int32_t friendnumber, u
    return 0;
 }
-int send_custom_lossless_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint32_t length)
+int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -1769,7 +1781,7 @@ int send_custom_lossless_packet(Messenger *m, int32_t friendnumber, uint8_t *dat
 /* Function to filter out some friend requests*/
 static int friend_already_added(const uint8_t *client_id, void *data)
 {
-    Messenger *m = data;
+    const Messenger *m = data;
    if (getfriend_id(m, client_id) == -1)
        return 0;
@@ -2026,13 +2038,13 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
        }
        case PACKET_ID_MESSAGE: {
-            uint8_t *message_id = data;
+            const uint8_t *message_id = data;
            uint8_t message_id_length = 4;
            if (data_length <= message_id_length)
                break;
-            uint8_t *message = data + message_id_length;
+            const uint8_t *message = data + message_id_length;
            uint16_t message_length = data_length - message_id_length;
            /* Make sure the NULL terminator is present. */
@@ -2051,13 +2063,13 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
        }
        case PACKET_ID_ACTION: {
-            uint8_t *message_id = data;
+            const uint8_t *message_id = data;
            uint8_t message_id_length = 4;
            if (data_length <= message_id_length)
                break;
-            uint8_t *action = data + message_id_length;
+            const uint8_t *action = data + message_id_length;
            uint16_t action_length = data_length - message_id_length;
            /* Make sure the NULL terminator is present. */
@@ -2125,8 +2137,8 @@ static int handle_packet(void *object, int i, uint8_t *temp, uint16_t len)
            uint8_t filenumber = data[0];
            uint64_t filesize;
-            net_to_host(data + 1, sizeof(filesize));
            memcpy(&filesize, data + 1, sizeof(filesize));
+            net_to_host((uint8_t *) &filesize, sizeof(filesize));
            m->friendlist[i].file_receiving[filenumber].status = FILESTATUS_NOT_ACCEPTED;
            m->friendlist[i].file_receiving[filenumber].size = filesize;
            m->friendlist[i].file_receiving[filenumber].transferred = 0;
@@ -2213,7 +2225,7 @@ 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, uint8_t *real_public_key)
+static int friend_new_connection(Messenger *m, int32_t friendnumber, const uint8_t *real_public_key)
 {
    if (friend_not_valid(m, friendnumber))
        return -1;
@@ -2334,7 +2346,7 @@ void do_friends(Messenger *m)
 #define DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS 60UL
 static time_t lastdump = 0;
 static char IDString[CLIENT_ID_SIZE * 2 + 1];
-static char *ID2String(uint8_t *client_id)
+static char *ID2String(const uint8_t *client_id)
 {
    uint32_t i;
@@ -2346,8 +2358,9 @@ static char *ID2String(uint8_t *client_id)
 }
 #endif
-/* Minimum messenger run interval in ms */
+/* Minimum messenger run interval in ms
-#define MIN_RUN_INTERVAL 1000
+   TODO: A/V */
+#define MIN_RUN_INTERVAL 50
 /* Return the time in milliseconds before do_messenger() should be called again
 * for optimal performance.
@@ -2526,12 +2539,12 @@ struct SAVED_FRIEND {
    uint64_t ping_lastrecv;
 };
-static uint32_t saved_friendslist_size(Messenger *m)
+static uint32_t saved_friendslist_size(const Messenger *m)
 {
    return count_friendlist(m) * sizeof(struct SAVED_FRIEND);
 }
-static uint32_t friends_list_save(Messenger *m, uint8_t *data)
+static uint32_t friends_list_save(const Messenger *m, uint8_t *data)
 {
    uint32_t i;
    uint32_t num = 0;
@@ -2588,6 +2601,10 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
        if (temp.status >= 3) {
            int fnum = m_addfriend_norequest(m, temp.client_id);
+            if (fnum < 0)
+                continue;
            setfriendname(m, fnum, temp.name, ntohs(temp.name_length));
            set_friend_statusmessage(m, fnum, temp.statusmessage, ntohs(temp.statusmessage_length));
            set_friend_userstatus(m, fnum, temp.userstatus);
@@ -2610,7 +2627,7 @@ static int friends_list_load(Messenger *m, const uint8_t *data, uint32_t length)
 }
 /*  return size of the messenger data (for saving) */
-uint32_t messenger_size(Messenger *m)
+uint32_t messenger_size(const Messenger *m)
 {
    uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2;
    return   size32 * 2                                      // global cookie
@@ -2635,7 +2652,7 @@ static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t typ
 /* Save the messenger in data of size Messenger_size(). */
-void messenger_save(Messenger *m, uint8_t *data)
+void messenger_save(const Messenger *m, uint8_t *data)
 {
    uint32_t len;
    uint16_t type;
@@ -2693,7 +2710,6 @@ void messenger_save(Messenger *m, uint8_t *data)
    memset(relays, 0, len);
    copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS);
    memcpy(data, relays, len);
-    data += len;
 }
 static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)
@@ -2773,7 +2789,7 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
 }
 /* Load the messenger from data of size length. */
-int messenger_load(Messenger *m, uint8_t *data, uint32_t length)
+int messenger_load(Messenger *m, const uint8_t *data, uint32_t length)
 {
    uint32_t data32[2];
    uint32_t cookie_len = sizeof(data32);
@@ -2793,7 +2809,7 @@ int messenger_load(Messenger *m, uint8_t *data, uint32_t length)
 /* 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 count_friendlist(Messenger *m)
+uint32_t count_friendlist(const Messenger *m)
 {
    uint32_t ret = 0;
    uint32_t i;
@@ -2808,7 +2824,7 @@ uint32_t count_friendlist(Messenger *m)
 }
 /* Return the number of online friends in the instance m. */
-uint32_t get_num_online_friends(Messenger *m)
+uint32_t get_num_online_friends(const Messenger *m)
 {
    return m->numonline_friends;
 }
@@ -2818,7 +2834,7 @@ uint32_t get_num_online_friends(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 *m, int32_t *out_list, uint32_t list_size)
+uint32_t copy_friendlist(Messenger const *m, int32_t *out_list, uint32_t list_size)
 {
    if (!out_list)
        return 0;
@@ -2850,7 +2866,7 @@ uint32_t copy_friendlist(Messenger *m, int32_t *out_list, uint32_t list_size)
 * retun 0 if success.
 * return -1 if failure.
 */
-int get_friendlist(Messenger *m, int32_t **out_list, uint32_t *out_list_length)
+int get_friendlist(const Messenger *m, int32_t **out_list, uint32_t *out_list_length)
 {
    uint32_t i;
@@ -2880,7 +2896,7 @@ int get_friendlist(Messenger *m, int32_t **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(Messenger *m)
+uint32_t count_chatlist(const Messenger *m)
 {
    uint32_t ret = 0;
    uint32_t i;
@@ -2899,7 +2915,7 @@ uint32_t count_chatlist(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_chatlist(Messenger *m, int *out_list, uint32_t list_size)
+uint32_t copy_chatlist(const Messenger *m, int *out_list, uint32_t list_size)
 {
    if (!out_list)
        return 0;
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index e6ea59c1..ce0e5825 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -172,12 +172,12 @@ typedef struct {
    uint16_t invited_groups_num;
    struct {
-        int (*function)(void *object, uint8_t *data, uint32_t len);
+        int (*function)(void *object, const uint8_t *data, uint32_t len);
        void *object;
    } lossy_packethandlers[PACKET_ID_LOSSY_RANGE_SIZE];
    struct {
-        int (*function)(void *object, uint8_t *data, uint32_t len);
+        int (*function)(void *object, const uint8_t *data, uint32_t len);
        void *object;
    } lossless_packethandlers[PACKET_ID_LOSSLESS_RANGE_SIZE];
 } Friend;
@@ -212,13 +212,13 @@ typedef struct Messenger {
    uint64_t last_LANdiscovery;
-    void (*friend_message)(struct Messenger *m, int32_t, uint8_t *, uint16_t, void *);
+    void (*friend_message)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
    void *friend_message_userdata;
-    void (*friend_action)(struct Messenger *m, int32_t, uint8_t *, uint16_t, void *);
+    void (*friend_action)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
    void *friend_action_userdata;
-    void (*friend_namechange)(struct Messenger *m, int32_t, uint8_t *, uint16_t, void *);
+    void (*friend_namechange)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
    void *friend_namechange_userdata;
-    void (*friend_statusmessagechange)(struct Messenger *m, int32_t, uint8_t *, uint16_t, void *);
+    void (*friend_statusmessagechange)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
    void *friend_statusmessagechange_userdata;
    void (*friend_userstatuschange)(struct Messenger *m, int32_t, uint8_t, void *);
    void *friend_userstatuschange_userdata;
@@ -233,23 +233,23 @@ typedef struct Messenger {
    void (*friend_connectionstatuschange_internal)(struct Messenger *m, int32_t, uint8_t, void *);
    void *friend_connectionstatuschange_internal_userdata;
-    void (*group_invite)(struct Messenger *m, int32_t, uint8_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, uint8_t *, uint16_t, void *);
+    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, uint8_t *, uint16_t, void *);
+    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 (*file_sendrequest)(struct Messenger *m, int32_t, uint8_t, uint64_t, uint8_t *, uint16_t, void *);
+    void (*file_sendrequest)(struct Messenger *m, int32_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, uint8_t *, uint16_t, void *);
+    void (*file_filecontrol)(struct Messenger *m, int32_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, uint8_t *, uint16_t length, void *);
+    void (*file_filedata)(struct Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length, void *);
    void *file_filedata_userdata;
-    void (*msi_packet)(struct Messenger *m, int32_t, uint8_t *, uint16_t, void *);
+    void (*msi_packet)(struct Messenger *m, int32_t, const uint8_t *, uint16_t, void *);
    void *msi_packet_userdata;
 } Messenger;
@@ -258,7 +258,7 @@ typedef struct Messenger {
 *
 *  return FRIEND_ADDRESS_SIZE byte address to give to others.
 */
-void getaddress(Messenger *m, uint8_t *address);
+void getaddress(const Messenger *m, uint8_t *address);
 /* Add a friend.
 * Set the data that will be sent along with friend request.
@@ -276,7 +276,7 @@ void getaddress(Messenger *m, uint8_t *address);
 *  (the nospam for that friend was set to the new one).
 *  return -8 if increasing the friend list size fails.
 */
-int32_t m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t length);
+int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, uint16_t length);
 /* Add a friend without sending a friendrequest.
@@ -296,7 +296,7 @@ int32_t getfriend_id(const Messenger *m, const uint8_t *client_id);
 *  return 0 if success
 *  return -1 if failure
 */
-int getclient_id(Messenger *m, int32_t friendnumber, uint8_t *client_id);
+int getclient_id(const Messenger *m, int32_t friendnumber, uint8_t *client_id);
 /* Remove a friend.
 *
@@ -311,14 +311,14 @@ int m_delfriend(Messenger *m, int32_t friendnumber);
 *  return 0 if friend is not connected to us (Offline).
 *  return -1 on failure.
 */
-int m_get_friend_connectionstatus(Messenger *m, int32_t friendnumber);
+int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber);
 /* Checks if there exists a friend with given friendnumber.
 *
 *  return 1 if friend exists.
 *  return 0 if friend doesn't exist.
 */
-int m_friend_exists(Messenger *m, int32_t friendnumber);
+int m_friend_exists(const Messenger *m, int32_t friendnumber);
 /* Send a text chat message to an online friend.
 *
@@ -344,8 +344,9 @@ uint32_t m_sendmessage_withid(Messenger *m, int32_t friendnumber, uint32_t theid
 *  m_sendaction_withid will send an action message with the id of your choosing,
 *  however we can generate an id for you by calling plain m_sendaction.
 */
-uint32_t m_sendaction(Messenger *m, int32_t friendnumber, uint8_t *action, uint32_t length);
+uint32_t m_sendaction(Messenger *m, int32_t friendnumber, const uint8_t *action, uint32_t length);
-uint32_t m_sendaction_withid(Messenger *m, int32_t friendnumber, uint32_t theid, uint8_t *action, uint32_t length);
+uint32_t m_sendaction_withid(const Messenger *m, int32_t friendnumber, uint32_t theid, const uint8_t *action,
+                             uint32_t length);
 /* Set the name and name_length of a friend.
 * name must be a string of maximum MAX_NAME_LENGTH length.
@@ -355,7 +356,7 @@ uint32_t m_sendaction_withid(Messenger *m, int32_t friendnumber, uint32_t theid,
 *  return 0 if success.
 *  return -1 if failure.
 */
-int setfriendname(Messenger *m, int32_t friendnumber, uint8_t *name, uint16_t length);
+int setfriendname(Messenger *m, int32_t friendnumber, const uint8_t *name, uint16_t length);
 /* Set our nickname.
 * name must be a string of maximum MAX_NAME_LENGTH length.
@@ -375,7 +376,7 @@ int setname(Messenger *m, const uint8_t *name, uint16_t length);
 *  return length of the name.
 *  return 0 on error.
 */
-uint16_t getself_name(Messenger *m, uint8_t *name);
+uint16_t getself_name(const Messenger *m, uint8_t *name);
 /* 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.
@@ -383,13 +384,13 @@ uint16_t getself_name(Messenger *m, uint8_t *name);
 *  return length of name if success.
 *  return -1 if failure.
 */
-int getname(Messenger *m, int32_t friendnumber, uint8_t *name);
+int getname(const Messenger *m, int32_t friendnumber, uint8_t *name);
 /*  return the length of name, including null on success.
 *  return -1 on failure.
 */
-int m_get_name_size(Messenger *m, int32_t friendnumber);
+int m_get_name_size(const Messenger *m, int32_t friendnumber);
-int m_get_self_name_size(Messenger *m);
+int m_get_self_name_size(const Messenger *m);
 /* Set our user status.
 * You are responsible for freeing status after.
@@ -403,8 +404,8 @@ int m_set_userstatus(Messenger *m, uint8_t status);
 /*  return the length of friendnumber's status message, including null on success.
 *  return -1 on failure.
 */
-int m_get_statusmessage_size(Messenger *m, int32_t friendnumber);
+int m_get_statusmessage_size(const Messenger *m, int32_t friendnumber);
-int m_get_self_statusmessage_size(Messenger *m);
+int m_get_self_statusmessage_size(const Messenger *m);
 /* 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.
@@ -413,21 +414,21 @@ int m_get_self_statusmessage_size(Messenger *m);
 * returns the length of the copied data on success
 * retruns -1 on failure.
 */
-int m_copy_statusmessage(Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
+int m_copy_statusmessage(const Messenger *m, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
-int m_copy_self_statusmessage(Messenger *m, uint8_t *buf, uint32_t maxlen);
+int m_copy_self_statusmessage(const Messenger *m, uint8_t *buf, uint32_t maxlen);
 /*  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 m_get_userstatus(Messenger *m, int32_t friendnumber);
+uint8_t m_get_userstatus(const Messenger *m, int32_t friendnumber);
-uint8_t m_get_self_userstatus(Messenger *m);
+uint8_t m_get_self_userstatus(const Messenger *m);
 /* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
 * returns -1 on error.
 */
-uint64_t m_get_last_online(Messenger *m, int32_t friendnumber);
+uint64_t m_get_last_online(const Messenger *m, int32_t friendnumber);
 /* Set our typing status for a friend.
 * You are responsible for turning it on or off.
@@ -442,7 +443,7 @@ 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(Messenger *m, int32_t friendnumber);
+uint8_t m_get_istyping(const Messenger *m, int32_t friendnumber);
 /* Sets whether we send read receipts for friendnumber.
 * This function is not lazy, and it will fail if yesno is not (0 or 1).
@@ -458,20 +459,20 @@ void m_callback_friendrequest(Messenger *m, void (*function)(Messenger *m, const
 /* 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 m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t *, uint16_t, void *),
+void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_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)
 */
-void m_callback_action(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t *, uint16_t, void *),
+void m_callback_action(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                       void *userdata);
 /* Set the callback for name changes.
 *  Function(int32_t friendnumber, uint8_t *newname, uint16_t length)
 *  You are not responsible for freeing newname.
 */
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t *, uint16_t, void *),
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                           void *userdata);
 /* Set the callback for status message changes.
@@ -479,7 +480,7 @@ void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int32_t,
 *
 *  You are not responsible for freeing newstatus
 */
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t *, uint16_t, void *),
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                              void *userdata);
 /* Set the callback for status type changes.
@@ -526,20 +527,21 @@ void m_callback_connectionstatus_internal_av(Messenger *m, void (*function)(Mess
 *
 *  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, uint8_t *, void *), 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(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, uint8_t *, uint16_t, void *),
+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.
 *
 *  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, uint8_t *, uint16_t, void *),
+void m_callback_group_action(Messenger *m, void (*function)(Messenger *m, int, int, const uint8_t *, uint16_t, void *),
                             void *userdata);
 /* Set callback function for peer name list changes.
@@ -570,7 +572,7 @@ int del_groupchat(Messenger *m, int groupnumber);
 * return length of name if success
 * return -1 if failure
 */
-int m_group_peername(Messenger *m, int groupnumber, int peernumber, uint8_t *name);
+int m_group_peername(const Messenger *m, int groupnumber, int peernumber, uint8_t *name);
 /* invite friendnumber to groupnumber
 * return 0 on success
@@ -583,24 +585,24 @@ int invite_friend(Messenger *m, int32_t friendnumber, int groupnumber);
 * returns group number on success
 * returns -1 on failure.
 */
-int join_groupchat(Messenger *m, int32_t friendnumber, uint8_t *friend_group_public_key);
+int join_groupchat(Messenger *m, int32_t friendnumber, const uint8_t *friend_group_public_key);
 /* send a group message
 * return 0 on success
 * return -1 on failure
 */
-int group_message_send(Messenger *m, int groupnumber, uint8_t *message, uint32_t length);
+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(Messenger *m, int groupnumber, uint8_t *action, uint32_t length);
+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(Messenger *m, int groupnumber);
+int group_number_peers(const Messenger *m, int groupnumber);
 /* List all the peers in the group chat.
 *
@@ -612,7 +614,8 @@ int group_number_peers(Messenger *m, int groupnumber);
 *
 * return -1 on failure.
 */
-int group_names(Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[], uint16_t length);
+int group_names(const Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t lengths[],
+                uint16_t length);
 /****************FILE SENDING*****************/
@@ -621,7 +624,7 @@ int group_names(Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES],
 *
 *  Function(Tox *tox, int32_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, uint8_t *,
+void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint64_t, const uint8_t *,
                               uint16_t, void *), void *userdata);
 /* Set the callback for file control requests.
@@ -629,15 +632,15 @@ void callback_file_sendrequest(Messenger *m, void (*function)(Messenger *m, int3
 *  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 callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t, uint8_t *,
+void callback_file_control(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t, uint8_t,
-                           uint16_t, void *), void *userdata);
+                           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)
 *
 */
-void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, uint8_t *, uint16_t length,
+void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
                        void *), void *userdata);
 /* Send a file send request.
@@ -645,15 +648,16 @@ void callback_file_data(Messenger *m, void (*function)(Messenger *m, int32_t, ui
 *  return 1 on success
 *  return 0 on failure
 */
-int file_sendrequest(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize, uint8_t *filename,
+int file_sendrequest(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint64_t filesize,
-                     uint16_t filename_length);
+                     const uint8_t *filename, uint16_t filename_length);
 /* Send a file send request.
 * Maximum filename length is 255 bytes.
 *  return file number on success
 *  return -1 on failure
 */
-int new_filesender(Messenger *m, int32_t friendnumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length);
+int new_filesender(const Messenger *m, int32_t friendnumber, uint64_t filesize, const uint8_t *filename,
+                   uint16_t 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.
@@ -661,15 +665,15 @@ int new_filesender(Messenger *m, int32_t friendnumber, uint64_t filesize, uint8_
 *  return 1 on success
 *  return 0 on failure
 */
-int file_control(Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
+int file_control(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
-                 uint8_t *data, uint16_t length);
+                 const uint8_t *data, uint16_t length);
 /* Send file data.
 *
 *  return 1 on success
 *  return 0 on failure
 */
-int file_data(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length);
+int file_data(const Messenger *m, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length);
 /* Give the number of bytes left to be sent/received.
 *
@@ -678,7 +682,7 @@ int file_data(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t *d
 *  return number of bytes remaining to be sent/received on success
 *  return 0 on failure
 */
-uint64_t file_dataremaining(Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive);
+uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive);
 /*************** A/V related ******************/
@@ -686,7 +690,7 @@ uint64_t file_dataremaining(Messenger *m, int32_t friendnumber, uint8_t filenumb
 *
 *  Function(Messenger *m, int32_t friendnumber, uint8_t *data, uint16_t length, void *userdata)
 */
-void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t, uint8_t *, uint16_t, void *),
+void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t, const uint8_t *, uint16_t, void *),
                           void *userdata);
 /* Send an msi packet.
@@ -694,7 +698,7 @@ void m_callback_msi_packet(Messenger *m, void (*function)(Messenger *m, int32_t,
 *  return 1 on success
 *  return 0 on failure
 */
-int m_msi_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint16_t length);
+int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint16_t length);
 /**********************************************/
@@ -704,14 +708,14 @@ int m_msi_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint16_t len
 * return 0 on success.
 */
 int custom_lossy_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-                                        int (*packet_handler_callback)(void *object, uint8_t *data, uint32_t len), void *object);
+                                        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object);
 /* High level function to send custom lossy packets.
 *
 * return -1 on failure.
 * return 0 on success.
 */
-int send_custom_lossy_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint32_t length);
+int send_custom_lossy_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length);
 /* Set handlers for custom lossless packets.
@@ -722,14 +726,14 @@ int send_custom_lossy_packet(Messenger *m, int32_t friendnumber, uint8_t *data,
 * return 0 on success.
 */
 int custom_lossless_packet_registerhandler(Messenger *m, int32_t friendnumber, uint8_t byte,
-        int (*packet_handler_callback)(void *object, uint8_t *data, uint32_t len), void *object);
+        int (*packet_handler_callback)(void *object, const uint8_t *data, uint32_t len), void *object);
 /* High level function to send custom lossless packets.
 *
 * return -1 on failure.
 * return 0 on success.
 */
-int send_custom_lossless_packet(Messenger *m, int32_t friendnumber, uint8_t *data, uint32_t length);
+int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data, uint32_t length);
 /**********************************************/
 /* Run this at startup.
@@ -756,28 +760,28 @@ uint32_t messenger_run_interval(Messenger *m);
 /* SAVING AND LOADING FUNCTIONS: */
 /* return size of the messenger data (for saving). */
-uint32_t messenger_size(Messenger *m);
+uint32_t messenger_size(const Messenger *m);
 /* Save the messenger in data (must be allocated memory of size Messenger_size()) */
-void messenger_save(Messenger *m, uint8_t *data);
+void messenger_save(const Messenger *m, uint8_t *data);
 /* Load the messenger from data of size length. */
-int messenger_load(Messenger *m, uint8_t *data, uint32_t length);
+int messenger_load(Messenger *m, const uint8_t *data, uint32_t length);
 /* 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 count_friendlist(Messenger *m);
+uint32_t count_friendlist(const Messenger *m);
 /* Return the number of online friends in the instance m. */
-uint32_t get_num_online_friends(Messenger *m);
+uint32_t get_num_online_friends(const Messenger *m);
 /* 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 copy_friendlist(Messenger *m, int32_t *out_list, uint32_t 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.
@@ -785,18 +789,18 @@ uint32_t copy_friendlist(Messenger *m, int32_t *out_list, uint32_t list_size);
 * retun 0 if success.
 * return -1 if failure.
 */
-int get_friendlist(Messenger *m, int **out_list, uint32_t *out_list_length);
+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(Messenger *m);
+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(Messenger *m, int *out_list, uint32_t list_size);
+uint32_t copy_chatlist(const Messenger *m, int *out_list, uint32_t list_size);
 #endif
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index e4845852..82720ae8 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -65,7 +65,8 @@ static int connect_sock_to(sock_t sock, IP_Port ip_port)
 /* return 0 on success.
 * return -1 on failure.
 */
-static int generate_handshake(TCP_Client_Connection *TCP_conn, uint8_t *self_public_key, uint8_t *self_secret_key)
+static int generate_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *self_public_key,
+                              const uint8_t *self_secret_key)
 {
    uint8_t plain[crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES];
    crypto_box_keypair(plain, TCP_conn->temp_secret_key);
@@ -90,7 +91,7 @@ static int generate_handshake(TCP_Client_Connection *TCP_conn, uint8_t *self_pub
 * return 0 on success.
 * return -1 on failure.
 */
-static int handle_handshake(TCP_Client_Connection *TCP_conn, uint8_t *data)
+static int handle_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *data)
 {
    uint8_t plain[crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES];
    int len = decrypt_data_symmetric(TCP_conn->shared_key, data, data + crypto_box_NONCEBYTES,
@@ -137,7 +138,7 @@ static int send_pending_data(TCP_Client_Connection *con)
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, uint8_t *data, uint16_t length)
+static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length)
 {
    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
        return -1;
@@ -183,7 +184,7 @@ int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key)
 }
 void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
-                              uint8_t *public_key), void *object)
+                              const uint8_t *public_key), void *object)
 {
    con->response_callback = response_callback;
    con->response_callback_object = object;
@@ -196,11 +197,13 @@ void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(v
    con->status_callback_object = object;
 }
+static int send_ping_response(TCP_Client_Connection *con);
 /* return 1 on success.
 * return 0 if could not send packet.
 * return -1 on failure.
 */
-int send_data(TCP_Client_Connection *con, uint8_t con_id, uint8_t *data, uint16_t length)
+int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, uint16_t length)
 {
    if (con_id >= NUM_CLIENT_CONNECTIONS)
        return -1;
@@ -208,6 +211,9 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, uint8_t *data, uint16_
    if (con->connections[con_id].status != 2)
        return -1;
+    if (send_ping_response(con) == 0)
+        return 0;
    uint8_t packet[1 + length];
    packet[0] = con_id + NUM_RESERVED_PORTS;
    memcpy(packet + 1, data, length);
@@ -218,7 +224,7 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, uint8_t *data, uint16_
 * return 0 if could not send packet.
 * return -1 on failure.
 */
-int send_oob_packet(TCP_Client_Connection *con, uint8_t *public_key, uint8_t *data, uint16_t length)
+int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const uint8_t *data, uint16_t length)
 {
    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH)
        return -1;
@@ -251,14 +257,14 @@ int set_tcp_connection_number(TCP_Client_Connection *con, uint8_t con_id, uint32
 }
 void routing_data_handler(TCP_Client_Connection *con, int (*data_callback)(void *object, uint32_t number,
-                          uint8_t connection_id, uint8_t *data, uint16_t length), void *object)
+                          uint8_t connection_id, const uint8_t *data, uint16_t length), void *object)
 {
    con->data_callback = data_callback;
    con->data_callback_object = object;
 }
-void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, uint8_t *public_key,
+void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, const uint8_t *public_key,
-                      uint8_t *data, uint16_t length), void *object)
+                      const uint8_t *data, uint16_t length), void *object)
 {
    con->oob_data_callback = oob_data_callback;
    con->oob_data_callback_object = object;
@@ -292,12 +298,21 @@ static int send_ping_request(TCP_Client_Connection *con, uint64_t ping_id)
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-static int send_ping_response(TCP_Client_Connection *con, uint64_t ping_id)
+static int send_ping_response(TCP_Client_Connection *con)
 {
+    if (!con->ping_response_id)
+        return 1;
    uint8_t packet[1 + sizeof(uint64_t)];
    packet[0] = TCP_PACKET_PONG;
-    memcpy(packet + 1, &ping_id, sizeof(uint64_t));
+    memcpy(packet + 1, &con->ping_response_id, sizeof(uint64_t));
-    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
+    int ret;
+    if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet))) == 1) {
+        con->ping_response_id = 0;
+    }
+    return ret;
 }
 /* return 1 on success.
@@ -318,7 +333,7 @@ int send_disconnect_request(TCP_Client_Connection *con, uint8_t con_id)
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-int send_onion_request(TCP_Client_Connection *con, uint8_t *data, uint16_t length)
+int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t length)
 {
    uint8_t packet[1 + length];
    packet[0] = TCP_PACKET_ONION_REQUEST;
@@ -326,7 +341,7 @@ int send_onion_request(TCP_Client_Connection *con, uint8_t *data, uint16_t lengt
    return write_packet_TCP_secure_connection(con, packet, sizeof(packet));
 }
-void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, uint8_t *data,
+void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
                            uint16_t length), void *object)
 {
    con->onion_callback = onion_callback;
@@ -335,8 +350,8 @@ void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(vo
 /* Create new TCP connection to ip_port/public_key
 */
-TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, uint8_t *public_key, uint8_t *self_public_key,
+TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public_key, const uint8_t *self_public_key,
-        uint8_t *self_secret_key)
+        const uint8_t *self_secret_key)
 {
    if (networking_at_startup() != 0) {
        return NULL;
@@ -388,7 +403,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, uint8_t *public_key,
 /* return 0 on success
 * return -1 on failure
 */
-static int handle_TCP_packet(TCP_Client_Connection *conn, uint8_t *data, uint16_t length)
+static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length)
 {
    if (length <= 1)
        return -1;
@@ -467,7 +482,8 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, uint8_t *data, uint16_
            uint64_t ping_id;
            memcpy(&ping_id, data + 1, sizeof(uint64_t));
-            send_ping_response(conn, ping_id);
+            conn->ping_response_id = ping_id;
+            send_ping_response(conn);
            return 0;
        }
@@ -522,6 +538,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, uint8_t *data, uint16_
 static int do_confirmed_TCP(TCP_Client_Connection *conn)
 {
    send_pending_data(conn);
+    send_ping_response(conn);
    uint8_t packet[MAX_PACKET_SIZE];
    int len;
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index afb95392..e6d232ed 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -57,6 +57,7 @@ typedef struct  {
    uint64_t last_pinged;
    uint64_t ping_id;
+    uint64_t ping_response_id;
    void *net_crypto_pointer;
    uint32_t net_crypto_location;
    struct {
@@ -64,23 +65,23 @@ typedef struct  {
        uint8_t public_key[crypto_box_PUBLICKEYBYTES];
        uint32_t number;
    } connections[NUM_CLIENT_CONNECTIONS];
-    int (*response_callback)(void *object, uint8_t connection_id, uint8_t *public_key);
+    int (*response_callback)(void *object, uint8_t connection_id, const uint8_t *public_key);
    void *response_callback_object;
    int (*status_callback)(void *object, uint32_t number, uint8_t connection_id, uint8_t status);
    void *status_callback_object;
-    int (*data_callback)(void *object, uint32_t number, uint8_t connection_id, uint8_t *data, uint16_t length);
+    int (*data_callback)(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length);
    void *data_callback_object;
-    int (*oob_data_callback)(void *object, uint8_t *public_key, uint8_t *data, uint16_t length);
+    int (*oob_data_callback)(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length);
    void *oob_data_callback_object;
-    int (*onion_callback)(void *object, uint8_t *data, uint16_t length);
+    int (*onion_callback)(void *object, const uint8_t *data, uint16_t length);
    void *onion_callback_object;
 } TCP_Client_Connection;
 /* Create new TCP connection to ip_port/public_key
 */
-TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, uint8_t *public_key, uint8_t *self_public_key,
+TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public_key, const uint8_t *self_public_key,
-        uint8_t *self_secret_key);
+        const uint8_t *self_secret_key);
 /* Run the TCP connection
 */
@@ -94,8 +95,8 @@ void kill_TCP_connection(TCP_Client_Connection *TCP_connection);
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-int send_onion_request(TCP_Client_Connection *con, uint8_t *data, uint16_t length);
+int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t length);
-void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, uint8_t *data,
+void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
                            uint16_t length), void *object);
 /* return 1 on success.
@@ -104,7 +105,7 @@ void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(vo
 */
 int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key);
 void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
-                              uint8_t *public_key), void *object);
+                              const uint8_t *public_key), void *object);
 void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(void *object, uint32_t number,
                            uint8_t connection_id, uint8_t status), void *object);
@@ -127,17 +128,17 @@ int set_tcp_connection_number(TCP_Client_Connection *con, uint8_t con_id, uint32
 * return 0 if could not send packet.
 * return -1 on failure.
 */
-int send_data(TCP_Client_Connection *con, uint8_t con_id, uint8_t *data, uint16_t length);
+int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, uint16_t length);
 void routing_data_handler(TCP_Client_Connection *con, int (*data_callback)(void *object, uint32_t number,
-                          uint8_t connection_id, uint8_t *data, uint16_t length), void *object);
+                          uint8_t connection_id, const uint8_t *data, uint16_t length), void *object);
 /* return 1 on success.
 * return 0 if could not send packet.
 * return -1 on failure.
 */
-int send_oob_packet(TCP_Client_Connection *con, uint8_t *public_key, uint8_t *data, uint16_t length);
+int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const uint8_t *data, uint16_t length);
-void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, uint8_t *public_key,
+void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void *object, const uint8_t *public_key,
-                      uint8_t *data, uint16_t length), void *object);
+                      const uint8_t *data, uint16_t length), void *object);
 #endif
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index b900db6b..7487ad4f 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -97,7 +97,7 @@ static int realloc_connection(TCP_Server *TCP_server, uint32_t num)
 /* return index corresponding to connection with peer on success
 * return -1 on failure.
 */
-static int get_TCP_connection_index(TCP_Server *TCP_server, uint8_t *public_key)
+static int get_TCP_connection_index(const TCP_Server *TCP_server, const uint8_t *public_key)
 {
    return bs_list_find(&TCP_server->accepted_key_list, public_key);
 }
@@ -110,7 +110,7 @@ static int kill_accepted(TCP_Server *TCP_server, int index);
 * return index on success
 * return -1 on failure
 */
-static int add_accepted(TCP_Server *TCP_server, TCP_Secure_Connection *con)
+static int add_accepted(TCP_Server *TCP_server, const TCP_Secure_Connection *con)
 {
    int index = get_TCP_connection_index(TCP_server, con->public_key);
@@ -249,7 +249,7 @@ int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length)
 * return 0 if could not read any packet.
 * return -1 on failure (connection must be killed).
 */
-int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, uint8_t *shared_key,
+int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, const uint8_t *shared_key,
                                      uint8_t *recv_nonce, uint8_t *data, uint16_t max_len)
 {
    if (*next_packet_length == 0) {
@@ -318,7 +318,7 @@ static int send_pending_data(TCP_Secure_Connection *con)
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, uint8_t *data, uint16_t length)
+static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length)
 {
    if (length + crypto_box_MACBYTES > MAX_PACKET_SIZE)
        return -1;
@@ -389,7 +389,8 @@ static int kill_accepted(TCP_Server *TCP_server, int index)
 /* return 1 if everything went well.
 * return -1 if the connection must be killed.
 */
-static int handle_TCP_handshake(TCP_Secure_Connection *con, uint8_t *data, uint16_t length, uint8_t *self_secret_key)
+static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data, uint16_t length,
+                                const uint8_t *self_secret_key)
 {
    if (length != TCP_CLIENT_HANDSHAKE_SIZE)
        return -1;
@@ -435,7 +436,7 @@ static int handle_TCP_handshake(TCP_Secure_Connection *con, uint8_t *data, uint1
 * return 0 if we didn't get it yet.
 * return -1 if the connection must be killed.
 */
-static int read_connection_handshake(TCP_Secure_Connection *con, uint8_t *self_secret_key)
+static int read_connection_handshake(TCP_Secure_Connection *con, const uint8_t *self_secret_key)
 {
    uint8_t data[TCP_CLIENT_HANDSHAKE_SIZE];
    int len = 0;
@@ -451,7 +452,7 @@ static int read_connection_handshake(TCP_Secure_Connection *con, uint8_t *self_s
 * return 0 if could not send packet.
 * return -1 on failure (connection must be killed).
 */
-static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, uint8_t *public_key)
+static int send_routing_response(TCP_Secure_Connection *con, uint8_t rpid, const uint8_t *public_key)
 {
    uint8_t data[1 + 1 + crypto_box_PUBLICKEYBYTES];
    data[0] = TCP_PACKET_ROUTING_RESPONSE;
@@ -484,7 +485,7 @@ static int send_disconnect_notification(TCP_Secure_Connection *con, uint8_t id)
 /* return 0 on success.
 * return -1 on failure (connection must be killed).
 */
-static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, uint8_t *public_key)
+static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *public_key)
 {
    uint32_t i;
    uint32_t index = ~0;
@@ -562,7 +563,7 @@ static int handle_TCP_routing_req(TCP_Server *TCP_server, uint32_t con_id, uint8
 /* return 0 on success.
 * return -1 on failure (connection must be killed).
 */
-static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, uint8_t *public_key, uint8_t *data,
+static int handle_TCP_oob_send(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *public_key, const uint8_t *data,
                               uint16_t length)
 {
    if (length == 0 || length > TCP_MAX_OOB_DATA_LENGTH)
@@ -645,7 +646,7 @@ static int handle_onion_recv_1(void *object, IP_Port dest, const uint8_t *data,
 /* return 0 on success
 * return -1 on failure
 */
-static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, uint8_t *data, uint16_t length)
+static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, const uint8_t *data, uint16_t length)
 {
    if (length == 0)
        return -1;
@@ -764,7 +765,8 @@ static int handle_TCP_packet(TCP_Server *TCP_server, uint32_t con_id, uint8_t *d
 }
-static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection *con, uint8_t *data, uint16_t length)
+static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection *con, const uint8_t *data,
+                                  uint16_t length)
 {
    int index = add_accepted(TCP_server, con);
@@ -818,9 +820,10 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
        return ~0;
    }
-    int ok = 1;
 #ifndef TCP_SERVER_USE_EPOLL
-    ok = set_socket_nonblock(sock);
+    int ok = set_socket_nonblock(sock);
+#else
+    int ok = 1;
 #endif
    if (ok && family == AF_INET6) {
@@ -837,8 +840,8 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
    return sock;
 }
-TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, uint16_t *ports, uint8_t *public_key,
+TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *public_key,
-                           uint8_t *secret_key, Onion *onion)
+                           const uint8_t *secret_key, Onion *onion)
 {
    if (num_sockets == 0 || ports == NULL)
        return NULL;
@@ -914,7 +917,7 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, uint16_t
    memcpy(temp->public_key, public_key, crypto_box_PUBLICKEYBYTES);
    memcpy(temp->secret_key, secret_key, crypto_box_SECRETKEYBYTES);
-    bs_list_init(&temp->accepted_key_list, crypto_box_PUBLICKEYBYTES);
+    bs_list_init(&temp->accepted_key_list, crypto_box_PUBLICKEYBYTES, 8);
    return temp;
 }
diff --git a/toxcore/TCP_server.h b/toxcore/TCP_server.h
index 40984778..def0a978 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -133,8 +133,8 @@ typedef struct {
 /* Create new TCP server instance.
 */
-TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, uint16_t *ports, uint8_t *public_key,
+TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *public_key,
-                           uint8_t *secret_key, Onion *onion);
+                           const uint8_t *secret_key, Onion *onion);
 /* Run the TCP_server
 */
@@ -164,7 +164,7 @@ int read_TCP_packet(sock_t sock, uint8_t *data, uint16_t length);
 * return 0 if could not read any packet.
 * return -1 on failure (connection must be killed).
 */
-int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, uint8_t *shared_key,
+int read_packet_TCP_secure_connection(sock_t sock, uint16_t *next_packet_length, const uint8_t *shared_key,
                                      uint8_t *recv_nonce, uint8_t *data, uint16_t max_len);
diff --git a/toxcore/assoc.c b/toxcore/assoc.c
index 5ea67965..4d837aa3 100644
--- a/toxcore/assoc.c
+++ b/toxcore/assoc.c
@@ -886,7 +886,7 @@ void do_Assoc(Assoc *assoc, DHT *dht)
         * send getnode() requests to both */
        uint8_t *target_id = NULL;
        Client_entry *heard = NULL, *seen = NULL;
-        size_t i, k, m, bckt;
+        size_t i, k, m;
        for (i = 1; i < assoc->candidates_bucket_count; i++) {
            if (i % 2)
@@ -894,7 +894,7 @@ void do_Assoc(Assoc *assoc, DHT *dht)
            else
                k = i >> 1;
-            bckt = (candidate + k) % assoc->candidates_bucket_count;
+            size_t bckt = (candidate + k) % assoc->candidates_bucket_count;
            for (m = 0; m < assoc->candidates_bucket_size; m++)
                if (assoc->candidates[bckt].list[m].hash) {
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
index 1f76878b..53ef69d3 100644
--- a/toxcore/group_chats.c
+++ b/toxcore/group_chats.c
@@ -471,16 +471,6 @@ static int handle_sendnodes(Group_Chat *chat, IP_Port source, int peernum, const
    int ok = add_closepeer(chat, chat->group[peernum].client_id, source);
-    if (chat->assoc) {
-        ippts_send.ip_port = chat->group[peernum].ping_via;
-        ippts_send.timestamp = chat->group[peernum].last_pinged;
-        IP_Port ipp_recv;
-        ipp_recv = source;
-        Assoc_add_entry(chat->assoc, contents.nodes[i].client_id, &ippts_send, &ipp_recv, ok == 0 ? 1 : 0);
-    }
    return 0;
 }
diff --git a/toxcore/list.c b/toxcore/list.c
index c513afab..301e56f8 100644
--- a/toxcore/list.c
+++ b/toxcore/list.c
@@ -63,7 +63,7 @@ static int find(const BS_LIST *list, const void *data)
    //closest match is found if we move back to where we have already been
    while (1) {
-        int r = memcmp(data, list->data + list->size * i, list->size);
+        int r = memcmp(data, list->data + list->element_size * i, list->element_size);
        if (r == 0) {
            return i;
@@ -105,14 +105,54 @@ static int find(const BS_LIST *list, const void *data)
    }
 }
+/* Resized the list list
+ *
+ * return value:
+ *  1 : success
+ *  0 : failure
+ */
+static int resize(BS_LIST *list, uint32_t new_size)
+{
+    void *p;
+    p = realloc(list->data, list->element_size * new_size);
+    if (!p) {
+        return 0;
+    } else {
+        list->data = p;
+    }
+    p = realloc(list->ids, sizeof(int) * new_size);
-void bs_list_init(BS_LIST *list, uint32_t element_size)
+    if (!p) {
+        return 0;
+    } else {
+        list->ids = p;
+    }
+    return 1;
+}
+int bs_list_init(BS_LIST *list, uint32_t element_size, uint32_t initial_capacity)
 {
    //set initial values
    list->n = 0;
-    list->size = element_size;
+    list->element_size = element_size;
+    list->capacity = 0;
    list->data = NULL;
    list->ids = NULL;
+    if (initial_capacity != 0) {
+        if (!resize(list, initial_capacity)) {
+            return 0;
+        }
+    }
+    list->capacity = initial_capacity;
+    return 1;
 }
 void bs_list_free(BS_LIST *list)
@@ -147,28 +187,22 @@ int bs_list_add(BS_LIST *list, const void *data, int id)
    i = ~i;
-    //increase the size of the arrays by one
+    //increase the size of the arrays if needed
-    void *p;
+    if (list->n == list->capacity) {
+        // 1.5 * n + 1
-    p = realloc(list->data, list->size * (list->n + 1));
+        const uint32_t new_capacity = list->n + list->n / 2 + 1;
-    if (!p) {
+        if (!resize(list, new_capacity)) {
-        return 0;
+            return 0;
-    } else {
+        }
-        list->data = p;
-    }
-    p = realloc(list->ids, sizeof(int) * (list->n + 1));
-    if (!p) {
+        list->capacity = new_capacity;
-        return 0;
-    } else {
-        list->ids = p;
    }
    //insert data to element array
-    memmove(list->data + (i + 1) * list->size, list->data + i * list->size, (list->n - i) * list->size);
+    memmove(list->data + (i + 1) * list->element_size, list->data + i * list->element_size,
-    memcpy(list->data + i * list->size, data, list->size);
+            (list->n - i) * list->element_size);
+    memcpy(list->data + i * list->element_size, data, list->element_size);
    //insert id to id array
    memmove(&list->ids[i + 1], &list->ids[i], (list->n - i) * sizeof(int));
@@ -193,10 +227,30 @@ int bs_list_remove(BS_LIST *list, const void *data, int id)
        return 0;
    }
+    //decrease the size of the arrays if needed
+    if (list->n < list->capacity / 2) {
+        const uint32_t new_capacity = list->capacity / 2;
+        if (resize(list, new_capacity)) {
+            list->capacity = new_capacity;
+        }
+    }
    list->n--;
-    memmove(list->data + i * list->size, list->data + (i + 1) * list->size, (list->n - i) * list->size);
+    memmove(list->data + i * list->element_size, list->data + (i + 1) * list->element_size,
+            (list->n - i) * list->element_size);
    memmove(&list->ids[i], &list->ids[i + 1], (list->n - i) * sizeof(int));
    return 1;
 }
+int bs_list_trim(BS_LIST *list)
+{
+    if (!resize(list, list->n)) {
+        return 0;
+    }
+    list->capacity = list->n;
+    return 1;
+}
diff --git a/toxcore/list.h b/toxcore/list.h
index 1a1fe57d..03ac04dd 100644
--- a/toxcore/list.h
+++ b/toxcore/list.h
@@ -32,13 +32,20 @@
 typedef struct {
    uint32_t n; //number of elements
-    uint32_t size; //size of the elements
+    uint32_t capacity; //number of elements memory is allocated for
+    uint32_t element_size; //size of the elements
    void *data; //array of elements
    int *ids; //array of element ids
 } BS_LIST;
-/* Initialize a list, element_size is the size of the elements in the list */
+/* Initialize a list, element_size is the size of the elements in the list and
-void bs_list_init(BS_LIST *list, uint32_t element_size);
+ * initial_capacity is the number of elements the memory will be initially allocated for
+ *
+ * return value:
+ *  1 : success
+ *  0 : failure
+ */
+int bs_list_init(BS_LIST *list, uint32_t element_size, uint32_t initial_capacity);
 /* Free a list initiated with list_init */
 void bs_list_free(BS_LIST *list);
@@ -67,4 +74,12 @@ int bs_list_add(BS_LIST *list, const void *data, int id);
 */
 int bs_list_remove(BS_LIST *list, const void *data, int id);
+/* Removes the memory overhead
+ *
+ * return value:
+ *  1 : success
+ *  0 : failure
+ */
+int bs_list_trim(BS_LIST *list);
 #endif
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 0e88c86c..e0319f34 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -32,7 +32,7 @@
 #include "util.h"
 #include "math.h"
-static uint8_t crypt_connection_id_not_valid(Net_Crypto *c, int crypt_connection_id)
+static uint8_t crypt_connection_id_not_valid(const Net_Crypto *c, int crypt_connection_id)
 {
    return (uint32_t)crypt_connection_id >= c->crypto_connections_length;
 }
@@ -70,7 +70,7 @@ static int is_alive(uint8_t status)
 * return -1 on failure.
 * return COOKIE_REQUEST_LENGTH on success.
 */
-static int create_cookie_request(Net_Crypto *c, uint8_t *packet, uint8_t *dht_public_key, uint64_t number,
+static int create_cookie_request(const Net_Crypto *c, uint8_t *packet, uint8_t *dht_public_key, uint64_t number,
                                 uint8_t *shared_key)
 {
    uint8_t plain[COOKIE_REQUEST_PLAIN_LENGTH];
@@ -100,7 +100,7 @@ static int create_cookie_request(Net_Crypto *c, uint8_t *packet, uint8_t *dht_pu
 * return -1 on failure.
 * return 0 on success.
 */
-static int create_cookie(uint8_t *cookie, uint8_t *bytes, uint8_t *encryption_key)
+static int create_cookie(uint8_t *cookie, const uint8_t *bytes, const uint8_t *encryption_key)
 {
    uint8_t contents[COOKIE_CONTENTS_LENGTH];
    uint64_t temp_time = unix_time();
@@ -148,8 +148,8 @@ static int open_cookie(uint8_t *bytes, const uint8_t *cookie, const uint8_t *enc
 * return -1 on failure.
 * return COOKIE_RESPONSE_LENGTH on success.
 */
-static int create_cookie_response(Net_Crypto *c, uint8_t *packet, uint8_t *request_plain, uint8_t *shared_key,
+static int create_cookie_response(const Net_Crypto *c, uint8_t *packet, const uint8_t *request_plain,
-                                  uint8_t *dht_public_key)
+                                  const uint8_t *shared_key, const uint8_t *dht_public_key)
 {
    uint8_t cookie_plain[COOKIE_DATA_LENGTH];
    memcpy(cookie_plain, request_plain, crypto_box_PUBLICKEYBYTES);
@@ -177,8 +177,8 @@ static int create_cookie_response(Net_Crypto *c, uint8_t *packet, uint8_t *reque
 * return -1 on failure.
 * return 0 on success.
 */
-static int handle_cookie_request(Net_Crypto *c, uint8_t *request_plain, uint8_t *shared_key, uint8_t *dht_public_key,
+static int handle_cookie_request(const Net_Crypto *c, uint8_t *request_plain, uint8_t *shared_key,
-                                 const uint8_t *packet, uint16_t length)
+                                 uint8_t *dht_public_key, const uint8_t *packet, uint16_t length)
 {
    if (length != COOKIE_REQUEST_LENGTH)
        return -1;
@@ -220,8 +220,8 @@ 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(Net_Crypto *c, TCP_Client_Connection *TCP_con, uint8_t conn_id, uint8_t *packet,
+static int tcp_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connection *TCP_con, uint8_t conn_id,
-                                     uint32_t length)
+                                     const uint8_t *packet, uint32_t length)
 {
    uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
    uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -243,8 +243,8 @@ static int tcp_handle_cookie_request(Net_Crypto *c, TCP_Client_Connection *TCP_c
 /* Handle the cookie request packet (for TCP oob packets)
 */
-static int tcp_oob_handle_cookie_request(Net_Crypto *c, TCP_Client_Connection *TCP_con, uint8_t *dht_public_key,
+static int tcp_oob_handle_cookie_request(const Net_Crypto *c, TCP_Client_Connection *TCP_con,
-        uint8_t *packet, uint32_t length)
+        const uint8_t *dht_public_key, const uint8_t *packet, uint32_t length)
 {
    uint8_t request_plain[COOKIE_REQUEST_PLAIN_LENGTH];
    uint8_t shared_key[crypto_box_BEFORENMBYTES];
@@ -302,8 +302,8 @@ static int handle_cookie_response(uint8_t *cookie, uint64_t *number, const uint8
 * return -1 on failure.
 * return HANDSHAKE_PACKET_LENGTH on success.
 */
-static int create_crypto_handshake(Net_Crypto *c, uint8_t *packet, uint8_t *cookie, uint8_t *nonce, uint8_t *session_pk,
+static int create_crypto_handshake(const Net_Crypto *c, uint8_t *packet, const uint8_t *cookie, const uint8_t *nonce,
-                                   uint8_t *peer_real_pk, uint8_t *peer_dht_pubkey)
+                                   const uint8_t *session_pk, const uint8_t *peer_real_pk, const uint8_t *peer_dht_pubkey)
 {
    uint8_t plain[crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + crypto_hash_sha512_BYTES + COOKIE_LENGTH];
    memcpy(plain, nonce, crypto_box_NONCEBYTES);
@@ -348,8 +348,8 @@ static int create_crypto_handshake(Net_Crypto *c, uint8_t *packet, uint8_t *cook
 * return -1 on failure.
 * return 0 on success.
 */
-static int handle_crypto_handshake(Net_Crypto *c, uint8_t *nonce, uint8_t *session_pk, uint8_t *peer_real_pk,
+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, uint8_t *expected_real_pk)
+                                   uint8_t *dht_public_key, uint8_t *cookie, const uint8_t *packet, uint32_t length, const uint8_t *expected_real_pk)
 {
    if (length != HANDSHAKE_PACKET_LENGTH)
        return -1;
@@ -386,7 +386,7 @@ static int handle_crypto_handshake(Net_Crypto *c, uint8_t *nonce, uint8_t *sessi
 }
-static Crypto_Connection *get_crypto_connection(Net_Crypto *c, int crypt_connection_id)
+static Crypto_Connection *get_crypto_connection(const Net_Crypto *c, int crypt_connection_id)
 {
    if (crypt_connection_id_not_valid(c, crypt_connection_id))
        return 0;
@@ -400,7 +400,7 @@ static Crypto_Connection *get_crypto_connection(Net_Crypto *c, int crypt_connect
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_packet_to(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint16_t length)
+static int send_packet_to(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
 //TODO TCP, etc...
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -456,7 +456,7 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
 /* Return number of packets in array
 * Note that holes are counted too.
 */
-static uint32_t num_packets_array(Packets_Array *array)
+static uint32_t num_packets_array(const Packets_Array *array)
 {
    return array->buffer_end - array->buffer_start;
 }
@@ -466,7 +466,7 @@ static uint32_t num_packets_array(Packets_Array *array)
 * return -1 on failure.
 * return 0 on success.
 */
-static int add_data_to_buffer(Packets_Array *array, uint32_t number, Packet_Data *data)
+static int add_data_to_buffer(Packets_Array *array, uint32_t number, const Packet_Data *data)
 {
    if (number - array->buffer_start > CRYPTO_PACKET_BUFFER_SIZE)
        return -1;
@@ -496,7 +496,7 @@ static int add_data_to_buffer(Packets_Array *array, uint32_t number, Packet_Data
 * return 0 if data at number is empty.
 * return 1 if data pointer was put in data.
 */
-static int get_data_pointer(Packets_Array *array, Packet_Data **data, uint32_t number)
+static int get_data_pointer(const Packets_Array *array, Packet_Data **data, uint32_t number)
 {
    uint32_t num_spots = array->buffer_end - array->buffer_start;
@@ -517,7 +517,7 @@ static int get_data_pointer(Packets_Array *array, Packet_Data **data, uint32_t n
 * return -1 on failure.
 * return packet number on success.
 */
-static int64_t add_data_end_of_buffer(Packets_Array *array, Packet_Data *data)
+static int64_t add_data_end_of_buffer(Packets_Array *array, const Packet_Data *data)
 {
    if (num_packets_array(array) >= CRYPTO_PACKET_BUFFER_SIZE)
        return -1;
@@ -607,7 +607,7 @@ static int set_buffer_end(Packets_Array *array, uint32_t number)
 * return -1 on failure.
 * return length of packet on success.
 */
-static int generate_request_packet(uint8_t *data, uint16_t length, Packets_Array *recv_array)
+static int generate_request_packet(uint8_t *data, uint16_t length, const Packets_Array *recv_array)
 {
    if (length == 0)
        return -1;
@@ -656,7 +656,7 @@ static int generate_request_packet(uint8_t *data, uint16_t length, Packets_Array
 * return -1 on failure.
 * return number of requested packets on success.
 */
-static int handle_request_packet(Packets_Array *send_array, uint8_t *data, uint16_t length)
+static int handle_request_packet(Packets_Array *send_array, const uint8_t *data, uint16_t length)
 {
    if (length < 1)
        return -1;
@@ -718,7 +718,7 @@ static int handle_request_packet(Packets_Array *send_array, uint8_t *data, uint1
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_data_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint16_t length)
+static int send_data_packet(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint16_t length)
 {
    if (length == 0 || length + (1 + sizeof(uint16_t) + crypto_box_MACBYTES) > MAX_CRYPTO_PACKET_SIZE)
        return -1;
@@ -750,8 +750,8 @@ static int send_data_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *dat
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_data_packet_helper(Net_Crypto *c, int crypt_connection_id, uint32_t buffer_start, uint32_t num,
+static int send_data_packet_helper(const Net_Crypto *c, int crypt_connection_id, uint32_t buffer_start, uint32_t num,
-                                   uint8_t *data, uint32_t length)
+                                   const uint8_t *data, uint32_t length)
 {
    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
        return -1;
@@ -771,7 +771,7 @@ 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, uint8_t *data, uint32_t length)
+static int64_t send_lossless_packet(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
 {
    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
        return -1;
@@ -781,8 +781,29 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, uint
    if (conn == 0)
        return -1;
+    uint64_t temp_time = current_time_monotonic();
+    /* If last packet send failed, try to send packet again.
+       If sending it fails we won't be able to send the new packet. */
+    if (conn->maximum_speed_reached) {
+        Packet_Data *dt = NULL;
+        uint32_t packet_num = conn->send_array.buffer_end - 1;
+        int ret = get_data_pointer(&conn->send_array, &dt, packet_num);
+        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;
+                }
+                dt->time = temp_time;
+            }
+        }
+    }
    Packet_Data dt;
-    dt.time = current_time_monotonic();
+    dt.time = temp_time;
    dt.length = length;
    memcpy(dt.data, data, length);
    int64_t packet_num = add_data_end_of_buffer(&conn->send_array, &dt);
@@ -790,8 +811,15 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, uint
    if (packet_num == -1)
        return -1;
-    if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, data, length) != 0)
+    conn->maximum_speed_reached = 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;
+        conn->maximum_speed_reached = 1;
        fprintf(stderr, "send_data_packet failed\n");
+    }
    return packet_num;
 }
@@ -799,7 +827,7 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, uint
 /* Get the lowest 2 bytes from the nonce and convert
 * them to host byte format before returning them.
 */
-static uint16_t get_nonce_uint16(uint8_t *nonce)
+static uint16_t get_nonce_uint16(const uint8_t *nonce)
 {
    uint16_t num;
    memcpy(&num, nonce + (crypto_box_NONCEBYTES - sizeof(uint16_t)), sizeof(uint16_t));
@@ -815,7 +843,7 @@ static uint16_t get_nonce_uint16(uint8_t *nonce)
 * return -1 on failure.
 * return length of data on success.
 */
-static int handle_data_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *data, const uint8_t *packet,
+static int handle_data_packet(const Net_Crypto *c, int crypt_connection_id, uint8_t *data, const uint8_t *packet,
                              uint16_t length)
 {
    if (length <= (1 + sizeof(uint16_t) + crypto_box_MACBYTES) || length > MAX_CRYPTO_PACKET_SIZE)
@@ -852,7 +880,7 @@ static int handle_data_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *d
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_request_packet(Net_Crypto *c, int crypt_connection_id)
+static int send_request_packet(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -874,7 +902,7 @@ static int send_request_packet(Net_Crypto *c, int crypt_connection_id)
 * return -1 on failure.
 * return number of packets sent on success.
 */
-static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint16_t max_num)
+static int send_requested_packets(const Net_Crypto *c, int crypt_connection_id, uint16_t max_num)
 {
    if (max_num == 0)
        return -1;
@@ -920,7 +948,7 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint16
 * return -1 on failure.
 * return 0 on success.
 */
-static int new_temp_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *packet, uint16_t length)
+static int new_temp_packet(const Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length)
 {
    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
        return -1;
@@ -951,7 +979,7 @@ static int new_temp_packet(Net_Crypto *c, int crypt_connection_id, uint8_t *pack
 * return -1 on failure.
 * return 0 on success.
 */
-static int clear_temp_packet(Net_Crypto *c, int crypt_connection_id)
+static int clear_temp_packet(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -974,7 +1002,7 @@ static int clear_temp_packet(Net_Crypto *c, int crypt_connection_id)
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_temp_packet(Net_Crypto *c, int crypt_connection_id)
+static int send_temp_packet(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -998,7 +1026,8 @@ static int send_temp_packet(Net_Crypto *c, int crypt_connection_id)
 * return -1 on failure.
 * return 0 on success.
 */
-static int create_send_handshake(Net_Crypto *c, int crypt_connection_id, uint8_t *cookie, uint8_t *dht_public_key)
+static int create_send_handshake(const Net_Crypto *c, int crypt_connection_id, const uint8_t *cookie,
+                                 const uint8_t *dht_public_key)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1023,7 +1052,7 @@ static int create_send_handshake(Net_Crypto *c, int crypt_connection_id, uint8_t
 * return -1 on failure.
 * return 0 on success.
 */
-static int send_kill_packet(Net_Crypto *c, int crypt_connection_id)
+static int send_kill_packet(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1040,7 +1069,8 @@ static int send_kill_packet(Net_Crypto *c, int crypt_connection_id)
 * return -1 on failure.
 * return 0 on success.
 */
-static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, const uint8_t *packet, uint16_t length)
+static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_id, const uint8_t *packet,
+                                     uint16_t length)
 {
    if (length > MAX_CRYPTO_PACKET_SIZE || length <= CRYPTO_DATA_PACKET_MIN_SIZE)
        return -1;
@@ -1289,7 +1319,7 @@ static int wipe_crypto_connection(Net_Crypto *c, int crypt_connection_id)
 *  return -1 if there are no connections like we are looking for.
 *  return id if it found it.
 */
-static int getcryptconnection_id(Net_Crypto *c, uint8_t *public_key)
+static int getcryptconnection_id(const Net_Crypto *c, const uint8_t *public_key)
 {
    uint32_t i;
@@ -1307,7 +1337,7 @@ static int getcryptconnection_id(Net_Crypto *c, uint8_t *public_key)
 *  return -1 if there are no connections like we are looking for.
 *  return id if it found it.
 */
-static int getcryptconnection_id_dht_pubkey(Net_Crypto *c, uint8_t *dht_public_key)
+static int getcryptconnection_id_dht_pubkey(const Net_Crypto *c, const uint8_t *dht_public_key)
 {
    uint32_t i;
@@ -1465,7 +1495,7 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
 * return -1 on failure.
 * return connection id on success.
 */
-int new_crypto_connection(Net_Crypto *c, uint8_t *real_public_key)
+int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key)
 {
    int crypt_connection_id = getcryptconnection_id(c, real_public_key);
@@ -1495,7 +1525,7 @@ int new_crypto_connection(Net_Crypto *c, uint8_t *real_public_key)
 * return -1 on failure.
 * return 0 on success.
 */
-static int disconnect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
+static int disconnect_peer_tcp(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1520,7 +1550,7 @@ static int disconnect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
 * return -1 on failure.
 * return 0 on success.
 */
-static int connect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
+static int connect_peer_tcp(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1545,7 +1575,7 @@ static int connect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
 * return 0 on failure (no key copied).
 * return timestamp on success (key copied).
 */
-uint64_t get_connection_dht_key(Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key)
+uint64_t 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);
@@ -1567,7 +1597,8 @@ uint64_t get_connection_dht_key(Net_Crypto *c, int crypt_connection_id, uint8_t
 * return -1 on failure.
 * return 0 on success.
 */
-int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key, uint64_t timestamp)
+int set_connection_dht_public_key(const Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key,
+                                  uint64_t timestamp)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1628,7 +1659,7 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port)
    return -1;
 }
-static int tcp_response_callback(void *object, uint8_t connection_id, uint8_t *public_key)
+static int tcp_response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
 {
    TCP_Client_Connection *TCP_con = object;
    Net_Crypto *c = TCP_con->net_crypto_pointer;
@@ -1695,7 +1726,7 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
    return 0;
 }
-static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t *data, uint16_t length)
+static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length)
 {
    if (length == 0)
@@ -1720,7 +1751,7 @@ static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_i
    return 0;
 }
-static int tcp_oob_callback(void *object, uint8_t *public_key, uint8_t *data, uint16_t length)
+static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length)
 {
    if (length == 0 || length > MAX_CRYPTO_PACKET_SIZE)
        return -1;
@@ -1762,7 +1793,7 @@ static int tcp_oob_callback(void *object, uint8_t *public_key, uint8_t *data, ui
 * return -1 if it can't.
 * return 0 if it can.
 */
-static int tcp_connection_check(Net_Crypto *c, uint8_t *public_key)
+static int tcp_connection_check(const Net_Crypto *c, const uint8_t *public_key)
 {
    uint32_t i;
@@ -1797,7 +1828,7 @@ static int tcp_connection_check(Net_Crypto *c, uint8_t *public_key)
 * return 0 if it was added.
 * return -1 if it wasn't.
 */
-int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, uint8_t *public_key)
+int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, const uint8_t *public_key)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -1850,7 +1881,7 @@ int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port,
 * return 0 if it was added.
 * return -1 if it wasn't.
 */
-int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key)
+int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key)
 {
    if (ip_port.ip.family == TCP_INET) {
        ip_port.ip.family = AF_INET;
@@ -1882,7 +1913,7 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key)
 * return number of relays copied to tcp_relays on success.
 * return 0 on failure.
 */
-unsigned int copy_connected_tcp_relays(Net_Crypto *c, Node_format *tcp_relays, uint16_t num)
+unsigned int copy_connected_tcp_relays(const Net_Crypto *c, Node_format *tcp_relays, uint16_t num)
 {
    if (num == 0)
        return 0;
@@ -2046,8 +2077,8 @@ static void clear_disconnected_tcp(Net_Crypto *c)
 * return -1 on failure.
 * return 0 on success.
 */
-int connection_status_handler(Net_Crypto *c, int crypt_connection_id, int (*connection_status_callback)(void *object,
+int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
-                              int id, uint8_t status), void *object, int id)
+                              int (*connection_status_callback)(void *object, int id, uint8_t status), void *object, int id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -2068,7 +2099,7 @@ int connection_status_handler(Net_Crypto *c, int crypt_connection_id, int (*conn
 * return -1 on failure.
 * return 0 on success.
 */
-int connection_data_handler(Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
+int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
                            int id, uint8_t *data, uint16_t length), void *object, int id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -2091,7 +2122,7 @@ int connection_data_handler(Net_Crypto *c, int crypt_connection_id, int (*connec
 * return 0 on success.
 */
 int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
-                                  int (*connection_lossy_data_callback)(void *object, int id, uint8_t *data, uint16_t length), void *object, int id)
+                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object, int id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -2109,7 +2140,7 @@ int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
 * return -1 on failure.
 * return connection id on success.
 */
-static int crypto_id_ip_port(Net_Crypto *c, IP_Port ip_port)
+static int crypto_id_ip_port(const Net_Crypto *c, IP_Port ip_port)
 {
    return bs_list_find(&c->ip_port_list, &ip_port);
 }
@@ -2159,7 +2190,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
 /* The dT for the average packet recieving rate calculations.
   Also used as the */
-#define PACKET_COUNTER_AVERAGE_INTERVAL 200
+#define PACKET_COUNTER_AVERAGE_INTERVAL 100
 /* Ratio of recv queue size / recv packet rate (in seconds) times
 * the number of ms between request packets to send at that ratio
@@ -2225,13 +2256,13 @@ static void send_crypto_packets(Net_Crypto *c)
                }
                //new "dropped" value: weighted average of previous value and packet drop rate measured by the number of packets which were resends of previous packets
-                double dropped = (conn->dropped) * 0.5 + (conn->packets_resent / dt) * 0.5;
+                double dropped = (conn->dropped) * 0.30 + ((double)conn->packets_resent / dt) * 0.70;
                //since the "dropped" packets measure is delayed in time from the actual # of dropped packets,
-                // ignore dropped packet measure for a second after it becomes high and the send rate is lowered as a result
+                // ignore dropped packet measure for 2 seconds after it becomes high and the send rate is lowered as a result
                double drop_ignore_new;
-                if (conn->drop_ignore_start + 1000 < temp_time) {
+                if (conn->drop_ignore_start + 2000 < temp_time) {
                    drop_ignore_new = 0.0;
                    if ((dropped * 1000.0) / conn->packet_send_rate >= 0.10) {
@@ -2249,7 +2280,6 @@ static void send_crypto_packets(Net_Crypto *c)
                    realrate = r;
                }
                //calculate exponential increase in rate, triggered when drop rate is below 5% for 5 seconds
                if ((dropped * 1000.0) / conn->packet_send_rate >= 0.05) {
                    conn->rate_increase_stop_start = temp_time;
@@ -2290,7 +2320,7 @@ static void send_crypto_packets(Net_Crypto *c)
            if (conn->last_packets_left_set == 0) {
                conn->last_packets_left_set = temp_time;
-                conn->packets_left = conn->packet_send_rate;
+                conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
            } 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;
@@ -2346,7 +2376,7 @@ static void send_crypto_packets(Net_Crypto *c)
 /* returns the number of packet slots left in the sendbuffer.
 * return 0 if failure.
 */
-uint32_t crypto_num_free_sendqueue_slots(Net_Crypto *c, int crypt_connection_id)
+uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connection_id)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -2363,7 +2393,7 @@ uint32_t crypto_num_free_sendqueue_slots(Net_Crypto *c, int crypt_connection_id)
 *
 * The first byte of data must be in the CRYPTO_RESERVED_PACKETS to PACKET_ID_LOSSY_RANGE_START range.
 */
-int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint32_t length)
+int64_t write_cryptpacket(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
 {
    if (length == 0)
        return -1;
@@ -2400,7 +2430,7 @@ int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
 *
 * Sends a lossy cryptopacket. (first byte must in the PACKET_ID_LOSSY_RANGE_*)
 */
-int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint32_t length)
+int send_lossy_cryptpacket(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length)
 {
    if (length == 0 || length > MAX_CRYPTO_DATA_SIZE)
        return -1;
@@ -2442,7 +2472,7 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id)
 *
 * sets direct_connected to 1 if connection connects directly to other, 0 if it isn't.
 */
-unsigned int crypto_connection_status(Net_Crypto *c, int crypt_connection_id, uint8_t *direct_connected)
+unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, uint8_t *direct_connected)
 {
    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
@@ -2465,7 +2495,7 @@ void new_keys(Net_Crypto *c)
 /* Save the public and private keys to the keys array.
 * Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
 */
-void save_keys(Net_Crypto *c, uint8_t *keys)
+void save_keys(const Net_Crypto *c, uint8_t *keys)
 {
    memcpy(keys, c->self_public_key, crypto_box_PUBLICKEYBYTES);
    memcpy(keys + crypto_box_PUBLICKEYBYTES, c->self_secret_key, crypto_box_SECRETKEYBYTES);
@@ -2507,7 +2537,7 @@ Net_Crypto *new_net_crypto(DHT *dht)
    networking_registerhandler(dht->net, NET_PACKET_CRYPTO_HS, &udp_handle_packet, temp);
    networking_registerhandler(dht->net, NET_PACKET_CRYPTO_DATA, &udp_handle_packet, temp);
-    bs_list_init(&temp->ip_port_list, sizeof(IP_Port));
+    bs_list_init(&temp->ip_port_list, sizeof(IP_Port), 8);
    return temp;
 }
@@ -2553,7 +2583,7 @@ static void kill_timedout(Net_Crypto *c)
 /* return the optimal interval in ms for running do_net_crypto.
 */
-uint32_t crypto_run_interval(Net_Crypto *c)
+uint32_t crypto_run_interval(const Net_Crypto *c)
 {
    return c->current_sleep_time;
 }
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index ee790f24..4fed0000 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -41,7 +41,7 @@
 #define CRYPTO_PACKET_MIN_RATE 16.0
 /* Minimum packet queue max length. */
-#define CRYPTO_MIN_QUEUE_LENGTH 8
+#define CRYPTO_MIN_QUEUE_LENGTH 16
 #define MAX_CRYPTO_PACKET_SIZE 1400
@@ -129,7 +129,7 @@ typedef struct {
    void *connection_data_callback_object;
    int connection_data_callback_id;
-    int (*connection_lossy_data_callback)(void *object, int id, uint8_t *data, uint16_t length);
+    int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
    void *connection_lossy_data_callback_object;
    int connection_lossy_data_callback_id;
@@ -157,6 +157,8 @@ typedef struct {
    Node_format tcp_relays[MAX_TCP_RELAYS_PEER];
    uint16_t num_tcp_relays;
+    uint8_t maximum_speed_reached;
    pthread_mutex_t mutex;
 } Crypto_Connection;
@@ -218,14 +220,14 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c);
 * return -1 on failure.
 * return connection id on success.
 */
-int new_crypto_connection(Net_Crypto *c, uint8_t *real_public_key);
+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).
 */
-uint64_t get_connection_dht_key(Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key);
+uint64_t 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
@@ -234,7 +236,8 @@ uint64_t get_connection_dht_key(Net_Crypto *c, int crypt_connection_id, uint8_t
 * return -1 on failure.
 * return 0 on success.
 */
-int set_connection_dht_public_key(Net_Crypto *c, int crypt_connection_id, uint8_t *dht_public_key, uint64_t timestamp);
+int set_connection_dht_public_key(const Net_Crypto *c, int crypt_connection_id, const uint8_t *dht_public_key,
+                                  uint64_t timestamp);
 /* Set the direct ip of the crypto connection.
 *
@@ -253,8 +256,8 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port);
 * return -1 on failure.
 * return 0 on success.
 */
-int connection_status_handler(Net_Crypto *c, int crypt_connection_id, int (*connection_status_callback)(void *object,
+int connection_status_handler(const Net_Crypto *c, int crypt_connection_id,
-                              int id, uint8_t status), void *object, int id);
+                              int (*connection_status_callback)(void *object, int id, uint8_t status), void *object, int id);
 /* Set function to be called when connection with crypt_connection_id receives a lossless data packet of length.
 *
@@ -264,7 +267,7 @@ int connection_status_handler(Net_Crypto *c, int crypt_connection_id, int (*conn
 * return -1 on failure.
 * return 0 on success.
 */
-int connection_data_handler(Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
+int connection_data_handler(const Net_Crypto *c, int crypt_connection_id, int (*connection_data_callback)(void *object,
                            int id, uint8_t *data, uint16_t length), void *object, int id);
@@ -277,12 +280,13 @@ int connection_data_handler(Net_Crypto *c, int crypt_connection_id, int (*connec
 * return 0 on success.
 */
 int connection_lossy_data_handler(Net_Crypto *c, int crypt_connection_id,
-                                  int (*connection_lossy_data_callback)(void *object, int id, uint8_t *data, uint16_t length), void *object, int id);
+                                  int (*connection_lossy_data_callback)(void *object, int id, const uint8_t *data, uint16_t length), void *object,
+                                  int id);
 /* returns the number of packet slots left in the sendbuffer.
 * return 0 if failure.
 */
-uint32_t crypto_num_free_sendqueue_slots(Net_Crypto *c, int crypt_connection_id);
+uint32_t crypto_num_free_sendqueue_slots(const Net_Crypto *c, int crypt_connection_id);
 /* Sends a lossless cryptopacket.
 *
@@ -291,28 +295,28 @@ uint32_t crypto_num_free_sendqueue_slots(Net_Crypto *c, int crypt_connection_id)
 *
 * The first byte of data must be in the CRYPTO_RESERVED_PACKETS to PACKET_ID_LOSSY_RANGE_START range.
 */
-int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint32_t length);
+int64_t write_cryptpacket(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length);
 /* return -1 on failure.
 * return 0 on success.
 *
 * Sends a lossy cryptopacket. (first byte must in the PACKET_ID_LOSSY_RANGE_*)
 */
-int send_lossy_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data, uint32_t length);
+int send_lossy_cryptpacket(const Net_Crypto *c, int crypt_connection_id, const uint8_t *data, uint32_t length);
 /* Add a tcp relay, associating it to a crypt_connection_id.
 *
 * return 0 if it was added.
 * return -1 if it wasn't.
 */
-int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, uint8_t *public_key);
+int add_tcp_relay_peer(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, const uint8_t *public_key);
 /* Add a tcp relay to the array.
 *
 * return 0 if it was added.
 * return -1 if it wasn't.
 */
-int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key);
+int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, const uint8_t *public_key);
 /* 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.
@@ -320,7 +324,7 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key);
 * return number of relays copied to tcp_relays on success.
 * return 0 on failure.
 */
-unsigned int copy_connected_tcp_relays(Net_Crypto *c, Node_format *tcp_relays, uint16_t num);
+unsigned int copy_connected_tcp_relays(const Net_Crypto *c, Node_format *tcp_relays, uint16_t num);
 /* Kill a crypto connection.
 *
@@ -334,7 +338,7 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id);
 *
 * sets direct_connected to 1 if connection connects directly to other, 0 if it isn't.
 */
-unsigned int crypto_connection_status(Net_Crypto *c, int crypt_connection_id, uint8_t *direct_connected);
+unsigned int crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, uint8_t *direct_connected);
 /* Generate our public and private keys.
@@ -345,7 +349,7 @@ void new_keys(Net_Crypto *c);
 /* Save the public and private keys to the keys array.
 *  Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
 */
-void save_keys(Net_Crypto *c, uint8_t *keys);
+void save_keys(const Net_Crypto *c, uint8_t *keys);
 /* Load the public and private keys from the keys array.
 *  Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
@@ -359,7 +363,7 @@ Net_Crypto *new_net_crypto(DHT *dht);
 /* return the optimal interval in ms for running do_net_crypto.
 */
-uint32_t crypto_run_interval(Net_Crypto *c);
+uint32_t crypto_run_interval(const Net_Crypto *c);
 /* Main loop. */
 void do_net_crypto(Net_Crypto *c);
diff --git a/toxcore/network.c b/toxcore/network.c
index 68359016..0009a558 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -181,13 +181,13 @@ int set_socket_dualstack(sock_t sock)
 {
    int ipv6only = 0;
    socklen_t optsize = sizeof(ipv6only);
-    int res = getsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6only, &optsize);
+    int res = getsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&ipv6only, &optsize);
    if ((res == 0) && (ipv6only == 0))
        return 1;
    ipv6only = 0;
-    return (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6only, sizeof(ipv6only)) == 0);
+    return (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&ipv6only, sizeof(ipv6only)) == 0);
 }
@@ -596,10 +596,10 @@ Networking_Core *new_networking(IP ip, uint16_t port)
     */
    uint16_t port_to_try = port;
    *portptr = htons(port_to_try);
-    int tries, res;
+    int tries;
    for (tries = TOX_PORTRANGE_FROM; tries <= TOX_PORTRANGE_TO; tries++) {
-        res = bind(temp->sock, (struct sockaddr *)&addr, addrsize);
+        int res = bind(temp->sock, (struct sockaddr *)&addr, addrsize);
        if (!res) {
            temp->port = *portptr;
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 194178f3..1915324f 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -54,7 +54,7 @@ static void change_symmetric_key(Onion *onion)
 * return -1 on failure.
 * return 0 on success.
 */
-int create_onion_path(DHT *dht, Onion_Path *new_path, Node_format *nodes)
+int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *nodes)
 {
    if (!new_path || !nodes)
        return -1;
@@ -84,17 +84,19 @@ int create_onion_path(DHT *dht, Onion_Path *new_path, Node_format *nodes)
    return 0;
 }
-/* Create and send a onion packet.
+/* Create a onion packet.
 *
- * Use Onion_Path path to send data of length to dest.
+ * Use Onion_Path path to create packet for data of length to dest.
 * Maximum length of data is ONION_MAX_DATA_SIZE.
+ * packet should be at least ONION_MAX_PACKET_SIZE big.
 *
 * return -1 on failure.
- * return 0 on success.
+ * return length of created packet on success.
 */
-int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint8_t *data, uint32_t length)
+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)
 {
-    if (1 + length + SEND_1 > ONION_MAX_PACKET_SIZE || length == 0)
+    if (1 + length + SEND_1 > max_packet_length || length == 0)
        return -1;
    to_net_family(&dest.ip);
@@ -126,7 +128,6 @@ int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint
    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE + length + crypto_box_MACBYTES)
        return -1;
-    uint8_t packet[1 + length + SEND_1];
    packet[0] = NET_PACKET_ONION_SEND_INITIAL;
    memcpy(packet + 1, nonce, crypto_box_NONCEBYTES);
    memcpy(packet + 1 + crypto_box_NONCEBYTES, path->public_key1, crypto_box_PUBLICKEYBYTES);
@@ -137,7 +138,26 @@ int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint
    if ((uint32_t)len != SIZE_IPPORT + SEND_BASE * 2 + length + crypto_box_MACBYTES)
        return -1;
-    if ((uint32_t)sendpacket(net, path->ip_port1, packet, sizeof(packet)) != sizeof(packet))
+    return 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + len;
+}
+/* Create and send a onion packet.
+ *
+ * Use Onion_Path path to send data of length to dest.
+ * Maximum length of data is ONION_MAX_DATA_SIZE.
+ *
+ * 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)
+{
+    uint8_t packet[ONION_MAX_PACKET_SIZE];
+    int len = create_onion_packet(packet, sizeof(packet), path, dest, data, length);
+    if (len == -1)
+        return -1;
+    if (sendpacket(net, path->ip_port1, packet, len) != len)
        return -1;
    return 0;
@@ -189,7 +209,7 @@ static int handle_send_initial(void *object, IP_Port source, const uint8_t *pack
    return onion_send_1(onion, plain, len, source, packet + 1);
 }
-int onion_send_1(Onion *onion, uint8_t *plain, uint32_t len, IP_Port source, const uint8_t *nonce)
+int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_t len, IP_Port source, const uint8_t *nonce)
 {
    IP_Port send_to;
    ipport_unpack(&send_to, plain);
diff --git a/toxcore/onion.h b/toxcore/onion.h
index 7ee630e6..527f5c60 100644
--- a/toxcore/onion.h
+++ b/toxcore/onion.h
@@ -76,7 +76,19 @@ typedef struct {
 * return -1 on failure.
 * return 0 on success.
 */
-int create_onion_path(DHT *dht, Onion_Path *new_path, Node_format *nodes);
+int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *nodes);
+/* Create a onion packet.
+ *
+ * Use Onion_Path path to create packet for data of length to dest.
+ * Maximum length of data is ONION_MAX_DATA_SIZE.
+ * packet should be at least ONION_MAX_PACKET_SIZE big.
+ *
+ * return -1 on failure.
+ * 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);
 /* Create and send a onion packet.
 *
@@ -86,7 +98,7 @@ int create_onion_path(DHT *dht, Onion_Path *new_path, Node_format *nodes);
 * return -1 on failure.
 * return 0 on success.
 */
-int send_onion_packet(Networking_Core *net, Onion_Path *path, IP_Port dest, uint8_t *data, uint32_t length);
+int send_onion_packet(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *data, uint32_t length);
 /* Create and send a onion response sent initially to dest with.
 * Maximum length of data is ONION_RESPONSE_MAX_DATA_SIZE.
@@ -106,7 +118,7 @@ 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(Onion *onion, uint8_t *plain, uint32_t len, IP_Port source, const uint8_t *nonce);
+int onion_send_1(const Onion *onion, const uint8_t *plain, uint32_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.
 *
diff --git a/toxcore/onion_announce.c b/toxcore/onion_announce.c
index 27d13a8f..dff05135 100644
--- a/toxcore/onion_announce.c
+++ b/toxcore/onion_announce.c
@@ -35,7 +35,7 @@
 #define DATA_REQUEST_MIN_SIZE ONION_DATA_REQUEST_MIN_SIZE
 #define DATA_REQUEST_MIN_SIZE_RECV (DATA_REQUEST_MIN_SIZE + ONION_RETURN_3)
-/* Create and send an onion announce request packet.
+/* Create an onion announce request packet in packet of max_packet_length (recommended size ONION_MAX_PACKET_SIZE).
 *
 * path is the path the request will take before it is sent to dest.
 *
@@ -47,10 +47,11 @@
 * receive back in the response.
 *
 * return -1 on failure.
- * return 0 on success.
+ * return packet length on success.
 */
-int send_announce_request(Networking_Core *net, Onion_Path *path, Node_format dest, uint8_t *public_key,
+int create_announce_request(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, Node_format dest,
-                          uint8_t *secret_key, uint8_t *ping_id, uint8_t *client_id, uint8_t *data_public_key, uint64_t sendback_data)
+                            const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id, const uint8_t *client_id,
+                            const uint8_t *data_public_key, uint64_t sendback_data)
 {
    uint8_t plain[ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES +
                  ONION_ANNOUNCE_SENDBACK_DATA_LENGTH];
@@ -59,22 +60,22 @@ int send_announce_request(Networking_Core *net, Onion_Path *path, Node_format de
    memcpy(plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES, data_public_key, crypto_box_PUBLICKEYBYTES);
    memcpy(plain + ONION_PING_ID_SIZE + crypto_box_PUBLICKEYBYTES + crypto_box_PUBLICKEYBYTES, &sendback_data,
           sizeof(sendback_data));
-    uint8_t packet[ANNOUNCE_REQUEST_SIZE];
+    uint8_t temp[ANNOUNCE_REQUEST_SIZE];
-    packet[0] = NET_PACKET_ANNOUNCE_REQUEST;
+    temp[0] = NET_PACKET_ANNOUNCE_REQUEST;
-    random_nonce(packet + 1);
+    random_nonce(temp + 1);
-    int len = encrypt_data(dest.client_id, secret_key, packet + 1, plain, sizeof(plain),
+    int len = encrypt_data(dest.client_id, secret_key, temp + 1, plain, sizeof(plain),
-                           packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+                           temp + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
    if ((uint32_t)len + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES != ANNOUNCE_REQUEST_SIZE)
        return -1;
-    memcpy(packet + 1 + crypto_box_NONCEBYTES, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(temp + 1 + crypto_box_NONCEBYTES, public_key, crypto_box_PUBLICKEYBYTES);
-    return send_onion_packet(net, path, dest.ip_port, packet, sizeof(packet));
+    return create_onion_packet(packet, max_packet_length, path, dest.ip_port, temp, sizeof(temp));
 }
-/* Create and send an onion data request packet.
+/* Create an onion data request packet in packet of max_packet_length (recommended size ONION_MAX_PACKET_SIZE).
 *
 * path is the path the request will take before it is sent to dest.
 * (if dest knows the person with the public_key they should
@@ -88,35 +89,96 @@ int send_announce_request(Networking_Core *net, Onion_Path *path, Node_format de
 * return -1 on failure.
 * return 0 on success.
 */
-int send_data_request(Networking_Core *net, Onion_Path *path, IP_Port dest, uint8_t *public_key,
+int create_data_request(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
-                      uint8_t *encrypt_public_key, uint8_t *nonce, uint8_t *data, uint16_t length)
+                        const uint8_t *public_key, const uint8_t *encrypt_public_key, const uint8_t *nonce, const uint8_t *data,
+                        uint16_t length)
 {
    if ((unsigned int)DATA_REQUEST_MIN_SIZE + length > ONION_MAX_DATA_SIZE)
        return -1;
-    uint8_t packet[DATA_REQUEST_MIN_SIZE + length];
+    uint8_t temp[DATA_REQUEST_MIN_SIZE + length];
-    packet[0] = NET_PACKET_ONION_DATA_REQUEST;
+    temp[0] = NET_PACKET_ONION_DATA_REQUEST;
-    memcpy(packet + 1, public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(temp + 1, public_key, crypto_box_PUBLICKEYBYTES);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
+    memcpy(temp + 1 + crypto_box_PUBLICKEYBYTES, nonce, crypto_box_NONCEBYTES);
    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);
-    memcpy(packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, random_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(temp + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES, random_public_key, crypto_box_PUBLICKEYBYTES);
+    int len = encrypt_data(encrypt_public_key, random_secret_key, temp + 1 + crypto_box_PUBLICKEYBYTES,
+                           data, length, temp + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
-    int len = encrypt_data(encrypt_public_key, random_secret_key, packet + 1 + crypto_box_PUBLICKEYBYTES,
+    if (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + (uint32_t)len != sizeof(temp))
-                           data, length, packet + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES);
+        return -1;
+    return create_onion_packet(packet, max_packet_length, path, dest, temp, sizeof(temp));
+}
+/* Create and send an onion announce request packet.
+ *
+ * path is the path the request will take before it is sent to dest.
+ *
+ * public_key and secret_key is the kepair which will be used to encrypt the request.
+ * ping_id is the ping id that will be sent in the request.
+ * client_id is the client id of the node we are searching for.
+ * data_public_key is the public key we want others to encrypt their data packets with.
+ * sendback_data is the data of ONION_ANNOUNCE_SENDBACK_DATA_LENGTH length that we expect to
+ * receive back in the response.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int send_announce_request(Networking_Core *net, const Onion_Path *path, Node_format dest, const uint8_t *public_key,
+                          const uint8_t *secret_key, const uint8_t *ping_id, const uint8_t *client_id, const uint8_t *data_public_key,
+                          uint64_t sendback_data)
+{
+    uint8_t packet[ONION_MAX_PACKET_SIZE];
+    int len = create_announce_request(packet, sizeof(packet), path, dest, public_key, secret_key, ping_id, client_id,
+                                      data_public_key, sendback_data);
+    if (len == -1)
+        return -1;
-    if (1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES + (uint32_t)len != sizeof(packet))
+    if (sendpacket(net, path->ip_port1, packet, len) != len)
        return -1;
-    return send_onion_packet(net, path, dest, packet, sizeof(packet));
+    return 0;
+}
+/* Create and send an onion data request packet.
+ *
+ * path is the path the request will take before it is sent to dest.
+ * (if dest knows the person with the public_key they should
+ * send the packet to that person in the form of a response)
+ *
+ * public_key is the real public key of the node which we want to send the data of length length to.
+ * encrypt_public_key is the public key used to encrypt the data packet.
+ *
+ * nonce is the nonce to encrypt this packet with
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int send_data_request(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *public_key,
+                      const uint8_t *encrypt_public_key, const uint8_t *nonce, const uint8_t *data, uint16_t length)
+{
+    uint8_t packet[ONION_MAX_PACKET_SIZE];
+    int len = create_data_request(packet, sizeof(packet), path, dest, public_key, encrypt_public_key, nonce, data, length);
+    if (len == -1)
+        return -1;
+    if (sendpacket(net, path->ip_port1, packet, len) != len)
+        return -1;
+    return 0;
 }
 /* Generate a ping_id and put it in ping_id */
-static void generate_ping_id(Onion_Announce *onion_a, uint64_t time, const uint8_t *public_key, IP_Port ret_ip_port,
+static void generate_ping_id(const Onion_Announce *onion_a, uint64_t time, const uint8_t *public_key,
-                             uint8_t *ping_id)
+                             IP_Port ret_ip_port, uint8_t *ping_id)
 {
    time /= PING_ID_TIMEOUT;
    uint8_t data[crypto_box_KEYBYTES + sizeof(time) + crypto_box_PUBLICKEYBYTES + sizeof(ret_ip_port)];
diff --git a/toxcore/onion_announce.h b/toxcore/onion_announce.h
index ea320998..d31355e5 100644
--- a/toxcore/onion_announce.h
+++ b/toxcore/onion_announce.h
@@ -61,6 +61,42 @@ typedef struct {
    Shared_Keys shared_keys_recv;
 } Onion_Announce;
+/* Create an onion announce request packet in packet of max_packet_length (recommended size ONION_MAX_PACKET_SIZE).
+ *
+ * path is the path the request will take before it is sent to dest.
+ *
+ * public_key and secret_key is the kepair which will be used to encrypt the request.
+ * ping_id is the ping id that will be sent in the request.
+ * client_id is the client id of the node we are searching for.
+ * data_public_key is the public key we want others to encrypt their data packets with.
+ * sendback_data is the data of ONION_ANNOUNCE_SENDBACK_DATA_LENGTH length that we expect to
+ * receive back in the response.
+ *
+ * return -1 on failure.
+ * return packet length on success.
+ */
+int create_announce_request(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, Node_format dest,
+                            const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id, const uint8_t *client_id,
+                            const uint8_t *data_public_key, uint64_t sendback_data);
+/* Create an onion data request packet in packet of max_packet_length (recommended size ONION_MAX_PACKET_SIZE).
+ *
+ * path is the path the request will take before it is sent to dest.
+ * (if dest knows the person with the public_key they should
+ * send the packet to that person in the form of a response)
+ *
+ * public_key is the real public key of the node which we want to send the data of length length to.
+ * encrypt_public_key is the public key used to encrypt the data packet.
+ *
+ * nonce is the nonce to encrypt this packet with
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int create_data_request(uint8_t *packet, uint16_t max_packet_length, const Onion_Path *path, IP_Port dest,
+                        const uint8_t *public_key, const uint8_t *encrypt_public_key, const uint8_t *nonce, const uint8_t *data,
+                        uint16_t length);
 /* Create and send an onion announce request packet.
 *
 * path is the path the request will take before it is sent to dest.
@@ -75,8 +111,9 @@ typedef struct {
 * return -1 on failure.
 * return 0 on success.
 */
-int send_announce_request(Networking_Core *net, Onion_Path *path, Node_format dest, uint8_t *public_key,
+int send_announce_request(Networking_Core *net, const Onion_Path *path, Node_format dest, const uint8_t *public_key,
-                          uint8_t *secret_key, uint8_t *ping_id, uint8_t *client_id, uint8_t *data_public_key, uint64_t sendback_data);
+                          const uint8_t *secret_key, const uint8_t *ping_id, const uint8_t *client_id, const uint8_t *data_public_key,
+                          uint64_t sendback_data);
 /* Create and send an onion data request packet.
 *
@@ -94,8 +131,8 @@ int send_announce_request(Networking_Core *net, Onion_Path *path, Node_format de
 * return -1 on failure.
 * return 0 on success.
 */
-int send_data_request(Networking_Core *net, Onion_Path *path, IP_Port dest, uint8_t *public_key,
+int send_data_request(Networking_Core *net, const Onion_Path *path, IP_Port dest, const uint8_t *public_key,
-                      uint8_t *encrypt_public_key, uint8_t *nonce, uint8_t *data, uint16_t length);
+                      const uint8_t *encrypt_public_key, const uint8_t *nonce, const uint8_t *data, uint16_t length);
 Onion_Announce *new_onion_announce(DHT *dht);
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index 644a7c5b..42982ea8 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -38,7 +38,7 @@
 * return -1 if nodes are suitable for creating a new path.
 * return path number of already existing similar path if one already exists.
 */
-static int is_path_used(Onion_Client_Paths *onion_paths, Node_format *nodes)
+static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format *nodes)
 {
    uint32_t i;
@@ -68,7 +68,7 @@ static int is_path_used(Onion_Client_Paths *onion_paths, Node_format *nodes)
 * TODO: Make this function better, it currently probably is vulnerable to some attacks that
 * could de anonimize us.
 */
-static int random_path(DHT *dht, Onion_Client_Paths *onion_paths, uint32_t pathnum, Onion_Path *path)
+static int random_path(const DHT *dht, Onion_Client_Paths *onion_paths, uint32_t pathnum, Onion_Path *path)
 {
    if (pathnum >= NUMBER_ONION_PATHS)
        pathnum = rand() % NUMBER_ONION_PATHS;
@@ -125,6 +125,23 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, IP_Port s
    return ~0;
 }
+/* Function to send onion packet via TCP and UDP.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int send_onion_packet_tcp_udp(const Onion_Client *onion_c, IP_Port ip_port, const uint8_t *data, uint32_t length)
+{
+    if (ip_port.ip.family == AF_INET || ip_port.ip.family == AF_INET6) {
+        if ((uint32_t)sendpacket(onion_c->net, ip_port, data, length) != length)
+            return -1;
+        return 0;
+    } else {
+        return -1; //TODO: TCP
+    }
+}
 /* Creates a sendback for use in an announce request.
 *
 * num is 0 if we used our secret public key for the announce
@@ -140,7 +157,8 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, IP_Port s
 * return 0 on success
 *
 */
-static int new_sendback(Onion_Client *onion_c, uint32_t num, uint8_t *public_key, IP_Port ip_port, uint64_t *sendback)
+static int new_sendback(Onion_Client *onion_c, uint32_t num, const uint8_t *public_key, IP_Port ip_port,
+                        uint64_t *sendback)
 {
    uint8_t data[sizeof(uint32_t) + crypto_box_PUBLICKEYBYTES + sizeof(IP_Port)];
    memcpy(data, &num, sizeof(uint32_t));
@@ -181,8 +199,8 @@ static uint32_t check_sendback(Onion_Client *onion_c, const uint8_t *sendback, u
    return num;
 }
-static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_Port dest, uint8_t *dest_pubkey,
+static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_Port dest, const uint8_t *dest_pubkey,
-                                        uint8_t *ping_id, uint32_t pathnum)
+                                        const uint8_t *ping_id, uint32_t pathnum)
 {
    if (num > onion_c->num_friends)
        return -1;
@@ -207,16 +225,29 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
        if (random_path(onion_c->dht, &onion_c->onion_paths, pathnum, &path) == -1)
            return -1;
-        return send_announce_request(onion_c->net, &path, dest_node, onion_c->c->self_public_key,
+        uint8_t packet[ONION_MAX_PACKET_SIZE];
-                                     onion_c->c->self_secret_key, ping_id,
+        int len = create_announce_request(packet, sizeof(packet), &path, dest_node, onion_c->c->self_public_key,
-                                     onion_c->c->self_public_key, onion_c->temp_public_key, sendback);
+                                          onion_c->c->self_secret_key, ping_id, onion_c->c->self_public_key, onion_c->temp_public_key, sendback);
+        if (len == -1) {
+            return -1;
+        }
+        return send_onion_packet_tcp_udp(onion_c, path.ip_port1, packet, len);
    } else {
        if (random_path(onion_c->dht, &onion_c->friends_list[num - 1].onion_paths, pathnum, &path) == -1)
            return -1;
-        return send_announce_request(onion_c->net, &path, dest_node, onion_c->friends_list[num - 1].temp_public_key,
+        uint8_t packet[ONION_MAX_PACKET_SIZE];
-                                     onion_c->friends_list[num - 1].temp_secret_key, ping_id,
+        int len = create_announce_request(packet, sizeof(packet), &path, dest_node,
-                                     onion_c->friends_list[num - 1].real_client_id, zero_ping_id, sendback);
+                                          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, sendback);
+        if (len == -1) {
+            return -1;
+        }
+        return send_onion_packet_tcp_udp(onion_c, path.ip_port1, packet, len);
    }
 }
@@ -249,8 +280,8 @@ static int cmp_entry(const void *a, const void *b)
    return 0;
 }
-static int client_add_to_list(Onion_Client *onion_c, uint32_t num, uint8_t *public_key, IP_Port ip_port,
+static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t *public_key, IP_Port ip_port,
-                              uint8_t is_stored, uint8_t *pingid_or_key, IP_Port source)
+                              uint8_t is_stored, const uint8_t *pingid_or_key, IP_Port source)
 {
    if (num > onion_c->num_friends)
        return -1;
@@ -308,7 +339,7 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, uint8_t *publ
    return 0;
 }
-static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, uint8_t *client_id)
+static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, const uint8_t *client_id)
 {
    uint32_t i;
@@ -324,7 +355,7 @@ static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, ui
    return 1;
 }
-static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, Node_format *nodes, uint16_t num_nodes,
+static int client_ping_nodes(Onion_Client *onion_c, uint32_t num, const Node_format *nodes, uint16_t num_nodes,
                             IP_Port source)
 {
    if (num > onion_c->num_friends)
@@ -578,9 +609,15 @@ int send_onion_data(const Onion_Client *onion_c, int friend_num, const uint8_t *
    uint32_t good = 0;
    for (i = 0; i < num_good; ++i) {
-        if (send_data_request(onion_c->net, &path[i], list_nodes[good_nodes[i]].ip_port,
+        uint8_t o_packet[ONION_MAX_PACKET_SIZE];
-                              onion_c->friends_list[friend_num].real_client_id, list_nodes[good_nodes[i]].data_public_key, nonce, packet,
+        len = create_data_request(o_packet, sizeof(o_packet), &path[i], list_nodes[good_nodes[i]].ip_port,
-                              sizeof(packet)) == 0)
+                                  onion_c->friends_list[friend_num].real_client_id, 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].ip_port1, o_packet, len) == 0)
            ++good;
    }
@@ -594,7 +631,7 @@ int send_onion_data(const Onion_Client *onion_c, int friend_num, const uint8_t *
 * return the number of packets sent on success
 * return -1 on failure.
 */
-static int send_dht_fakeid(Onion_Client *onion_c, int friend_num, uint8_t *data, uint32_t length)
+static int send_dht_fakeid(const Onion_Client *onion_c, int friend_num, const uint8_t *data, uint32_t length)
 {
    if ((uint32_t)friend_num >= onion_c->num_friends)
        return -1;
@@ -657,7 +694,7 @@ 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(Onion_Client *onion_c, uint16_t friend_num, uint8_t onion_dht_both)
+static int send_fakeid_announce(const Onion_Client *onion_c, uint16_t friend_num, uint8_t onion_dht_both)
 {
    if (friend_num >= onion_c->num_friends)
        return -1;
@@ -794,7 +831,7 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
    uint32_t i;
    for (i = onion_c->num_friends; i != 0; --i) {
-        if (onion_c->friends_list[i].status != 0)
+        if (onion_c->friends_list[i - 1].status != 0)
            break;
    }
@@ -815,7 +852,7 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
 * return 0 on success.
 */
 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, uint8_t *public_key), void *object, uint32_t number)
+                           uint32_t number, IP_Port ip_port, const uint8_t *public_key), void *object, uint32_t number)
 {
    if ((uint32_t)friend_num >= onion_c->num_friends)
        return -1;
@@ -869,7 +906,7 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
 * return 0 on failure (no key copied).
 * return timestamp on success (key copied).
 */
-uint64_t onion_getfriend_DHT_pubkey(Onion_Client *onion_c, int friend_num, uint8_t *dht_key)
+uint64_t 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;
@@ -891,7 +928,7 @@ uint64_t onion_getfriend_DHT_pubkey(Onion_Client *onion_c, int friend_num, uint8
 *  return  1, ip if client_id refers to a friend and we found him
 *
 */
-int onion_getfriendip(Onion_Client *onion_c, int friend_num, IP_Port *ip_port)
+int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_port)
 {
    uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
@@ -965,7 +1002,7 @@ static void do_friend(Onion_Client *onion_c, uint16_t friendnum)
            if (count < (uint32_t)rand() % MAX_ONION_CLIENTS) {
                Node_format nodes_list[MAX_SENT_NODES];
                uint32_t num_nodes = get_close_nodes(onion_c->dht, onion_c->friends_list[friendnum].real_client_id, nodes_list,
-                                                     rand() % 2 ? AF_INET : AF_INET6, 1, 0);
+                                                     (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
                for (i = 0; i < num_nodes; ++i)
                    client_send_announce_request(onion_c, friendnum + 1, nodes_list[i].ip_port, nodes_list[i].client_id, 0, ~0);
@@ -1047,7 +1084,7 @@ static void do_announce(Onion_Client *onion_c)
        if (count < (uint32_t)rand() % MAX_ONION_CLIENTS) {
            Node_format nodes_list[MAX_SENT_NODES];
            uint32_t num_nodes = get_close_nodes(onion_c->dht, onion_c->c->self_public_key, nodes_list,
-                                                 rand() % 2 ? AF_INET : AF_INET6, 1, 0);
+                                                 (rand() % 2) ? AF_INET : AF_INET6, 1, 0);
            for (i = 0; i < num_nodes; ++i) {
                client_send_announce_request(onion_c, 0, nodes_list[i].ip_port, nodes_list[i].client_id, 0, ~0);
diff --git a/toxcore/onion_client.h b/toxcore/onion_client.h
index a74783f6..bf891e7a 100644
--- a/toxcore/onion_client.h
+++ b/toxcore/onion_client.h
@@ -97,7 +97,7 @@ typedef struct {
    Last_Pinged last_pinged[MAX_STORED_PINGED_NODES];
    uint8_t last_pinged_index;
-    int (*tcp_relay_node_callback)(void *object, uint32_t number, IP_Port ip_port, uint8_t *public_key);
+    int (*tcp_relay_node_callback)(void *object, uint32_t number, IP_Port ip_port, const uint8_t *public_key);
    void *tcp_relay_node_callback_object;
    uint32_t tcp_relay_node_callback_number;
 } Onion_Friend;
@@ -171,7 +171,7 @@ int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_on
 *  return  1, ip if client_id refers to a friend and we found him
 *
 */
-int onion_getfriendip(Onion_Client *onion_c, int friend_num, IP_Port *ip_port);
+int onion_getfriendip(const Onion_Client *onion_c, int friend_num, IP_Port *ip_port);
 /* Set the function for this friend that will be callbacked with object and number
 * when that friends gives us one of the TCP relays he is connected to.
@@ -182,7 +182,7 @@ int onion_getfriendip(Onion_Client *onion_c, int friend_num, IP_Port *ip_port);
 * return 0 on success.
 */
 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, uint8_t *public_key), void *object, uint32_t number);
+                           uint32_t number, IP_Port ip_port, const uint8_t *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
@@ -198,7 +198,7 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, const uin
 * return 0 on failure (no key copied).
 * return timestamp on success (key copied).
 */
-uint64_t onion_getfriend_DHT_pubkey(Onion_Client *onion_c, int friend_num, uint8_t *dht_key);
+uint64_t 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)
diff --git a/toxcore/ping_array.c b/toxcore/ping_array.c
index 5c92527e..93dade05 100644
--- a/toxcore/ping_array.c
+++ b/toxcore/ping_array.c
@@ -135,7 +135,7 @@ int ping_array_init(Ping_Array *empty_array, uint32_t size, uint32_t timeout)
    if (size == 0 || timeout == 0 || empty_array == NULL)
        return -1;
-    empty_array->entries = calloc(size * sizeof(Ping_Array_Entry), 1);
+    empty_array->entries = calloc(size, sizeof(Ping_Array_Entry));
    if (empty_array->entries == NULL)
        return -1;
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 79e4c042..1b6597ba 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -38,9 +38,9 @@ typedef struct Messenger Tox;
 * Format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
 *
 */
-void tox_get_address(Tox *tox, uint8_t *address)
+void tox_get_address(const Tox *tox, uint8_t *address)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    getaddress(m, address);
 }
@@ -61,7 +61,7 @@ void tox_get_address(Tox *tox, uint8_t *address)
 *  (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, uint8_t *address, uint8_t *data, uint16_t length)
+int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, uint16_t length)
 {
    Messenger *m = tox;
    return m_addfriend(m, address, data, length);
@@ -81,9 +81,9 @@ int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id)
 /*  return the friend number associated to that client id.
 *  return -1 if no such friend.
 */
-int32_t tox_get_friend_number(Tox *tox, uint8_t *client_id)
+int32_t tox_get_friend_number(const Tox *tox, const uint8_t *client_id)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return getfriend_id(m, client_id);
 }
@@ -93,9 +93,9 @@ int32_t tox_get_friend_number(Tox *tox, uint8_t *client_id)
 *  return 0 if success.
 *  return -1 if failure.
 */
-int tox_get_client_id(Tox *tox, int32_t friendnumber, uint8_t *client_id)
+int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return getclient_id(m, friendnumber, client_id);
 }
@@ -112,9 +112,9 @@ int tox_del_friend(Tox *tox, int32_t friendnumber)
 *  return 0 if friend is not connected to us (Offline).
 *  return -1 on failure.
 */
-int tox_get_friend_connection_status(Tox *tox, int32_t friendnumber)
+int tox_get_friend_connection_status(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_friend_connectionstatus(m, friendnumber);
 }
@@ -123,9 +123,9 @@ int tox_get_friend_connection_status(Tox *tox, int32_t friendnumber)
 *  return 1 if friend exists.
 *  return 0 if friend doesn't exist.
 */
-int tox_friend_exists(Tox *tox, int32_t friendnumber)
+int tox_friend_exists(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_friend_exists(m, friendnumber);
 }
@@ -144,7 +144,8 @@ uint32_t tox_send_message(Tox *tox, int32_t friendnumber, const uint8_t *message
    return m_sendmessage(m, friendnumber, message, length);
 }
-uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid, uint8_t *message, uint32_t length)
+uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid, const uint8_t *message,
+                                 uint32_t length)
 {
    Messenger *m = tox;
    return m_sendmessage_withid(m, friendnumber, theid, message, length);
@@ -160,13 +161,13 @@ uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid,
 *  m_sendaction_withid will send an action message with the id of your choosing,
 *  however we can generate an id for you by calling plain m_sendaction.
 */
-uint32_t tox_send_action(Tox *tox, int32_t friendnumber, uint8_t *action, uint32_t length)
+uint32_t tox_send_action(Tox *tox, int32_t friendnumber, const uint8_t *action, uint32_t length)
 {
    Messenger *m = tox;
    return m_sendaction(m, friendnumber, action, length);
 }
-uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid, uint8_t *action, uint32_t length)
+uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid, const uint8_t *action, uint32_t length)
 {
    Messenger *m = tox;
    return m_sendaction_withid(m, friendnumber, theid, action, length);
@@ -180,7 +181,7 @@ uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid,
 *  return 0 if success.
 *  return -1 if failure.
 */
-int tox_set_name(Tox *tox, uint8_t *name, uint16_t length)
+int tox_set_name(Tox *tox, const uint8_t *name, uint16_t length)
 {
    Messenger *m = tox;
    return setname(m, name, length);
@@ -193,9 +194,9 @@ int tox_set_name(Tox *tox, uint8_t *name, uint16_t length)
 *  return length of the name.
 *  return 0 on error.
 */
-uint16_t tox_get_self_name(Tox *tox, uint8_t *name)
+uint16_t tox_get_self_name(const Tox *tox, uint8_t *name)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return getself_name(m, name);
 }
@@ -205,24 +206,24 @@ uint16_t tox_get_self_name(Tox *tox, uint8_t *name)
 *  return length of name (with the NULL terminator) if success.
 *  return -1 if failure.
 */
-int tox_get_name(Tox *tox, int32_t friendnumber, uint8_t *name)
+int tox_get_name(const Tox *tox, int32_t friendnumber, uint8_t *name)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return getname(m, friendnumber, name);
 }
 /*  returns the length of name on success.
 *  returns -1 on failure.
 */
-int tox_get_name_size(Tox *tox, int32_t friendnumber)
+int tox_get_name_size(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_name_size(m, friendnumber);
 }
-int tox_get_self_name_size(Tox *tox)
+int tox_get_self_name_size(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_self_name_size(m);
 }
@@ -231,7 +232,7 @@ int tox_get_self_name_size(Tox *tox)
 *
 *  return 0 on success, -1 on failure.
 */
-int tox_set_status_message(Tox *tox, uint8_t *status, uint16_t length)
+int tox_set_status_message(Tox *tox, const uint8_t *status, uint16_t length)
 {
    Messenger *m = tox;
    return m_set_statusmessage(m, status, length);
@@ -246,15 +247,15 @@ int tox_set_user_status(Tox *tox, uint8_t status)
 /*  returns the length of status message on success.
 *  returns -1 on failure.
 */
-int tox_get_status_message_size(Tox *tox, int32_t friendnumber)
+int tox_get_status_message_size(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_statusmessage_size(m, friendnumber);
 }
-int tox_get_self_status_message_size(Tox *tox)
+int tox_get_self_status_message_size(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_self_statusmessage_size(m);
 }
@@ -262,15 +263,15 @@ int tox_get_self_status_message_size(Tox *tox)
 * 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(Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
+int tox_get_status_message(const Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_copy_statusmessage(m, friendnumber, buf, maxlen);
 }
-int tox_get_self_status_message(Tox *tox, uint8_t *buf, uint32_t maxlen)
+int tox_get_self_status_message(const Tox *tox, uint8_t *buf, uint32_t maxlen)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_copy_self_statusmessage(m, buf, maxlen);
 }
@@ -279,24 +280,24 @@ int tox_get_self_status_message(Tox *tox, uint8_t *buf, uint32_t maxlen)
 * 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(Tox *tox, int32_t friendnumber)
+uint8_t tox_get_user_status(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_userstatus(m, friendnumber);
 }
-uint8_t tox_get_self_user_status(Tox *tox)
+uint8_t tox_get_self_user_status(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_self_userstatus(m);
 }
 /* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
 * returns -1 on error.
 */
-uint64_t tox_get_last_online(Tox *tox, int32_t friendnumber)
+uint64_t tox_get_last_online(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_last_online(m, friendnumber);
 }
@@ -317,9 +318,9 @@ int tox_set_user_is_typing(Tox *tox, int32_t friendnumber, uint8_t is_typing)
 * returns 0 if friend is not typing.
 * returns 1 if friend is typing.
 */
-uint8_t tox_get_is_typing(Tox *tox, int32_t friendnumber)
+uint8_t tox_get_is_typing(const Tox *tox, int32_t friendnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_get_istyping(m, friendnumber);
 }
@@ -335,16 +336,16 @@ void tox_set_sends_receipts(Tox *tox, int32_t friendnumber, int yesno)
 /* 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(Tox *tox)
+uint32_t tox_count_friendlist(const Tox *tox)
 {
-    Messenger *m = tox;
+    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(Tox *tox)
+uint32_t tox_get_num_online_friends(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return get_num_online_friends(m);
 }
@@ -353,9 +354,9 @@ uint32_t tox_get_num_online_friends(Tox *tox)
 * 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(Tox *tox, int32_t *out_list, uint32_t list_size)
+uint32_t tox_get_friendlist(const Tox *tox, int32_t *out_list, uint32_t list_size)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return copy_friendlist(m, out_list, list_size);
 }
@@ -373,7 +374,7 @@ void tox_callback_friend_request(Tox *tox, void (*function)(Tox *tox, const uint
 /* 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, uint8_t *, uint16_t, void *),
+void tox_callback_friend_message(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
                                 void *userdata)
 {
    Messenger *m = tox;
@@ -383,7 +384,7 @@ void tox_callback_friend_message(Tox *tox, void (*function)(Messenger *tox, int3
 /* 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, uint8_t *, uint16_t, void *),
+void tox_callback_friend_action(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
                                void *userdata)
 {
    Messenger *m = tox;
@@ -394,7 +395,7 @@ void tox_callback_friend_action(Tox *tox, void (*function)(Messenger *tox, int32
 *  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, uint8_t *, uint16_t, void *),
+void tox_callback_name_change(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
                              void *userdata)
 {
    Messenger *m = tox;
@@ -405,7 +406,7 @@ void tox_callback_name_change(Tox *tox, void (*function)(Messenger *tox, int32_t
 *  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, uint8_t *, uint16_t, void *),
+void tox_callback_status_message(Tox *tox, void (*function)(Messenger *tox, int32_t, const uint8_t *, uint16_t, void *),
                                 void *userdata)
 {
    Messenger *m = tox;
@@ -468,9 +469,9 @@ void tox_callback_connection_status(Tox *tox, void (*function)(Messenger *tox, i
 /* Functions to get/set the nospam part of the id.
 */
-uint32_t tox_get_nospam(Tox *tox)
+uint32_t tox_get_nospam(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return get_nospam(&(m->fr));
 }
@@ -486,7 +487,8 @@ void tox_set_nospam(Tox *tox, uint32_t nospam)
 *
 *  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, uint8_t *, void *), 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);
@@ -496,7 +498,7 @@ void tox_callback_group_invite(Tox *tox, void (*function)(Messenger *tox, int32_
 *
 *  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, uint8_t *, uint16_t, void *),
+void tox_callback_group_message(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
                                void *userdata)
 {
    Messenger *m = tox;
@@ -507,7 +509,7 @@ void tox_callback_group_message(Tox *tox, void (*function)(Messenger *tox, int,
 *
 *  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, uint8_t *, uint16_t, void *),
+void tox_callback_group_action(Tox *tox, void (*function)(Messenger *tox, int, int, const uint8_t *, uint16_t, void *),
                               void *userdata)
 {
    Messenger *m = tox;
@@ -552,9 +554,9 @@ int tox_del_groupchat(Tox *tox, int groupnumber)
 * return length of name if success
 * return -1 if failure
 */
-int tox_group_peername(Tox *tox, int groupnumber, int peernumber, uint8_t *name)
+int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return m_group_peername(m, groupnumber, peernumber, name);
 }
 /* invite friendnumber to groupnumber
@@ -571,7 +573,7 @@ int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber)
 * returns group number on success
 * returns -1 on failure.
 */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, uint8_t *friend_group_public_key)
+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);
@@ -581,7 +583,7 @@ int tox_join_groupchat(Tox *tox, int32_t friendnumber, uint8_t *friend_group_pub
 * return 0 on success
 * return -1 on failure
 */
-int tox_group_message_send(Tox *tox, int groupnumber, uint8_t *message, uint32_t length)
+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);
@@ -591,7 +593,7 @@ int tox_group_message_send(Tox *tox, int groupnumber, uint8_t *message, uint32_t
 * return 0 on success
 * return -1 on failure
 */
-int tox_group_action_send(Tox *tox, int groupnumber, uint8_t *action, uint32_t length)
+int tox_group_action_send(Tox *tox, int groupnumber, const uint8_t *action, uint32_t length)
 {
    Messenger *m = tox;
    return group_action_send(m, groupnumber, action, length);
@@ -600,9 +602,9 @@ int tox_group_action_send(Tox *tox, int groupnumber, uint8_t *action, uint32_t l
 /* Return the number of peers in the group chat on success.
 * return -1 on failure
 */
-int tox_group_number_peers(Tox *tox, int groupnumber)
+int tox_group_number_peers(const Tox *tox, int groupnumber)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return group_number_peers(m, groupnumber);
 }
@@ -616,19 +618,19 @@ int tox_group_number_peers(Tox *tox, int groupnumber)
 *
 * return -1 on failure.
 */
-int tox_group_get_names(Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
+int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
                        uint16_t length)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return group_names(m, groupnumber, names, lengths, length);
 }
 /* Return the number of chats in the instance m.
 * You should use this to determine how much memory to allocate
 * for copy_chatlist. */
-uint32_t tox_count_chatlist(Tox *tox)
+uint32_t tox_count_chatlist(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return count_chatlist(m);
 }
@@ -637,9 +639,9 @@ uint32_t tox_count_chatlist(Tox *tox)
 * 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(Tox *tox, int *out_list, uint32_t list_size)
+uint32_t tox_get_chatlist(const Tox *tox, int *out_list, uint32_t list_size)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return copy_chatlist(m, out_list, list_size);
 }
@@ -651,9 +653,8 @@ uint32_t tox_get_chatlist(Tox *tox, int *out_list, uint32_t list_size)
 *
 *  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, uint8_t *,
+void tox_callback_file_send_request(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, uint64_t,
-                                    uint16_t,
+                                    const uint8_t *, uint16_t, void *), void *userdata)
-                                    void *), void *userdata)
 {
    Messenger *m = tox;
    callback_file_sendrequest(m, function, userdata);
@@ -663,8 +664,8 @@ void tox_callback_file_send_request(Tox *tox, void (*function)(Messenger *tox, i
 *  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, uint8_t *,
+void tox_callback_file_control(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, uint8_t, uint8_t,
-                               uint16_t, void *), void *userdata)
+                               const uint8_t *, uint16_t, void *), void *userdata)
 {
    Messenger *m = tox;
    callback_file_control(m, function, userdata);
@@ -674,9 +675,8 @@ void tox_callback_file_control(Tox *tox, void (*function)(Messenger *tox, int32_
 *  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, uint8_t *, uint16_t length,
+void tox_callback_file_data(Tox *tox, void (*function)(Messenger *tox, int32_t, uint8_t, const uint8_t *,
-                            void *),
+                            uint16_t length, void *), void *userdata)
-                            void *userdata)
 {
    Messenger *m = tox;
@@ -687,7 +687,8 @@ void tox_callback_file_data(Tox *tox, void (*function)(Messenger *tox, int32_t,
 *  return file number on success
 *  return -1 on failure
 */
-int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length)
+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);
@@ -699,7 +700,7 @@ int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, uint8
 *  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,
-                          uint8_t *data, uint16_t length)
+                          const uint8_t *data, uint16_t length)
 {
    Messenger *m = tox;
    return file_control(m, friendnumber, send_receive, filenumber, message_id, data, length);
@@ -709,7 +710,7 @@ int tox_file_send_control(Tox *tox, int32_t friendnumber, uint8_t send_receive,
 *  return 0 on success
 *  return -1 on failure
 */
-int tox_file_send_data(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length)
+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);
@@ -720,7 +721,7 @@ int tox_file_send_data(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8
 *  return size on success
 *  return -1 on failure (currently will never return -1)
 */
-int tox_file_data_size(Tox *tox, int32_t friendnumber)
+int tox_file_data_size(const Tox *tox, int32_t friendnumber)
 {
    return MAX_CRYPTO_DATA_SIZE - 2;
 }
@@ -732,16 +733,17 @@ int tox_file_data_size(Tox *tox, int32_t friendnumber)
 *  return number of bytes remaining to be sent/received on success
 *  return 0 on failure
 */
-uint64_t tox_file_data_remaining(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
+uint64_t tox_file_data_remaining(const Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return file_dataremaining(m, friendnumber, filenumber, send_receive);
 }
 /***************END OF FILE SENDING FUNCTIONS******************/
 /* TODO: expose this properly. */
-static int tox_add_tcp_relay(Tox *tox, const char *address, uint8_t ipv6enabled, uint16_t port, uint8_t *public_key)
+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;
@@ -766,7 +768,7 @@ static int tox_add_tcp_relay(Tox *tox, const char *address, uint8_t ipv6enabled,
 }
 int tox_bootstrap_from_address(Tox *tox, const char *address,
-                               uint8_t ipv6enabled, uint16_t port, uint8_t *public_key)
+                               uint8_t ipv6enabled, uint16_t port, const uint8_t *public_key)
 {
    Messenger *m = tox;
    tox_add_tcp_relay(tox, address, ipv6enabled, port, public_key);
@@ -776,9 +778,9 @@ int tox_bootstrap_from_address(Tox *tox, const char *address,
 /*  return 0 if we are not connected to the DHT.
 *  return 1 if we are.
 */
-int tox_isconnected(Tox *tox)
+int tox_isconnected(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return DHT_isconnected(m->dht);
 }
@@ -823,21 +825,21 @@ void tox_do(Tox *tox)
 /* SAVING AND LOADING FUNCTIONS: */
 /*  return size of the messenger data (for saving). */
-uint32_t tox_size(Tox *tox)
+uint32_t tox_size(const Tox *tox)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    return messenger_size(m);
 }
 /* Save the messenger in data (must be allocated memory of size Messenger_size()). */
-void tox_save(Tox *tox, uint8_t *data)
+void tox_save(const Tox *tox, uint8_t *data)
 {
-    Messenger *m = tox;
+    const Messenger *m = tox;
    messenger_save(m, data);
 }
 /* Load the messenger from data of size length. */
-int tox_load(Tox *tox, uint8_t *data, uint32_t length)
+int tox_load(Tox *tox, const uint8_t *data, uint32_t length)
 {
    Messenger *m = tox;
    return messenger_load(m, data, length);
diff --git a/toxcore/tox.h b/toxcore/tox.h
index afa502f5..d931b9be 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -82,7 +82,7 @@ typedef struct Tox Tox;
 /*  return TOX_FRIEND_ADDRESS_SIZE byte address to give to others.
 * format: [client_id (32 bytes)][nospam number (4 bytes)][checksum (2 bytes)]
 */
-void tox_get_address(Tox *tox, uint8_t *address);
+void tox_get_address(const Tox *tox, uint8_t *address);
 /* Add a friend.
 * Set the data that will be sent along with friend request.
@@ -90,7 +90,7 @@ void tox_get_address(Tox *tox, uint8_t *address);
 * data is the data and length is the length.
 *
 *  return the friend number if success.
- *  return TOX_FA_TOOLONG if message length is too long.
+ *  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.
@@ -100,7 +100,7 @@ void tox_get_address(Tox *tox, uint8_t *address);
 *  (the nospam for that friend was set to the new one).
 *  return TOX_FAERR_NOMEM if increasing the friend list size fails.
 */
-int32_t tox_add_friend(Tox *tox, uint8_t *address, uint8_t *data, uint16_t length);
+int32_t tox_add_friend(Tox *tox, const uint8_t *address, const uint8_t *data, uint16_t length);
 /* Add a friend without sending a friendrequest.
@@ -111,14 +111,14 @@ int32_t tox_add_friend_norequest(Tox *tox, const uint8_t *client_id);
 /*  return the friend number associated to that client id.
    return -1 if no such friend */
-int32_t tox_get_friend_number(Tox *tox, uint8_t *client_id);
+int32_t tox_get_friend_number(const Tox *tox, const uint8_t *client_id);
 /* 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(Tox *tox, int32_t friendnumber, uint8_t *client_id);
+int tox_get_client_id(const Tox *tox, int32_t friendnumber, uint8_t *client_id);
 /* Remove a friend.
 *
@@ -133,14 +133,14 @@ int tox_del_friend(Tox *tox, int32_t friendnumber);
 *  return 0 if friend is not connected to us (Offline).
 *  return -1 on failure.
 */
-int tox_get_friend_connection_status(Tox *tox, int32_t friendnumber);
+int tox_get_friend_connection_status(const Tox *tox, int32_t friendnumber);
 /* 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(Tox *tox, int32_t friendnumber);
+int tox_friend_exists(const Tox *tox, int32_t friendnumber);
 /* Send a text chat message to an online friend.
 *
@@ -157,7 +157,8 @@ int tox_friend_exists(Tox *tox, int32_t friendnumber);
 * however we can generate an id for you by calling plain m_sendmessage.
 */
 uint32_t tox_send_message(Tox *tox, int32_t friendnumber, const uint8_t *message, uint32_t length);
-uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid, uint8_t *message, uint32_t length);
+uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid, const uint8_t *message,
+                                 uint32_t length);
 /* Send an action to an online friend.
 *
@@ -173,8 +174,8 @@ uint32_t tox_send_message_withid(Tox *tox, int32_t friendnumber, uint32_t theid,
 *  m_sendaction_withid will send an action message with the id of your choosing,
 *  however we can generate an id for you by calling plain m_sendaction.
 */
-uint32_t tox_send_action(Tox *tox, int32_t friendnumber, uint8_t *action, uint32_t length);
+uint32_t tox_send_action(Tox *tox, int32_t friendnumber, const uint8_t *action, uint32_t length);
-uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid, uint8_t *action, uint32_t length);
+uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid, const uint8_t *action, uint32_t length);
 /* Set our nickname.
 * name must be a string of maximum MAX_NAME_LENGTH length.
@@ -184,7 +185,7 @@ uint32_t tox_send_action_withid(Tox *tox, int32_t friendnumber, uint32_t theid,
 *  return 0 if success.
 *  return -1 if failure.
 */
-int tox_set_name(Tox *tox, uint8_t *name, uint16_t length);
+int tox_set_name(Tox *tox, const uint8_t *name, uint16_t length);
 /*
 * Get your nickname.
@@ -194,7 +195,7 @@ int tox_set_name(Tox *tox, uint8_t *name, uint16_t length);
 *  return length of name.
 *  return 0 on error.
 */
-uint16_t tox_get_self_name(Tox *tox, uint8_t *name);
+uint16_t tox_get_self_name(const Tox *tox, uint8_t *name);
 /* 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.
@@ -202,13 +203,13 @@ uint16_t tox_get_self_name(Tox *tox, uint8_t *name);
 *  return length of name if success.
 *  return -1 if failure.
 */
-int tox_get_name(Tox *tox, int32_t friendnumber, uint8_t *name);
+int tox_get_name(const Tox *tox, int32_t friendnumber, uint8_t *name);
 /*  returns the length of name on success.
 *  returns -1 on failure.
 */
-int tox_get_name_size(Tox *tox, int32_t friendnumber);
+int tox_get_name_size(const Tox *tox, int32_t friendnumber);
-int tox_get_self_name_size(Tox *tox);
+int tox_get_self_name_size(const Tox *tox);
 /* Set our user status.
 *
@@ -218,14 +219,14 @@ int tox_get_self_name_size(Tox *tox);
 *  returns 0 on success.
 *  returns -1 on failure.
 */
-int tox_set_status_message(Tox *tox, uint8_t *status, uint16_t length);
+int tox_set_status_message(Tox *tox, const uint8_t *status, uint16_t length);
 int tox_set_user_status(Tox *tox, uint8_t userstatus);
 /*  returns the length of status message on success.
 *  returns -1 on failure.
 */
-int tox_get_status_message_size(Tox *tox, int32_t friendnumber);
+int tox_get_status_message_size(const Tox *tox, int32_t friendnumber);
-int tox_get_self_status_message_size(Tox *tox);
+int tox_get_self_status_message_size(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.
@@ -234,22 +235,22 @@ int tox_get_self_status_message_size(Tox *tox);
 * returns the length of the copied data on success
 * retruns -1 on failure.
 */
-int tox_get_status_message(Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
+int tox_get_status_message(const Tox *tox, int32_t friendnumber, uint8_t *buf, uint32_t maxlen);
-int tox_get_self_status_message(Tox *tox, uint8_t *buf, uint32_t maxlen);
+int tox_get_self_status_message(const Tox *tox, uint8_t *buf, uint32_t maxlen);
 /*  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.
 */
-uint8_t tox_get_user_status(Tox *tox, int32_t friendnumber);
+uint8_t tox_get_user_status(const Tox *tox, int32_t friendnumber);
-uint8_t tox_get_self_user_status(Tox *tox);
+uint8_t tox_get_self_user_status(const Tox *tox);
 /* returns timestamp of last time friendnumber was seen online, or 0 if never seen.
 * returns -1 on error.
 */
-uint64_t tox_get_last_online(Tox *tox, int32_t friendnumber);
+uint64_t tox_get_last_online(const Tox *tox, int32_t friendnumber);
 /* Set our typing status for a friend.
 * You are responsible for turning it on or off.
@@ -264,7 +265,7 @@ int tox_set_user_is_typing(Tox *tox, int32_t friendnumber, uint8_t is_typing);
 * returns 0 if friend is not typing.
 * returns 1 if friend is typing.
 */
-uint8_t tox_get_is_typing(Tox *tox, int32_t friendnumber);
+uint8_t tox_get_is_typing(const Tox *tox, int32_t friendnumber);
 /* Sets whether we send read receipts for friendnumber.
 * This function is not lazy, and it will fail if yesno is not (0 or 1).
@@ -274,17 +275,17 @@ void tox_set_sends_receipts(Tox *tox, int32_t friendnumber, int yesno);
 /* 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(Tox *tox);
+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(Tox *tox);
+uint32_t tox_get_num_online_friends(const Tox *tox);
 /* 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(Tox *tox, int32_t *out_list, uint32_t list_size);
+uint32_t tox_get_friendlist(const Tox *tox, int32_t *out_list, uint32_t list_size);
 /* 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)
@@ -295,27 +296,27 @@ void tox_callback_friend_request(Tox *tox, void (*function)(Tox *tox, const uint
 /* 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, uint32_t length, void *userdata)
 */
-void tox_callback_friend_message(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t *, uint16_t, void *),
+void tox_callback_friend_message(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                                 void *userdata);
 /* 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, uint32_t length, void *userdata)
 */
-void tox_callback_friend_action(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t *, uint16_t, void *),
+void tox_callback_friend_action(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                                void *userdata);
 /* 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
 */
-void tox_callback_name_change(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t *, uint16_t, void *),
+void tox_callback_name_change(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                              void *userdata);
 /* 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.
 */
-void tox_callback_status_message(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t *, uint16_t, void *),
+void tox_callback_status_message(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, uint16_t, void *),
                                 void *userdata);
 /* Set the callback for status type changes.
@@ -357,7 +358,7 @@ void tox_callback_connection_status(Tox *tox, void (*function)(Tox *tox, int32_t
 /* Functions to get/set the nospam part of the id.
 */
-uint32_t tox_get_nospam(Tox *tox);
+uint32_t tox_get_nospam(const Tox *tox);
 void tox_set_nospam(Tox *tox, uint32_t nospam);
@@ -367,20 +368,20 @@ void tox_set_nospam(Tox *tox, uint32_t nospam);
 *
 *  Function(Tox *tox, int friendnumber, uint8_t *group_public_key, void *userdata)
 */
-void tox_callback_group_invite(Tox *tox, void (*function)(Tox *tox, int32_t, uint8_t *, void *), void *userdata);
+void tox_callback_group_invite(Tox *tox, void (*function)(Tox *tox, int32_t, const uint8_t *, void *), void *userdata);
 /* 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)(Tox *tox, int, int, uint8_t *, uint16_t, void *),
+void tox_callback_group_message(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
                                void *userdata);
 /* Set the callback for group actions.
 *
 *  Function(Tox *tox, int groupnumber, int friendgroupnumber, uint8_t * action, uint16_t length, void *userdata)
 */
-void tox_callback_group_action(Tox *tox, void (*function)(Tox *tox, int, int, uint8_t *, uint16_t, void *),
+void tox_callback_group_action(Tox *tox, void (*function)(Tox *tox, int, int, const uint8_t *, uint16_t, void *),
                               void *userdata);
 /* Set callback function for peer name list changes.
@@ -417,7 +418,7 @@ int tox_del_groupchat(Tox *tox, int groupnumber);
 * return length of name if success
 * return -1 if failure
 */
-int tox_group_peername(Tox *tox, int groupnumber, int peernumber, uint8_t *name);
+int tox_group_peername(const Tox *tox, int groupnumber, int peernumber, uint8_t *name);
 /* invite friendnumber to groupnumber
 * return 0 on success
@@ -430,24 +431,24 @@ int tox_invite_friend(Tox *tox, int32_t friendnumber, int groupnumber);
 * returns group number on success
 * returns -1 on failure.
 */
-int tox_join_groupchat(Tox *tox, int32_t friendnumber, uint8_t *friend_group_public_key);
+int tox_join_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *friend_group_public_key);
 /* send a group message
 * return 0 on success
 * return -1 on failure
 */
-int tox_group_message_send(Tox *tox, int groupnumber, uint8_t *message, uint32_t length);
+int tox_group_message_send(Tox *tox, int groupnumber, const uint8_t *message, uint32_t length);
 /* send a group action
 * return 0 on success
 * return -1 on failure
 */
-int tox_group_action_send(Tox *tox, int groupnumber, uint8_t *action, uint32_t length);
+int tox_group_action_send(Tox *tox, 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 tox_group_number_peers(Tox *tox, int groupnumber);
+int tox_group_number_peers(const Tox *tox, int groupnumber);
 /* List all the peers in the group chat.
 *
@@ -459,20 +460,20 @@ int tox_group_number_peers(Tox *tox, int groupnumber);
 *
 * return -1 on failure.
 */
-int tox_group_get_names(Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
+int tox_group_get_names(const Tox *tox, int groupnumber, uint8_t names[][TOX_MAX_NAME_LENGTH], uint16_t lengths[],
                        uint16_t length);
 /* Return the number of chats in the instance m.
 * You should use this to determine how much memory to allocate
 * for copy_chatlist. */
-uint32_t tox_count_chatlist(Tox *tox);
+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(Tox *tox, int *out_list, uint32_t list_size);
+uint32_t tox_get_chatlist(const Tox *tox, int *out_list, uint32_t list_size);
 /****************FILE SENDING FUNCTIONS*****************/
@@ -523,8 +524,8 @@ enum {
 *
 *  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)(Tox *m, int32_t, uint8_t, uint64_t, uint8_t *, uint16_t,
+void tox_callback_file_send_request(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, uint64_t, const uint8_t *,
-                                    void *), void *userdata);
+                                    uint16_t, void *), void *userdata);
 /* Set the callback for file control requests.
 *
@@ -534,7 +535,7 @@ void tox_callback_file_send_request(Tox *tox, void (*function)(Tox *m, int32_t,
 *  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)
 *
 */
-void tox_callback_file_control(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, uint8_t, uint8_t, uint8_t *,
+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);
 /* Set the callback for file data.
@@ -542,8 +543,8 @@ void tox_callback_file_control(Tox *tox, void (*function)(Tox *m, int32_t, uint8
 *  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)(Tox *m, int32_t, uint8_t, uint8_t *, uint16_t length, void *),
+void tox_callback_file_data(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t, const uint8_t *, uint16_t length,
-                            void *userdata);
+                            void *), void *userdata);
 /* Send a file send request.
@@ -551,7 +552,8 @@ void tox_callback_file_data(Tox *tox, void (*function)(Tox *m, int32_t, uint8_t,
 *  return file number on success
 *  return -1 on failure
 */
-int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length);
+int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, const uint8_t *filename,
+                        uint16_t filename_length);
 /* Send a file control request.
 *
@@ -562,21 +564,21 @@ int tox_new_file_sender(Tox *tox, int32_t friendnumber, uint64_t filesize, uint8
 *  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,
-                          uint8_t *data, uint16_t length);
+                          const uint8_t *data, uint16_t 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, uint8_t *data, uint16_t length);
+int tox_file_send_data(Tox *tox, int32_t friendnumber, uint8_t filenumber, const uint8_t *data, uint16_t length);
 /* 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(Tox *tox, int32_t friendnumber);
+int tox_file_data_size(const Tox *tox, int32_t friendnumber);
 /* Give the number of bytes left to be sent/received.
 *
@@ -585,7 +587,7 @@ int tox_file_data_size(Tox *tox, int32_t friendnumber);
 *  return number of bytes remaining to be sent/received on success
 *  return 0 on failure
 */
-uint64_t tox_file_data_remaining(Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive);
+uint64_t tox_file_data_remaining(const Tox *tox, int32_t friendnumber, uint8_t filenumber, uint8_t send_receive);
 /***************END OF FILE SENDING FUNCTIONS******************/
@@ -606,12 +608,12 @@ uint64_t tox_file_data_remaining(Tox *tox, int32_t friendnumber, uint8_t filenum
 *  returns 0 otherwise
 */
 int tox_bootstrap_from_address(Tox *tox, const char *address, uint8_t ipv6enabled,
-                               uint16_t port, uint8_t *public_key);
+                               uint16_t port, const uint8_t *public_key);
 /*  return 0 if we are not connected to the DHT.
 *  return 1 if we are.
 */
-int tox_isconnected(Tox *tox);
+int tox_isconnected(const Tox *tox);
 /*
 *  Run this function at startup.
@@ -645,17 +647,17 @@ void tox_do(Tox *tox);
 /* SAVING AND LOADING FUNCTIONS: */
 /*  return size of messenger data (for saving). */
-uint32_t tox_size(Tox *tox);
+uint32_t tox_size(const Tox *tox);
 /* Save the messenger in data (must be allocated memory of size Messenger_size()). */
-void tox_save(Tox *tox, uint8_t *data);
+void tox_save(const Tox *tox, uint8_t *data);
 /* Load the messenger from data of size length.
 *
 *  returns 0 on success
 *  returns -1 on failure
 */
-int tox_load(Tox *tox, uint8_t *data, uint32_t length);
+int tox_load(Tox *tox, const uint8_t *data, uint32_t length);
 #ifdef __cplusplus
 }
diff --git a/toxdns/toxdns.c b/toxdns/toxdns.c
index 79d2adbb..7a7a052d 100644
--- a/toxdns/toxdns.c
+++ b/toxdns/toxdns.c
@@ -26,6 +26,7 @@
 #endif
 #include "../toxcore/Messenger.h"
+#include "../toxcore/logger.h"
 #include "toxdns.h"
 static const char base32[32] = {"abcdefghijklmnopqrstuvwxyz012345"};
@@ -143,7 +144,7 @@ int tox_generate_dns3_string(void *dns3_object, uint8_t *string, uint16_t string
    }
    if (end_len != string - old_str) {
-        printf("tox_generate_dns3_string Fail, %u != %u\n", end_len, string - old_str);
+        LOGGER_ERROR("tox_generate_dns3_string Fail, %u != %lu\n", end_len, string - old_str);
        return -1;
    }
@@ -216,8 +217,11 @@ int tox_decrypt_dns3_TXT(void *dns3_object, uint8_t *tox_id, uint8_t *id_record,
    /*if (id_record_len > 255 || id_record_len <= (sizeof(uint32_t) + crypto_box_MACBYTES))
        return -1;*/
+    uint8_t id_record_null[id_record_len + 1];
+    memcpy(id_record_null, id_record, id_record_len);
+    id_record_null[id_record_len] = 0;
    uint8_t data[id_record_len];
-    int length = decode(data, id_record);
+    int length = decode(data, id_record_null);
    if (length == -1)
        return -1;