8 files changed, 309 insertions, 101 deletions

diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index b0d5a2e5..96005237 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -195,6 +195,21 @@ void getaddress(Messenger *m, uint8_t *address)
     memcpy(address + crypto_box_PUBLICKEYBYTES + sizeof(nospam), &checksum, sizeof(checksum));
 }
 
+/* callback for recv TCP relay nodes. */
+static int tcp_relay_node_callback(void *object, uint32_t number, IP_Port ip_port, uint8_t *public_key)
+{
+    Messenger *m = object;
+
+    if (friend_not_valid(m, number))
+        return -1;
+
+    if (m->friendlist[number].crypt_connection_id != -1) {
+        return add_tcp_relay_peer(m->net_crypto, m->friendlist[number].crypt_connection_id, ip_port, public_key);
+    } else {
+        return add_tcp_relay(m->net_crypto, ip_port, public_key);
+    }
+}
+
 /*
  * Add a friend.
  * Set the data that will be sent along with friend request.
@@ -277,6 +292,7 @@ int32_t m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t leng
             m->friendlist[i].message_id = 0;
             m->friendlist[i].receives_read_receipts = 1; /* Default: YES. */
             memcpy(&(m->friendlist[i].friendrequest_nospam), address + crypto_box_PUBLICKEYBYTES, sizeof(uint32_t));
+            recv_tcp_relay_handler(m->onion_c, onion_friendnum, &tcp_relay_node_callback, m, i);
 
             if (m->numfriends == i)
                 ++m->numfriends;
@@ -322,6 +338,7 @@ int32_t m_addfriend_norequest(Messenger *m, uint8_t *client_id)
             m->friendlist[i].is_typing = 0;
             m->friendlist[i].message_id = 0;
             m->friendlist[i].receives_read_receipts = 1; /* Default: YES. */
+            recv_tcp_relay_handler(m->onion_c, onion_friendnum, &tcp_relay_node_callback, m, i);
 
             if (m->numfriends == i)
                 ++m->numfriends;
@@ -2203,17 +2220,15 @@ void do_friends(Messenger *m)
         }
 
         if (m->friendlist[i].crypt_connection_id != -1) {
-            uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
-            uint64_t timestamp = onion_getfriend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key);
-
-            if (timestamp != 0) {
-                set_connection_dht_public_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key, timestamp);
-            }
-
-            timestamp = get_connection_dht_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key);
-
-            if (timestamp != 0) {
-                onion_set_friend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key, timestamp);
+            uint8_t dht_public_key1[crypto_box_PUBLICKEYBYTES];
+            uint64_t timestamp1 = onion_getfriend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key1);
+            uint8_t dht_public_key2[crypto_box_PUBLICKEYBYTES];
+            uint64_t timestamp2 = get_connection_dht_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key2);
+
+            if (timestamp1 > timestamp2) {
+                set_connection_dht_public_key(m->net_crypto, m->friendlist[i].crypt_connection_id, dht_public_key1, timestamp1);
+            } else if (timestamp1 < timestamp2) {
+                onion_set_friend_DHT_pubkey(m->onion_c, m->friendlist[i].onion_friendnum, dht_public_key2, timestamp2);
             }
 
             uint8_t direct_connected;
@@ -2462,9 +2477,10 @@ int wait_cleanup_messenger(Messenger *m, uint8_t *data)
 #define MESSENGER_STATE_TYPE_NAME          4
 #define MESSENGER_STATE_TYPE_STATUSMESSAGE 5
 #define MESSENGER_STATE_TYPE_STATUS        6
+#define MESSENGER_STATE_TYPE_TCP_RELAY     10
 
 #define SAVED_FRIEND_REQUEST_SIZE 1024
-
+#define NUM_SAVED_TCP_RELAYS 8
 struct SAVED_FRIEND {
     uint8_t status;
     uint8_t client_id[CLIENT_ID_SIZE];
@@ -2599,6 +2615,7 @@ uint32_t messenger_size(Messenger *m)
              + sizesubhead + m->name_length                    // Own nickname.
              + sizesubhead + m->statusmessage_length           // status message
              + sizesubhead + 1                                 // status
+             + sizesubhead + NUM_SAVED_TCP_RELAYS * sizeof(Node_format) //TCP relays
              ;
 }
 
@@ -2663,74 +2680,15 @@ void messenger_save(Messenger *m, uint8_t *data)
     data = z_state_save_subheader(data, len, type);
     *data = m->userstatus;
     data += len;
-}
-
-static int messenger_load_state_callback_old(void *outer, uint8_t *data, uint32_t length, uint16_t type)
-{
-    Messenger *m = outer;
-
-    switch (type) {
-        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
-
-                if (m->dht->assoc)
-                    Assoc_self_client_id_changed(m->dht->assoc, m->net_crypto->self_public_key);
-
-#endif
-            } else
-                return -1;    /* critical */
-
-            break;
-
-        case MESSENGER_STATE_TYPE_DHT:
-            DHT_load(m->dht, data, length);
-            break;
-
-        case MESSENGER_STATE_TYPE_FRIENDS:
-            if (!(length % sizeof(Friend))) {
-                uint16_t num = length / sizeof(Friend);
-                Friend *friends = (Friend *)data;
-                uint32_t i;
-
-                for (i = 0; i < num; ++i) {
-                    if (friends[i].status >= 3) {
-                        int fnum = m_addfriend_norequest(m, friends[i].client_id);
-                        setfriendname(m, fnum, friends[i].name, friends[i].name_length);
-                        /* set_friend_statusmessage(fnum, temp[i].statusmessage, temp[i].statusmessage_length); */
-                    } else if (friends[i].status != 0) {
-                        /* TODO: This is not a good way to do this. */
-                        uint8_t address[FRIEND_ADDRESS_SIZE];
-                        id_copy(address, friends[i].client_id);
-                        memcpy(address + crypto_box_PUBLICKEYBYTES, &(friends[i].friendrequest_nospam), sizeof(uint32_t));
-                        uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
-                        memcpy(address + crypto_box_PUBLICKEYBYTES + sizeof(uint32_t), &checksum, sizeof(checksum));
-                        m_addfriend(m, address, friends[i].info, friends[i].info_size);
-                    }
-                }
-            }
-
-            break;
 
-        case MESSENGER_STATE_TYPE_NAME:
-            if ((length > 0) && (length < MAX_NAME_LENGTH)) {
-                setname(m, data, length);
-            }
-
-            break;
-
-#ifdef DEBUG
-
-        default:
-            fprintf(stderr, "Load state: contains unrecognized part (len %u, type %u)\n",
-                    length, type);
-            break;
-#endif
-    }
-
-    return 0;
+    Node_format relays[NUM_SAVED_TCP_RELAYS];
+    len = sizeof(relays);
+    type = MESSENGER_STATE_TYPE_TCP_RELAY;
+    data = z_state_save_subheader(data, len, type);
+    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, uint8_t *data, uint32_t length, uint16_t type)
@@ -2781,6 +2739,22 @@ static int messenger_load_state_callback(void *outer, uint8_t *data, uint32_t le
             }
 
             break;
+
+        case MESSENGER_STATE_TYPE_TCP_RELAY: {
+            Node_format relays[NUM_SAVED_TCP_RELAYS];
+
+            if (length != sizeof(relays)) {
+                return -1;
+            }
+
+            memcpy(relays, data, length);
+            uint32_t i;
+
+            for (i = 0; i < NUM_SAVED_TCP_RELAYS; ++i) {
+                add_tcp_relay(m->net_crypto, relays[i].ip_port, relays[i].client_id);
+            }
+        }
+        break;
 #ifdef DEBUG
 
         default:
@@ -2807,11 +2781,7 @@ int messenger_load(Messenger *m, uint8_t *data, uint32_t length)
     if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL))
         return load_state(messenger_load_state_callback, m, data + cookie_len,
                           length - cookie_len, MESSENGER_STATE_COOKIE_TYPE);
-
-    else if (!data32[0] && (data32[1] == MESSENGER_STATE_COOKIE_GLOBAL_OLD))
-        return load_state(messenger_load_state_callback_old, m, data + cookie_len,
-                          length - cookie_len, MESSENGER_STATE_COOKIE_TYPE);
-    else       /* old state file */
+    else
         return -1;
 }
 
diff --git a/toxcore/TCP_client.c b/toxcore/TCP_client.c
index 9091900f..e4845852 100644
--- a/toxcore/TCP_client.c
+++ b/toxcore/TCP_client.c
@@ -372,6 +372,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, uint8_t *public_key,
     temp->status = TCP_CLIENT_CONNECTING;
     temp->sock = sock;
     memcpy(temp->public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    temp->ip_port = ip_port;
 
     if (generate_handshake(temp, self_public_key, self_secret_key) == -1) {
         kill_sock(sock);
@@ -403,7 +404,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, uint8_t *data, uint16_
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
             if (conn->connections[con_id].status != 0)
-                return -1;
+                return 0;
 
             conn->connections[con_id].status = 1;
             conn->connections[con_id].number = ~0;
@@ -445,6 +446,9 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, uint8_t *data, uint16_
 
             uint8_t con_id = data[1] - NUM_RESERVED_PORTS;
 
+            if (conn->connections[con_id].status == 0)
+                return 0;
+
             if (conn->connections[con_id].status != 2)
                 return -1;
 
@@ -604,6 +608,9 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection)
  */
 void kill_TCP_connection(TCP_Client_Connection *TCP_connection)
 {
+    if (TCP_connection == NULL)
+        return;
+
     kill_sock(TCP_connection->sock);
     memset(TCP_connection, 0, sizeof(TCP_Client_Connection));
     free(TCP_connection);
diff --git a/toxcore/TCP_client.h b/toxcore/TCP_client.h
index 9583e15f..afb95392 100644
--- a/toxcore/TCP_client.h
+++ b/toxcore/TCP_client.h
@@ -40,6 +40,7 @@ typedef struct  {
     uint8_t status;
     sock_t  sock;
     uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* public key of the server */
+    IP_Port ip_port; /* The ip and port of the server */
     uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* Nonce of received packets. */
     uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* Nonce of sent packets. */
     uint8_t shared_key[crypto_box_BEFORENMBYTES];
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index 1e3456c3..875c639f 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -406,6 +406,8 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
     if (conn == 0)
         return -1;
 
+    int direct_send_attempt = 0;
+
     //TODO: on bad networks, direct connections might not last indefinitely.
     if (conn->ip_port.ip.family != 0) {
         uint8_t direct_connected = 0;
@@ -415,8 +417,10 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
             return 0;
 
         //TODO: a better way of sending packets directly to confirm the others ip.
-        if (length < 96 || data[0] == NET_PACKET_COOKIE_REQUEST || data[0] == NET_PACKET_CRYPTO_HS)
-            sendpacket(c->dht->net, conn->ip_port, data, length);
+        if (length < 96 || data[0] == NET_PACKET_COOKIE_REQUEST || data[0] == NET_PACKET_CRYPTO_HS) {
+            if ((uint32_t)sendpacket(c->dht->net, conn->ip_port, data, length) == length)
+                direct_send_attempt = 1;
+        }
 
     }
 
@@ -424,12 +428,23 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
     uint32_t i;
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
-        if (conn->status_tcp[i] == 2) {/* friend is connected to this relay. */
+        if (conn->status_tcp[i] == STATUS_TCP_ONLINE) {/* friend is connected to this relay. */
             if (send_data(c->tcp_connections[i], conn->con_number_tcp[i], data, length) == 1)
                 return 0;
         }
     }
 
+    for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
+        if (conn->status_tcp[i] == STATUS_TCP_INVISIBLE) {
+            if (send_oob_packet(c->tcp_connections[i], conn->dht_public_key, data, length) == 1)
+                return 0;
+        }
+    }
+
+    if (direct_send_attempt) {
+        return 0;
+    }
+
     return -1;
 }
 
@@ -1461,9 +1476,9 @@ static int disconnect_peer_tcp(Net_Crypto *c, int crypt_connection_id)
     uint32_t i;
 
     for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
-        if (conn->status_tcp[i]) {
+        if (conn->status_tcp[i] != STATUS_TCP_NULL) {
             send_disconnect_request(c->tcp_connections[i], conn->con_number_tcp[i]);
-            conn->status_tcp[i] = 0;
+            conn->status_tcp[i] = STATUS_TCP_NULL;
             conn->con_number_tcp[i] = 0;
         }
     }
@@ -1575,9 +1590,10 @@ int set_direct_ip_port(Net_Crypto *c, int crypt_connection_id, IP_Port ip_port)
     if (!ipport_equal(&ip_port, &conn->ip_port)) {
         conn->ip_port = ip_port;
         conn->direct_lastrecv_time = 0;
+        return 0;
     }
 
-    return 0;
+    return -1;
 }
 
 static int tcp_response_callback(void *object, uint8_t connection_id, uint8_t *public_key)
@@ -1605,8 +1621,17 @@ static int tcp_response_callback(void *object, uint8_t connection_id, uint8_t *p
     if (c->tcp_connections[location] != TCP_con)
         return -1;
 
-    conn->status_tcp[location] = 1;
     conn->con_number_tcp[location] = connection_id;
+    uint32_t i;
+
+    for (i = 0; i < conn->num_tcp_relays; ++i) {
+        if (memcmp(TCP_con->public_key, conn->tcp_relays[i].client_id, crypto_box_PUBLICKEYBYTES) == 0) {
+            conn->status_tcp[location] = STATUS_TCP_INVISIBLE;
+            return 0;
+        }
+    }
+
+    conn->status_tcp[location] = STATUS_TCP_OFFLINE;
     return 0;
 }
 
@@ -1628,13 +1653,19 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
     if (c->tcp_connections[location] != TCP_con)
         return -1;
 
-    conn->status_tcp[location] = status;
+    if (status == 1) {
+        conn->status_tcp[location] = STATUS_TCP_OFFLINE;
+    } else if (status == 2) {
+        conn->status_tcp[location] = STATUS_TCP_ONLINE;
+    }
+
     conn->con_number_tcp[location] = connection_id;
     return 0;
 }
 
 static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t *data, uint16_t length)
 {
+
     if (length == 0)
         return -1;
 
@@ -1729,6 +1760,59 @@ static int tcp_connection_check(Net_Crypto *c, uint8_t *public_key)
     return 0;
 }
 
+/* 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)
+{
+    Crypto_Connection *conn = get_crypto_connection(c, crypt_connection_id);
+
+    if (conn == 0)
+        return -1;
+
+    if (ip_port.ip.family == TCP_INET) {
+        ip_port.ip.family = AF_INET;
+    } else if (ip_port.ip.family == TCP_INET6) {
+        ip_port.ip.family = AF_INET6;
+    }
+
+    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+        return -1;
+
+    uint32_t i;
+
+    for (i = 0; i < conn->num_tcp_relays; ++i) {
+        if (memcmp(conn->tcp_relays[i].client_id, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+            conn->tcp_relays[i].ip_port = ip_port;
+            return 0;
+        }
+    }
+
+    if (conn->num_tcp_relays == MAX_TCP_RELAYS_PEER) {
+        uint16_t index = rand() % MAX_TCP_RELAYS_PEER;
+        conn->tcp_relays[index].ip_port = ip_port;
+        memcpy(conn->tcp_relays[index].client_id, public_key, crypto_box_PUBLICKEYBYTES);
+    } else {
+        conn->tcp_relays[conn->num_tcp_relays].ip_port = ip_port;
+        memcpy(conn->tcp_relays[conn->num_tcp_relays].client_id, public_key, crypto_box_PUBLICKEYBYTES);
+        ++conn->num_tcp_relays;
+    }
+
+    for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
+        if (c->tcp_connections[i] == NULL)
+            continue;
+
+        if (memcmp(c->tcp_connections[i]->public_key, public_key, crypto_box_PUBLICKEYBYTES) == 0) {
+            if (conn->status_tcp[i] == STATUS_TCP_OFFLINE)
+                conn->status_tcp[i] = STATUS_TCP_INVISIBLE;
+        }
+    }
+
+    return add_tcp_relay(c, ip_port, public_key);
+}
+
 /* Add a tcp relay to the array.
  *
  * return 0 if it was added.
@@ -1736,6 +1820,15 @@ static int tcp_connection_check(Net_Crypto *c, uint8_t *public_key)
  */
 int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key)
 {
+    if (ip_port.ip.family == TCP_INET) {
+        ip_port.ip.family = AF_INET;
+    } else if (ip_port.ip.family == TCP_INET6) {
+        ip_port.ip.family = AF_INET6;
+    }
+
+    if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6)
+        return -1;
+
     if (tcp_connection_check(c, public_key) != 0)
         return -1;
 
@@ -1751,6 +1844,41 @@ int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, uint8_t *public_key)
     return -1;
 }
 
+/* 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.
+ *
+ * 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)
+{
+    if (num == 0)
+        return 0;
+
+    uint32_t i;
+    uint16_t copied = 0;
+
+    for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
+        if (c->tcp_connections[i] != NULL) {
+            memcpy(tcp_relays[copied].client_id, c->tcp_connections[i]->public_key, crypto_box_PUBLICKEYBYTES);
+            tcp_relays[copied].ip_port = c->tcp_connections[i]->ip_port;
+
+            if (tcp_relays[copied].ip_port.ip.family == AF_INET) {
+                tcp_relays[copied].ip_port.ip.family = TCP_INET;
+            } else if (tcp_relays[copied].ip_port.ip.family == AF_INET6) {
+                tcp_relays[copied].ip_port.ip.family = TCP_INET6;
+            }
+
+            ++copied;
+
+            if (copied == num)
+                return copied;
+        }
+    }
+
+    return copied;
+}
+
 /* Add a connected tcp connection to the tcp_connections array.
  *
  * return 0 if it was added.
@@ -1834,7 +1962,7 @@ static void clear_disconnected_tcp_peer(Crypto_Connection *conn, uint32_t number
     if (number >= MAX_TCP_CONNECTIONS)
         return;
 
-    conn->status_tcp[number] = 0;
+    conn->status_tcp[number] = STATUS_TCP_NULL;
     conn->con_number_tcp[number] = 0;
 }
 
@@ -2255,6 +2383,11 @@ void kill_net_crypto(Net_Crypto *c)
         crypto_kill(c, i);
     }
 
+    for (i = 0; i < MAX_TCP_CONNECTIONS; ++i) {
+        kill_TCP_connection(c->tcp_connections_new[i]);
+        kill_TCP_connection(c->tcp_connections[i]);
+    }
+
     networking_registerhandler(c->dht->net, NET_PACKET_COOKIE_REQUEST, NULL, NULL);
     networking_registerhandler(c->dht->net, NET_PACKET_COOKIE_RESPONSE, NULL, NULL);
     networking_registerhandler(c->dht->net, NET_PACKET_CRYPTO_HS, NULL, NULL);
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
index e41e7e1d..25f8c2f7 100644
--- a/toxcore/net_crypto.h
+++ b/toxcore/net_crypto.h
@@ -61,7 +61,13 @@
 
 #define CRYPTO_RESERVED_PACKETS 16
 
-#define MAX_TCP_CONNECTIONS 8
+#define MAX_TCP_CONNECTIONS 32
+#define MAX_TCP_RELAYS_PEER 4
+
+#define STATUS_TCP_NULL      0
+#define STATUS_TCP_OFFLINE   1
+#define STATUS_TCP_INVISIBLE 2 /* we know the other peer is connected to this relay but he isn't appearing online */
+#define STATUS_TCP_ONLINE    3
 
 typedef struct {
     uint64_t time;
@@ -127,8 +133,11 @@ typedef struct {
 
     uint8_t killed; /* set to 1 to kill the connection. */
 
-    uint8_t status_tcp[MAX_TCP_CONNECTIONS];
+    uint8_t status_tcp[MAX_TCP_CONNECTIONS]; /* set to one of STATUS_TCP_* */
     uint8_t con_number_tcp[MAX_TCP_CONNECTIONS];
+
+    Node_format tcp_relays[MAX_TCP_RELAYS_PEER];
+    uint16_t num_tcp_relays;
 } Crypto_Connection;
 
 typedef struct {
@@ -244,6 +253,13 @@ uint32_t crypto_num_free_sendqueue_slots(Net_Crypto *c, int crypt_connection_id)
  */
 int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, 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);
+
 /* Add a tcp relay to the array.
  *
  * return 0 if it was added.
@@ -251,6 +267,14 @@ int64_t write_cryptpacket(Net_Crypto *c, int crypt_connection_id, uint8_t *data,
  */
 int add_tcp_relay(Net_Crypto *c, IP_Port ip_port, 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.
+ *
+ * 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);
+
 /* Kill a crypto connection.
  *
  * return -1 on failure.
diff --git a/toxcore/onion_client.c b/toxcore/onion_client.c
index be4d12aa..03ffbaa7 100644
--- a/toxcore/onion_client.c
+++ b/toxcore/onion_client.c
@@ -505,7 +505,7 @@ static int handle_fakeid_announce(void *object, uint8_t *source_pubkey, uint8_t
     if (len_nodes != 0) {
         Node_format nodes[MAX_SENT_NODES];
         int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, data + 1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES,
-                                     len_nodes, 0);
+                                     len_nodes, 1);
 
         if (num_nodes <= 0)
             return 1;
@@ -513,7 +513,17 @@ static int handle_fakeid_announce(void *object, uint8_t *source_pubkey, uint8_t
         int i;
 
         for (i = 0; i < num_nodes; ++i) {
-            DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].client_id, onion_c->friends_list[friend_num].fake_client_id);
+            uint8_t family = nodes[i].ip_port.ip.family;
+
+            if (family == AF_INET || family == AF_INET6) {
+                DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].client_id, onion_c->friends_list[friend_num].fake_client_id);
+            } else if (family == TCP_INET || family == TCP_INET6) {
+                if (onion_c->friends_list[friend_num].tcp_relay_node_callback) {
+                    void *obj = onion_c->friends_list[friend_num].tcp_relay_node_callback_object;
+                    uint32_t number = onion_c->friends_list[friend_num].tcp_relay_node_callback_number;
+                    onion_c->friends_list[friend_num].tcp_relay_node_callback(obj, number, nodes[i].ip_port, nodes[i].client_id);
+                }
+            }
         }
     }
 
@@ -664,8 +674,9 @@ static int send_fakeid_announce(Onion_Client *onion_c, uint16_t friend_num, uint
     memcpy(data + 1, &no_replay, sizeof(no_replay));
     memcpy(data + 1 + sizeof(uint64_t), onion_c->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
     Node_format nodes[MAX_SENT_NODES];
-    uint16_t num_nodes = closelist_nodes(onion_c->dht, nodes, MAX_SENT_NODES);
-
+    uint16_t num_relays = copy_connected_tcp_relays(onion_c->c, nodes, (MAX_SENT_NODES / 2));
+    uint16_t num_nodes = closelist_nodes(onion_c->dht, &nodes[num_relays], MAX_SENT_NODES - num_relays);
+    num_nodes += num_relays;
     int nodes_len = 0;
 
     if (num_nodes != 0) {
@@ -800,6 +811,26 @@ int onion_delfriend(Onion_Client *onion_c, int friend_num)
     return friend_num;
 }
 
+/* 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.
+ *
+ * object and number will be passed as argument to this function.
+ *
+ * return -1 on failure.
+ * 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)
+{
+    if ((uint32_t)friend_num >= onion_c->num_friends)
+        return -1;
+
+    onion_c->friends_list[friend_num].tcp_relay_node_callback = tcp_relay_node_callback;
+    onion_c->friends_list[friend_num].tcp_relay_node_callback_object = object;
+    onion_c->friends_list[friend_num].tcp_relay_node_callback_number = number;
+    return 0;
+}
+
 /* Set a friends DHT public key.
  * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
  * the other peer.
@@ -830,6 +861,7 @@ int onion_set_friend_DHT_pubkey(Onion_Client *onion_c, int friend_num, uint8_t *
         return -1;
     }
 
+    onion_c->friends_list[friend_num].last_seen = unix_time();
     onion_c->friends_list[friend_num].is_fake_clientid = 1;
     onion_c->friends_list[friend_num].fake_client_id_timestamp = timestamp;
     memcpy(onion_c->friends_list[friend_num].fake_client_id, dht_key, crypto_box_PUBLICKEYBYTES);
diff --git a/toxcore/onion_client.h b/toxcore/onion_client.h
index 029f5624..0d2e84a5 100644
--- a/toxcore/onion_client.h
+++ b/toxcore/onion_client.h
@@ -102,6 +102,10 @@ 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);
+    void *tcp_relay_node_callback_object;
+    uint32_t tcp_relay_node_callback_number;
 } Onion_Friend;
 
 typedef int (*oniondata_handler_callback)(void *object, uint8_t *source_pubkey, uint8_t *data, uint32_t len);
@@ -176,6 +180,17 @@ int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_on
  */
 int onion_getfriendip(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.
+ *
+ * object and number will be passed as argument to this function.
+ *
+ * return -1 on failure.
+ * 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);
+
 /* Set a friends DHT public key.
  * timestamp is the time (current_time_monotonic()) at which the key was last confirmed belonging to
  * the other peer.
diff --git a/toxcore/tox.c b/toxcore/tox.c
index d86f1a17..083582bb 100644
--- a/toxcore/tox.c
+++ b/toxcore/tox.c
@@ -739,12 +739,38 @@ uint64_t tox_file_data_remaining(Tox *tox, int32_t friendnumber, uint8_t filenum
 
 /***************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)
+{
+    Messenger *m = tox;
+    IP_Port ip_port_v64;
+    IP *ip_extra = NULL;
+    IP_Port ip_port_v4;
+    ip_init(&ip_port_v64.ip, ipv6enabled);
+
+    if (ipv6enabled) {
+        /* setup for getting BOTH: an IPv6 AND an IPv4 address */
+        ip_port_v64.ip.family = AF_UNSPEC;
+        ip_reset(&ip_port_v4.ip);
+        ip_extra = &ip_port_v4.ip;
+    }
+
+    if (addr_resolve_or_parse_ip(address, &ip_port_v64.ip, ip_extra)) {
+        ip_port_v64.port = port;
+        add_tcp_relay(m->net_crypto, ip_port_v64, public_key);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
 int tox_bootstrap_from_address(Tox *tox, const char *address,
                                uint8_t ipv6enabled, uint16_t port, uint8_t *public_key)
 {
     Messenger *m = tox;
+    tox_add_tcp_relay(tox, address, ipv6enabled, port, public_key);
     return DHT_bootstrap_from_address(m->dht, address, ipv6enabled, port, public_key);
-};
+}
 
 /*  return 0 if we are not connected to the DHT.
  *  return 1 if we are.