22 files changed, 294 insertions, 160 deletions

diff --git a/toxcore/DHT.c b/toxcore/DHT.c
index 9ebe11cf..8cd8852c 100644
--- a/toxcore/DHT.c
+++ b/toxcore/DHT.c
@@ -145,7 +145,7 @@ void get_shared_key(Shared_Keys *shared_keys, uint8_t *shared_key, const uint8_t
  */
 void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *client_id)
 {
-    return get_shared_key(&dht->shared_keys_recv, shared_key, dht->self_secret_key, client_id);
+    get_shared_key(&dht->shared_keys_recv, shared_key, dht->self_secret_key, client_id);
 }
 
 /* Copy shared_key to encrypt/decrypt DHT packet from client_id into shared_key
@@ -153,7 +153,7 @@ void DHT_get_shared_key_recv(DHT *dht, uint8_t *shared_key, const uint8_t *clien
  */
 void DHT_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *client_id)
 {
-    return get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, client_id);
+    get_shared_key(&dht->shared_keys_sent, shared_key, dht->self_secret_key, client_id);
 }
 
 void to_net_family(IP *ip)
diff --git a/toxcore/LAN_discovery.c b/toxcore/LAN_discovery.c
index dbce762e..5ab5b0e1 100644
--- a/toxcore/LAN_discovery.c
+++ b/toxcore/LAN_discovery.c
@@ -227,18 +227,43 @@ static IP broadcast_ip(sa_family_t family_socket, sa_family_t family_broadcast)
     return ip;
 }
 
+/* Is IP a local ip or not. */
+_Bool Local_ip(IP ip)
+{
+    if (ip.family == AF_INET) {
+        IP4 ip4 = ip.ip4;
+
+        /* Loopback. */
+        if (ip4.uint8[0] == 127)
+            return 1;
+    } else {
+        /* embedded IPv4-in-IPv6 */
+        if (IPV6_IPV4_IN_V6(ip.ip6)) {
+            IP ip4;
+            ip4.family = AF_INET;
+            ip4.ip4.uint32 = ip.ip6.uint32[3];
+            return Local_ip(ip4);
+        }
+
+        /* localhost in IPv6 (::1) */
+        if (ip.ip6.uint64[0] == 0 && ip.ip6.uint32[2] == 0 && ip.ip6.uint32[3] == htonl(1))
+            return 1;
+    }
+
+    return 0;
+}
+
 /*  return 0 if ip is a LAN ip.
  *  return -1 if it is not.
  */
 int LAN_ip(IP ip)
 {
+    if (Local_ip(ip))
+        return 0;
+
     if (ip.family == AF_INET) {
         IP4 ip4 = ip.ip4;
 
-        /* Loopback. */
-        if (ip4.uint8[0] == 127)
-            return 0;
-
         /* 10.0.0.0 to 10.255.255.255 range. */
         if (ip4.uint8[0] == 10)
             return 0;
@@ -276,10 +301,6 @@ int LAN_ip(IP ip)
             ip4.ip4.uint32 = ip.ip6.uint32[3];
             return LAN_ip(ip4);
         }
-
-        /* localhost in IPv6 (::1) */
-        if (ip.ip6.uint64[0] == 0 && ip.ip6.uint32[2] == 0 && ip.ip6.uint32[3] == htonl(1))
-            return 0;
     }
 
     return -1;
diff --git a/toxcore/LAN_discovery.h b/toxcore/LAN_discovery.h
index 5243bd93..358bea2f 100644
--- a/toxcore/LAN_discovery.h
+++ b/toxcore/LAN_discovery.h
@@ -40,6 +40,9 @@ void LANdiscovery_init(DHT *dht);
 /* Clear packet handlers. */
 void LANdiscovery_kill(DHT *dht);
 
+/* Is IP a local ip or not. */
+_Bool Local_ip(IP ip);
+
 /* checks if a given IP isn't routable
  *
  *  return 0 if ip is a LAN ip.
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index a7e0a9fe..dc0e605a 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -52,24 +52,6 @@ static uint8_t friend_not_valid(const Messenger *m, int32_t friendnumber)
     return 1;
 }
 
-static int add_online_friend(Messenger *m, int32_t friendnumber)
-{
-    if (friend_not_valid(m, friendnumber))
-        return -1;
-
-    ++m->numonline_friends;
-    return 0;
-}
-
-
-static int remove_online_friend(Messenger *m, int32_t friendnumber)
-{
-    if (friend_not_valid(m, friendnumber))
-        return -1;
-
-    --m->numonline_friends;
-    return 0;
-}
 /* Set the size of the friend list to numfriends.
  *
  *  return -1 if realloc fails.
@@ -399,9 +381,6 @@ int m_delfriend(Messenger *m, int32_t friendnumber)
     if (friend_not_valid(m, friendnumber))
         return -1;
 
-    if (m->friendlist[friendnumber].status == FRIEND_ONLINE)
-        remove_online_friend(m, friendnumber);
-
     clear_receipts(m, friendnumber);
     remove_request_received(&(m->fr), m->friendlist[friendnumber].real_pk);
     friend_connection_callbacks(m->fr_c, m->friendlist[friendnumber].friendcon_id, MESSENGER_CALLBACK_INDEX, 0, 0, 0, 0, 0);
@@ -884,10 +863,7 @@ static void check_friend_connectionstatus(Messenger *m, int32_t friendnumber, ui
     if (is_online != was_online) {
         if (was_online) {
             break_files(m, friendnumber);
-            remove_online_friend(m, friendnumber);
             clear_receipts(m, friendnumber);
-        } else {
-            add_online_friend(m, friendnumber);
         }
 
         m->friendlist[friendnumber].status = status;
@@ -1831,6 +1807,27 @@ Messenger *new_messenger(Messenger_Options *options, unsigned int *error)
         return NULL;
     }
 
+    if (options->tcp_server_port) {
+        m->tcp_server = new_TCP_server(options->ipv6enabled, 1, &options->tcp_server_port, m->dht->self_public_key,
+                                       m->dht->self_secret_key, m->onion);
+
+        if (m->tcp_server == NULL) {
+            kill_friend_connections(m->fr_c);
+            kill_onion(m->onion);
+            kill_onion_announce(m->onion_a);
+            kill_onion_client(m->onion_c);
+            kill_DHT(m->dht);
+            kill_net_crypto(m->net_crypto);
+            kill_networking(m->net);
+            free(m);
+
+            if (error)
+                *error = MESSENGER_ERROR_TCP_SERVER;
+
+            return NULL;
+        }
+    }
+
     m->options = *options;
     friendreq_init(&(m->fr), m->fr_c);
     set_nospam(&(m->fr), random_int());
@@ -1850,6 +1847,10 @@ void kill_messenger(Messenger *m)
 
     uint32_t i;
 
+    if (m->tcp_server) {
+        kill_TCP_server(m->tcp_server);
+    }
+
     kill_friend_connections(m->fr_c);
     kill_onion(m->onion);
     kill_onion_announce(m->onion_a);
@@ -2285,6 +2286,15 @@ void do_messenger(Messenger *m)
         for (i = 0; i < NUM_SAVED_TCP_RELAYS; ++i) {
             add_tcp_relay(m->net_crypto, m->loaded_relays[i].ip_port, m->loaded_relays[i].public_key);
         }
+
+        if (m->tcp_server) {
+            /* Add self tcp server. */
+            IP_Port local_ip_port;
+            local_ip_port.port = m->options.tcp_server_port;
+            local_ip_port.ip.family = AF_INET;
+            local_ip_port.ip.ip4.uint32 = INADDR_LOOPBACK;
+            add_tcp_relay(m->net_crypto, local_ip_port, m->tcp_server->public_key);
+        }
     }
 
     unix_time_update();
@@ -2294,6 +2304,10 @@ void do_messenger(Messenger *m)
         do_DHT(m->dht);
     }
 
+    if (m->tcp_server) {
+        do_TCP_server(m->tcp_server);
+    }
+
     do_net_crypto(m->net_crypto);
     do_onion_client(m->onion_c);
     do_friend_connections(m->fr_c);
@@ -2622,13 +2636,11 @@ static int messenger_load_state_callback(void *outer, const uint8_t *data, uint3
         case MESSENGER_STATE_TYPE_NOSPAMKEYS:
             if (length == crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES + sizeof(uint32_t)) {
                 set_nospam(&(m->fr), *(uint32_t *)data);
-                load_keys(m->net_crypto, &data[sizeof(uint32_t)]);
-#ifdef ENABLE_ASSOC_DHT
+                load_secret_key(m->net_crypto, (&data[sizeof(uint32_t)]) + crypto_box_PUBLICKEYBYTES);
 
-                if (m->dht->assoc)
-                    Assoc_self_client_id_changed(m->dht->assoc, m->net_crypto->self_public_key);
-
-#endif
+                if (memcmp((&data[sizeof(uint32_t)]), m->net_crypto->self_public_key, crypto_box_PUBLICKEYBYTES) != 0) {
+                    return -1;
+                }
             } else
                 return -1;    /* critical */
 
@@ -2738,12 +2750,6 @@ uint32_t count_friendlist(const Messenger *m)
     return ret;
 }
 
-/* Return the number of online friends in the instance m. */
-uint32_t get_num_online_friends(const Messenger *m)
-{
-    return m->numonline_friends;
-}
-
 /* 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.
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 6943475f..26704dd1 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -27,7 +27,6 @@
 #define MESSENGER_H
 
 #include "friend_requests.h"
-#include "LAN_discovery.h"
 #include "friend_connection.h"
 
 #define MAX_NAME_LENGTH 128
@@ -71,6 +70,7 @@ typedef struct {
     uint8_t udp_disabled;
     TCP_Proxy_Info proxy_info;
     uint16_t port_range[2];
+    uint16_t tcp_server_port;
 } Messenger_Options;
 
 
@@ -220,6 +220,7 @@ struct Messenger {
 
     Friend_Connections *fr_c;
 
+    TCP_Server *tcp_server;
     Friend_Requests fr;
     uint8_t name[MAX_NAME_LENGTH];
     uint16_t name_length;
@@ -232,8 +233,6 @@ struct Messenger {
     Friend *friendlist;
     uint32_t numfriends;
 
-    uint32_t numonline_friends;
-
 #define NUM_SAVED_TCP_RELAYS 8
     uint8_t has_added_relays; // If the first connection has occurred in do_messenger
     Node_format loaded_relays[NUM_SAVED_TCP_RELAYS]; // Relays loaded from config
@@ -730,6 +729,7 @@ int send_custom_lossless_packet(const Messenger *m, int32_t friendnumber, const
 enum {
     MESSENGER_ERROR_NONE,
     MESSENGER_ERROR_PORT,
+    MESSENGER_ERROR_TCP_SERVER,
     MESSENGER_ERROR_OTHER
 };
 
@@ -772,9 +772,6 @@ int messenger_load(Messenger *m, const uint8_t *data, uint32_t length);
  * for copy_friendlist. */
 uint32_t count_friendlist(const Messenger *m);
 
-/* Return the number of online friends in the instance 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.
diff --git a/toxcore/TCP_connection.c b/toxcore/TCP_connection.c
index fe39dc52..b0b26d20 100644
--- a/toxcore/TCP_connection.c
+++ b/toxcore/TCP_connection.c
@@ -249,7 +249,6 @@ int send_packet_tcp_connection(TCP_Connections *tcp_c, int connections_number, c
         for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) {
             uint32_t tcp_con_num = con_to->connections[i].tcp_connection;
             uint8_t status = con_to->connections[i].status;
-            uint8_t connection_id = con_to->connections[i].connection_id;
 
             if (tcp_con_num && status == TCP_CONNECTIONS_STATUS_REGISTERED) {
                 tcp_con_num -= 1;
diff --git a/toxcore/TCP_server.h b/toxcore/TCP_server.h
index 727c4b4e..ba3e7308 100644
--- a/toxcore/TCP_server.h
+++ b/toxcore/TCP_server.h
@@ -85,7 +85,7 @@ typedef struct TCP_Priority_List TCP_Priority_List;
 struct TCP_Priority_List {
     TCP_Priority_List *next;
     uint16_t size, sent;
-    uint8_t data[0];
+    uint8_t data[];
 };
 
 typedef struct TCP_Secure_Connection {
diff --git a/toxcore/crypto_core.h b/toxcore/crypto_core.h
index d7306a8a..eefb1d90 100644
--- a/toxcore/crypto_core.h
+++ b/toxcore/crypto_core.h
@@ -35,6 +35,7 @@
 #include <crypto_hash_sha512.h>
 #include <crypto_verify_16.h>
 #include <crypto_verify_32.h>
+#include <crypto_scalarmult_curve25519.h>
 #define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
 #endif
 
diff --git a/toxcore/friend_connection.c b/toxcore/friend_connection.c
index c13ca949..1656def0 100644
--- a/toxcore/friend_connection.c
+++ b/toxcore/friend_connection.c
@@ -158,6 +158,15 @@ int friend_add_tcp_relay(Friend_Connections *fr_c, int friendcon_id, IP_Port ip_
     if (!friend_con)
         return -1;
 
+    /* Local ip and same pk means that they are hosting a TCP relay. */
+    if (Local_ip(ip_port.ip) && memcmp(friend_con->dht_temp_pk, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+        if (friend_con->dht_ip_port.ip.family != 0) {
+            ip_port.ip = friend_con->dht_ip_port.ip;
+        } else {
+            friend_con->hosting_tcp_relay = 0;
+        }
+    }
+
     unsigned int i;
 
     uint16_t index = friend_con->tcp_relay_counter % FRIEND_MAX_STORED_TCP_RELAYS;
@@ -265,9 +274,14 @@ static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port)
         friend_new_connection(fr_c, number);
     }
 
-    set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port);
+    set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port, 1);
     friend_con->dht_ip_port = ip_port;
     friend_con->dht_ip_port_lastrecv = unix_time();
+
+    if (friend_con->hosting_tcp_relay) {
+        friend_add_tcp_relay(fr_c, number, ip_port, friend_con->dht_temp_pk);
+        friend_con->hosting_tcp_relay = 0;
+    }
 }
 
 static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint8_t *dht_public_key)
@@ -317,6 +331,7 @@ static int handle_status(void *object, int number, uint8_t status)
 
         friend_con->status = FRIENDCONN_STATUS_CONNECTING;
         friend_con->crypt_connection_id = -1;
+        friend_con->hosting_tcp_relay = 0;
     }
 
     if (call_cb) {
@@ -458,7 +473,7 @@ static int handle_new_connections(void *object, New_Connection *n_c)
         friend_con->crypt_connection_id = id;
 
         if (n_c->source.ip.family != AF_INET && n_c->source.ip.family != AF_INET6) {
-            set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port);
+            set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port, 0);
         } else {
             friend_con->dht_ip_port = n_c->source;
             friend_con->dht_ip_port_lastrecv = unix_time();
@@ -796,7 +811,7 @@ void do_friend_connections(Friend_Connections *fr_c)
 
                 if (friend_con->dht_lock) {
                     if (friend_new_connection(fr_c, i) == 0) {
-                        set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port);
+                        set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port, 0);
                         connect_to_saved_tcp_relays(fr_c, i, (MAX_FRIEND_TCP_CONNECTIONS / 2)); /* Only fill it half up. */
                     }
                 }
diff --git a/toxcore/friend_connection.h b/toxcore/friend_connection.h
index baca4b76..32e947ac 100644
--- a/toxcore/friend_connection.h
+++ b/toxcore/friend_connection.h
@@ -96,6 +96,8 @@ typedef struct {
 
     Node_format tcp_relays[FRIEND_MAX_STORED_TCP_RELAYS];
     uint16_t tcp_relay_counter;
+
+    _Bool hosting_tcp_relay;
 } Friend_Conn;
 
 
diff --git a/toxcore/list.c b/toxcore/list.c
index 301e56f8..b97727f8 100644
--- a/toxcore/list.c
+++ b/toxcore/list.c
@@ -45,7 +45,7 @@
  *  < 0  : no match, returns index (return value is INDEX(index)) where
  *         the data should be inserted
  */
-static int find(const BS_LIST *list, const void *data)
+static int find(const BS_LIST *list, const uint8_t *data)
 {
     //should work well, but could be improved
     if (list->n == 0) {
@@ -162,7 +162,7 @@ void bs_list_free(BS_LIST *list)
     free(list->ids);
 }
 
-int bs_list_find(const BS_LIST *list, const void *data)
+int bs_list_find(const BS_LIST *list, const uint8_t *data)
 {
     int r = find(list, data);
 
@@ -174,7 +174,7 @@ int bs_list_find(const BS_LIST *list, const void *data)
     return list->ids[r];
 }
 
-int bs_list_add(BS_LIST *list, const void *data, int id)
+int bs_list_add(BS_LIST *list, const uint8_t *data, int id)
 {
     //find where the new element should be inserted
     //see: return value of find()
@@ -214,7 +214,7 @@ int bs_list_add(BS_LIST *list, const void *data, int id)
     return 1;
 }
 
-int bs_list_remove(BS_LIST *list, const void *data, int id)
+int bs_list_remove(BS_LIST *list, const uint8_t *data, int id)
 {
     int i = find(list, data);
 
diff --git a/toxcore/list.h b/toxcore/list.h
index 03ac04dd..b04177e1 100644
--- a/toxcore/list.h
+++ b/toxcore/list.h
@@ -34,7 +34,7 @@ typedef struct {
     uint32_t n; //number of elements
     uint32_t capacity; //number of elements memory is allocated for
     uint32_t element_size; //size of the elements
-    void *data; //array of elements
+    uint8_t *data; //array of elements
     int *ids; //array of element ids
 } BS_LIST;
 
@@ -56,7 +56,7 @@ void bs_list_free(BS_LIST *list);
  *  >= 0 : id associated with data
  *  -1   : failure
  */
-int bs_list_find(const BS_LIST *list, const void *data);
+int bs_list_find(const BS_LIST *list, const uint8_t *data);
 
 /* Add an element with associated id to the list
  *
@@ -64,7 +64,7 @@ int bs_list_find(const BS_LIST *list, const void *data);
  *  1 : success
  *  0 : failure (data already in list)
  */
-int bs_list_add(BS_LIST *list, const void *data, int id);
+int bs_list_add(BS_LIST *list, const uint8_t *data, int id);
 
 /* Remove element from the list
  *
@@ -72,7 +72,7 @@ int bs_list_add(BS_LIST *list, const void *data, int id);
  *  1 : success
  *  0 : failure (element not found or id does not match)
  */
-int bs_list_remove(BS_LIST *list, const void *data, int id);
+int bs_list_remove(BS_LIST *list, const uint8_t *data, int id);
 
 /* Removes the memory overhead
  *
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 0ed855bb..6d4f6a9b 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -676,6 +676,8 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
     uint32_t i, n = 1;
     uint32_t requested = 0;
 
+    uint64_t temp_time = current_time_monotonic();
+
     for (i = send_array->buffer_start; i != send_array->buffer_end; ++i) {
         if (length == 0)
             break;
@@ -684,7 +686,11 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
 
         if (n == data[0]) {
             if (send_array->buffer[num]) {
-                send_array->buffer[num]->sent = 0;
+                uint64_t sent_time = send_array->buffer[num]->sent_time;
+
+                if ((sent_time + DEFAULT_PING_CONNECTION) < temp_time) {
+                    send_array->buffer[num]->sent_time = 0;
+                }
             }
 
             ++data;
@@ -788,12 +794,12 @@ static int reset_max_speed_reached(Net_Crypto *c, int crypt_connection_id)
         uint8_t send_failed = 0;
 
         if (ret == 1) {
-            if (!dt->sent) {
+            if (!dt->sent_time) {
                 if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, dt->data,
                                             dt->length) != 0) {
                     send_failed = 1;
                 } else {
-                    dt->sent = 1;
+                    dt->sent_time = current_time_monotonic();
                 }
             }
         }
@@ -831,7 +837,7 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
     }
 
     Packet_Data dt;
-    dt.sent = 0;
+    dt.sent_time = 0;
     dt.length = length;
     memcpy(dt.data, data, length);
     pthread_mutex_lock(&conn->mutex);
@@ -849,7 +855,7 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
         Packet_Data *dt1 = NULL;
 
         if (get_data_pointer(&conn->send_array, &dt1, packet_num) == 1)
-            dt1->sent = 1;
+            dt1->sent_time = current_time_monotonic();
     } else {
         conn->maximum_speed_reached = 1;
         LOGGER_ERROR("send_data_packet failed\n");
@@ -936,7 +942,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(Net_Crypto *c, int crypt_connection_id, uint32_t max_num)
 {
     if (max_num == 0)
         return -1;
@@ -946,6 +952,7 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint16
     if (conn == 0)
         return -1;
 
+    uint64_t temp_time = current_time_monotonic();
     uint32_t i, num_sent = 0, array_size = num_packets_array(&conn->send_array);
 
     for (i = 0; i < array_size; ++i) {
@@ -959,13 +966,13 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint16
             continue;
         }
 
-        if (dt->sent) {
+        if (dt->sent_time) {
             continue;
         }
 
         if (send_data_packet_helper(c, crypt_connection_id, conn->recv_array.buffer_start, packet_num, dt->data,
                                     dt->length) == 0) {
-            dt->sent = 1;
+            dt->sent_time = temp_time;
             ++num_sent;
         }
 
@@ -1439,10 +1446,10 @@ static int crypto_connection_add_source(Net_Crypto *c, int crypt_connection_id,
 
     if (source.ip.family == AF_INET || source.ip.family == AF_INET6) {
         if (!ipport_equal(&source, &conn->ip_port)) {
-            if (!bs_list_add(&c->ip_port_list, &source, crypt_connection_id))
+            if (!bs_list_add(&c->ip_port_list, (uint8_t *)&source, crypt_connection_id))
                 return -1;
 
-            bs_list_remove(&c->ip_port_list, &conn->ip_port, crypt_connection_id);
+            bs_list_remove(&c->ip_port_list, (uint8_t *)&conn->ip_port, crypt_connection_id);
             conn->ip_port = source;
         }
 
@@ -1547,12 +1554,13 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
         return -1;
 
     pthread_mutex_lock(&c->tcp_mutex);
-    conn->connection_number_tcp = new_tcp_connection_to(c->tcp_c, n_c->dht_public_key, crypt_connection_id);
+    int connection_number_tcp = new_tcp_connection_to(c->tcp_c, n_c->dht_public_key, crypt_connection_id);
     pthread_mutex_unlock(&c->tcp_mutex);
 
-    if (conn->connection_number_tcp == -1)
+    if (connection_number_tcp == -1)
         return -1;
 
+    conn->connection_number_tcp = connection_number_tcp;
     memcpy(conn->public_key, n_c->public_key, crypto_box_PUBLICKEYBYTES);
     memcpy(conn->recv_nonce, n_c->recv_nonce, crypto_box_NONCEBYTES);
     memcpy(conn->peersessionpublic_key, n_c->peersessionpublic_key, crypto_box_PUBLICKEYBYTES);
@@ -1600,12 +1608,13 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
         return -1;
 
     pthread_mutex_lock(&c->tcp_mutex);
-    conn->connection_number_tcp = new_tcp_connection_to(c->tcp_c, dht_public_key, crypt_connection_id);
+    int connection_number_tcp = new_tcp_connection_to(c->tcp_c, dht_public_key, crypt_connection_id);
     pthread_mutex_unlock(&c->tcp_mutex);
 
-    if (conn->connection_number_tcp == -1)
+    if (connection_number_tcp == -1)
         return -1;
 
+    conn->connection_number_tcp = connection_number_tcp;
     memcpy(conn->public_key, real_public_key, crypto_box_PUBLICKEYBYTES);
     random_nonce(conn->sent_nonce);
     crypto_box_keypair(conn->sessionpublic_key, conn->sessionsecret_key);
@@ -1632,10 +1641,12 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
 
 /* Set the direct ip of the crypto connection.
  *
+ * Connected is 0 if we are not sure we are connected to that person, 1 if we are sure.
+ *
  * return -1 on failure.
  * return 0 on success.
  */
-int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port)
+int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, _Bool connected)
 {
     Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
 
@@ -1656,10 +1667,16 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port)
                 return -1;
         }
 
-        if (bs_list_add(&c->ip_port_list, &ip_port, crypt_connection_id)) {
-            bs_list_remove(&c->ip_port_list, &conn->ip_port, crypt_connection_id);
+        if (bs_list_add(&c->ip_port_list, (uint8_t *)&ip_port, crypt_connection_id)) {
+            bs_list_remove(&c->ip_port_list, (uint8_t *)&conn->ip_port, crypt_connection_id);
             conn->ip_port = ip_port;
-            conn->direct_lastrecv_time = 0;
+
+            if (connected) {
+                conn->direct_lastrecv_time = unix_time();
+            } else {
+                conn->direct_lastrecv_time = 0;
+            }
+
             return 0;
         }
     }
@@ -1931,7 +1948,7 @@ int nc_dht_pk_callback(Net_Crypto *c, int crypt_connection_id, void (*function)(
  */
 static int crypto_id_ip_port(const Net_Crypto *c, IP_Port ip_port)
 {
-    return bs_list_find(&c->ip_port_list, &ip_port);
+    return bs_list_find(&c->ip_port_list, (uint8_t *)&ip_port);
 }
 
 #define CRYPTO_MIN_PACKET_SIZE (1 + sizeof(uint16_t) + crypto_box_MACBYTES)
@@ -1983,7 +2000,14 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
 /* Ratio of recv queue size / recv packet rate (in seconds) times
  * the number of ms between request packets to send at that ratio
  */
-#define REQUEST_PACKETS_COMPARE_CONSTANT (0.5 * 100.0)
+#define REQUEST_PACKETS_COMPARE_CONSTANT (0.125 * 100.0)
+
+/* Multiplier for maximum allowed resends. */
+#define PACKET_RESEND_MULTIPLIER 2
+
+/* Timeout for increasing speed after congestion event (in ms). */
+#define CONGESTION_EVENT_TIMEOUT 4000
+
 static void send_crypto_packets(Net_Crypto *c)
 {
     uint32_t i;
@@ -2061,7 +2085,11 @@ static void send_crypto_packets(Net_Crypto *c)
                 double min_speed = 1000.0 * (((double)(total_sent)) / ((double)(CONGESTION_QUEUE_ARRAY_SIZE) *
                                              PACKET_COUNTER_AVERAGE_INTERVAL));
 
-                conn->packet_send_rate = min_speed * 1.2;
+                if (conn->last_congestion_event + CONGESTION_EVENT_TIMEOUT < temp_time) {
+                    conn->packet_send_rate = min_speed * 1.2;
+                } else {
+                    conn->packet_send_rate = min_speed;
+                }
 
                 if (conn->packet_send_rate < CRYPTO_PACKET_MIN_RATE) {
                     conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
@@ -2084,10 +2112,15 @@ static void send_crypto_packets(Net_Crypto *c)
                 conn->last_packets_left_set = temp_time;
             }
 
-            int ret = send_requested_packets(c, i, conn->packets_left);
+            int ret = send_requested_packets(c, i, conn->packets_left * PACKET_RESEND_MULTIPLIER);
 
             if (ret != -1) {
-                conn->packets_left -= ret;
+                if (ret < conn->packets_left) {
+                    conn->packets_left -= ret;
+                } else {
+                    conn->last_congestion_event = temp_time;
+                    conn->packets_left = 0;
+                }
             }
 
             if (conn->packet_send_rate > CRYPTO_PACKET_MIN_RATE * 1.5) {
@@ -2280,7 +2313,7 @@ int crypto_kill(Net_Crypto *c, int crypt_connection_id)
         kill_tcp_connection_to(c->tcp_c, conn->connection_number_tcp);
         pthread_mutex_unlock(&c->tcp_mutex);
 
-        bs_list_remove(&c->ip_port_list, &conn->ip_port, crypt_connection_id);
+        bs_list_remove(&c->ip_port_list, (uint8_t *)&conn->ip_port, crypt_connection_id);
         clear_temp_packet(c, crypt_connection_id);
         clear_buffer(&conn->send_array);
         clear_buffer(&conn->recv_array);
@@ -2326,6 +2359,8 @@ 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.
+ *
+ * TODO: Save only secret key.
  */
 void save_keys(const Net_Crypto *c, uint8_t *keys)
 {
@@ -2333,13 +2368,13 @@ void save_keys(const Net_Crypto *c, uint8_t *keys)
     memcpy(keys + crypto_box_PUBLICKEYBYTES, c->self_secret_key, crypto_box_SECRETKEYBYTES);
 }
 
-/* Load the public and private keys from the keys array.
- * Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES.
+/* Load the secret key.
+ * Length must be crypto_box_SECRETKEYBYTES.
  */
-void load_keys(Net_Crypto *c, const uint8_t *keys)
+void load_secret_key(Net_Crypto *c, const uint8_t *sk)
 {
-    memcpy(c->self_public_key, keys, crypto_box_PUBLICKEYBYTES);
-    memcpy(c->self_secret_key, keys + crypto_box_PUBLICKEYBYTES, crypto_box_SECRETKEYBYTES);
+    memcpy(c->self_secret_key, sk, crypto_box_SECRETKEYBYTES);
+    crypto_scalarmult_curve25519_base(c->self_public_key, c->self_secret_key);
 }
 
 /* Run this to (re)initialize net_crypto.
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index 9eb5e2d3..56f43cc4 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -82,8 +82,11 @@
    at the dT defined in net_crypto.c */
 #define CONGESTION_QUEUE_ARRAY_SIZE 24
 
+/* Connection ping in ms. TODO: calculate it per connection. */
+#define DEFAULT_PING_CONNECTION 50
+
 typedef struct {
-    _Bool sent;
+    uint64_t sent_time;
     uint16_t length;
     uint8_t data[MAX_CRYPTO_DATA_SIZE];
 } Packet_Data;
@@ -146,6 +149,7 @@ typedef struct {
     uint32_t last_sendqueue_size[CONGESTION_QUEUE_ARRAY_SIZE], last_sendqueue_counter;
     long signed int last_num_packets_sent[CONGESTION_QUEUE_ARRAY_SIZE];
     uint32_t packets_sent;
+    uint64_t last_congestion_event;
 
     /* TCP_connection connection_number */
     unsigned int connection_number_tcp;
@@ -224,10 +228,12 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
 
 /* Set the direct ip of the crypto connection.
  *
+ * Connected is 0 if we are not sure we are connected to that person, 1 if we are sure.
+ *
  * return -1 on failure.
  * return 0 on success.
  */
-int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port);
+int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port, _Bool connected);
 
 /* Set function to be called when connection with crypt_connection_id goes connects/disconnects.
  *
@@ -378,10 +384,10 @@ void new_keys(Net_Crypto *c);
  */
 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.
+/* Load the secret key.
+ * Length must be crypto_box_SECRETKEYBYTES.
  */
-void load_keys(Net_Crypto *c, const uint8_t *keys);
+void load_secret_key(Net_Crypto *c, const uint8_t *sk);
 
 /* Create new instance of Net_Crypto.
  *  Sets all the global connection variables to their default values.
diff --git a/toxcore/network.c b/toxcore/network.c
index e8787127..22ee4202 100644
--- a/toxcore/network.c
+++ b/toxcore/network.c
@@ -813,7 +813,7 @@ void ipport_copy(IP_Port *target, const IP_Port *source)
         return;
 
     memcpy(target, source, sizeof(IP_Port));
-};
+}
 
 /* ip_ntoa
  *   converts ip into a string
diff --git a/toxcore/onion.c b/toxcore/onion.c
index 48e4c769..cec178b9 100644
--- a/toxcore/onion.c
+++ b/toxcore/onion.c
@@ -104,7 +104,7 @@ static int ipport_unpack(IP_Port *target, const uint8_t *data, unsigned int data
 
 /* Create a new onion path.
  *
- * Create a new onion path out of nodes (nodes is a list of 3 nodes)
+ * Create a new onion path out of nodes (nodes is a list of ONION_PATH_LENGTH nodes)
  *
  * new_path must be an empty memory location of atleast Onion_Path size.
  *
@@ -148,7 +148,7 @@ int create_onion_path(const DHT *dht, Onion_Path *new_path, const Node_format *n
  */
 int onion_path_to_nodes(Node_format *nodes, unsigned int num_nodes, const Onion_Path *path)
 {
-    if (num_nodes < 3)
+    if (num_nodes < ONION_PATH_LENGTH)
         return -1;
 
     nodes[0].ip_port = path->ip_port1;
diff --git a/toxcore/onion.h b/toxcore/onion.h
index b05d2c8c..2b270ea9 100644
--- a/toxcore/onion.h
+++ b/toxcore/onion.h
@@ -53,6 +53,8 @@ typedef struct {
 #define ONION_MAX_DATA_SIZE (ONION_MAX_PACKET_SIZE - (ONION_SEND_1 + 1))
 #define ONION_RESPONSE_MAX_DATA_SIZE (ONION_MAX_PACKET_SIZE - (1 + ONION_RETURN_3))
 
+#define ONION_PATH_LENGTH 3
+
 typedef struct {
     uint8_t shared_key1[crypto_box_BEFORENMBYTES];
     uint8_t shared_key2[crypto_box_BEFORENMBYTES];
@@ -76,7 +78,7 @@ typedef struct {
 
 /* Create a new onion path.
  *
- * Create a new onion path out of nodes (nodes is a list of 3 nodes)
+ * Create a new onion path out of nodes (nodes is a list of ONION_PATH_LENGTH nodes)
  *
  * new_path must be an empty memory location of atleast Onion_Path size.
  *
diff --git a/toxcore/onion_announce.h b/toxcore/onion_announce.h
index 36ffe767..0e041e50 100644
--- a/toxcore/onion_announce.h
+++ b/toxcore/onion_announce.h
@@ -25,7 +25,7 @@
 
 #include "onion.h"
 
-#define ONION_ANNOUNCE_MAX_ENTRIES 64
+#define ONION_ANNOUNCE_MAX_ENTRIES 96
 #define ONION_ANNOUNCE_TIMEOUT 300
 #define ONION_PING_ID_SIZE crypto_hash_sha256_BYTES
 
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index ed328fb3..6575f632 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -190,7 +190,7 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
             continue;
         }
 
-        if (ipport_equal(&onion_paths->paths[i].ip_port1, &nodes[2].ip_port)) {
+        if (ipport_equal(&onion_paths->paths[i].ip_port1, &nodes[ONION_PATH_LENGTH - 1].ip_port)) {
             return i;
         }
     }
@@ -215,9 +215,9 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
     if ((onion_paths->last_path_success[pathnum] + ONION_PATH_TIMEOUT < onion_paths->last_path_used[pathnum]
             && onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES)
             || is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME)) {
-        Node_format nodes[3];
+        Node_format nodes[ONION_PATH_LENGTH];
 
-        if (random_nodes_path_onion(onion_c, nodes, 3) != 3)
+        if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH)
             return -1;
 
         int n = is_path_used(onion_paths, nodes);
@@ -267,13 +267,12 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
         onion_paths->last_path_success[path_num % NUMBER_ONION_PATHS] = unix_time();
         onion_paths->last_path_used_times[path_num % NUMBER_ONION_PATHS] = 0;
 
-        unsigned int path_len = 3;
-        Node_format nodes[path_len];
+        Node_format nodes[ONION_PATH_LENGTH];
 
-        if (onion_path_to_nodes(nodes, path_len, &onion_paths->paths[path_num % NUMBER_ONION_PATHS]) == 0) {
+        if (onion_path_to_nodes(nodes, ONION_PATH_LENGTH, &onion_paths->paths[path_num % NUMBER_ONION_PATHS]) == 0) {
             unsigned int i;
 
-            for (i = 0; i < path_len; ++i) {
+            for (i = 0; i < ONION_PATH_LENGTH; ++i) {
                 onion_add_path_node(onion_c, nodes[i].ip_port, nodes[i].public_key);
             }
         }
@@ -1205,7 +1204,7 @@ static void populate_path_nodes_tcp(Onion_Client *onion_c)
     unsigned int i;
 
     for (i = 0; i < num_nodes; ++i) {
-        onion_add_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].public_key);
+        onion_add_bs_path_node(onion_c, nodes_list[i].ip_port, nodes_list[i].public_key);
     }
 }
 
diff --git a/toxcore/ping.c b/toxcore/ping.c
index 1c3564a3..2decca0a 100644
--- a/toxcore/ping.c
+++ b/toxcore/ping.c
@@ -304,16 +304,18 @@ void do_to_ping(PING *ping)
     if (!ip_isset(&ping->to_ping[0].ip_port.ip))
         return;
 
-    ping->last_to_ping = unix_time();
     uint32_t i;
 
     for (i = 0; i < MAX_TO_PING; ++i) {
         if (!ip_isset(&ping->to_ping[i].ip_port.ip))
-            return;
+            break;
 
         send_ping_request(ping, ping->to_ping[i].ip_port, ping->to_ping[i].public_key);
         ip_reset(&ping->to_ping[i].ip_port.ip);
     }
+
+    if (i != 0)
+        ping->last_to_ping = unix_time();
 }
 
 
diff --git a/toxcore/tox.c b/toxcore/tox.c
index 848f81c7..de615768 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -152,6 +152,7 @@ Tox *tox_new(const struct Tox_Options *options, const uint8_t *data, size_t leng
         m_options.udp_disabled = !options->udp_enabled;
         m_options.port_range[0] = options->start_port;
         m_options.port_range[1] = options->end_port;
+        m_options.tcp_server_port = options->tcp_port;
 
         switch (options->proxy_type) {
             case TOX_PROXY_TYPE_HTTP:
@@ -238,31 +239,6 @@ void tox_get_savedata(const Tox *tox, uint8_t *data)
     }
 }
 
-static int address_to_ip(Messenger *m, const char *address, IP_Port *ip_port, IP_Port *ip_port_v4)
-{
-    if (!addr_parse_ip(address, &ip_port->ip)) {
-        if (m->options.udp_disabled) { /* Disable DNS when udp is disabled. */
-            return -1;
-        }
-
-        IP *ip_extra = NULL;
-        ip_init(&ip_port->ip, m->options.ipv6enabled);
-
-        if (m->options.ipv6enabled && ip_port_v4) {
-            /* setup for getting BOTH: an IPv6 AND an IPv4 address */
-            ip_port->ip.family = AF_UNSPEC;
-            ip_reset(&ip_port_v4->ip);
-            ip_extra = &ip_port_v4->ip;
-        }
-
-        if (!addr_resolve(address, &ip_port->ip, ip_extra)) {
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
 bool tox_bootstrap(Tox *tox, const char *address, uint16_t port, const uint8_t *public_key, TOX_ERR_BOOTSTRAP *error)
 {
     if (!address || !public_key) {
@@ -270,23 +246,53 @@ bool tox_bootstrap(Tox *tox, const char *address, uint16_t port, const uint8_t *
         return 0;
     }
 
-    Messenger *m = tox;
-    bool ret = tox_add_tcp_relay(tox, address, port, public_key, error);
+    if (port == 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_PORT);
+        return 0;
+    }
 
-    if (!ret) {
+    struct addrinfo *root, *info;
+
+    if (getaddrinfo(address, NULL, NULL, &root) != 0) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
         return 0;
     }
 
-    if (m->options.udp_disabled) {
-        return ret;
-    } else { /* DHT only works on UDP. */
-        if (DHT_bootstrap_from_address(m->dht, address, m->options.ipv6enabled, htons(port), public_key) == 0) {
-            SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
-            return 0;
+    info = root;
+
+    unsigned int count = 0;
+
+    do {
+        IP_Port ip_port;
+        ip_port.port = htons(port);
+        ip_port.ip.family = info->ai_family;
+
+        if (info->ai_socktype && info->ai_socktype != SOCK_DGRAM) {
+            continue;
+        }
+
+        if (info->ai_family == AF_INET) {
+            ip_port.ip.ip4.in_addr = ((struct sockaddr_in *)info->ai_addr)->sin_addr;
+        } else if (info->ai_family == AF_INET6) {
+            ip_port.ip.ip6.in6_addr = ((struct sockaddr_in6 *)info->ai_addr)->sin6_addr;
+        } else {
+            continue;
         }
 
+        Messenger *m = tox;
+        onion_add_bs_path_node(m->onion_c, ip_port, public_key);
+        DHT_bootstrap(m->dht, ip_port, public_key);
+        ++count;
+    } while ((info = info->ai_next));
+
+    freeaddrinfo(root);
+
+    if (count) {
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
         return 1;
+    } else {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
+        return 0;
     }
 }
 
@@ -298,25 +304,53 @@ bool tox_add_tcp_relay(Tox *tox, const char *address, uint16_t port, const uint8
         return 0;
     }
 
-    Messenger *m = tox;
-    IP_Port ip_port, ip_port_v4;
-
     if (port == 0) {
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_PORT);
         return 0;
     }
 
-    if (address_to_ip(m, address, &ip_port, &ip_port_v4) == -1) {
+    struct addrinfo *root, *info;
+
+    if (getaddrinfo(address, NULL, NULL, &root) != 0) {
         SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
         return 0;
     }
 
-    ip_port.port = htons(port);
-    add_tcp_relay(m->net_crypto, ip_port, public_key);
-    onion_add_bs_path_node(m->onion_c, ip_port, public_key); //TODO: move this
+    info = root;
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
-    return 1;
+    unsigned int count = 0;
+
+    do {
+        IP_Port ip_port;
+        ip_port.port = htons(port);
+        ip_port.ip.family = info->ai_family;
+
+        if (info->ai_socktype && info->ai_socktype != SOCK_STREAM) {
+            continue;
+        }
+
+        if (info->ai_family == AF_INET) {
+            ip_port.ip.ip4.in_addr = ((struct sockaddr_in *)info->ai_addr)->sin_addr;
+        } else if (info->ai_family == AF_INET6) {
+            ip_port.ip.ip6.in6_addr = ((struct sockaddr_in6 *)info->ai_addr)->sin6_addr;
+        } else {
+            continue;
+        }
+
+        Messenger *m = tox;
+        add_tcp_relay(m->net_crypto, ip_port, public_key);
+        ++count;
+    } while ((info = info->ai_next));
+
+    freeaddrinfo(root);
+
+    if (count) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_OK);
+        return 1;
+    } else {
+        SET_ERROR_PARAMETER(error, TOX_ERR_BOOTSTRAP_BAD_HOST);
+        return 0;
+    }
 }
 
 TOX_CONNECTION tox_self_get_connection_status(const Tox *tox)
@@ -1205,9 +1239,15 @@ uint16_t tox_self_get_udp_port(const Tox *tox, TOX_ERR_GET_PORT *error)
 
 uint16_t tox_self_get_tcp_port(const Tox *tox, TOX_ERR_GET_PORT *error)
 {
-    /* TCP server not yet implemented in clients. */
-    SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_NOT_BOUND);
-    return 0;
+    const Messenger *m = tox;
+
+    if (m->tcp_server) {
+        SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_OK);
+        return m->options.tcp_server_port;
+    } else {
+        SET_ERROR_PARAMETER(error, TOX_ERR_GET_PORT_NOT_BOUND);
+        return 0;
+    }
 }
 
 #include "tox_old_code.h"
diff --git a/toxcore/tox.h b/toxcore/tox.h
index abd2f051..4afdf7c3 100644
--- a/toxcore/tox.h
+++ b/toxcore/tox.h
@@ -426,6 +426,12 @@ struct Tox_Options {
      */
     uint16_t end_port;
 
+
+    /**
+     * The port to use for the TCP server. If 0, the tcp server is disabled.
+     */
+    uint16_t tcp_port;
+
 };