13 files changed, 922 insertions, 20 deletions

diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index e222cf01..a03baf92 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -419,6 +419,7 @@ START_TEST(test_client)
     uint8_t f2_public_key[crypto_box_PUBLICKEYBYTES];
     uint8_t f2_secret_key[crypto_box_SECRETKEYBYTES];
     crypto_box_keypair(f2_public_key, f2_secret_key);
+    ip_port_tcp_s.port = htons(ports[rand() % NUM_PORTS]);
     TCP_Client_Connection *conn2 = new_TCP_connection(ip_port_tcp_s, self_public_key, f2_public_key, f2_secret_key, 0);
     routing_response_handler(conn, response_callback, ((void *)conn) + 2);
     routing_status_handler(conn, status_callback, (void *)2);
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index f27fefb8..31566471 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -275,7 +275,8 @@ Onions *new_onions(uint16_t port)
     DHT *dht = new_DHT(new_networking(ip, port));
     on->onion = new_onion(dht);
     on->onion_a = new_onion_announce(dht);
-    on->onion_c = new_onion_client(new_net_crypto(dht, 0));
+    TCP_Proxy_Info inf = {0};
+    on->onion_c = new_onion_client(new_net_crypto(dht, &inf));
 
     if (on->onion && on->onion_a && on->onion_c)
         return on;
@@ -294,15 +295,70 @@ void kill_onions(Onions *on)
 {
     Networking_Core *net = on->onion->dht->net;
     DHT *dht = on->onion->dht;
+    Net_Crypto *c = on->onion_c->c;
     kill_onion_client(on->onion_c);
     kill_onion_announce(on->onion_a);
     kill_onion(on->onion);
+    kill_net_crypto(c);
     kill_DHT(dht);
     kill_networking(net);
     free(on);
 }
 
 #define NUM_ONIONS 50
+#define NUM_FIRST 7
+#define NUM_LAST 37
+
+_Bool first_ip, last_ip;
+void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
+{
+    if (NUM_FIRST == number) {
+        first_ip = 1;
+        return;
+    }
+
+    if (NUM_LAST == number) {
+        last_ip = 1;
+        return;
+    }
+
+    ck_abort_msg("Error.");
+}
+
+_Bool first, last;
+uint8_t first_dht_pk[crypto_box_PUBLICKEYBYTES];
+uint8_t last_dht_pk[crypto_box_PUBLICKEYBYTES];
+
+static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_public_key)
+{
+    Onions *on = object;
+    uint16_t count = 0;
+    int ret = DHT_addfriend(on->onion->dht, dht_public_key, &dht_ip_callback, object, number, &count);
+    ck_assert_msg(count == 1, "Count not 1");
+    ck_assert_msg(ret == 0, "DHT_addfriend() did not return 0");
+
+    if (NUM_FIRST == number && !first) {
+        first = 1;
+
+        if (memcmp(dht_public_key, last_dht_pk, crypto_box_PUBLICKEYBYTES) != 0) {
+            ck_abort_msg("Error wrong dht key.");
+        }
+
+        return;
+    }
+
+    if (NUM_LAST == number && !last) {
+        last = 1;
+
+        if (memcmp(dht_public_key, first_dht_pk, crypto_box_PUBLICKEYBYTES) != 0) {
+            ck_abort_msg("Error wrong dht key.");
+        }
+
+        return;
+    }
+
+    ck_abort_msg("Error.");
+}
 
 START_TEST(test_announce)
 {
@@ -340,6 +396,8 @@ START_TEST(test_announce)
         c_sleep(50);
     }
 
+    printf("connected\n");
+
     for (i = 0; i < 25 * 2; ++i) {
         for (j = 0; j < NUM_ONIONS; ++j) {
             do_onions(onions[j]);
@@ -348,37 +406,40 @@ START_TEST(test_announce)
         c_sleep(50);
     }
 
-    onion_addfriend(onions[7]->onion_c, onions[37]->onion_c->c->self_public_key);
-    int frnum = onion_addfriend(onions[37]->onion_c, onions[7]->onion_c->c->self_public_key);
+    memcpy(first_dht_pk, onions[NUM_FIRST]->onion->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+    memcpy(last_dht_pk, onions[NUM_LAST]->onion->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
+
+    printf("adding friend\n");
+    int frnum_f = onion_addfriend(onions[NUM_FIRST]->onion_c, onions[NUM_LAST]->onion_c->c->self_public_key);
+    int frnum = onion_addfriend(onions[NUM_LAST]->onion_c, onions[NUM_FIRST]->onion_c->c->self_public_key);
+
+    onion_dht_pk_callback(onions[NUM_FIRST]->onion_c, frnum_f, &dht_pk_callback, onions[NUM_FIRST], NUM_FIRST);
+    onion_dht_pk_callback(onions[NUM_LAST]->onion_c, frnum, &dht_pk_callback, onions[NUM_LAST], NUM_LAST);
 
     int ok = -1;
 
     IP_Port ip_port;
 
-    while (ok == -1) {
+    while (!first || !last) {
         for (i = 0; i < NUM_ONIONS; ++i) {
-            networking_poll(onions[i]->onion->net);
-            do_onion_client(onions[i]->onion_c);
+            do_onions(onions[i]);
         }
 
-        ok = onion_getfriendip(onions[37]->onion_c, frnum, &ip_port);
-
         c_sleep(50);
     }
 
-    printf("id discovered\n");
+    printf("Waiting for ips\n");
 
-    while (ok != 1) {
+    while (!first_ip || !last_ip) {
         for (i = 0; i < NUM_ONIONS; ++i) {
             do_onions(onions[i]);
         }
 
-        ok = onion_getfriendip(onions[37]->onion_c, frnum, &ip_port);
-
         c_sleep(50);
     }
 
-    ck_assert_msg(ip_port.port == onions[7]->onion->net->port, "Port in returned ip not correct.");
+    onion_getfriendip(onions[NUM_LAST]->onion_c, frnum, &ip_port);
+    ck_assert_msg(ip_port.port == onions[NUM_FIRST]->onion->net->port, "Port in returned ip not correct.");
 
     for (i = 0; i < NUM_ONIONS; ++i) {
         kill_onions(onions[i]);
@@ -391,7 +452,7 @@ Suite *onion_suite(void)
     Suite *s = suite_create("Onion");
 
     DEFTESTCASE_SLOW(basic, 5);
-    //DEFTESTCASE_SLOW(announce, 50); //TODO: fix test.
+    DEFTESTCASE_SLOW(announce, 70);
     return s;
 }
 
diff --git a/configure.ac b/configure.ac
index e43e8f78..a100f344 100644
--- a/configure.ac
+++ b/configure.ac
@@ -472,7 +472,7 @@ AC_C_BIGENDIAN
 # Checks for library functions.
 AC_FUNC_FORK
 AC_CHECK_FUNCS([gettimeofday memset socket strchr malloc])
-if (test "x$WIN32" != "xyes") && (test "x$MACH" != "xyes") && (test "x$DISABLE_RT" != "xyes"); then
+if (test "x$WIN32" != "xyes") && (test "x$MACH" != "xyes") && (test "x${host_os#*openbsd}" == "x$host_os") && (test "x$DISABLE_RT" != "xyes"); then
     AC_CHECK_LIB(rt, clock_gettime,
         [
             RT_LIBS="-lrt"
diff --git a/toxcore/Makefile.inc b/toxcore/Makefile.inc
index 9afe7791..9fb910fc 100644
--- a/toxcore/Makefile.inc
+++ b/toxcore/Makefile.inc
@@ -46,6 +46,8 @@ libtoxcore_la_SOURCES = ../toxcore/DHT.h \
                         ../toxcore/TCP_client.c \
                         ../toxcore/TCP_server.h \
                         ../toxcore/TCP_server.c \
+                        ../toxcore/TCP_connection.h \
+                        ../toxcore/TCP_connection.c \
                         ../toxcore/list.c \
                         ../toxcore/list.h \
                         ../toxcore/misc_tools.h
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 23c41120..fefc3b17 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -172,7 +172,7 @@ static int send_online_packet(Messenger *m, int32_t friendnumber)
                              m->friendlist[friendnumber].friendcon_id), &packet, sizeof(packet), 0) != -1;
 }
 
-static int send_offine_packet(Messenger *m, int friendcon_id)
+static int send_offline_packet(Messenger *m, int friendcon_id)
 {
     uint8_t packet = PACKET_ID_OFFLINE;
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), &packet,
@@ -408,7 +408,7 @@ int m_delfriend(Messenger *m, int32_t friendnumber)
     kill_friend_connection(m->fr_c, m->friendlist[friendnumber].friendcon_id);
 
     if (friend_con_connected(m->fr_c, m->friendlist[friendnumber].friendcon_id) == FRIENDCONN_STATUS_CONNECTED) {
-        send_offine_packet(m, m->friendlist[friendnumber].friendcon_id);
+        send_offline_packet(m, m->friendlist[friendnumber].friendcon_id);
     }
 
     memset(&(m->friendlist[friendnumber]), 0, sizeof(Friend));
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index e37a4ee0..d4d18a4b 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -78,8 +78,10 @@ typedef struct  {
     uint64_t ping_response_id;
     uint64_t ping_request_id;
 
+    //TODO: remove
     void *net_crypto_pointer;
     uint32_t net_crypto_location;
+
     struct {
         uint8_t status; /* 0 if not used, 1 if other is offline, 2 if other is online. */
         uint8_t public_key[crypto_box_PUBLICKEYBYTES];
@@ -96,6 +98,10 @@ typedef struct  {
 
     int (*onion_callback)(void *object, const uint8_t *data, uint16_t length);
     void *onion_callback_object;
+
+    /* Can be used by user. */
+    void *custom_object;
+    uint32_t custom_uint;
 } TCP_Client_Connection;
 
 /* Create new TCP connection to ip_port/public_key
diff --git a/toxcore/TCP_connection.c b/toxcore/TCP_connection.c
new file mode 100644
index 00000000..ddcbd1d8
--- /dev/null
+++ b/toxcore/TCP_connection.c
@@ -0,0 +1,722 @@
+/* TCP_connection.c
+ *
+ * Handles TCP relay connections between two Tox clients.
+ *
+ *  Copyright (C) 2015 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "TCP_connection.h"
+
+/* Set the size of the array to num.
+ *
+ *  return -1 if realloc fails.
+ *  return 0 if it succeeds.
+ */
+#define realloc_tox_array(array, element_size, num, temp_pointer) (num ? (temp_pointer = realloc(array, num * element_size), temp_pointer ? (array = temp_pointer, 0) : (-1) ) : (free(array), array = NULL, 0))
+
+
+/* return 1 if the connections_number is not valid.
+ * return 0 if the connections_number is valid.
+ */
+static _Bool connections_number_not_valid(const TCP_Connections *tcp_c, int connections_number)
+{
+    if ((unsigned int)connections_number >= tcp_c->connections_length)
+        return 1;
+
+    if (tcp_c->connections == NULL)
+        return 1;
+
+    if (tcp_c->connections[connections_number].status == TCP_CONN_NONE)
+        return 1;
+
+    return 0;
+}
+
+/* return 1 if the tcp_connections_number is not valid.
+ * return 0 if the tcp_connections_number is valid.
+ */
+static _Bool tcp_connections_number_not_valid(const TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    if ((unsigned int)tcp_connections_number >= tcp_c->tcp_connections_length)
+        return 1;
+
+    if (tcp_c->tcp_connections == NULL)
+        return 1;
+
+    if (tcp_c->tcp_connections[tcp_connections_number].status == TCP_CONN_NONE)
+        return 1;
+
+    return 0;
+}
+
+/* Create a new empty connection.
+ *
+ * return -1 on failure.
+ * return connections_number on success.
+ */
+static int create_connection(TCP_Connections *tcp_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < tcp_c->connections_length; ++i) {
+        if (tcp_c->connections[i].status == TCP_CONN_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    TCP_Connection_to *temp_pointer;
+
+    if (realloc_tox_array(tcp_c->connections, sizeof(TCP_Connection_to), tcp_c->connections_length + 1,
+                          temp_pointer) == 0) {
+        id = tcp_c->connections_length;
+        ++tcp_c->connections_length;
+        memset(&(tcp_c->connections[id]), 0, sizeof(TCP_Connection_to));
+    }
+
+    return id;
+}
+
+/* Create a new empty tcp connection.
+ *
+ * return -1 on failure.
+ * return tcp_connections_number on success.
+ */
+static int create_tcp_connection(TCP_Connections *tcp_c)
+{
+    uint32_t i;
+
+    for (i = 0; i < tcp_c->tcp_connections_length; ++i) {
+        if (tcp_c->tcp_connections[i].status == TCP_CONN_NONE)
+            return i;
+    }
+
+    int id = -1;
+
+    TCP_con *temp_pointer;
+
+    if (realloc_tox_array(tcp_c->tcp_connections, sizeof(TCP_con), tcp_c->tcp_connections_length + 1, temp_pointer) == 0) {
+        id = tcp_c->tcp_connections_length;
+        ++tcp_c->tcp_connections_length;
+        memset(&(tcp_c->tcp_connections[id]), 0, sizeof(TCP_con));
+    }
+
+    return id;
+}
+
+/* Wipe a connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_connection(TCP_Connections *tcp_c, int connections_number)
+{
+    if (connections_number_not_valid(tcp_c, connections_number))
+        return -1;
+
+    uint32_t i;
+    memset(&(tcp_c->connections[connections_number]), 0 , sizeof(TCP_Connection_to));
+
+    for (i = tcp_c->connections_length; i != 0; --i) {
+        if (tcp_c->connections[i - 1].status != TCP_CONN_NONE)
+            break;
+    }
+
+    if (tcp_c->connections_length != i) {
+        tcp_c->connections_length = i;
+        TCP_Connection_to *temp_pointer;
+        realloc_tox_array(tcp_c->connections, sizeof(TCP_Connection_to), tcp_c->connections_length, temp_pointer);
+    }
+
+    return 0;
+}
+
+/* Wipe a connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+static int wipe_tcp_connection(TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number))
+        return -1;
+
+    uint32_t i;
+    memset(&(tcp_c->tcp_connections[tcp_connections_number]), 0 , sizeof(TCP_con));
+
+    for (i = tcp_c->tcp_connections_length; i != 0; --i) {
+        if (tcp_c->tcp_connections[i - 1].status != TCP_CONN_NONE)
+            break;
+    }
+
+    if (tcp_c->tcp_connections_length != i) {
+        tcp_c->tcp_connections_length = i;
+        TCP_con *temp_pointer;
+        realloc_tox_array(tcp_c->tcp_connections, sizeof(TCP_con), tcp_c->tcp_connections_length, temp_pointer);
+    }
+
+    return 0;
+}
+
+static TCP_Connection_to *get_connection(const TCP_Connections *tcp_c, int connections_number)
+{
+    if (connections_number_not_valid(tcp_c, connections_number))
+        return 0;
+
+    return &tcp_c->connections[connections_number];
+}
+
+static TCP_con *get_tcp_connection(const TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    if (tcp_connections_number_not_valid(tcp_c, tcp_connections_number))
+        return 0;
+
+    return &tcp_c->tcp_connections[tcp_connections_number];
+}
+
+/* Send a packet to the TCP connection.
+ *
+ * return -1 on failure.
+ * return 0 on success.
+ */
+int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, uint8_t *packet, uint16_t length)
+{
+    TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
+
+    if (!con_to) {
+        return -1;
+    }
+
+    unsigned int i;
+    int ret = -1;
+
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        uint32_t tcp_con_num = con_to->connections[i].tcp_connection;
+
+        //TODO
+        if (tcp_con_num) {
+            tcp_con_num -= 1;
+            TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_con_num);
+
+            if (!tcp_con) {
+                continue;
+            }
+
+            // ret = send_data(c->tcp_connections[tcp_index], conn->con_number_tcp[tcp_index], packet, length);
+        }
+    }
+
+    return ret;
+}
+
+void set_packet_tcp_connection_callback(TCP_Connections *tcp_c, int (*tcp_data_callback)(void *object, int id,
+                                        const uint8_t *data, uint16_t length), void *object)
+{
+    tcp_c->tcp_data_callback = tcp_data_callback;
+    tcp_c->tcp_data_callback_object = object;
+}
+
+/* Find the TCP connection with public_key.
+ *
+ * return connections_number on success.
+ * return -1 on failure.
+ */
+static int find_tcp_connection_to(TCP_Connections *tcp_c, const uint8_t *public_key)
+{
+    unsigned int i;
+
+    for (i = 0; i < tcp_c->connections_length; ++i) {
+        TCP_Connection_to *con_to = get_connection(tcp_c, i);
+
+        if (con_to) {
+            if (memcmp(con_to->public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+                return i;
+            }
+        }
+    }
+
+    return -1;
+}
+
+/* Find the TCP connection to a relay with relay_pk.
+ *
+ * return connections_number on success.
+ * return -1 on failure.
+ */
+static int find_tcp_connection_relay(TCP_Connections *tcp_c, const uint8_t *relay_pk)
+{
+    unsigned int i;
+
+    for (i = 0; i < tcp_c->tcp_connections_length; ++i) {
+        TCP_con *tcp_con = get_tcp_connection(tcp_c, i);
+
+        if (tcp_con) {
+            if (memcmp(tcp_con->connection->public_key, relay_pk, crypto_box_PUBLICKEYBYTES) == 0) {
+                return i;
+            }
+        }
+    }
+
+    return -1;
+}
+
+/* Create a new TCP connection to public_key.
+ *
+ * id is the id in the callbacks for that connection.
+ *
+ * return connections_number on success.
+ * return -1 on failure.
+ */
+int new_tcp_connection_to(TCP_Connections *tcp_c, const uint8_t *public_key, int id)
+{
+    if (find_tcp_connection_to(tcp_c, public_key) != -1)
+        return -1;
+
+    int connections_number = create_connection(tcp_c);
+
+    if (connections_number == -1)
+        return -1;
+
+    TCP_Connection_to *con_to = &tcp_c->connections[connections_number];
+
+    con_to->status = TCP_CONN_VALID;
+    memcpy(con_to->public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    con_to->id = id;
+
+    return connections_number;
+}
+
+/* return 0 on success.
+ * return -1 on failure.
+ */
+int kill_tcp_connection_to(TCP_Connections *tcp_c, int connections_number)
+{
+    TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
+
+    if (!con_to)
+        return -1;
+
+    //TODO
+    return wipe_connection(tcp_c, connections_number);
+}
+
+static _Bool tcp_connection_in_conn(TCP_Connection_to *con_to, int tcp_connections_number)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        if (con_to->connections[i].tcp_connection == (tcp_connections_number + 1)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+/* return index on success.
+ * return -1 on failure.
+ */
+static int add_tcp_connection_to_conn(TCP_Connection_to *con_to, int tcp_connections_number)
+{
+    unsigned int i;
+
+    if (tcp_connection_in_conn(con_to, tcp_connections_number))
+        return -1;
+
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        if (con_to->connections[i].tcp_connection == 0) {
+            con_to->connections[i].tcp_connection = tcp_connections_number + 1;
+            con_to->connections[i].status = TCP_CONNECTIONS_STATUS_NONE;
+            con_to->connections[i].connection_id = 0;
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/* return index on success.
+ * return -1 on failure.
+ */
+static int rm_tcp_connection_from_conn(TCP_Connection_to *con_to, int tcp_connections_number)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        if (con_to->connections[i].tcp_connection == (tcp_connections_number + 1)) {
+            con_to->connections[i].tcp_connection = 0;
+            con_to->connections[i].status = TCP_CONNECTIONS_STATUS_NONE;
+            con_to->connections[i].connection_id = 0;
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/* return index on success.
+ * return -1 on failure.
+ */
+static int set_tcp_connection_status(TCP_Connection_to *con_to, int tcp_connections_number, unsigned int status,
+                                     uint8_t connection_id)
+{
+    unsigned int i;
+
+    for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
+        if (con_to->connections[i].tcp_connection == (tcp_connections_number + 1)) {
+            con_to->connections[i].status = status;
+            con_to->connections[i].connection_id = connection_id;
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/* Kill a TCP relay connection.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static int kill_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    unsigned int i;
+
+    for (i = 0; i < tcp_c->connections_length; ++i) {
+        TCP_Connection_to *con_to = get_connection(tcp_c, i);
+
+        if (con_to) {
+            rm_tcp_connection_from_conn(con_to, tcp_connections_number);
+        }
+    }
+
+    kill_TCP_connection(tcp_con->connection);
+
+    return wipe_tcp_connection(tcp_c, tcp_connections_number);
+}
+
+/* Send a TCP routing request.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static int send_tcp_relay_routing_request(TCP_Connections *tcp_c, int tcp_connections_number, uint8_t *public_key)
+{
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    if (send_routing_request(tcp_con->connection, public_key) != 1)
+        return -1;
+
+    return 0;
+}
+
+static int tcp_response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
+{
+    TCP_Client_Connection *TCP_client_con = object;
+    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+
+    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    int connections_number = find_tcp_connection_to(tcp_c, public_key);
+
+    if (connections_number == -1)
+        return -1;
+
+    set_tcp_connection_number(tcp_con->connection, connection_id, connections_number);
+
+    TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
+
+    if (con_to == NULL)
+        return -1;
+
+    if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1)
+        return -1;
+
+    return 0;
+}
+
+static int tcp_status_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t status)
+{
+    TCP_Client_Connection *TCP_client_con = object;
+    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+
+    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+    TCP_Connection_to *con_to = get_connection(tcp_c, number);
+
+    if (!con_to || !tcp_con)
+        return -1;
+
+    if (status == 1) {
+        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_REGISTERED, connection_id) == -1)
+            return -1;
+
+    } else if (status == 2) {
+        if (set_tcp_connection_status(con_to, tcp_connections_number, TCP_CONNECTIONS_STATUS_ONLINE, connection_id) == -1)
+            return -1;
+
+    }
+
+    return 0;
+}
+
+static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length)
+{
+
+    if (length == 0)
+        return -1;
+
+    TCP_Client_Connection *TCP_client_con = object;
+    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+
+    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    TCP_Connection_to *con_to = get_connection(tcp_c, number);
+
+    if (!con_to)
+        return -1;
+
+    if (tcp_c->tcp_data_callback)
+        tcp_c->tcp_data_callback(tcp_c->tcp_data_callback_object, con_to->id, data, length);
+
+    return 0;
+}
+
+static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length)
+{
+    if (length == 0)
+        return -1;
+
+    TCP_Client_Connection *TCP_client_con = object;
+    TCP_Connections *tcp_c = TCP_client_con->custom_object;
+
+    unsigned int tcp_connections_number = TCP_client_con->custom_uint;
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    uint8_t relay_pk[crypto_box_PUBLICKEYBYTES];
+    memcpy(relay_pk, tcp_con->connection->public_key, crypto_box_PUBLICKEYBYTES);
+
+    if (tcp_c->tcp_oob_callback)
+        tcp_c->tcp_oob_callback(tcp_c->tcp_oob_callback_object, public_key, relay_pk, data, length);
+
+    return 0;
+}
+
+static int tcp_onion_callback(void *object, const uint8_t *data, uint16_t length)
+{
+    TCP_Connections *tcp_c = object;
+
+    if (tcp_c->tcp_onion_callback)
+        tcp_c->tcp_onion_callback(tcp_c->tcp_onion_callback_object, data, length);
+
+    return 0;
+}
+
+/* Set callbacks for the TCP relay connection.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+static int tcp_relay_set_callbacks(TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    TCP_Client_Connection *con = tcp_con->connection;
+
+    con->custom_object = tcp_c;
+    con->custom_uint = tcp_connections_number;
+    onion_response_handler(con, &tcp_onion_callback, tcp_c);
+    routing_response_handler(con, &tcp_response_callback, con);
+    routing_status_handler(con, &tcp_status_callback, con);
+    routing_data_handler(con, &tcp_data_callback, con);
+    oob_data_handler(con, &tcp_oob_callback, con);
+
+    return 0;
+}
+
+static int tcp_relay_on_online(TCP_Connections *tcp_c, int tcp_connections_number)
+{
+    TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+    if (!tcp_con)
+        return -1;
+
+    unsigned int i;
+
+    for (i = 0; i < tcp_c->connections_length; ++i) {
+        TCP_Connection_to *con_to = get_connection(tcp_c, i);
+
+        if (con_to) {
+            if (tcp_connection_in_conn(con_to, tcp_connections_number)) {
+                send_tcp_relay_routing_request(tcp_c, tcp_connections_number, con_to->public_key);
+            }
+        }
+    }
+
+    tcp_relay_set_callbacks(tcp_c, tcp_connections_number);
+    tcp_con->status = TCP_CONN_CONNECTED;
+    return 0;
+}
+
+static int add_tcp_relay(TCP_Connections *tcp_c, IP_Port ip_port, const uint8_t *relay_pk)
+{
+    int tcp_connections_number = create_tcp_connection(tcp_c);
+
+    if (tcp_connections_number == -1)
+        return -1;
+
+    TCP_con *tcp_con = &tcp_c->tcp_connections[tcp_connections_number];
+
+
+    tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->dht->self_public_key, tcp_c->dht->self_secret_key,
+                          &tcp_c->proxy_info);
+
+    if (!tcp_con->connection)
+        return -1;
+
+    tcp_con->status = TCP_CONN_VALID;
+
+    return tcp_connections_number;
+}
+
+/* Add a TCP relay tied to a connection.
+ *
+ * return 0 on success.
+ * return -1 on failure.
+ */
+int add_tcp_relay_connection(TCP_Connections *tcp_c, int connections_number, IP_Port ip_port, const uint8_t *relay_pk)
+{
+    TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
+
+    if (!con_to)
+        return -1;
+
+    int tcp_connections_number = find_tcp_connection_relay(tcp_c, relay_pk);
+
+    if (tcp_connections_number != -1) {
+        if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1)
+            return -1;
+
+        TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+        if (!tcp_con)
+            return -1;
+
+        ++tcp_con->lock_count;
+
+        if (tcp_con->status == TCP_CONN_CONNECTED) {
+            send_tcp_relay_routing_request(tcp_c, tcp_connections_number, con_to->public_key);
+        }
+
+        return 0;
+    } else {
+        int tcp_connections_number = add_tcp_relay(tcp_c, ip_port, relay_pk);
+
+        if (add_tcp_connection_to_conn(con_to, tcp_connections_number) == -1) {
+            return -1;
+        }
+
+        TCP_con *tcp_con = get_tcp_connection(tcp_c, tcp_connections_number);
+
+        if (!tcp_con)
+            return -1;
+
+        ++tcp_con->lock_count;
+        return 0;
+    }
+}
+
+
+TCP_Connections *new_tcp_connections(DHT *dht)
+{
+    if (dht == NULL)
+        return NULL;
+
+    TCP_Connections *temp = calloc(1, sizeof(TCP_Connections));
+
+    if (temp == NULL)
+        return NULL;
+
+    temp->dht = dht;
+    return temp;
+}
+
+static void do_tcp_conns(TCP_Connections *tcp_c)
+{
+    unsigned int i;
+
+    for (i = 0; i < tcp_c->tcp_connections_length; ++i) {
+        TCP_con *tcp_con = get_tcp_connection(tcp_c, i);
+
+        if (tcp_con) {
+            do_TCP_connection(tcp_con->connection);
+
+            if (tcp_con->connection->status == TCP_CLIENT_DISCONNECTED) {
+                kill_tcp_relay_connection(tcp_c, i);
+                continue;
+            }
+
+            if (tcp_con->status == TCP_CONN_VALID && tcp_con->connection->status == TCP_CLIENT_CONFIRMED) {
+                tcp_relay_on_online(tcp_c, i);
+            }
+        }
+    }
+}
+
+
+void do_tcp_connections(TCP_Connections *tcp_c)
+{
+//TODO kill unused conns
+
+    do_tcp_conns(tcp_c);
+}
+
+void kill_tcp_connections(TCP_Connections *tcp_c)
+{
+    //TODO
+    free(tcp_c);
+}
+
+
diff --git a/toxcore/TCP_connection.h b/toxcore/TCP_connection.h
new file mode 100644
index 00000000..94213814
--- /dev/null
+++ b/toxcore/TCP_connection.h
@@ -0,0 +1,88 @@
+/* TCP_connection.h
+ *
+ * Handles TCP relay connections between two Tox clients.
+ *
+ *  Copyright (C) 2015 Tox project All Rights Reserved.
+ *
+ *  This file is part of Tox.
+ *
+ *  Tox is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Tox is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TCP_CONNECTION_H
+#define TCP_CONNECTION_H
+
+#include "TCP_client.h"
+
+#define TCP_CONN_NONE 0
+#define TCP_CONN_VALID 1
+#define TCP_CONN_CONNECTED 2
+
+#define TCP_CONNECTIONS_STATUS_NONE 0
+#define TCP_CONNECTIONS_STATUS_REGISTERED 1
+#define TCP_CONNECTIONS_STATUS_ONLINE 2
+
+#define MAX_FRIEND_TCP_CONNECTIONS 4
+
+
+typedef struct {
+    uint8_t status;
+    uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* The dht public key of the peer */
+
+    struct {
+        uint32_t tcp_connection;
+        unsigned int status;
+        unsigned int connection_id;
+    } connections[MAX_FRIEND_TCP_CONNECTIONS];
+
+    int id; /* id used in callbacks. */
+} TCP_Connection_to;
+
+typedef struct {
+    uint8_t status;
+    TCP_Client_Connection *connection;
+    uint32_t lock_count;
+} TCP_con;
+
+typedef struct {
+    DHT *dht;
+
+    TCP_Connection_to *connections;
+    uint32_t connections_length; /* Length of connections array. */
+
+    TCP_con *tcp_connections;
+    uint32_t tcp_connections_length; /* Length of tcp_connections array. */
+
+    int (*tcp_data_callback)(void *object, int id, const uint8_t *data, uint16_t length);
+    void *tcp_data_callback_object;
+
+    int (*tcp_oob_callback)(void *object, const uint8_t *public_key, const uint8_t *relay_pk, const uint8_t *data,
+                            uint16_t length);
+    void *tcp_oob_callback_object;
+
+    int (*tcp_onion_callback)(void *object, const uint8_t *data, uint16_t length);
+    void *tcp_onion_callback_object;
+
+    TCP_Proxy_Info proxy_info;
+} TCP_Connections;
+
+
+
+TCP_Connections *new_tcp_connections(DHT *dht);
+void do_tcp_connections(TCP_Connections *tcp_c);
+void kill_tcp_connections(TCP_Connections *tcp_c);
+
+#endif
+
diff --git a/toxcore/TCP_server.c b/toxcore/TCP_server.c
index d7401de8..f07df2c6 100644
--- a/toxcore/TCP_server.c
+++ b/toxcore/TCP_server.c
@@ -925,6 +925,10 @@ static sock_t new_listening_TCP_socket(int family, uint16_t port)
         ok = set_socket_dualstack(sock);
     }
 
+    if (ok) {
+        ok = set_socket_reuseaddr(sock);
+    }
+
     ok = ok && bind_to_port(sock, family, port) && (listen(sock, TCP_MAX_BACKLOG) == 0);
 
     if (!ok) {
diff --git a/toxcore/network.c b/toxcore/network.c
index d974ddc2..b3df3fbd 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -172,6 +172,17 @@ int set_socket_nosigpipe(sock_t sock)
 #endif
 }
 
+/* Enable SO_REUSEADDR on socket.
+ *
+ * return 1 on success
+ * return 0 on failure
+ */
+int set_socket_reuseaddr(sock_t sock)
+{
+    int set = 1;
+    return (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set)) == 0);
+}
+
 /* Set socket to dual (IPv4 + IPv6 socket)
  *
  * return 1 on success
diff --git a/toxcore/network.h b/toxcore/network.h
index c67f523d..b06c0f6a 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -334,6 +334,13 @@ int set_socket_nonblock(sock_t sock);
  */
 int set_socket_nosigpipe(sock_t sock);
 
+/* Enable SO_REUSEADDR on socket.
+ *
+ * return 1 on success
+ * return 0 on failure
+ */
+int set_socket_reuseaddr(sock_t sock);
+
 /* Set socket to dual (IPv4 + IPv6 socket)
  *
  * return 1 on success
diff --git a/toxcore/tox.c b/toxcore/tox.c
index a9306efc..848f81c7 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -851,7 +851,7 @@ void tox_callback_friend_message(Tox *tox, tox_friend_message_cb *function, void
 
 bool tox_hash(uint8_t *hash, const uint8_t *data, size_t length)
 {
-    if (!hash || !data) {
+    if (!hash || (length && !data)) {
         return 0;
     }
 
diff --git a/toxcore/tox.h b/toxcore/tox.h
index 034b1d78..8e368851 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -1418,8 +1418,8 @@ enum TOX_FILE_KIND {
  * primarily for validating cached avatars. This use is highly recommended to
  * avoid unnecessary avatar updates.
  *
- * If length is zero or data is NULL, the hash will contain all zero. If hash is
- * NULL, the function returns false, otherwise it returns true.
+ * If hash is NULL or data is NULL while length is not 0 the function returns false,
+ * otherwise it returns true.
  *
  * This function is a wrapper to internal message-digest functions.
  *