Merge upstream fo real now?

6 files changed, 201 insertions, 77 deletions

diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index de37bb97..ca5afd9a 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -89,7 +89,7 @@ START_TEST(test_basic)
     uint8_t r_req[2 + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES];
     uint16_t size = 1 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES;
     size = htons(size);
-    ret = encrypt_data_fast(f_shared_key, f_nonce, r_req_p, 1 + crypto_box_PUBLICKEYBYTES, r_req + 2);
+    ret = encrypt_data_symmetric(f_shared_key, f_nonce, r_req_p, 1 + crypto_box_PUBLICKEYBYTES, r_req + 2);
     increment_nonce(f_nonce);
     memcpy(r_req, &size, 2);
     uint32_t i;
@@ -110,7 +110,7 @@ START_TEST(test_basic)
     memcpy(&size, packet_resp, 2);
     ck_assert_msg(ntohs(size) == 2 + crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES, "Wrong packet size.");
     uint8_t packet_resp_plain[4096];
-    ret = decrypt_data_fast(f_shared_key, f_nonce_r, packet_resp + 2, recv_data_len - 2, packet_resp_plain);
+    ret = decrypt_data_symmetric(f_shared_key, f_nonce_r, packet_resp + 2, recv_data_len - 2, packet_resp_plain);
     ck_assert_msg(ret != -1, "decryption failed");
     increment_nonce(f_nonce_r);
     ck_assert_msg(packet_resp_plain[0] == 1, "wrong packet id %u", packet_resp_plain[0]);
@@ -179,7 +179,7 @@ int write_packet_TCP_secure_connection(struct sec_TCP_con *con, uint8_t *data, u
 
     uint16_t c_length = htons(length + crypto_box_MACBYTES);
     memcpy(packet, &c_length, sizeof(uint16_t));
-    int len = encrypt_data_fast(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
+    int len = encrypt_data_symmetric(con->shared_key, con->sent_nonce, data, length, packet + sizeof(uint16_t));
 
     if ((unsigned int)len != (sizeof(packet) - sizeof(uint16_t)))
         return -1;
@@ -194,7 +194,7 @@ int read_packet_sec_TCP(struct sec_TCP_con *con, uint8_t *data, uint16_t length)
 {
     int len;
     ck_assert_msg((len = recv(con->sock, data, length, 0)) == length, "wrong len %i\n", len);
-    ck_assert_msg((len = decrypt_data_fast(con->shared_key, con->recv_nonce, data + 2, length - 2, data)) != -1,
+    ck_assert_msg((len = decrypt_data_symmetric(con->shared_key, con->recv_nonce, data + 2, length - 2, data)) != -1,
                   "Decrypt failed");
     increment_nonce(con->recv_nonce);
     return len;
@@ -291,6 +291,76 @@ START_TEST(test_some)
 }
 END_TEST
 
+static int response_callback_good;
+static uint8_t response_callback_connection_id;
+static uint8_t response_callback_public_key[crypto_box_PUBLICKEYBYTES];
+static int response_callback(void *object, uint8_t connection_id, uint8_t *public_key)
+{
+    if (set_tcp_connection_number(object - 2, connection_id, 7) != 0)
+        return 1;
+
+    response_callback_connection_id = connection_id;
+    memcpy(response_callback_public_key, public_key, crypto_box_PUBLICKEYBYTES);
+    response_callback_good++;
+    return 0;
+}
+static int status_callback_good;
+static uint8_t status_callback_connection_id;
+static uint8_t status_callback_status;
+static int status_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t status)
+{
+    if (object != (void *)2)
+        return 1;
+
+    if (number != 7)
+        return 1;
+
+    status_callback_connection_id = connection_id;
+    status_callback_status = status;
+    status_callback_good++;
+    return 0;
+}
+static int data_callback_good;
+static int data_callback(void *object, uint32_t number, uint8_t connection_id, uint8_t *data, uint16_t length)
+{
+    if (object != (void *)3)
+        return 1;
+
+    if (number != 7)
+        return 1;
+
+    if (length != 5)
+        return 1;
+
+    if (data[0] == 1 && data[1] == 2 && data[2] == 3 && data[3] == 4 && data[4] == 5) {
+        data_callback_good++;
+        return 0;
+    }
+
+    return 1;
+}
+
+static int oob_data_callback_good;
+static uint8_t oob_pubkey[crypto_box_PUBLICKEYBYTES];
+static int oob_data_callback(void *object, uint8_t *public_key, uint8_t *data, uint16_t length)
+{
+    if (object != (void *)4)
+        return 1;
+
+    if (length != 5)
+        return 1;
+
+    if (memcmp(public_key, oob_pubkey, crypto_box_PUBLICKEYBYTES) != 0)
+        return 1;
+
+    if (data[0] == 1 && data[1] == 2 && data[2] == 3 && data[3] == 4 && data[4] == 5) {
+        oob_data_callback_good++;
+        return 0;
+    }
+
+    return 1;
+}
+
 START_TEST(test_client)
 {
     unix_time_update();
@@ -320,6 +390,71 @@ START_TEST(test_client)
     do_TCP_connection(conn);
     ck_assert_msg(conn->status == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_CONFIRMED,
                   conn->status);
+    c_sleep(500);
+    do_TCP_connection(conn);
+    ck_assert_msg(conn->status == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_CONFIRMED,
+                  conn->status);
+    c_sleep(500);
+    do_TCP_connection(conn);
+    ck_assert_msg(conn->status == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_CONFIRMED,
+                  conn->status);
+    do_TCP_server(tcp_s);
+    c_sleep(50);
+    ck_assert_msg(conn->status == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %u, is: %u", TCP_CLIENT_CONFIRMED,
+                  conn->status);
+
+    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);
+    TCP_Client_Connection *conn2 = new_TCP_connection(ip_port_tcp_s, self_public_key, f2_public_key, f2_secret_key);
+    routing_response_handler(conn, response_callback, ((void *)conn) + 2);
+    routing_status_handler(conn, status_callback, (void *)2);
+    routing_data_handler(conn, data_callback, (void *)3);
+    oob_data_handler(conn, oob_data_callback, (void *)4);
+    oob_data_callback_good = response_callback_good = status_callback_good = data_callback_good = 0;
+    c_sleep(50);
+    do_TCP_connection(conn);
+    do_TCP_connection(conn2);
+    c_sleep(50);
+    do_TCP_server(tcp_s);
+    c_sleep(50);
+    do_TCP_connection(conn);
+    do_TCP_connection(conn2);
+    c_sleep(50);
+    uint8_t data[5] = {1, 2, 3, 4, 5};
+    memcpy(oob_pubkey, f2_public_key, crypto_box_PUBLICKEYBYTES);
+    send_oob_packet(conn2, f_public_key, data, 5);
+    send_routing_request(conn, f2_public_key);
+    send_routing_request(conn2, f_public_key);
+    c_sleep(50);
+    do_TCP_server(tcp_s);
+    c_sleep(50);
+    do_TCP_connection(conn);
+    do_TCP_connection(conn2);
+    ck_assert_msg(oob_data_callback_good == 1, "oob callback not called");
+    ck_assert_msg(response_callback_good == 1, "response callback not called");
+    ck_assert_msg(memcmp(response_callback_public_key, f2_public_key, crypto_box_PUBLICKEYBYTES) == 0, "wrong public key");
+    ck_assert_msg(status_callback_good == 1, "status callback not called");
+    ck_assert_msg(status_callback_status == 2, "wrong status");
+    ck_assert_msg(status_callback_connection_id == response_callback_connection_id, "connection ids not equal");
+    c_sleep(50);
+    do_TCP_server(tcp_s);
+    ck_assert_msg(send_data(conn2, 0, data, 5) == 1, "send data failed");
+    c_sleep(50);
+    do_TCP_server(tcp_s);
+    c_sleep(50);
+    do_TCP_connection(conn);
+    do_TCP_connection(conn2);
+    ck_assert_msg(data_callback_good == 1, "data callback not called");
+    status_callback_good = 0;
+    send_disconnect_request(conn2, 0);
+    c_sleep(50);
+    do_TCP_server(tcp_s);
+    c_sleep(50);
+    do_TCP_connection(conn);
+    do_TCP_connection(conn2);
+    ck_assert_msg(status_callback_good == 1, "status callback not called");
+    ck_assert_msg(status_callback_status == 1, "wrong status");
 }
 END_TEST
 
diff --git a/auto_tests/crypto_test.c b/auto_tests/crypto_test.c
index 95cdefcd..252f7275 100644
--- a/auto_tests/crypto_test.c
+++ b/auto_tests/crypto_test.c
@@ -9,12 +9,6 @@
 #include <check.h>
 #include <stdlib.h>
 #include <time.h>
-#ifndef VANILLA_NACL
-#include <sodium.h>
-#else
-#include <crypto_box.h>
-#define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
-#endif
 
 void rand_bytes(uint8_t *b, size_t blen)
 {
@@ -126,12 +120,12 @@ START_TEST(test_fast_known)
     ck_assert_msg(sizeof(test_c) == sizeof(c), "sanity check failed");
     ck_assert_msg(sizeof(test_m) == sizeof(m), "sanity check failed");
 
-    clen = encrypt_data_fast(k, nonce, test_m, sizeof(test_m) / sizeof(unsigned char), c);
+    clen = encrypt_data_symmetric(k, nonce, test_m, sizeof(test_m) / sizeof(unsigned char), c);
 
     ck_assert_msg(memcmp(test_c, c, sizeof(c)) == 0, "cyphertext doesn't match test vector");
     ck_assert_msg(clen == sizeof(c) / sizeof(unsigned char), "wrong ciphertext length");
 
-    mlen = decrypt_data_fast(k, nonce, test_c, sizeof(test_c) / sizeof(unsigned char), m);
+    mlen = decrypt_data_symmetric(k, nonce, test_c, sizeof(test_c) / sizeof(unsigned char), m);
 
     ck_assert_msg(memcmp(test_m, m, sizeof(m)) == 0, "decrypted text doesn't match test vector");
     ck_assert_msg(mlen == sizeof(m) / sizeof(unsigned char), "wrong plaintext length");
@@ -186,8 +180,8 @@ START_TEST(test_endtoend)
         //Encrypt all four ways
         c1len = encrypt_data(pk2, sk1, n, m, mlen, c1);
         c2len = encrypt_data(pk1, sk2, n, m, mlen, c2);
-        c3len = encrypt_data_fast(k1, n, m, mlen, c3);
-        c4len = encrypt_data_fast(k2, n, m, mlen, c4);
+        c3len = encrypt_data_symmetric(k1, n, m, mlen, c3);
+        c4len = encrypt_data_symmetric(k2, n, m, mlen, c4);
 
         ck_assert_msg(c1len == c2len && c1len == c3len && c1len == c4len, "cyphertext lengths differ");
         ck_assert_msg(c1len == mlen + (int)crypto_box_MACBYTES, "wrong cyphertext length");
@@ -197,8 +191,8 @@ START_TEST(test_endtoend)
         //Decrypt all four ways
         m1len = decrypt_data(pk2, sk1, n, c1, c1len, m1);
         m2len = decrypt_data(pk1, sk2, n, c1, c1len, m2);
-        m3len = decrypt_data_fast(k1, n, c1, c1len, m3);
-        m4len = decrypt_data_fast(k2, n, c1, c1len, m4);
+        m3len = decrypt_data_symmetric(k1, n, c1, c1len, m3);
+        m4len = decrypt_data_symmetric(k2, n, c1, c1len, m4);
 
         ck_assert_msg(m1len == m2len && m1len == m3len && m1len == m4len, "decrypted text lengths differ");
         ck_assert_msg(m1len == mlen, "wrong decrypted text length");
@@ -215,11 +209,11 @@ START_TEST(test_large_data)
 
     unsigned char n[crypto_box_NONCEBYTES];
 
-    unsigned char m1[MAX_DATA_SIZE - crypto_box_MACBYTES];
+    unsigned char m1[MAX_CRYPTO_PACKET_SIZE - crypto_box_MACBYTES];
     unsigned char c1[sizeof(m1) + crypto_box_MACBYTES];
     unsigned char m1prime[sizeof(m1)];
 
-    unsigned char m2[MAX_DATA_SIZE];
+    unsigned char m2[MAX_CRYPTO_PACKET_SIZE];
     unsigned char c2[sizeof(m2) + crypto_box_MACBYTES];
 
     int c1len, c2len;
@@ -233,13 +227,13 @@ START_TEST(test_large_data)
     //Generate key
     rand_bytes(k, crypto_box_BEFORENMBYTES);
 
-    c1len = encrypt_data_fast(k, n, m1, sizeof(m1), c1);
-    c2len = encrypt_data_fast(k, n, m2, sizeof(m2), c2);
+    c1len = encrypt_data_symmetric(k, n, m1, sizeof(m1), c1);
+    c2len = encrypt_data_symmetric(k, n, m2, sizeof(m2), c2);
 
-    ck_assert_msg(c1len == sizeof(m1) + crypto_box_MACBYTES, "could not encrypt max size");
-    ck_assert_msg(c2len == -1, "incorrectly succeeded encrypting massive size");
+    ck_assert_msg(c1len == sizeof(m1) + crypto_box_MACBYTES, "could not encrypt");
+    ck_assert_msg(c2len == sizeof(m2) + crypto_box_MACBYTES, "could not encrypt");
 
-    m1plen = decrypt_data_fast(k, n, c1, c1len, m1prime);
+    m1plen = decrypt_data_symmetric(k, n, c1, c1len, m1prime);
 
     ck_assert_msg(m1plen == sizeof(m1), "decrypted text lengths differ");
     ck_assert_msg(memcmp(m1prime, m1, sizeof(m1)) == 0, "decrypted texts differ");
@@ -248,9 +242,9 @@ END_TEST
 
 START_TEST(test_large_data_symmetric)
 {
-    unsigned char k[crypto_secretbox_KEYBYTES];
+    unsigned char k[crypto_box_KEYBYTES];
 
-    unsigned char n[crypto_secretbox_NONCEBYTES];
+    unsigned char n[crypto_box_NONCEBYTES];
 
     unsigned char m1[16 * 16 * 16];
     unsigned char c1[sizeof(m1) + crypto_box_MACBYTES];
@@ -276,6 +270,7 @@ START_TEST(test_large_data_symmetric)
 }
 END_TEST
 
+
 #define DEFTESTCASE(NAME) \
     TCase *NAME = tcase_create(#NAME); \
     tcase_add_test(NAME, test_##NAME); \
diff --git a/auto_tests/messenger_test.c b/auto_tests/messenger_test.c
index 5e5f7b06..7ab7d674 100644
--- a/auto_tests/messenger_test.c
+++ b/auto_tests/messenger_test.c
@@ -16,7 +16,6 @@
 
 #include "../testing/misc_tools.c" // hex_string_to_bin
 #include "../toxcore/Messenger.h"
-#include "../toxcore/Lossless_UDP.h"
 #include <sys/types.h>
 #include <stdint.h>
 #include <string.h>
@@ -46,7 +45,7 @@ START_TEST(test_m_sendmesage)
 {
     char *message = "h-hi :3";
     int good_len = strlen(message);
-    int bad_len = MAX_DATA_SIZE;
+    int bad_len = MAX_CRYPTO_PACKET_SIZE;
 
 
     ck_assert(m_sendmessage(m, -1, (uint8_t *)message, good_len) == 0);
@@ -127,7 +126,7 @@ START_TEST(test_m_addfriend)
 
     int good_len = strlen(good_data);
     int bad_len = strlen(bad_data);
-    int really_bad_len = (MAX_DATA_SIZE - crypto_box_PUBLICKEYBYTES
+    int really_bad_len = (MAX_CRYPTO_PACKET_SIZE - crypto_box_PUBLICKEYBYTES
                      - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES
                                       + crypto_box_ZEROBYTES + 100); */
 /* TODO: Update this properly to latest master
@@ -299,27 +298,6 @@ START_TEST(test_messenger_state_saveloadsave)
 }
 END_TEST
 
-START_TEST(test_messenger_state_saveload_encrypted)
-{
-    uint8_t addr[FRIEND_ADDRESS_SIZE];
-    getaddress(m, addr);
-    Messenger *m_temp = new_messenger(TOX_ENABLE_IPV6_DEFAULT);
-
-    size_t size = messenger_size_encrypted(m);
-    uint8_t buffer[size];
-    messenger_save_encrypted(m, buffer, "Gentoo", sizeof("Gentoo"));
-
-    ck_assert_msg(messenger_load_encrypted(m_temp, buffer, size, "Ubuntu", sizeof("Ubuntu")) == -1,
-                  "Bad password didn't make the function fail.");
-    ck_assert_msg(messenger_load_encrypted(m_temp, buffer, size, "Gentoo", sizeof("Gentoo")) == 0,
-                  "Good password didn't make the function succeed.");
-    uint8_t addr1[FRIEND_ADDRESS_SIZE];
-    getaddress(m_temp, addr1);
-    ck_assert_msg(memcmp(addr1, addr, FRIEND_ADDRESS_SIZE) == 0, "Didn't load messenger successfully");
-    kill_messenger(m_temp);
-}
-END_TEST
-
 #define DEFTESTCASE(NAME) \
     TCase *tc_##NAME = tcase_create(#NAME); \
     tcase_add_test(tc_##NAME, test_##NAME); \
@@ -331,7 +309,6 @@ Suite *messenger_suite(void)
 
     DEFTESTCASE(dht_state_saveloadsave);
     DEFTESTCASE(messenger_state_saveloadsave);
-    DEFTESTCASE(messenger_state_saveload_encrypted);
 
     DEFTESTCASE(getself_name);
     DEFTESTCASE(m_get_userstatus_size);
diff --git a/auto_tests/network_test.c b/auto_tests/network_test.c
index 3b4b50cd..afd90e7a 100644
--- a/auto_tests/network_test.c
+++ b/auto_tests/network_test.c
@@ -136,9 +136,8 @@ START_TEST(test_struct_sizes)
 {
     ck_assert_msg(sizeof(IP4) == 4, "sizeof(IP4): expected result 4, got %u.", sizeof(IP4));
     ck_assert_msg(sizeof(IP6) == 16, "sizeof(IP6): expected result 16, got %u.", sizeof(IP6));
-    ck_assert_msg(sizeof(IP) == 20, "sizeof(IP): expected result 20, got %u.", sizeof(IP));
-    ck_assert_msg(sizeof(IP_Port) == 24, "sizeof(IP_Port): expected result 24, got %u.", sizeof(IP_Port));
-    ck_assert_msg(sizeof(IP4_Port) == 8, "sizeof(IP4_Port): expected result 8, got %u.", sizeof(IP4_Port));
+    ck_assert_msg(sizeof(IP) == 17, "sizeof(IP): expected result 17, got %u.", sizeof(IP));
+    ck_assert_msg(sizeof(IP_Port) == 19, "sizeof(IP_Port): expected result 19, got %u.", sizeof(IP_Port));
 }
 END_TEST
 
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 2f244693..4489a894 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -80,7 +80,7 @@ static int handle_test_3(void *object, IP_Port source, uint8_t *packet, uint32_t
 
     uint8_t plain[1 + crypto_hash_sha256_BYTES];
     //print_client_id(packet, length);
-    int len = decrypt_data(test_3_pub_key, onion->dht->c->self_secret_key, packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
+    int len = decrypt_data(test_3_pub_key, onion->dht->self_secret_key, packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,
                            packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,
                            1 + crypto_hash_sha256_BYTES + crypto_box_MACBYTES, plain);
 
@@ -111,7 +111,7 @@ static int handle_test_4(void *object, IP_Port source, uint8_t *packet, uint32_t
     if (memcmp(nonce, packet + 1, crypto_box_NONCEBYTES) != 0)
         return 1;
 
-    int len = decrypt_data(packet + 1 + crypto_box_NONCEBYTES, onion->dht->c->self_secret_key, packet + 1,
+    int len = decrypt_data(packet + 1 + crypto_box_NONCEBYTES, onion->dht->self_secret_key, packet + 1,
                            packet + 1 + crypto_box_NONCEBYTES + crypto_box_PUBLICKEYBYTES, sizeof("Install gentoo") + crypto_box_MACBYTES, plain);
 
     if (len == -1)
@@ -129,8 +129,8 @@ START_TEST(test_basic)
     IP ip;
     ip_init(&ip, 1);
     ip.ip6.uint8[15] = 1;
-    Onion *onion1 = new_onion(new_DHT(new_net_crypto(new_networking(ip, 34567))));
-    Onion *onion2 = new_onion(new_DHT(new_net_crypto(new_networking(ip, 34568))));
+    Onion *onion1 = new_onion(new_DHT(new_networking(ip, 34567)));
+    Onion *onion2 = new_onion(new_DHT(new_networking(ip, 34568)));
     ck_assert_msg((onion1 != NULL) && (onion2 != NULL), "Onion failed initializing.");
     networking_registerhandler(onion2->net, 'I', &handle_test_1, onion2);
 
@@ -176,26 +176,30 @@ START_TEST(test_basic)
     ck_assert_msg((onion1_a != NULL) && (onion2_a != NULL), "Onion_Announce failed initializing.");
     uint8_t zeroes[64] = {0};
     randombytes(sb_data, sizeof(sb_data));
+    uint64_t s;
+    memcpy(&s, sb_data, sizeof(uint64_t));
     memcpy(test_3_pub_key, nodes[3].client_id, crypto_box_PUBLICKEYBYTES);
-    ret = send_announce_request(onion1->net, &path, nodes[3], onion1->dht->c->self_public_key,
-                                onion1->dht->c->self_secret_key,
-                                zeroes, onion1->dht->c->self_public_key, onion1->dht->c->self_public_key, sb_data);
+    ret = send_announce_request(onion1->net, &path, nodes[3], onion1->dht->self_public_key,
+                                onion1->dht->self_secret_key,
+                                zeroes, onion1->dht->self_public_key, onion1->dht->self_public_key, s);
     ck_assert_msg(ret == 0, "Failed to create/send onion announce_request packet.");
     handled_test_3 = 0;
 
     while (handled_test_3 == 0) {
         do_onion(onion1);
         do_onion(onion2);
+        c_sleep(50);
     }
 
     randombytes(sb_data, sizeof(sb_data));
+    memcpy(&s, sb_data, sizeof(uint64_t));
     memcpy(onion2_a->entries[1].public_key, onion2->dht->self_public_key, crypto_box_PUBLICKEYBYTES);
     onion2_a->entries[1].time = unix_time();
     networking_registerhandler(onion1->net, NET_PACKET_ONION_DATA_RESPONSE, &handle_test_4, onion1);
-    send_announce_request(onion1->net, &path, nodes[3], onion1->dht->c->self_public_key, onion1->dht->c->self_secret_key,
-                          test_3_ping_id, onion1->dht->c->self_public_key, onion1->dht->c->self_public_key, sb_data);
+    send_announce_request(onion1->net, &path, nodes[3], onion1->dht->self_public_key, onion1->dht->self_secret_key,
+                          test_3_ping_id, onion1->dht->self_public_key, onion1->dht->self_public_key, s);
 
-    while (memcmp(onion2_a->entries[ONION_ANNOUNCE_MAX_ENTRIES - 2].public_key, onion1->dht->c->self_public_key,
+    while (memcmp(onion2_a->entries[ONION_ANNOUNCE_MAX_ENTRIES - 2].public_key, onion1->dht->self_public_key,
                   crypto_box_PUBLICKEYBYTES) != 0) {
         do_onion(onion1);
         do_onion(onion2);
@@ -203,12 +207,12 @@ START_TEST(test_basic)
     }
 
     c_sleep(1000);
-    Onion *onion3 = new_onion(new_DHT(new_net_crypto(new_networking(ip, 34569))));
+    Onion *onion3 = new_onion(new_DHT(new_networking(ip, 34569)));
     ck_assert_msg((onion3 != NULL), "Onion failed initializing.");
 
     new_nonce(nonce);
-    ret = send_data_request(onion3->net, &path, nodes[3].ip_port, onion1->dht->c->self_public_key,
-                            onion1->dht->c->self_public_key,
+    ret = send_data_request(onion3->net, &path, nodes[3].ip_port, onion1->dht->self_public_key,
+                            onion1->dht->self_public_key,
                             nonce, (uint8_t *)"Install gentoo", sizeof("Install gentoo"));
     ck_assert_msg(ret == 0, "Failed to create/send onion data_request packet.");
     handled_test_4 = 0;
@@ -233,10 +237,10 @@ Onions *new_onions(uint16_t port)
     ip_init(&ip, 1);
     ip.ip6.uint8[15] = 1;
     Onions *on = malloc(sizeof(Onions));
-    DHT *dht = new_DHT(new_net_crypto(new_networking(ip, 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(dht);
+    on->onion_c = new_onion_client(new_net_crypto(dht));
 
     if (on->onion && on->onion_a && on->onion_c)
         return on;
@@ -297,8 +301,8 @@ START_TEST(test_announce)
         c_sleep(50);
     }
 
-    onion_addfriend(onions[7]->onion_c, onions[37]->onion->dht->c->self_public_key);
-    int frnum = onion_addfriend(onions[37]->onion_c, onions[7]->onion->dht->c->self_public_key);
+    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);
 
     int ok = -1;
 
diff --git a/auto_tests/tox_test.c b/auto_tests/tox_test.c
index 1e01aee7..9b63b35b 100644
--- a/auto_tests/tox_test.c
+++ b/auto_tests/tox_test.c
@@ -96,21 +96,26 @@ void file_print_control(Tox *m, int friendnumber, uint8_t send_recieve, uint8_t
 }
 
 uint64_t size_recv;
+uint8_t num;
 void write_file(Tox *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length, void *userdata)
 {
     if (*((uint32_t *)userdata) != 974536)
         return;
 
     uint8_t *f_data = malloc(length);
-    memset(f_data, 6, length);
+    memset(f_data, num, length);
+    ++num;
 
-    if (memcmp(f_data, data, length) == 0)
+    if (memcmp(f_data, data, length) == 0) {
         size_recv += length;
+    } else {
+        printf("FILE_CORRUPTED\n");
+    }
 }
 
 START_TEST(test_few_clients)
 {
-    long long unsigned int cur_time = time(NULL);
+    long long unsigned int con_time, cur_time = time(NULL);
     Tox *tox1 = tox_new(TOX_ENABLE_IPV6_DEFAULT);
     Tox *tox2 = tox_new(TOX_ENABLE_IPV6_DEFAULT);
     Tox *tox3 = tox_new(TOX_ENABLE_IPV6_DEFAULT);
@@ -131,6 +136,7 @@ START_TEST(test_few_clients)
 
         if (tox_isconnected(tox1) && tox_isconnected(tox2) && tox_isconnected(tox3) && off) {
             printf("Toxes are online, took %llu seconds\n", time(NULL) - cur_time);
+            con_time = time(NULL);
             off = 0;
         }
 
@@ -141,7 +147,7 @@ START_TEST(test_few_clients)
         c_sleep(50);
     }
 
-    printf("tox clients connected\n");
+    printf("tox clients connected took %llu seconds\n", time(NULL) - con_time);
     to_compare = 974536;
     tox_callback_friend_message(tox3, print_message, &to_compare);
     tox_send_message(tox2, 0, (uint8_t *)"Install Gentoo", sizeof("Install Gentoo"));
@@ -227,8 +233,8 @@ START_TEST(test_few_clients)
     ck_assert_msg(fnum != -1, "tox_new_file_sender fail");
     int fpiece_size = tox_file_data_size(tox2, 0);
     uint8_t *f_data = malloc(fpiece_size);
-    memset(f_data, 6, fpiece_size);
-
+    uint8_t num = 0;
+    memset(f_data, num, fpiece_size);
     while (1) {
         file_sent = 0;
         tox_do(tox1);
@@ -241,6 +247,8 @@ START_TEST(test_few_clients)
                     sendf_ok = 0;
                     tox_file_send_control(tox2, 0, 0, fnum, TOX_FILECONTROL_FINISHED, NULL, 0);
                 }
+                ++num;
+                memset(f_data, num, fpiece_size);
 
                 totalf_size -= fpiece_size;
             }
@@ -284,6 +292,12 @@ START_TEST(test_many_clients)
 loop_top:
         pairs[i].tox1 = rand() % NUM_TOXES;
         pairs[i].tox2 = (pairs[i].tox1 + rand() % (NUM_TOXES - 1) + 1) % NUM_TOXES;
+
+        for (j = 0; j < i; ++j) {
+            if (pairs[j].tox2 == pairs[i].tox1 && pairs[j].tox1 == pairs[i].tox2)
+                goto loop_top;
+        }
+
         tox_get_address(toxes[pairs[i].tox1], address);
         int test = tox_add_friend(toxes[pairs[i].tox2], address, (uint8_t *)"Gentoo", 7);
 
@@ -331,7 +345,7 @@ Suite *tox_suite(void)
     Suite *s = suite_create("Tox");
 
     DEFTESTCASE_SLOW(few_clients, 50);
-    DEFTESTCASE_SLOW(many_clients, 300);
+    DEFTESTCASE_SLOW(many_clients, 150);
     return s;
 }