From 2d93eb204804b0d02318ffdb9914e148d5e67488 Mon Sep 17 00:00:00 2001 From: irungentoo Date: Fri, 11 Dec 2015 17:50:36 -0500 Subject: [PATCH] Better DHT tests. --- auto_tests/dht_test.c | 304 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 302 insertions(+), 2 deletions(-) diff --git a/auto_tests/dht_test.c b/auto_tests/dht_test.c index 8304a046..e18d3b74 100644 --- a/auto_tests/dht_test.c +++ b/auto_tests/dht_test.c @@ -366,12 +366,311 @@ START_TEST(test_addto_lists_ipv6) } END_TEST +#define DHT_DEFAULT_PORT (TOX_PORT_DEFAULT + 20) + +#define DHT_LIST_LENGTH 128 + +void print_pk(uint8_t *public_key) +{ + uint32_t j; + + for (j = 0; j < crypto_box_PUBLICKEYBYTES; j++) { + printf("%02hhX", public_key[j]); + } + + printf("\n"); +} + +void test_add_to_list(uint8_t cmp_list[][crypto_box_PUBLICKEYBYTES + 1], unsigned int length, const uint8_t *pk, + const uint8_t *cmp_pk) +{ + uint8_t p_b[crypto_box_PUBLICKEYBYTES]; + unsigned int i; + + for (i = 0; i < length; ++i) { + if (!cmp_list[i][crypto_box_PUBLICKEYBYTES]) { + memcpy(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES); + cmp_list[i][crypto_box_PUBLICKEYBYTES] = 1; + return; + } else { + if (memcmp(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES) == 0) { + return; + } + } + } + + for (i = 0; i < length; ++i) { + if (id_closest(cmp_pk, cmp_list[i], pk) == 2) { + memcpy(p_b, cmp_list[i], crypto_box_PUBLICKEYBYTES); + memcpy(cmp_list[i], pk, crypto_box_PUBLICKEYBYTES); + test_add_to_list(cmp_list, length, p_b, cmp_pk); + break; + } + } +} + +void test_list_main() +{ + uint8_t keys[DHT_LIST_LENGTH][crypto_box_PUBLICKEYBYTES]; + uint8_t cmp_list1[LCLIENT_LIST][crypto_box_PUBLICKEYBYTES + 1]; + uint8_t cmp_list2[LCLIENT_LIST][crypto_box_PUBLICKEYBYTES + 1]; + + memset(cmp_list1, 0, sizeof(cmp_list1)); + memset(cmp_list2, 0, sizeof(cmp_list2)); + IP ip; + ip_init(&ip, 1); + + unsigned int i, j; + + for (i = 0; i < DHT_LIST_LENGTH; ++i) { + for (j = 0; j < crypto_box_PUBLICKEYBYTES; ++j) + keys[i][j] = rand(); + } + + DHT *dht1 = new_DHT(new_networking(ip, DHT_DEFAULT_PORT)), *dht2 = new_DHT(new_networking(ip, DHT_DEFAULT_PORT + 1)); + + ck_assert_msg(dht1 && dht2, "Failed to create DHTs"); + memcpy(dht2->self_public_key, dht1->self_public_key, crypto_box_PUBLICKEYBYTES); + memcpy(dht2->self_secret_key, dht1->self_secret_key, crypto_box_SECRETKEYBYTES); + + for (i = 0; i < DHT_LIST_LENGTH; ++i) { + IP_Port ip_port; + ip_init(&ip_port.ip, 0); + ip_port.ip.ip4.uint32 = rand(); + ip_port.port = rand() % (UINT16_MAX - 1); + ++ip_port.port; + addto_lists(dht1, ip_port, keys[i]); + + ip_init(&ip_port.ip, 0); + ip_port.ip.ip4.uint32 = rand(); + ip_port.port = rand() % (UINT16_MAX - 1); + ++ip_port.port; + addto_lists(dht2, ip_port, keys[(DHT_LIST_LENGTH - (i + 1))]); + + test_add_to_list(cmp_list1, LCLIENT_LIST, keys[i], dht1->self_public_key); + test_add_to_list(cmp_list2, LCLIENT_LIST, keys[(DHT_LIST_LENGTH - (i + 1))], dht2->self_public_key); + } + + /* + for (i = 0; i < LCLIENT_LIST; ++i) { + printf("----Entry %u----\n", i); + + print_pk(cmp_list1[i]); + print_pk(cmp_list2[i]); + print_pk(dht1->close_clientlist[i].public_key); + print_pk(dht2->close_clientlist[i].public_key); + } + */ + for (i = 0; i < LCLIENT_LIST; ++i) { + uint8_t *pk = cmp_list1[i]; + + unsigned int count = 0; + + for (j = 0; j < LCLIENT_LIST; ++j) { + if (memcmp(pk, cmp_list2[j], crypto_box_PUBLICKEYBYTES) == 0) + ++count; + } + + ck_assert_msg(count == 1, "Bad distance formula"); + } + + for (i = 0; i < LCLIENT_LIST; ++i) { + uint8_t *pk = cmp_list1[i]; + + unsigned int count = 0; + + for (j = 0; j < LCLIENT_LIST; ++j) { + if (memcmp(pk, dht1->close_clientlist[j].public_key, crypto_box_PUBLICKEYBYTES) == 0) + ++count; + } + + ck_assert_msg(count == 1, "Keys not in first close list, %u, %X %X", i, cmp_list1[i][0], dht1->self_public_key[0]); + + for (j = 0; j < LCLIENT_LIST; ++j) { + if (memcmp(pk, dht2->close_clientlist[j].public_key, crypto_box_PUBLICKEYBYTES) == 0) + ++count; + } + + ck_assert_msg(count == 2, "Keys not in second close list, %u, %X %X", i, cmp_list1[i][0], dht2->self_public_key[0]); + } + + uint8_t cmp_list3[MAX_SENT_NODES][crypto_box_PUBLICKEYBYTES + 1]; + memset(cmp_list3, 0, sizeof(cmp_list3)); + + for (i = 0; i < DHT_LIST_LENGTH; ++i) { + test_add_to_list(cmp_list3, MAX_SENT_NODES, keys[i], dht1->self_public_key); + } + + Node_format n_list[MAX_SENT_NODES]; + ck_assert_msg(get_close_nodes(dht1, dht1->self_public_key, n_list, 0, 1, 0) == MAX_SENT_NODES, + "Wrong number of nodes returned"); + /* + for (i = 0; i < MAX_SENT_NODES; ++i) { + printf("----Close %u----\n", i); + + print_pk(cmp_list3[i]); + print_pk(n_list[i].public_key); + } + */ + + for (i = 0; i < MAX_SENT_NODES; ++i) { + uint8_t *pk = cmp_list3[i]; + unsigned int count = 0; + + for (j = 0; j < MAX_SENT_NODES; ++j) { + if (memcmp(pk, n_list[j].public_key, crypto_box_PUBLICKEYBYTES) == 0) + ++count; + } + + ck_assert_msg(count == 1, "Bad get_close_nodes"); + } + + uint8_t cmp_new[crypto_box_PUBLICKEYBYTES]; + memcpy(cmp_new, cmp_list3[0], crypto_box_PUBLICKEYBYTES); + ck_assert_msg(get_close_nodes(dht1, cmp_new, n_list, 0, 1, 0) == MAX_SENT_NODES, + "Wrong number of nodes returned"); + + memset(cmp_list3, 0, sizeof(cmp_list3)); + + for (i = 0; i < DHT_LIST_LENGTH; ++i) { + test_add_to_list(cmp_list3, MAX_SENT_NODES, keys[i], cmp_new); + } + + for (i = 0; i < MAX_SENT_NODES; ++i) { + uint8_t *pk = cmp_list3[i]; + unsigned int count = 0; + + for (j = 0; j < MAX_SENT_NODES; ++j) { + if (memcmp(pk, n_list[j].public_key, crypto_box_PUBLICKEYBYTES) == 0) + ++count; + } + + ck_assert_msg(count == 1, "Bad get_close_nodes"); + } + + void *n = dht1->net; + kill_DHT(dht1); + kill_networking(n); + + n = dht2->net; + kill_DHT(dht2); + kill_networking(n); +} + + +START_TEST(test_list) +{ + unsigned int i; + + for (i = 0; i < 10; ++i) + test_list_main(); +} +END_TEST + +void ip_callback(void *data, int32_t number, IP_Port ip_port) +{ + + +} + + +#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32) +#define c_sleep(x) Sleep(1*x) +#else +#include +#define c_sleep(x) usleep(1000*x) +#endif + +#define NUM_DHT 100 +#define NUM_DHT_FRIENDS 20 + +START_TEST(test_DHT_test) +{ + uint32_t to_comp = 8394782; + DHT *dhts[NUM_DHT]; + + unsigned int i, j; + + for (i = 0; i < NUM_DHT; ++i) { + IP ip; + ip_init(&ip, 1); + + dhts[i] = new_DHT(new_networking(ip, DHT_DEFAULT_PORT + i)); + ck_assert_msg(dhts[i] != 0, "Failed to create dht instances %u", i); + ck_assert_msg(dhts[i]->net->port != DHT_DEFAULT_PORT + i, "Bound to wrong port"); + } + + struct { + uint16_t tox1; + uint16_t tox2; + } pairs[NUM_DHT_FRIENDS]; + + uint8_t address[TOX_ADDRESS_SIZE]; + + unsigned int num_f = 0; + + for (i = 0; i < NUM_DHT_FRIENDS; ++i) { +loop_top: + pairs[i].tox1 = rand() % NUM_DHT; + pairs[i].tox2 = (pairs[i].tox1 + (rand() % (NUM_DHT - 1)) + 1) % NUM_DHT; + + for (j = 0; j < i; ++j) { + if (pairs[j].tox2 == pairs[i].tox2 && pairs[j].tox1 == pairs[i].tox1) + goto loop_top; + } + + uint16_t lock_count = 0; + ck_assert_msg(DHT_addfriend(dhts[pairs[i].tox2], dhts[pairs[i].tox1]->self_public_key, &ip_callback, &to_comp, 1337, + &lock_count) == 0, "Failed to add friend"); + ck_assert_msg(lock_count == 1, "bad lock count: %u %u", lock_count, i); + } + + for (i = 0; i < NUM_DHT; ++i) { + IP_Port ip_port; + ip_init(&ip_port.ip, 1); + ip_port.ip.ip6.uint8[15] = 1; + ip_port.port = htons(DHT_DEFAULT_PORT + i); + DHT_bootstrap(dhts[(i - 1) % NUM_DHT], ip_port, dhts[i]->self_public_key); + } + + while (1) { + uint16_t counter = 0; + + for (i = 0; i < NUM_DHT_FRIENDS; ++i) { + IP_Port a; + + if (DHT_getfriendip(dhts[pairs[i].tox2], dhts[pairs[i].tox1]->self_public_key, &a) == 1) + ++counter; + } + + if (counter == NUM_DHT_FRIENDS) { + break; + } + + for (i = 0; i < NUM_DHT; ++i) { + networking_poll(dhts[i]->net); + do_DHT(dhts[i]); + } + + c_sleep(500); + } + + for (i = 0; i < NUM_DHT; ++i) { + void *n = dhts[i]->net; + kill_DHT(dhts[i]); + kill_networking(n); + } +} +END_TEST + Suite *dht_suite(void) { Suite *s = suite_create("DHT"); - DEFTESTCASE(addto_lists_ipv4); - DEFTESTCASE(addto_lists_ipv6); + //DEFTESTCASE(addto_lists_ipv4); + //DEFTESTCASE(addto_lists_ipv6); + DEFTESTCASE(list); + DEFTESTCASE_SLOW(DHT_test, 50); return s; } @@ -383,6 +682,7 @@ int main(int argc, char *argv[]) SRunner *test_runner = srunner_create(dht); int number_failed = 0; + //srunner_set_fork_status(test_runner, CK_NOFORK); srunner_run_all(test_runner, CK_NORMAL); number_failed = srunner_ntests_failed(test_runner);