summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/benc.c4
-rw-r--r--test/peers.c61
-rw-r--r--test/proto.c143
3 files changed, 192 insertions, 16 deletions
diff --git a/test/benc.c b/test/benc.c
index a9d6ddb..3916f87 100644
--- a/test/benc.c
+++ b/test/benc.c
@@ -262,7 +262,7 @@ void test_key_not_found() {
ssize_t found = bcur_find_key(&bcursor, (const enum benc_nodetype[]){BNT_STRING}, (const char*[]){"a"}, (const size_t[]){1}, 1);
- TEST_ASSERT_EQUAL(-1, found);
+ TEST_ASSERT_EQUAL(-BENC_EENDP, found);
TEST_ASSERT_EQUAL_PTR(stream+3, bcursor.readhead);
}
@@ -351,7 +351,7 @@ void test_stop_at_end() {
ssize_t found = bcur_find_key(&bcursor, (const enum benc_nodetype[]){BNT_STRING}, (const char*[]){"x"}, (const size_t[]){1}, 1);
- TEST_ASSERT_EQUAL_MESSAGE(-1, found, "Found something");
+ TEST_ASSERT_EQUAL_MESSAGE(-BENC_EENDP, found, "Found something");
TEST_ASSERT_EQUAL_PTR_MESSAGE(stream+4, bcursor.readhead, "Didn't stop at dict end");
}
diff --git a/test/peers.c b/test/peers.c
index 1e9a454..49bf6c1 100644
--- a/test/peers.c
+++ b/test/peers.c
@@ -13,7 +13,7 @@ void test_add_single_peer() {
struct infohash sometorrent = {.inner={0x0034048f, 0x08000020, 0x00888880, 0x02008460, 0x0ab00521}};
struct addr addr = (struct addr){.ip = IP(128,0,0,1), .port = 0};
- int rc = add_peer(&sometorrent, &addr);
+ int rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
}
@@ -23,24 +23,24 @@ void test_add_9_peers_same_torrent() {
struct infohash sometorrent = {.inner={0x0034048f, 0x08000020, 0x00888880, 0x02008460, 0x0ab00521}};
struct addr addr = (struct addr){.ip = IP(128,0,0,1), .port = 0};
- int rc = add_peer(&sometorrent, &addr);
+ int rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
// There's room for 8 peers per infohash
- rc = add_peer(&sometorrent, &addr);
+ rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(PEER_EFULL, rc);
}
@@ -52,9 +52,9 @@ void test_peers_for_only_torrent() {
struct addr someaddr = (struct addr){.ip = IP(128,0,0,1), .port = 0};
struct addr otheraddr = (struct addr){.ip = IP(128,0,0,1), .port = 1};
- int rc = add_peer(&sometorrent, &someaddr);
+ int rc = add_peer(&sometorrent, &someaddr, 0);
TEST_ASSERT_EQUAL(0, rc);
- rc = add_peer(&othertorrent, &otheraddr);
+ rc = add_peer(&othertorrent, &otheraddr, 0);
TEST_ASSERT_EQUAL(0, rc);
struct addr* found;
@@ -88,7 +88,7 @@ void test_grows() {
for(int i = 0; i < 17; i++) { // Peer table size + 1 to make sure it HAS to grow
struct infohash sometorrent = {.inner={0x0034048f, 0x08000020, 0x00888880, 0x02008460, i}};
- int rc = add_peer(&sometorrent, &addr);
+ int rc = add_peer(&sometorrent, &addr, 0);
TEST_ASSERT_EQUAL(0, rc);
}
@@ -102,3 +102,38 @@ void test_grows() {
TEST_ASSERT_EQUAL(1, found_len);
}
}
+
+void test_expired() {
+ allocate_hashtable();
+
+ struct infohash sometorrent = {.inner={0x0034048f, 0x08000020, 0x00888880, 0x02008460, 0x0ab00521}};
+ struct infohash other = {.inner={0x0034048f, 0x08000020, 0x00888880, 0x02008470, 0x0ab00521}};
+ struct addr addr = (struct addr){.ip = IP(128,0,0,1), .port = 0};
+ struct addr other_addr = (struct addr){.ip = IP(128,0,0,1), .port = 1};
+
+ int rc = add_peer(&sometorrent, &addr, 0);
+ TEST_ASSERT_EQUAL(0, rc);
+ rc = add_peer(&other, &addr, 0);
+ TEST_ASSERT_EQUAL(0, rc);
+
+ rc = add_peer(&other, &other_addr, 1);
+ TEST_ASSERT_EQUAL(0, rc);
+
+ expire_hashes(HASH_TIMEOUT + 1);
+
+ {
+ struct addr* found;
+ size_t found_len;
+ get_peers(&sometorrent, &found, &found_len);
+ TEST_ASSERT_NULL(found);
+ TEST_ASSERT_EQUAL(0, found_len);
+ }
+
+ {
+ struct addr* found;
+ size_t found_len;
+ get_peers(&other, &found, &found_len);
+ TEST_ASSERT_NOT_NULL(found);
+ TEST_ASSERT_EQUAL(2, found_len);
+ }
+}
diff --git a/test/proto.c b/test/proto.c
index c69a293..54cf158 100644
--- a/test/proto.c
+++ b/test/proto.c
@@ -72,6 +72,8 @@ void test_begin_pings_bootstrap_node() {
TEST_ASSERT_EQUAL(91, outbuff[0].payload_len);
TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:ad2:id20:BBBBBBBBBBBBBBBBBBBB6:target20:", outbuff[0].payload, 43);
TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:q9:find_node1:t1:01:y1:qe", outbuff[0].payload+63, 28);
+
+ proto_end(&dht);
}
void test_response_from_initial_probe() {
@@ -112,6 +114,8 @@ void test_response_from_initial_probe() {
TEST_ASSERT_EQUAL(((struct sockaddr_in*)&remote)->sin_addr.s_addr, entry->addr.ip);
TEST_ASSERT_EQUAL(((struct sockaddr_in*)&remote)->sin_port, entry->addr.port);
TEST_ASSERT_EQUAL(PROTO_UNCTM+10, entry->expire);
+
+ proto_end(&dht);
}
void test_reponse_from_wrong_ip() {
@@ -145,6 +149,8 @@ void test_reponse_from_wrong_ip() {
struct nodeid other = (struct nodeid){.inner={0x61616161, 0x61616161, 0x61616161, 0x61616161, 0x61616161}};
struct entry* entry = routing_get(&other);
TEST_ASSERT_NULL(entry);
+
+ proto_end(&dht);
}
void test_ping() {
@@ -172,6 +178,8 @@ void test_ping() {
TEST_ASSERT_EQUAL(47, outbuff[0].payload_len);
TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:rd2:id20:BBBBBBBBBBBBBBBBBBBBe1:t2:aa1:y1:re", outbuff[0].payload, 47);
+
+ proto_end(&dht);
}
void test_unknown_method() {
@@ -199,6 +207,8 @@ void test_unknown_method() {
TEST_ASSERT_EQUAL(42, outbuff[0].payload_len);
TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:eli204e14:Unknown Methode1:t2:aa1:y1:ee", outbuff[0].payload, 42);
+
+ proto_end(&dht);
}
void test_note_times_out() {
@@ -239,6 +249,8 @@ void test_note_times_out() {
TEST_ASSERT_GREATER_THAN(19, prefix(&dht.self, &target));
TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:q9:find_node1:t1:01:y1:qe", outbuff[1].payload+63, 28);
+
+ proto_end(&dht);
}
void test_response_after_retry() {
@@ -266,6 +278,8 @@ void test_response_after_retry() {
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&dht.self, &target, sizeof(struct nodeid), "Target should be our own id");
TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:q9:find_node1:t1:01:y1:qe", outbuff[0].payload+63, 28);
+
+ proto_end(&dht);
}
void test_remove_from_routing_after_3_retries() {
@@ -330,6 +344,8 @@ void test_remove_from_routing_after_3_retries() {
TEST_ASSERT_EQUAL_PTR_MESSAGE(message_cursor, outbuff, "The timeout should send not a message");
entry = routing_get(&other);
TEST_ASSERT_NULL(entry);
+
+ proto_end(&dht);
}
void test_ping_node_when_uncertain() {
@@ -387,6 +403,8 @@ void test_ping_node_when_uncertain() {
TEST_ASSERT_NOT_NULL(entry);
TEST_ASSERT_GREATER_THAN(now, entry->expire);
}
+
+ proto_end(&dht);
}
void test_query_find_node() {
@@ -438,6 +456,8 @@ void test_query_find_node() {
TEST_ASSERT_EQUAL_MEMORY(&((struct sockaddr_in*)&remote)->sin_port, outbuff[0].payload+66, 2);
TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:t2:aa1:y1:re", outbuff[0].payload+68, 15);
}
+
+ proto_end(&dht);
}
void test_query_get_peers_have_one() {
@@ -513,7 +533,6 @@ void test_query_get_peers_have_one() {
// Node announces that it's a peer for that torrent
char buff[] = "d1:ad2:id20:abcdefghij012345678912:implied_porti1e9:info_hash20:aaaaaaaaaaaaaaaaaaaa4:porti1337e5:token32: e1:q13:announce_peer1:t2:aa1:y1:qe";
memcpy(buff+106, token, SHA256_BLOCK_SIZE);
- dbg("PKT %s", buff);
struct message* message_cursor = outbuff;
proto_run(&dht, buff, sizeof(buff), (struct sockaddr_in*)&other, sizeof(other), now, &message_cursor, outbuff+2);
TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff+1);
@@ -548,4 +567,126 @@ void test_query_get_peers_have_one() {
TEST_ASSERT_EQUAL_CHAR_ARRAY("6:valuesl6:\x80\x00\x00\x01\x23\x82""ee1:t2:aa1:y1:re", cursor, 33);
cursor+=33;
}
+
+ proto_end(&dht);
+}
+
+void test_node_closer_to_infohash_is_discovered() {
+ struct message outbuff[10] = {0};
+ time_t now = 0;
+
+ struct sockaddr_storage remote;
+ socklen_t remote_len;
+
+ allocate_hashtable();
+
+ struct dht dht;
+ dht.self = (struct nodeid){.inner={0x42424242, 0x42424242, 0x42424242, 0x42424242, 0x42424242}};
+ routing_init(&dht.self);
+ struct nodeid other = (struct nodeid){.inner={0x30303030, 0x30303030, 0x30303030, 0x30303030, 0x3030303}};
+
+ {
+ struct message* message_cursor = outbuff;
+ proto_begin(&dht, 0, &message_cursor, outbuff+2);
+ remote_len = outbuff[0].dest_len;
+ memcpy(&remote, &outbuff[0].dest, remote_len);
+ }
+ now += 10;
+
+ // Some other then asks for peers
+ char token[SHA256_BLOCK_SIZE];
+ {
+ struct sockaddr_in other;
+ other.sin_family = AF_INET;
+ inet_pton(AF_INET, "128.0.0.1", &other.sin_addr.s_addr);
+ other.sin_port = htons(3);
+
+ // Node asks for peers to get token
+ char buff[] = "d1:ad2:id20:000000000000000000009:info_hash20:00000000000000000002e1:q9:get_peers1:t2:aa1:y1:qe";
+ struct message* message_cursor = outbuff;
+ proto_run(&dht, buff, sizeof(buff), &other, sizeof(other), 0, &message_cursor, outbuff+2);
+
+ // We should have sent a response
+ TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff+1);
+
+ TEST_ASSERT_EQUAL(98, outbuff[0].payload_len);
+ char* cursor = outbuff[0].payload;
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:rd2:id20:BBBBBBBBBBBBBBBBBBBB5:nodes0:", cursor, 41);
+ cursor+=41;
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("5:token32:", cursor, 10);
+ cursor+=10;
+ memcpy(token, cursor, SHA256_BLOCK_SIZE);
+ cursor+=SHA256_BLOCK_SIZE;
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:t2:aa1:y1:re", cursor, 15);
+ cursor+=15;
+ }
+ now += 1;
+
+ // Using the token from before that node then announces that it's a peer
+ {
+ struct sockaddr_in other;
+ other.sin_family = AF_INET;
+ inet_pton(AF_INET, "128.0.0.1", &other.sin_addr.s_addr);
+ other.sin_port = htons(3);
+
+ // Node announces that it's a peer for that torrent
+ char buff[] = "d1:ad2:id20:0000000000000000000012:implied_porti1e9:info_hash20:000000000000000000024:porti1337e5:token32: e1:q13:announce_peer1:t2:aa1:y1:qe";
+ memcpy(buff+106, token, SHA256_BLOCK_SIZE);
+ struct message* message_cursor = outbuff;
+ proto_run(&dht, buff, sizeof(buff), (struct sockaddr_in*)&other, sizeof(other), now, &message_cursor, outbuff+2);
+ TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff+1);
+
+ TEST_ASSERT_EQUAL(47, outbuff[0].payload_len);
+ char* cursor = outbuff[0].payload;
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:rd2:id20:BBBBBBBBBBBBBBBBBBBBe1:t2:aa1:y1:re", cursor, 47);
+ cursor+=47;
+ }
+ now += 1;
+
+ // The initial node responds with an id that happens to be closer to the
+ // announced infohash than we are. We should reannounce that infohash to
+ // it.
+ {
+ char buff[] = "d1:y1:r1:t1:01:rd2:id20:000000000000000000015:nodes0:ee";
+ struct message* message_cursor = outbuff;
+ proto_run(&dht, buff, sizeof(buff), (struct sockaddr_in*)&remote, remote_len, now, &message_cursor, outbuff+2);
+
+
+// Disable this part since we don't currently implementing this functionality.
+// It's technically part of the Kademlia spec, but I don't see how you can
+// implement it in DHT
+#if 0
+ TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff+1);
+ TEST_ASSERT_EQUAL(94, outbuff[0].payload_len);
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:ad2:id20:BBBBBBBBBBBBBBBBBBBB9:info_hash20:00000000000000000002e1:q9:get_peers1:t2:aa1:y:qe", outbuff[0].payload, 94);
+#else
+ TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff);
+#endif
+ }
+
+#if 0
+ struct entry* entry = routing_get(&other);
+ TEST_ASSERT_NOT_NULL(entry);
+ {
+ struct sockaddr_in other;
+ other.sin_family = AF_INET;
+ inet_pton(AF_INET, "255.255.255.255", &other.sin_addr.s_addr);
+ other.sin_port = htons(6881);
+
+ char buff[] = "d1:ad2:id20:abcdefghij01234567896:target20:aaaaaaaaaaaaaaaaaaaae1:q9:find_node1:t2:aa1:y1:qe";
+ struct message* message_cursor = outbuff;
+ proto_run(&dht, buff, sizeof(buff), &other, sizeof(other), 0, &message_cursor, outbuff+2);
+
+ // We should have sent a response
+ TEST_ASSERT_EQUAL_PTR(message_cursor, outbuff+1);
+
+ TEST_ASSERT_EQUAL(83, outbuff[0].payload_len);
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("d1:rd2:id20:BBBBBBBBBBBBBBBBBBBB5:nodes26:aaaaaaaaaaaaaaaaaaaa", outbuff[0].payload, 62);
+ TEST_ASSERT_EQUAL_MEMORY(&((struct sockaddr_in*)&remote)->sin_addr.s_addr, outbuff[0].payload+62, 4);
+ TEST_ASSERT_EQUAL_MEMORY(&((struct sockaddr_in*)&remote)->sin_port, outbuff[0].payload+66, 2);
+ TEST_ASSERT_EQUAL_CHAR_ARRAY("e1:t2:aa1:y1:re", outbuff[0].payload+68, 15);
+ }
+#endif
+
+ proto_end(&dht);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-03 22:59:33 +0000