1961 lines
60 KiB
C++
1961 lines
60 KiB
C++
/*
|
|
|
|
Copyright (c) 2008, Arvid Norberg
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in
|
|
the documentation and/or other materials provided with the distribution.
|
|
* Neither the name of the author nor the names of its
|
|
contributors may be used to endorse or promote products derived
|
|
from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
|
|
|
#include "libtorrent/config.hpp"
|
|
#include "libtorrent/session.hpp"
|
|
#include "libtorrent/kademlia/node.hpp" // for verify_message
|
|
#include "libtorrent/bencode.hpp"
|
|
#include "libtorrent/socket_io.hpp" // for hash_address
|
|
#include "libtorrent/broadcast_socket.hpp" // for supports_ipv6
|
|
#include "libtorrent/performance_counters.hpp" // for counters
|
|
#include "libtorrent/random.hpp"
|
|
#include "libtorrent/ed25519.hpp"
|
|
|
|
#include "libtorrent/kademlia/node_id.hpp"
|
|
#include "libtorrent/kademlia/routing_table.hpp"
|
|
#include "libtorrent/kademlia/item.hpp"
|
|
#include "libtorrent/kademlia/dht_observer.hpp"
|
|
#include "libtorrent/ed25519.hpp"
|
|
#include <numeric>
|
|
|
|
#include "test.hpp"
|
|
#include "setup_transfer.hpp"
|
|
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
#include <valgrind/memcheck.h>
|
|
#endif
|
|
|
|
#if TORRENT_USE_IOSTREAM
|
|
#include <iostream>
|
|
#endif
|
|
|
|
using namespace libtorrent;
|
|
using namespace libtorrent::dht;
|
|
|
|
void nop() {}
|
|
|
|
static sha1_hash to_hash(char const* s)
|
|
{
|
|
sha1_hash ret;
|
|
from_hex(s, 40, (char*)&ret[0]);
|
|
return ret;
|
|
}
|
|
|
|
void add_and_replace(libtorrent::dht::node_id& dst, libtorrent::dht::node_id const& add)
|
|
{
|
|
bool carry = false;
|
|
for (int k = 19; k >= 0; --k)
|
|
{
|
|
int sum = dst[k] + add[k] + (carry?1:0);
|
|
dst[k] = sum & 255;
|
|
carry = sum > 255;
|
|
}
|
|
}
|
|
|
|
void node_push_back(void* userdata, libtorrent::dht::node_entry const& n)
|
|
{
|
|
using namespace libtorrent::dht;
|
|
std::vector<node_entry>* nv = (std::vector<node_entry>*)userdata;
|
|
nv->push_back(n);
|
|
}
|
|
|
|
static void nop(void* userdata, libtorrent::dht::node_entry const& n) {}
|
|
|
|
std::list<std::pair<udp::endpoint, entry> > g_sent_packets;
|
|
|
|
struct mock_socket : udp_socket_interface
|
|
{
|
|
bool has_quota() { return true; }
|
|
bool send_packet(entry& msg, udp::endpoint const& ep, int flags)
|
|
{
|
|
g_sent_packets.push_back(std::make_pair(ep, msg));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
sha1_hash generate_next()
|
|
{
|
|
sha1_hash ret;
|
|
for (int i = 0; i < 20; ++i) ret[i] = rand() & 0xff;
|
|
return ret;
|
|
}
|
|
|
|
boost::array<char, 64> generate_key()
|
|
{
|
|
boost::array<char, 64> ret;
|
|
for (int i = 0; i < 64; ++i) ret[i] = rand() & 0xff;
|
|
return ret;
|
|
}
|
|
|
|
static const std::string no;
|
|
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator
|
|
find_packet(udp::endpoint ep)
|
|
{
|
|
return std::find_if(g_sent_packets.begin(), g_sent_packets.end()
|
|
, boost::bind(&std::pair<udp::endpoint, entry>::first, _1) == ep);
|
|
}
|
|
|
|
void lazy_from_entry(entry const& e, bdecode_node& l)
|
|
{
|
|
error_code ec;
|
|
static char inbuf[1500];
|
|
int len = bencode(inbuf, e);
|
|
int ret = bdecode(inbuf, inbuf + len, l, ec);
|
|
TEST_CHECK(ret == 0);
|
|
}
|
|
|
|
void send_dht_request(node& node, char const* msg, udp::endpoint const& ep
|
|
, bdecode_node* reply, char const* t = "10", char const* info_hash = 0
|
|
, char const* name = 0, std::string const token = std::string(), int port = 0
|
|
, char const* target = 0, entry const* value = 0
|
|
, bool scrape = false, bool seed = false
|
|
, std::string const key = std::string(), std::string const sig = std::string()
|
|
, int seq = -1, boost::int64_t cas = -1, sha1_hash const* nid = NULL
|
|
, char const* put_salt = NULL)
|
|
{
|
|
// we're about to clear out the backing buffer
|
|
// for this lazy_entry, so we better clear it now
|
|
reply->clear();
|
|
entry e;
|
|
e["q"] = msg;
|
|
e["t"] = t;
|
|
e["y"] = "q";
|
|
entry::dictionary_type& a = e["a"].dict();
|
|
if (nid == NULL) a["id"] = generate_next().to_string();
|
|
else a["id"] = nid->to_string();
|
|
if (info_hash) a["info_hash"] = std::string(info_hash, 20);
|
|
if (name) a["n"] = name;
|
|
if (!token.empty()) a["token"] = token;
|
|
if (port) a["port"] = port;
|
|
if (target) a["target"] = std::string(target, 20);
|
|
if (value) a["v"] = *value;
|
|
if (!sig.empty()) a["sig"] = sig;
|
|
if (!key.empty()) a["k"] = key;
|
|
if (scrape) a["scrape"] = 1;
|
|
if (seed) a["seed"] = 1;
|
|
if (seq >= 0) a["seq"] = seq;
|
|
if (cas != -1) a["cas"] = cas;
|
|
if (put_salt) a["salt"] = put_salt;
|
|
char msg_buf[1500];
|
|
int size = bencode(msg_buf, e);
|
|
#if defined TORRENT_DEBUG && TORRENT_USE_IOSTREAM
|
|
// this yields a lot of output. too much
|
|
// std::cerr << "sending: " << e << "\n";
|
|
#endif
|
|
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
VALGRIND_CHECK_MEM_IS_DEFINED(msg_buf, size);
|
|
#endif
|
|
|
|
bdecode_node decoded;
|
|
error_code ec;
|
|
bdecode(msg_buf, msg_buf + size, decoded, ec);
|
|
if (ec) fprintf(stderr, "bdecode failed: %s\n", ec.message().c_str());
|
|
|
|
dht::msg m(decoded, ep);
|
|
node.incoming(m);
|
|
|
|
// by now the node should have invoked the send function and put the
|
|
// response in g_sent_packets
|
|
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator i
|
|
= find_packet(ep);
|
|
if (i == g_sent_packets.end())
|
|
{
|
|
TEST_ERROR("not response from DHT node");
|
|
return;
|
|
}
|
|
|
|
lazy_from_entry(i->second, *reply);
|
|
g_sent_packets.erase(i);
|
|
}
|
|
|
|
void write_peers(entry::dictionary_type& r, std::set<tcp::endpoint> const& peers)
|
|
{
|
|
entry::list_type& pe = r["values"].list();
|
|
for (std::set<tcp::endpoint>::const_iterator it = peers.begin()
|
|
; it != peers.end(); ++it)
|
|
{
|
|
std::string endpoint(18, '\0');
|
|
std::string::iterator out = endpoint.begin();
|
|
libtorrent::detail::write_endpoint(*it, out);
|
|
endpoint.resize(out - endpoint.begin());
|
|
pe.push_back(entry(endpoint));
|
|
}
|
|
}
|
|
|
|
void send_dht_response(node& node, bdecode_node const& request, udp::endpoint const& ep
|
|
, nodes_t const& nodes = nodes_t()
|
|
, std::string const token = std::string(), int port = 0
|
|
, std::set<tcp::endpoint> const& peers = std::set<tcp::endpoint>()
|
|
, char const* target = 0, entry const* value = 0
|
|
, std::string const key = std::string(), std::string const sig = std::string()
|
|
, int seq = -1, sha1_hash const* nid = NULL)
|
|
{
|
|
entry e;
|
|
e["y"] = "r";
|
|
e["t"] = request.dict_find_string_value("t");
|
|
// e["ip"] = endpoint_to_bytes(ep);
|
|
entry::dictionary_type& r = e["r"].dict();
|
|
if (nid == NULL) r["id"] = generate_next().to_string();
|
|
else r["id"] = nid->to_string();
|
|
if (!token.empty()) r["token"] = token;
|
|
if (port) r["p"] = port;
|
|
if (!nodes.empty()) dht::write_nodes_entry(e["r"], nodes);
|
|
if (!peers.empty()) write_peers(r, peers);
|
|
if (value) r["v"] = *value;
|
|
if (!sig.empty()) r["sig"] = sig;
|
|
if (!key.empty()) r["k"] = key;
|
|
if (seq >= 0) r["seq"] = seq;
|
|
char msg_buf[1500];
|
|
int size = bencode(msg_buf, e);
|
|
#if defined TORRENT_DEBUG && TORRENT_USE_IOSTREAM
|
|
// this yields a lot of output. too much
|
|
// std::cerr << "sending: " << e << "\n";
|
|
#endif
|
|
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
VALGRIND_CHECK_MEM_IS_DEFINED(msg_buf, size);
|
|
#endif
|
|
|
|
bdecode_node decoded;
|
|
error_code ec;
|
|
bdecode(msg_buf, msg_buf + size, decoded, ec);
|
|
if (ec) fprintf(stderr, "bdecode failed: %s\n", ec.message().c_str());
|
|
|
|
dht::msg m(decoded, ep);
|
|
node.incoming(m);
|
|
}
|
|
|
|
struct announce_item
|
|
{
|
|
sha1_hash next;
|
|
int num_peers;
|
|
entry ent;
|
|
sha1_hash target;
|
|
void gen()
|
|
{
|
|
num_peers = (rand() % 5) + 1;
|
|
ent["next"] = next.to_string();
|
|
ent["A"] = "a";
|
|
ent["B"] = "b";
|
|
ent["num_peers"] = num_peers;
|
|
|
|
char buf[512];
|
|
char* ptr = buf;
|
|
int len = bencode(ptr, ent);
|
|
target = hasher(buf, len).final();
|
|
}
|
|
};
|
|
|
|
void announce_immutable_items(node& node, udp::endpoint const* eps
|
|
, announce_item const* items, int num_items)
|
|
{
|
|
std::string token;
|
|
for (int i = 0; i < 1000; ++i)
|
|
{
|
|
for (int j = 0; j < num_items; ++j)
|
|
{
|
|
if ((i % items[j].num_peers) == 0) continue;
|
|
bdecode_node response;
|
|
send_dht_request(node, "get", eps[i], &response, "10", 0
|
|
, 0, no, 0, (char const*)&items[j].target[0]);
|
|
|
|
key_desc_t desc[] =
|
|
{
|
|
{ "r", bdecode_node::dict_t, 0, key_desc_t::parse_children },
|
|
{ "id", bdecode_node::string_t, 20, 0},
|
|
{ "token", bdecode_node::string_t, 0, 0},
|
|
{ "ip", bdecode_node::string_t, 0, key_desc_t::optional | key_desc_t::last_child},
|
|
{ "y", bdecode_node::string_t, 1, 0},
|
|
};
|
|
|
|
bdecode_node parsed[6];
|
|
char error_string[200];
|
|
|
|
// fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
int ret = verify_message(response, desc, parsed, 5, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[4].string_value(), "r");
|
|
token = parsed[2].string_value();
|
|
// fprintf(stderr, "got token: %s\n", token.c_str());
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid get response: %s\n", error_string);
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
if (parsed[3])
|
|
{
|
|
address_v4::bytes_type b;
|
|
memcpy(&b[0], parsed[3].string_ptr(), b.size());
|
|
address_v4 addr(b);
|
|
TEST_EQUAL(addr, eps[i].address());
|
|
}
|
|
|
|
send_dht_request(node, "put", eps[i], &response, "10", 0
|
|
, 0, token, 0, (char const*)&items[j].target[0], &items[j].ent);
|
|
|
|
key_desc_t desc2[] =
|
|
{
|
|
{ "y", bdecode_node::string_t, 1, 0 }
|
|
};
|
|
|
|
ret = verify_message(response, desc2, parsed, 1, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
if (parsed[0].string_value() != "r")
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
|
|
TEST_EQUAL(parsed[0].string_value(), "r");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid put response: %s\n", error_string);
|
|
TEST_ERROR(error_string);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::set<int> items_num;
|
|
for (int j = 0; j < num_items; ++j)
|
|
{
|
|
bdecode_node response;
|
|
send_dht_request(node, "get", eps[j], &response, "10", 0
|
|
, 0, no, 0, (char const*)&items[j].target[0]);
|
|
|
|
key_desc_t desc[] =
|
|
{
|
|
{ "r", bdecode_node::dict_t, 0, key_desc_t::parse_children },
|
|
{ "v", bdecode_node::dict_t, 0, 0},
|
|
{ "id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
{ "y", bdecode_node::string_t, 1, 0},
|
|
};
|
|
|
|
bdecode_node parsed[4];
|
|
char error_string[200];
|
|
|
|
int ret = verify_message(response, desc, parsed, 4, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
items_num.insert(items_num.begin(), j);
|
|
}
|
|
}
|
|
|
|
TEST_EQUAL(items_num.size(), 4);
|
|
|
|
// items_num should contain 1,2 and 3
|
|
// #error this doesn't quite hold
|
|
// TEST_CHECK(items_num.find(1) != items_num.end());
|
|
// TEST_CHECK(items_num.find(2) != items_num.end());
|
|
// TEST_CHECK(items_num.find(3) != items_num.end());
|
|
}
|
|
|
|
int sum_distance_exp(int s, node_entry const& e, node_id const& ref)
|
|
{
|
|
return s + distance_exp(e.id, ref);
|
|
}
|
|
|
|
std::vector<tcp::endpoint> g_got_peers;
|
|
|
|
void get_peers_cb(std::vector<tcp::endpoint> const& peers)
|
|
{
|
|
g_got_peers.insert(g_got_peers.end(), peers.begin(), peers.end());
|
|
}
|
|
|
|
std::vector<dht::item> g_got_items;
|
|
dht::item g_put_item;
|
|
int g_put_count;
|
|
|
|
bool get_item_cb(dht::item& i)
|
|
{
|
|
if (!i.empty())
|
|
g_got_items.push_back(i);
|
|
if (!g_put_item.empty())
|
|
{
|
|
i = g_put_item;
|
|
g_put_count++;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
struct obs : dht::dht_observer
|
|
{
|
|
virtual void set_external_address(address const& addr
|
|
, address const& source) TORRENT_OVERRIDE
|
|
{}
|
|
|
|
virtual address external_address() TORRENT_OVERRIDE
|
|
{
|
|
return address_v4::from_string("236.0.0.1");
|
|
}
|
|
virtual void get_peers(sha1_hash const& ih) TORRENT_OVERRIDE {}
|
|
virtual void outgoing_get_peers(sha1_hash const& target
|
|
, sha1_hash const& sent_target, udp::endpoint const& ep) TORRENT_OVERRIDE {}
|
|
virtual void announce(sha1_hash const& ih, address const& addr, int port) TORRENT_OVERRIDE {}
|
|
virtual void log(dht_logger::module_t l, char const* fmt, ...) TORRENT_OVERRIDE {}
|
|
virtual void log_packet(message_direction_t dir, char const* pkt, int len
|
|
, udp::endpoint node) TORRENT_OVERRIDE {}
|
|
};
|
|
|
|
// TODO: test obfuscated_get_peers
|
|
TORRENT_TEST(dht)
|
|
{
|
|
dht_settings sett;
|
|
sett.max_torrents = 4;
|
|
sett.max_dht_items = 4;
|
|
sett.enforce_node_id = false;
|
|
mock_socket s;
|
|
obs observer;
|
|
counters cnt;
|
|
dht::node node(&s, sett, node_id(0), &observer, cnt);
|
|
|
|
// DHT should be running on port 48199 now
|
|
bdecode_node response;
|
|
bdecode_node parsed[11];
|
|
char error_string[200];
|
|
bool ret;
|
|
|
|
// ====== ping ======
|
|
udp::endpoint source(address::from_string("10.0.0.1"), 20);
|
|
send_dht_request(node, "ping", source, &response, "10");
|
|
|
|
dht::key_desc_t pong_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"r", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, pong_desc, parsed, 4, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
TEST_CHECK(parsed[1].string_value() == "10");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid ping response: %s\n", error_string);
|
|
}
|
|
|
|
// ====== invalid message ======
|
|
|
|
send_dht_request(node, "find_node", source, &response, "10");
|
|
|
|
dht::key_desc_t err_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"e", bdecode_node::list_t, 2, 0}
|
|
};
|
|
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, err_desc, parsed, 2, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "e");
|
|
if (parsed[1].list_at(0).type() == bdecode_node::int_t
|
|
&& parsed[1].list_at(1).type() == bdecode_node::string_t)
|
|
{
|
|
TEST_CHECK(parsed[1].list_at(1).string_value() == "missing 'target' key");
|
|
}
|
|
else
|
|
{
|
|
TEST_ERROR("invalid error response");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid error response: %s\n", error_string);
|
|
}
|
|
|
|
// ====== get_peers ======
|
|
|
|
send_dht_request(node, "get_peers", source, &response, "10", "01010101010101010101");
|
|
|
|
dht::key_desc_t peer1_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"r", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"token", bdecode_node::string_t, 0, 0},
|
|
{"id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
std::string token;
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, peer1_desc, parsed, 4, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
token = parsed[2].string_value();
|
|
// fprintf(stderr, "got token: %s\n", token.c_str());
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid get_peers response: %s\n", error_string);
|
|
}
|
|
|
|
// ====== announce ======
|
|
|
|
send_dht_request(node, "announce_peer", source, &response, "10", "01010101010101010101", "test", token, 8080);
|
|
|
|
dht::key_desc_t ann_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"r", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, ann_desc, parsed, 3, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid announce response: %s\n", error_string);
|
|
}
|
|
|
|
// announce from 100 random IPs and make sure scrape works
|
|
// 50 downloaders and 50 seeds
|
|
for (int i = 0; i < 100; ++i)
|
|
{
|
|
source = udp::endpoint(rand_v4(), 6000);
|
|
send_dht_request(node, "get_peers", source, &response, "10", "01010101010101010101");
|
|
ret = dht::verify_message(response, peer1_desc, parsed, 4, error_string
|
|
, sizeof(error_string));
|
|
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
token = parsed[2].string_value();
|
|
// fprintf(stderr, "got token: %s\n", token.c_str());
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid get_peers response: %s\n", error_string);
|
|
}
|
|
response.clear();
|
|
send_dht_request(node, "announce_peer", source, &response, "10", "01010101010101010101"
|
|
, "test", token, 8080, 0, 0, false, i >= 50);
|
|
response.clear();
|
|
}
|
|
|
|
// ====== get_peers ======
|
|
|
|
send_dht_request(node, "get_peers", source, &response, "10", "01010101010101010101"
|
|
, 0, no, 0, 0, 0, true);
|
|
|
|
dht::key_desc_t peer2_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"r", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"BFpe", bdecode_node::string_t, 256, 0},
|
|
{"BFsd", bdecode_node::string_t, 256, 0},
|
|
{"id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, peer2_desc, parsed, 5, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
TEST_EQUAL(parsed[1].dict_find_string_value("n"), "test");
|
|
|
|
bloom_filter<256> downloaders;
|
|
bloom_filter<256> seeds;
|
|
downloaders.from_string(parsed[2].string_ptr());
|
|
seeds.from_string(parsed[3].string_ptr());
|
|
|
|
fprintf(stderr, "seeds: %f\n", seeds.size());
|
|
fprintf(stderr, "downloaders: %f\n", downloaders.size());
|
|
|
|
TEST_CHECK(fabs(seeds.size() - 50.f) <= 3.f);
|
|
TEST_CHECK(fabs(downloaders.size() - 50.f) <= 3.f);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid get_peers response: %s\n", error_string);
|
|
}
|
|
|
|
// ====== test node ID testing =====
|
|
|
|
{
|
|
node_id rnd = generate_secret_id();
|
|
TEST_CHECK(verify_secret_id(rnd));
|
|
|
|
rnd[19] ^= 0x55;
|
|
TEST_CHECK(!verify_secret_id(rnd));
|
|
|
|
rnd = generate_random_id();
|
|
make_id_secret(rnd);
|
|
TEST_CHECK(verify_secret_id(rnd));
|
|
}
|
|
|
|
// ====== test node ID enforcement ======
|
|
|
|
// enable node_id enforcement
|
|
sett.enforce_node_id = true;
|
|
|
|
// this is one of the test vectors from:
|
|
// http://libtorrent.org/dht_sec.html
|
|
source = udp::endpoint(address::from_string("124.31.75.21"), 1);
|
|
node_id nid = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401");
|
|
send_dht_request(node, "find_node", source, &response, "10", 0, 0, std::string()
|
|
, 0, "0101010101010101010101010101010101010101", 0, false, false, std::string(), std::string(), -1, 0, &nid);
|
|
|
|
dht::key_desc_t nodes_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"r", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
ret = dht::verify_message(response, nodes_desc, parsed, 3, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "r");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid error response: %s\n", error_string);
|
|
}
|
|
|
|
// verify that we reject invalid node IDs
|
|
// this is now an invalid node-id for 'source'
|
|
nid[0] = 0x18;
|
|
send_dht_request(node, "find_node", source, &response, "10", 0, 0, std::string()
|
|
, 0, "0101010101010101010101010101010101010101", 0, false, false, std::string(), std::string(), -1, 0, &nid);
|
|
|
|
ret = dht::verify_message(response, err_desc, parsed, 2, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
if (ret)
|
|
{
|
|
TEST_CHECK(parsed[0].string_value() == "e");
|
|
if (parsed[1].list_at(0).type() == bdecode_node::int_t
|
|
&& parsed[1].list_at(1).type() == bdecode_node::string_t)
|
|
{
|
|
TEST_CHECK(parsed[1].list_at(1).string_value() == "invalid node ID");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR("invalid error response");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid error response: %s\n", error_string);
|
|
}
|
|
|
|
sett.enforce_node_id = false;
|
|
|
|
// ===========================
|
|
|
|
bloom_filter<256> test;
|
|
for (int i = 0; i < 256; ++i)
|
|
{
|
|
char adr[50];
|
|
snprintf(adr, 50, "192.0.2.%d", i);
|
|
address a = address::from_string(adr);
|
|
sha1_hash iphash;
|
|
hash_address(a, iphash);
|
|
test.set(iphash);
|
|
}
|
|
|
|
if (supports_ipv6())
|
|
{
|
|
for (int i = 0; i < 0x3E8; ++i)
|
|
{
|
|
char adr[50];
|
|
snprintf(adr, 50, "2001:db8::%x", i);
|
|
address a = address::from_string(adr);
|
|
sha1_hash iphash;
|
|
hash_address(a, iphash);
|
|
test.set(iphash);
|
|
}
|
|
}
|
|
|
|
// these are test vectors from BEP 33
|
|
// http://www.bittorrent.org/beps/bep_0033.html
|
|
fprintf(stderr, "test.size: %f\n", test.size());
|
|
fprintf(stderr, "%s\n", to_hex(test.to_string()).c_str());
|
|
if (supports_ipv6())
|
|
{
|
|
TEST_CHECK(fabs(test.size() - 1224.93f) < 0.001);
|
|
TEST_CHECK(to_hex(test.to_string()) == "f6c3f5eaa07ffd91bde89f777f26fb2bff37bdb8fb2bbaa2fd3ddde7bacfff75ee7ccbaefe5eedb1fbfaff67f6abff5e43ddbca3fd9b9ffdf4ffd3e9dff12d1bdf59db53dbe9fa5b7ff3b8fdfcde1afb8bedd7be2f3ee71ebbbfe93bcdeefe148246c2bc5dbff7e7efdcf24fd8dc7adffd8fffdfddfff7a4bbeedf5cb95ce81fc7fcff1ff4ffffdfe5f7fdcbb7fd79b3fa1fc77bfe07fff905b7b7ffc7fefeffe0b8370bb0cd3f5b7f2bd93feb4386cfdd6f7fd5bfaf2e9ebffffeecd67adbf7c67f17efd5d75eba6ffeba7fff47a91eb1bfbb53e8abfb5762abe8ff237279bfefbfeef5ffc5febfdfe5adffadfee1fb737ffffbfd9f6aeffeee76b6fd8f72ef");
|
|
}
|
|
else
|
|
{
|
|
TEST_CHECK(fabs(test.size() - 257.854f) < 0.001);
|
|
TEST_CHECK(to_hex(test.to_string()) == "24c0004020043000102012743e00480037110820422110008000c0e302854835a05401a4045021302a306c060001881002d8a0a3a8001901b40a800900310008d2108110c2496a0028700010d804188b01415200082004088026411104a804048002002000080680828c400080cc40020c042c0494447280928041402104080d4240040414a41f0205654800b0811830d2020042b002c5800004a71d0204804a0028120a004c10017801490b834004044106005421000c86900a0020500203510060144e900100924a1018141a028012913f0041802250042280481200002004430804210101c08111c10801001080002038008211004266848606b035001048");
|
|
}
|
|
|
|
response.clear();
|
|
|
|
// ====== put ======
|
|
|
|
udp::endpoint eps[1000];
|
|
|
|
for (int i = 0; i < 1000; ++i)
|
|
eps[i] = udp::endpoint(rand_v4(), (rand() % 16534) + 1);
|
|
|
|
announce_item items[] =
|
|
{
|
|
{ generate_next(), 1 },
|
|
{ generate_next(), 2 },
|
|
{ generate_next(), 3 },
|
|
{ generate_next(), 4 },
|
|
{ generate_next(), 5 },
|
|
{ generate_next(), 6 },
|
|
{ generate_next(), 7 },
|
|
{ generate_next(), 8 }
|
|
};
|
|
|
|
for (int i = 0; i < sizeof(items)/sizeof(items[0]); ++i)
|
|
items[i].gen();
|
|
|
|
announce_immutable_items(node, eps, items, sizeof(items)/sizeof(items[0]));
|
|
|
|
key_desc_t desc2[] =
|
|
{
|
|
{ "y", bdecode_node::string_t, 1, 0 }
|
|
};
|
|
|
|
key_desc_t desc_error[] =
|
|
{
|
|
{ "e", bdecode_node::list_t, 2, 0 },
|
|
{ "y", bdecode_node::string_t, 1, 0},
|
|
};
|
|
|
|
// ==== get / put mutable items ===
|
|
|
|
std::pair<char const*, int> itemv;
|
|
std::pair<char const*, int> empty_salt;
|
|
empty_salt.first = NULL;
|
|
empty_salt.second = 0;
|
|
|
|
char signature[item_sig_len];
|
|
char buffer[1200];
|
|
int seq = 4;
|
|
char private_key[item_sk_len];
|
|
char public_key[item_pk_len];
|
|
for (int with_salt = 0; with_salt < 2; ++with_salt)
|
|
{
|
|
seq = 4;
|
|
fprintf(stderr, "\nTEST GET/PUT%s \ngenerating ed25519 keys\n\n"
|
|
, with_salt ? " with-salt" : " no-salt");
|
|
unsigned char seed[32];
|
|
ed25519_create_seed(seed);
|
|
|
|
ed25519_create_keypair((unsigned char*)public_key, (unsigned char*)private_key, seed);
|
|
fprintf(stderr, "pub: %s priv: %s\n"
|
|
, to_hex(std::string(public_key, item_pk_len)).c_str()
|
|
, to_hex(std::string(private_key, item_sk_len)).c_str());
|
|
|
|
TEST_CHECK(ret);
|
|
|
|
std::pair<const char*, int> salt((char*)0, 0);
|
|
if (with_salt)
|
|
salt = std::pair<char const*, int>("foobar", 6);
|
|
|
|
hasher h(public_key, 32);
|
|
if (with_salt) h.update(salt.first, salt.second);
|
|
sha1_hash target_id = h.final();
|
|
|
|
fprintf(stderr, "target_id: %s\n"
|
|
, to_hex(target_id.to_string()).c_str());
|
|
|
|
send_dht_request(node, "get", source, &response, "10", 0
|
|
, 0, no, 0, (char*)&target_id[0]
|
|
, 0, false, false, std::string(), std::string());
|
|
|
|
key_desc_t desc[] =
|
|
{
|
|
{ "r", bdecode_node::dict_t, 0, key_desc_t::parse_children },
|
|
{ "id", bdecode_node::string_t, 20, 0},
|
|
{ "token", bdecode_node::string_t, 0, 0},
|
|
{ "ip", bdecode_node::string_t, 0, key_desc_t::optional | key_desc_t::last_child},
|
|
{ "y", bdecode_node::string_t, 1, 0},
|
|
};
|
|
|
|
ret = verify_message(response, desc, parsed, 5, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[4].string_value(), "r");
|
|
token = parsed[2].string_value();
|
|
fprintf(stderr, "get response: %s\n"
|
|
, print_entry(response).c_str());
|
|
fprintf(stderr, "got token: %s\n", to_hex(token).c_str());
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid get response: %s\n%s\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
itemv = std::pair<char const*, int>(buffer, bencode(buffer, items[0].ent));
|
|
sign_mutable_item(itemv, salt, seq, public_key, private_key, signature);
|
|
TEST_EQUAL(verify_mutable_item(itemv, salt, seq, public_key, signature), true);
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
VALGRIND_CHECK_MEM_IS_DEFINED(signature, item_sig_len);
|
|
#endif
|
|
|
|
send_dht_request(node, "put", source, &response, "10", 0
|
|
, 0, token, 0, 0, &items[0].ent, false, false
|
|
, std::string(public_key, item_pk_len)
|
|
, std::string(signature, item_sig_len), seq, -1, NULL, salt.first);
|
|
|
|
ret = verify_message(response, desc2, parsed, 1, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
fprintf(stderr, "put response: %s\n"
|
|
, print_entry(response).c_str());
|
|
TEST_EQUAL(parsed[0].string_value(), "r");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid put response: %s\n%s\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
send_dht_request(node, "get", source, &response, "10", 0
|
|
, 0, no, 0, (char*)&target_id[0]
|
|
, 0, false, false, std::string(), std::string());
|
|
|
|
fprintf(stderr, "target_id: %s\n"
|
|
, to_hex(target_id.to_string()).c_str());
|
|
|
|
key_desc_t desc3[] =
|
|
{
|
|
{ "r", bdecode_node::dict_t, 0, key_desc_t::parse_children },
|
|
{ "id", bdecode_node::string_t, 20, 0},
|
|
{ "v", bdecode_node::none_t, 0, 0},
|
|
{ "seq", bdecode_node::int_t, 0, 0},
|
|
{ "sig", bdecode_node::string_t, 0, 0},
|
|
{ "ip", bdecode_node::string_t, 0, key_desc_t::optional | key_desc_t::last_child},
|
|
{ "y", bdecode_node::string_t, 1, 0},
|
|
};
|
|
|
|
ret = verify_message(response, desc3, parsed, 7, error_string
|
|
, sizeof(error_string));
|
|
if (ret == 0)
|
|
{
|
|
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
|
|
fprintf(stderr, " invalid get response: %s\n%s\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "get response: %s\n"
|
|
, print_entry(response).c_str());
|
|
char value[1020];
|
|
char* ptr = value;
|
|
int value_len = bencode(ptr, items[0].ent);
|
|
TEST_EQUAL(value_len, parsed[2].data_section().second);
|
|
TEST_CHECK(memcmp(parsed[2].data_section().first, value, value_len) == 0);
|
|
|
|
TEST_EQUAL(seq, parsed[3].int_value());
|
|
}
|
|
|
|
// also test that invalid signatures fail!
|
|
|
|
itemv.second = bencode(buffer, items[0].ent);
|
|
sign_mutable_item(itemv, salt, seq, public_key, private_key, signature);
|
|
TEST_EQUAL(verify_mutable_item(itemv, salt, seq, public_key, signature), 1);
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
VALGRIND_CHECK_MEM_IS_DEFINED(signature, item_sig_len);
|
|
#endif
|
|
// break the signature
|
|
signature[2] ^= 0xaa;
|
|
|
|
fprintf(stderr, "PUT broken signature\n");
|
|
|
|
TEST_CHECK(verify_mutable_item(itemv, salt, seq, public_key, signature) != 1);
|
|
|
|
send_dht_request(node, "put", source, &response, "10", 0
|
|
, 0, token, 0, 0, &items[0].ent, false, false
|
|
, std::string(public_key, item_pk_len)
|
|
, std::string(signature, item_sig_len), seq, -1, NULL, salt.first);
|
|
|
|
ret = verify_message(response, desc_error, parsed, 2, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
fprintf(stderr, "put response: %s\n", print_entry(response).c_str());
|
|
TEST_EQUAL(parsed[1].string_value(), "e");
|
|
// 206 is the code for invalid signature
|
|
TEST_EQUAL(parsed[0].list_int_value_at(0), 206);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid put response: %s\n%s\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
// === test conditional get ===
|
|
|
|
send_dht_request(node, "get", source, &response, "10", 0
|
|
, 0, no, 0, (char*)&target_id[0]
|
|
, 0, false, false, std::string(), std::string(), seq-1);
|
|
|
|
{
|
|
bdecode_node r = response.dict_find_dict("r");
|
|
TEST_CHECK(r.dict_find("v"));
|
|
TEST_CHECK(r.dict_find("k"));
|
|
TEST_CHECK(r.dict_find("sig"));
|
|
}
|
|
|
|
send_dht_request(node, "get", source, &response, "10", 0
|
|
, 0, no, 0, (char*)&target_id[0]
|
|
, 0, false, false, std::string(), std::string(), seq);
|
|
|
|
{
|
|
bdecode_node r = response.dict_find_dict("r");
|
|
TEST_CHECK(!r.dict_find("v"));
|
|
TEST_CHECK(!r.dict_find("k"));
|
|
TEST_CHECK(!r.dict_find("sig"));
|
|
}
|
|
|
|
// === test CAS put ===
|
|
|
|
// this is the sequence number we expect to be there
|
|
boost::uint64_t cas = seq;
|
|
|
|
// increment sequence number
|
|
++seq;
|
|
// put item 1
|
|
itemv.second = bencode(buffer, items[1].ent);
|
|
sign_mutable_item(itemv, salt, seq, public_key, private_key, signature);
|
|
TEST_EQUAL(verify_mutable_item(itemv, salt, seq, public_key, signature), 1);
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
VALGRIND_CHECK_MEM_IS_DEFINED(signature, item_sig_len);
|
|
#endif
|
|
|
|
TEST_CHECK(item_target_id(salt, public_key) == target_id);
|
|
|
|
fprintf(stderr, "PUT CAS 1\n");
|
|
|
|
send_dht_request(node, "put", source, &response, "10", 0
|
|
, 0, token, 0, 0, &items[1].ent, false, false
|
|
, std::string(public_key, item_pk_len)
|
|
, std::string(signature, item_sig_len), seq
|
|
, cas, NULL, salt.first);
|
|
|
|
ret = verify_message(response, desc2, parsed, 1, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
fprintf(stderr, "put response: %s\n"
|
|
, print_entry(response).c_str());
|
|
TEST_EQUAL(parsed[0].string_value(), "r");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid put response: %s\n%s\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
fprintf(stderr, "PUT CAS 2\n");
|
|
|
|
// put the same message again. This should fail because the
|
|
// CAS hash is outdated, it's not the hash of the value that's
|
|
// stored anymore
|
|
send_dht_request(node, "put", source, &response, "10", 0
|
|
, 0, token, 0, 0, &items[1].ent, false, false
|
|
, std::string(public_key, item_pk_len)
|
|
, std::string(signature, item_sig_len), seq
|
|
, cas, NULL, salt.first);
|
|
|
|
ret = verify_message(response, desc_error, parsed, 2, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
fprintf(stderr, "put response: %s\n"
|
|
, print_entry(response).c_str());
|
|
TEST_EQUAL(parsed[1].string_value(), "e");
|
|
// 301 is the error code for CAS hash mismatch
|
|
TEST_EQUAL(parsed[0].list_int_value_at(0), 301);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid put response: %s\n%s\nExpected failure 301 (CAS hash mismatch)\n"
|
|
, error_string, print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
}
|
|
|
|
}
|
|
|
|
// test routing table
|
|
|
|
{
|
|
sett.extended_routing_table = false;
|
|
node_id id = to_hash("1234876923549721020394873245098347598635");
|
|
node_id diff = to_hash("15764f7459456a9453f8719b09547c11d5f34061");
|
|
|
|
routing_table tbl(id, 8, sett, &observer);
|
|
|
|
// insert 256 nodes evenly distributed across the ID space.
|
|
// we expect to fill the top 5 buckets
|
|
for (int i = 0; i < 256; ++i)
|
|
{
|
|
// test a node with the same IP:port changing ID
|
|
add_and_replace(id, diff);
|
|
id[0] = i;
|
|
tbl.node_seen(id, rand_udp_ep(), 20 + (id[19] & 0xff));
|
|
}
|
|
printf("num_active_buckets: %d\n", tbl.num_active_buckets());
|
|
TEST_EQUAL(tbl.num_active_buckets(), 6);
|
|
|
|
#if defined TORRENT_DHT_VERBOSE_LOGGING || defined TORRENT_DEBUG
|
|
tbl.print_state(std::cerr);
|
|
#endif
|
|
}
|
|
|
|
{
|
|
sett.extended_routing_table = true;
|
|
node_id id = to_hash("1234876923549721020394873245098347598635");
|
|
node_id diff = to_hash("15764f7459456a9453f8719b09547c11d5f34061");
|
|
|
|
routing_table tbl(id, 8, sett, &observer);
|
|
for (int i = 0; i < 256; ++i)
|
|
{
|
|
add_and_replace(id, diff);
|
|
id[0] = i;
|
|
tbl.node_seen(id, rand_udp_ep(), 20 + (id[19] & 0xff));
|
|
}
|
|
TEST_EQUAL(tbl.num_active_buckets(), 6);
|
|
|
|
#if defined TORRENT_DHT_VERBOSE_LOGGING || defined TORRENT_DEBUG
|
|
tbl.print_state(std::cerr);
|
|
#endif
|
|
}
|
|
|
|
// test verify_message
|
|
static const key_desc_t msg_desc[] = {
|
|
{"A", bdecode_node::string_t, 4, 0},
|
|
{"B", bdecode_node::dict_t, 0, key_desc_t::optional | key_desc_t::parse_children},
|
|
{"B1", bdecode_node::string_t, 0, 0},
|
|
{"B2", bdecode_node::string_t, 0, key_desc_t::last_child},
|
|
{"C", bdecode_node::dict_t, 0, key_desc_t::optional | key_desc_t::parse_children},
|
|
{"C1", bdecode_node::string_t, 0, 0},
|
|
{"C2", bdecode_node::string_t, 0, key_desc_t::last_child},
|
|
};
|
|
|
|
bdecode_node msg_keys[7];
|
|
|
|
bdecode_node ent;
|
|
|
|
error_code ec;
|
|
char const test_msg[] = "d1:A4:test1:Bd2:B15:test22:B25:test3ee";
|
|
bdecode(test_msg, test_msg + sizeof(test_msg)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
|
|
ret = verify_message(ent, msg_desc, msg_keys, 7, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
TEST_CHECK(msg_keys[0]);
|
|
if (msg_keys[0]) TEST_EQUAL(msg_keys[0].string_value(), "test");
|
|
TEST_CHECK(msg_keys[1]);
|
|
TEST_CHECK(msg_keys[2]);
|
|
if (msg_keys[2]) TEST_EQUAL(msg_keys[2].string_value(), "test2");
|
|
TEST_CHECK(msg_keys[3]);
|
|
if (msg_keys[3]) TEST_EQUAL(msg_keys[3].string_value(), "test3");
|
|
TEST_CHECK(!msg_keys[4]);
|
|
TEST_CHECK(!msg_keys[5]);
|
|
TEST_CHECK(!msg_keys[6]);
|
|
|
|
char const test_msg2[] = "d1:A4:test1:Cd2:C15:test22:C25:test3ee";
|
|
bdecode(test_msg2, test_msg2 + sizeof(test_msg2)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
|
|
ret = verify_message(ent, msg_desc, msg_keys, 7, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(ret);
|
|
TEST_CHECK(msg_keys[0]);
|
|
if (msg_keys[0]) TEST_EQUAL(msg_keys[0].string_value(), "test");
|
|
TEST_CHECK(!msg_keys[1]);
|
|
TEST_CHECK(!msg_keys[2]);
|
|
TEST_CHECK(!msg_keys[3]);
|
|
TEST_CHECK(msg_keys[4]);
|
|
TEST_CHECK(msg_keys[5]);
|
|
if (msg_keys[5]) TEST_EQUAL(msg_keys[5].string_value(), "test2");
|
|
TEST_CHECK(msg_keys[6]);
|
|
if (msg_keys[6]) TEST_EQUAL(msg_keys[6].string_value(), "test3");
|
|
|
|
|
|
char const test_msg3[] = "d1:Cd2:C15:test22:C25:test3ee";
|
|
bdecode(test_msg3, test_msg3 + sizeof(test_msg3)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
|
|
ret = verify_message(ent, msg_desc, msg_keys, 7, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(!ret);
|
|
fprintf(stderr, "%s\n", error_string);
|
|
TEST_EQUAL(error_string, std::string("missing 'A' key"));
|
|
|
|
char const test_msg4[] = "d1:A6:foobare";
|
|
bdecode(test_msg4, test_msg4 + sizeof(test_msg4)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
|
|
ret = verify_message(ent, msg_desc, msg_keys, 7, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(!ret);
|
|
fprintf(stderr, "%s\n", error_string);
|
|
TEST_EQUAL(error_string, std::string("invalid value for 'A'"));
|
|
|
|
char const test_msg5[] = "d1:A4:test1:Cd2:C15:test2ee";
|
|
bdecode(test_msg5, test_msg5 + sizeof(test_msg5)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
|
|
ret = verify_message(ent, msg_desc, msg_keys, 7, error_string
|
|
, sizeof(error_string));
|
|
TEST_CHECK(!ret);
|
|
fprintf(stderr, "%s\n", error_string);
|
|
TEST_EQUAL(error_string, std::string("missing 'C2' key"));
|
|
|
|
// test empty strings [ { "":1 }, "" ]
|
|
char const test_msg6[] = "ld0:i1ee0:e";
|
|
bdecode(test_msg6, test_msg6 + sizeof(test_msg6)-1, ent, ec);
|
|
fprintf(stderr, "%s\n", print_entry(ent).c_str());
|
|
TEST_CHECK(ent.type() == bdecode_node::list_t);
|
|
if (ent.type() == bdecode_node::list_t)
|
|
{
|
|
TEST_CHECK(ent.list_size() == 2);
|
|
if (ent.list_size() == 2)
|
|
{
|
|
TEST_CHECK(ent.list_at(0).dict_find_int_value("") == 1);
|
|
TEST_CHECK(ent.list_at(1).string_value() == "");
|
|
}
|
|
}
|
|
|
|
// test node-id functions
|
|
using namespace libtorrent::dht;
|
|
|
|
TEST_EQUAL(generate_prefix_mask(0), to_hash("0000000000000000000000000000000000000000"));
|
|
TEST_EQUAL(generate_prefix_mask(1), to_hash("8000000000000000000000000000000000000000"));
|
|
TEST_EQUAL(generate_prefix_mask(2), to_hash("c000000000000000000000000000000000000000"));
|
|
TEST_EQUAL(generate_prefix_mask(11), to_hash("ffe0000000000000000000000000000000000000"));
|
|
TEST_EQUAL(generate_prefix_mask(17), to_hash("ffff800000000000000000000000000000000000"));
|
|
TEST_EQUAL(generate_prefix_mask(160), to_hash("ffffffffffffffffffffffffffffffffffffffff"));
|
|
|
|
// test kademlia functions
|
|
|
|
// this is a bit too expensive to do under valgrind
|
|
#ifndef TORRENT_USE_VALGRIND
|
|
for (int i = 0; i < 160; i += 8)
|
|
{
|
|
for (int j = 0; j < 160; j += 8)
|
|
{
|
|
node_id a(0);
|
|
a[(159-i) / 8] = 1 << (i & 7);
|
|
node_id b(0);
|
|
b[(159-j) / 8] = 1 << (j & 7);
|
|
int dist = distance_exp(a, b);
|
|
|
|
TEST_CHECK(dist >= 0 && dist < 160);
|
|
TEST_CHECK(dist == ((i == j)?0:(std::max)(i, j)));
|
|
|
|
for (int k = 0; k < 160; k += 8)
|
|
{
|
|
node_id c(0);
|
|
c[(159-k) / 8] = 1 << (k & 7);
|
|
|
|
bool cmp = compare_ref(a, b, c);
|
|
TEST_CHECK(cmp == (distance(a, c) < distance(b, c)));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
{
|
|
// test kademlia routing table
|
|
dht_settings s;
|
|
s.extended_routing_table = false;
|
|
// s.restrict_routing_ips = false;
|
|
node_id id = to_hash("3123456789abcdef01232456789abcdef0123456");
|
|
const int bucket_size = 10;
|
|
dht::routing_table table(id, bucket_size, s, &observer);
|
|
std::vector<node_entry> nodes;
|
|
TEST_EQUAL(table.size().get<0>(), 0);
|
|
|
|
node_id tmp = id;
|
|
node_id diff = to_hash("15764f7459456a9453f8719b09547c11d5f34061");
|
|
|
|
// test a node with the same IP:port changing ID
|
|
add_and_replace(tmp, diff);
|
|
table.node_seen(tmp, udp::endpoint(address::from_string("4.4.4.4"), 4), 10);
|
|
table.find_node(id, nodes, 0, 10);
|
|
TEST_EQUAL(table.bucket_size(0), 1);
|
|
TEST_EQUAL(table.size().get<0>(), 1);
|
|
TEST_EQUAL(nodes.size(), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
TEST_EQUAL(nodes[0].timeout_count, 0);
|
|
}
|
|
|
|
// set timeout_count to 1
|
|
table.node_failed(tmp, udp::endpoint(address_v4::from_string("4.4.4.4"), 4));
|
|
|
|
nodes.clear();
|
|
table.for_each_node(node_push_back, nop, &nodes);
|
|
TEST_EQUAL(nodes.size(), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
TEST_EQUAL(nodes[0].timeout_count, 1);
|
|
}
|
|
|
|
// add the exact same node again, it should set the timeout_count to 0
|
|
table.node_seen(tmp, udp::endpoint(address::from_string("4.4.4.4"), 4), 10);
|
|
nodes.clear();
|
|
table.for_each_node(node_push_back, nop, &nodes);
|
|
TEST_EQUAL(nodes.size(), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
TEST_EQUAL(nodes[0].timeout_count, 0);
|
|
}
|
|
|
|
// test adding the same IP:port again with a new node ID (should replace the old one)
|
|
add_and_replace(tmp, diff);
|
|
table.node_seen(tmp, udp::endpoint(address::from_string("4.4.4.4"), 4), 10);
|
|
table.find_node(id, nodes, 0, 10);
|
|
TEST_EQUAL(table.bucket_size(0), 1);
|
|
TEST_EQUAL(nodes.size(), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
}
|
|
|
|
// test adding the same node ID again with a different IP (should be ignored)
|
|
table.node_seen(tmp, udp::endpoint(address::from_string("4.4.4.4"), 5), 10);
|
|
table.find_node(id, nodes, 0, 10);
|
|
TEST_EQUAL(table.bucket_size(0), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
}
|
|
|
|
// test adding a node that ends up in the same bucket with an IP
|
|
// very close to the current one (should be ignored)
|
|
// if restrict_routing_ips == true
|
|
table.node_seen(tmp, udp::endpoint(address::from_string("4.4.4.5"), 5), 10);
|
|
table.find_node(id, nodes, 0, 10);
|
|
TEST_EQUAL(table.bucket_size(0), 1);
|
|
if (!nodes.empty())
|
|
{
|
|
TEST_EQUAL(nodes[0].id, tmp);
|
|
TEST_EQUAL(nodes[0].addr(), address_v4::from_string("4.4.4.4"));
|
|
TEST_EQUAL(nodes[0].port(), 4);
|
|
}
|
|
|
|
s.restrict_routing_ips = false;
|
|
|
|
add_and_replace(tmp, diff);
|
|
table.node_seen(id, udp::endpoint(rand_v4(), rand()), 10);
|
|
|
|
nodes.clear();
|
|
for (int i = 0; i < 7000; ++i)
|
|
{
|
|
table.node_seen(tmp, udp::endpoint(rand_v4(), rand()), 20 + (tmp[19] & 0xff));
|
|
add_and_replace(tmp, diff);
|
|
}
|
|
printf("active buckets: %d\n", table.num_active_buckets());
|
|
TEST_EQUAL(table.num_active_buckets(), 10);
|
|
TEST_CHECK(table.size().get<0>() >= 10 * 10);
|
|
//#error test num_global_nodes
|
|
//#error test need_refresh
|
|
|
|
#if defined TORRENT_DHT_VERBOSE_LOGGING || defined TORRENT_DEBUG
|
|
table.print_state(std::cerr);
|
|
#endif
|
|
|
|
table.for_each_node(node_push_back, nop, &nodes);
|
|
|
|
printf("nodes: %d\n", int(nodes.size()));
|
|
|
|
std::vector<node_entry> temp;
|
|
|
|
std::generate(tmp.begin(), tmp.end(), random_byte);
|
|
table.find_node(tmp, temp, 0, nodes.size() * 2);
|
|
printf("returned-all: %d\n", int(temp.size()));
|
|
TEST_EQUAL(temp.size(), nodes.size());
|
|
|
|
// This makes sure enough of the nodes returned are actually
|
|
// part of the closest nodes
|
|
std::set<node_id> duplicates;
|
|
|
|
#ifdef TORRENT_USE_VALGRIND
|
|
const int reps = 3;
|
|
#else
|
|
const int reps = 50;
|
|
#endif
|
|
|
|
for (int r = 0; r < reps; ++r)
|
|
{
|
|
std::generate(tmp.begin(), tmp.end(), random_byte);
|
|
table.find_node(tmp, temp, 0, bucket_size * 2);
|
|
printf("returned: %d\n", int(temp.size()));
|
|
TEST_EQUAL(int(temp.size()), (std::min)(bucket_size * 2, int(nodes.size())));
|
|
|
|
std::sort(nodes.begin(), nodes.end(), boost::bind(&compare_ref
|
|
, boost::bind(&node_entry::id, _1)
|
|
, boost::bind(&node_entry::id, _2), tmp));
|
|
|
|
int expected = std::accumulate(nodes.begin(), nodes.begin() + (bucket_size * 2)
|
|
, 0, boost::bind(&sum_distance_exp, _1, _2, tmp));
|
|
int sum_hits = std::accumulate(temp.begin(), temp.end()
|
|
, 0, boost::bind(&sum_distance_exp, _1, _2, tmp));
|
|
TEST_EQUAL(bucket_size * 2, int(temp.size()));
|
|
printf("expected: %d actual: %d\n", expected, sum_hits);
|
|
TEST_EQUAL(expected, sum_hits);
|
|
|
|
duplicates.clear();
|
|
// This makes sure enough of the nodes returned are actually
|
|
// part of the closest nodes
|
|
for (std::vector<node_entry>::iterator i = temp.begin()
|
|
, end(temp.end()); i != end; ++i)
|
|
{
|
|
TEST_CHECK(duplicates.count(i->id) == 0);
|
|
duplicates.insert(i->id);
|
|
}
|
|
}
|
|
|
|
using namespace libtorrent::dht;
|
|
|
|
char const* ips[] = {
|
|
"124.31.75.21",
|
|
"21.75.31.124",
|
|
"65.23.51.170",
|
|
"84.124.73.14",
|
|
"43.213.53.83",
|
|
};
|
|
|
|
int rs[] = { 1,86,22,65,90 };
|
|
|
|
boost::uint8_t prefixes[][3] =
|
|
{
|
|
{ 0x5f, 0xbf, 0xbf },
|
|
{ 0x5a, 0x3c, 0xe9 },
|
|
{ 0xa5, 0xd4, 0x32 },
|
|
{ 0x1b, 0x03, 0x21 },
|
|
{ 0xe5, 0x6f, 0x6c }
|
|
};
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
{
|
|
address a = address_v4::from_string(ips[i]);
|
|
node_id id = generate_id_impl(a, rs[i]);
|
|
TEST_CHECK(id[0] == prefixes[i][0]);
|
|
TEST_CHECK(id[1] == prefixes[i][1]);
|
|
TEST_CHECK((id[2] & 0xf8) == (prefixes[i][2] & 0xf8));
|
|
|
|
TEST_CHECK(id[19] == rs[i]);
|
|
fprintf(stderr, "IP address: %s r: %d node ID: %s\n", ips[i]
|
|
, rs[i], to_hex(id.to_string()).c_str());
|
|
}
|
|
}
|
|
|
|
// test traversal algorithms
|
|
|
|
dht::key_desc_t find_node_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"q", bdecode_node::string_t, 9, 0},
|
|
{"a", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, 0},
|
|
{"target", bdecode_node::string_t, 20, key_desc_t::optional},
|
|
{"info_hash", bdecode_node::string_t, 20, key_desc_t::optional | key_desc_t::last_child},
|
|
};
|
|
|
|
dht::key_desc_t get_peers_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"q", bdecode_node::string_t, 9, 0},
|
|
{"a", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, 0},
|
|
{"info_hash", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
dht::key_desc_t get_item_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"q", bdecode_node::string_t, 3, 0},
|
|
{"a", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, 0},
|
|
{"target", bdecode_node::string_t, 20, key_desc_t::last_child},
|
|
};
|
|
|
|
// bootstrap
|
|
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
|
|
udp::endpoint initial_node(address_v4::from_string("4.4.4.4"), 1234);
|
|
std::vector<udp::endpoint> nodesv;
|
|
nodesv.push_back(initial_node);
|
|
node.bootstrap(nodesv, boost::bind(&nop));
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, initial_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, find_node_desc, parsed, 7, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_CHECK(parsed[2].string_value() == "find_node"
|
|
|| parsed[2].string_value() == "get_peers");
|
|
|
|
if (parsed[0].string_value() != "q"
|
|
|| (parsed[2].string_value() != "find_node"
|
|
&& parsed[2].string_value() != "get_peers")) break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid find_node request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
udp::endpoint found_node(address_v4::from_string("5.5.5.5"), 2235);
|
|
nodes_t nodes;
|
|
nodes.push_back(found_node);
|
|
g_sent_packets.clear();
|
|
send_dht_response(node, response, initial_node, nodes);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, found_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, find_node_desc, parsed, 7, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_CHECK(parsed[2].string_value() == "find_node"
|
|
|| parsed[2].string_value() == "get_peers");
|
|
if (parsed[0].string_value() != "q" || (parsed[2].string_value() != "find_node"
|
|
&& parsed[2].string_value() == "get_peers")) break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid find_node request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
send_dht_response(node, response, found_node);
|
|
|
|
TEST_CHECK(g_sent_packets.empty());
|
|
TEST_EQUAL(node.num_global_nodes(), 3);
|
|
} while (false);
|
|
|
|
// get_peers
|
|
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node_id target = to_hash("1234876923549721020394873245098347598635");
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
|
|
udp::endpoint initial_node(address_v4::from_string("4.4.4.4"), 1234);
|
|
node.m_table.add_node(initial_node);
|
|
|
|
node.announce(target, 1234, false, get_peers_cb);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, initial_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, get_peers_desc, parsed, 6, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "get_peers");
|
|
TEST_EQUAL(parsed[5].string_value(), target.to_string());
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "get_peers") break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid get_peers request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
std::set<tcp::endpoint> peers[2];
|
|
peers[0].insert(tcp::endpoint(address_v4::from_string("4.1.1.1"), 4111));
|
|
peers[0].insert(tcp::endpoint(address_v4::from_string("4.1.1.2"), 4112));
|
|
peers[0].insert(tcp::endpoint(address_v4::from_string("4.1.1.3"), 4113));
|
|
|
|
udp::endpoint next_node(address_v4::from_string("5.5.5.5"), 2235);
|
|
nodes_t nodes;
|
|
nodes.push_back(next_node);
|
|
|
|
g_sent_packets.clear();
|
|
send_dht_response(node, response, initial_node, nodes, "10", 1234, peers[0]);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, next_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, get_peers_desc, parsed, 6, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "get_peers");
|
|
TEST_EQUAL(parsed[5].string_value(), target.to_string());
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "get_peers") break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid get_peers request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
peers[1].insert(tcp::endpoint(address_v4::from_string("4.1.1.4"), 4114));
|
|
peers[1].insert(tcp::endpoint(address_v4::from_string("4.1.1.5"), 4115));
|
|
peers[1].insert(tcp::endpoint(address_v4::from_string("4.1.1.6"), 4116));
|
|
|
|
g_sent_packets.clear();
|
|
send_dht_response(node, response, next_node, nodes_t(), "11", 1234, peers[1]);
|
|
|
|
for (std::list<std::pair<udp::endpoint, entry> >::iterator i = g_sent_packets.begin()
|
|
, end(g_sent_packets.end()); i != end; ++i)
|
|
{
|
|
// fprintf(stderr, " %s:%d: %s\n", i->first.address().to_string(ec).c_str()
|
|
// , i->first.port(), i->second.to_string().c_str());
|
|
TEST_EQUAL(i->second["q"].string(), "announce_peer");
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
for (std::set<tcp::endpoint>::iterator peer = peers[i].begin(); peer != peers[i].end(); ++peer)
|
|
{
|
|
TEST_CHECK(std::find(g_got_peers.begin(), g_got_peers.end(), *peer) != g_got_peers.end());
|
|
}
|
|
}
|
|
g_got_peers.clear();
|
|
} while (false);
|
|
|
|
// immutable get
|
|
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
|
|
udp::endpoint initial_node(address_v4::from_string("4.4.4.4"), 1234);
|
|
node.m_table.add_node(initial_node);
|
|
|
|
node.get_item(items[0].target, get_item_cb);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, initial_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, get_item_desc, parsed, 6, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "get");
|
|
TEST_EQUAL(parsed[5].string_value(), items[0].target.to_string());
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "get") break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid get request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
send_dht_response(node, response, initial_node, nodes_t(), "10", 1234, std::set<tcp::endpoint>()
|
|
, NULL, &items[0].ent);
|
|
|
|
TEST_CHECK(g_sent_packets.empty());
|
|
TEST_EQUAL(g_got_items.size(), 1);
|
|
if (g_got_items.empty()) break;
|
|
|
|
TEST_EQUAL(g_got_items.front().value(), items[0].ent);
|
|
g_got_items.clear();
|
|
|
|
} while (false);
|
|
|
|
// mutable get
|
|
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
|
|
udp::endpoint initial_node(address_v4::from_string("4.4.4.4"), 1234);
|
|
node.m_table.add_node(initial_node);
|
|
|
|
sha1_hash target = hasher(public_key, item_pk_len).final();
|
|
node.get_item(target, get_item_cb);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), 1);
|
|
if (g_sent_packets.empty()) break;
|
|
TEST_EQUAL(g_sent_packets.front().first, initial_node);
|
|
|
|
lazy_from_entry(g_sent_packets.front().second, response);
|
|
ret = verify_message(response, get_item_desc, parsed, 6, error_string
|
|
, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "get");
|
|
TEST_EQUAL(parsed[5].string_value(), target.to_string());
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "get") break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid get request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
break;
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
|
|
itemv.second = bencode(buffer, items[0].ent);
|
|
sign_mutable_item(itemv, empty_salt, seq, public_key, private_key, signature);
|
|
send_dht_response(node, response, initial_node, nodes_t(), "10", 1234, std::set<tcp::endpoint>()
|
|
, NULL, &items[0].ent, std::string(public_key, item_pk_len), std::string(signature, item_sig_len), seq);
|
|
|
|
TEST_CHECK(g_sent_packets.empty());
|
|
TEST_EQUAL(g_got_items.size(), 1);
|
|
if (g_got_items.empty()) break;
|
|
|
|
TEST_EQUAL(g_got_items.front().value(), items[0].ent);
|
|
TEST_CHECK(memcmp(g_got_items.front().pk().data(), public_key, item_pk_len) == 0);
|
|
TEST_CHECK(memcmp(g_got_items.front().sig().data(), signature, item_sig_len) == 0);
|
|
TEST_EQUAL(g_got_items.front().seq(), seq);
|
|
g_got_items.clear();
|
|
|
|
} while (false);
|
|
|
|
dht::key_desc_t put_immutable_item_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"q", bdecode_node::string_t, 3, 0},
|
|
{"a", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, 0},
|
|
{"token", bdecode_node::string_t, 2, 0},
|
|
{"v", bdecode_node::none_t, 0, key_desc_t::last_child},
|
|
};
|
|
|
|
dht::key_desc_t put_mutable_item_desc[] = {
|
|
{"y", bdecode_node::string_t, 1, 0},
|
|
{"t", bdecode_node::string_t, 2, 0},
|
|
{"q", bdecode_node::string_t, 3, 0},
|
|
{"a", bdecode_node::dict_t, 0, key_desc_t::parse_children},
|
|
{"id", bdecode_node::string_t, 20, 0},
|
|
{"cas", bdecode_node::string_t, 20, key_desc_t::optional},
|
|
{"k", bdecode_node::string_t, item_pk_len, 0},
|
|
{"seq", bdecode_node::int_t, 0, 0},
|
|
{"sig", bdecode_node::string_t, item_sig_len, 0},
|
|
{"token", bdecode_node::string_t, 2, 0},
|
|
{"v", bdecode_node::none_t, 0, key_desc_t::last_child},
|
|
};
|
|
|
|
// immutable put
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
enum { num_test_nodes = 2 };
|
|
node_entry nodes[num_test_nodes] =
|
|
{ node_entry(generate_next(), udp::endpoint(address_v4::from_string("4.4.4.4"), 1234))
|
|
, node_entry(generate_next(), udp::endpoint(address_v4::from_string("5.5.5.5"), 1235)) };
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
node.m_table.add_node(nodes[i]);
|
|
|
|
g_put_item.assign(items[0].ent);
|
|
node.get_item(items[0].target, get_item_cb);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), num_test_nodes);
|
|
if (g_sent_packets.size() != num_test_nodes) break;
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
{
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator packet = find_packet(nodes[i].ep());
|
|
TEST_CHECK(packet != g_sent_packets.end());
|
|
if (packet == g_sent_packets.end()) continue;
|
|
|
|
lazy_from_entry(packet->second, response);
|
|
ret = verify_message(response, get_item_desc, parsed, 6, error_string
|
|
, sizeof(error_string));
|
|
if (!ret)
|
|
{
|
|
fprintf(stderr, " invalid get request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
continue;
|
|
}
|
|
char t[10];
|
|
snprintf(t, sizeof(t), "%02d", i);
|
|
send_dht_response(node, response, nodes[i].ep(), nodes_t(), t, 1234,
|
|
std::set<tcp::endpoint>(), 0, 0, std::string(), std::string(), -1, &nodes[i].id);
|
|
g_sent_packets.erase(packet);
|
|
}
|
|
|
|
TEST_EQUAL(g_put_count, 1);
|
|
TEST_EQUAL(g_sent_packets.size(), num_test_nodes);
|
|
if (g_sent_packets.size() != num_test_nodes) break;
|
|
|
|
itemv.second = bencode(buffer, items[0].ent);
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
{
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator packet = find_packet(nodes[i].ep());
|
|
TEST_CHECK(packet != g_sent_packets.end());
|
|
if (packet == g_sent_packets.end()) continue;
|
|
|
|
lazy_from_entry(packet->second, response);
|
|
ret = verify_message(response, put_immutable_item_desc, parsed, 7
|
|
, error_string, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "put");
|
|
std::pair<const char*, int> v = parsed[6].data_section();
|
|
TEST_EQUAL(v.second, itemv.second);
|
|
TEST_CHECK(memcmp(v.first, itemv.first, itemv.second) == 0);
|
|
char t[10];
|
|
snprintf(t, sizeof(t), "%02d", i);
|
|
TEST_EQUAL(parsed[5].string_value(), t);
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "put") continue;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid immutable put request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
g_put_item.clear();
|
|
g_put_count = 0;
|
|
|
|
} while (false);
|
|
|
|
// mutable put
|
|
g_sent_packets.clear();
|
|
do
|
|
{
|
|
dht::node node(&s, sett, (node_id::min)(), &observer, cnt);
|
|
enum { num_test_nodes = 2 };
|
|
node_entry nodes[num_test_nodes] =
|
|
{ node_entry(generate_next(), udp::endpoint(address_v4::from_string("4.4.4.4"), 1234))
|
|
, node_entry(generate_next(), udp::endpoint(address_v4::from_string("5.5.5.5"), 1235)) };
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
node.m_table.add_node(nodes[i]);
|
|
|
|
sha1_hash target = hasher(public_key, item_pk_len).final();
|
|
g_put_item.assign(items[0].ent, empty_salt, seq, public_key, private_key);
|
|
std::string sig(g_put_item.sig().data(), item_sig_len);
|
|
node.get_item(target, get_item_cb);
|
|
|
|
TEST_EQUAL(g_sent_packets.size(), num_test_nodes);
|
|
if (g_sent_packets.size() != num_test_nodes) break;
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
{
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator packet = find_packet(nodes[i].ep());
|
|
TEST_CHECK(packet != g_sent_packets.end());
|
|
if (packet == g_sent_packets.end()) continue;
|
|
|
|
lazy_from_entry(packet->second, response);
|
|
ret = verify_message(response, get_item_desc, parsed, 6
|
|
, error_string, sizeof(error_string));
|
|
if (!ret)
|
|
{
|
|
fprintf(stderr, " invalid mutable put request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
continue;
|
|
}
|
|
char t[10];
|
|
snprintf(t, sizeof(t), "%02d", i);
|
|
send_dht_response(node, response, nodes[i].ep(), nodes_t(), t, 1234,
|
|
std::set<tcp::endpoint>(), 0, 0, std::string(), std::string(), -1, &nodes[i].id);
|
|
g_sent_packets.erase(packet);
|
|
}
|
|
|
|
TEST_EQUAL(g_put_count, 1);
|
|
TEST_EQUAL(g_sent_packets.size(), num_test_nodes);
|
|
if (g_sent_packets.size() != num_test_nodes) break;
|
|
|
|
itemv.second = bencode(buffer, items[0].ent);
|
|
|
|
for (int i = 0; i < num_test_nodes; ++i)
|
|
{
|
|
std::list<std::pair<udp::endpoint, entry> >::iterator packet = find_packet(nodes[i].ep());
|
|
TEST_CHECK(packet != g_sent_packets.end());
|
|
if (packet == g_sent_packets.end()) continue;
|
|
|
|
lazy_from_entry(packet->second, response);
|
|
ret = verify_message(response, put_mutable_item_desc, parsed, 11
|
|
, error_string, sizeof(error_string));
|
|
if (ret)
|
|
{
|
|
TEST_EQUAL(parsed[0].string_value(), "q");
|
|
TEST_EQUAL(parsed[2].string_value(), "put");
|
|
TEST_EQUAL(parsed[6].string_value(), std::string(public_key, item_pk_len));
|
|
TEST_EQUAL(parsed[7].int_value(), seq);
|
|
TEST_EQUAL(parsed[8].string_value(), sig);
|
|
std::pair<const char*, int> v = parsed[10].data_section();
|
|
TEST_EQUAL(v.second, itemv.second);
|
|
TEST_CHECK(memcmp(v.first, itemv.first, itemv.second) == 0);
|
|
char t[10];
|
|
snprintf(t, sizeof(t), "%02d", i);
|
|
TEST_EQUAL(parsed[9].string_value(), t);
|
|
if (parsed[0].string_value() != "q" || parsed[2].string_value() != "put") continue;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, " invalid put request: %s\n", print_entry(response).c_str());
|
|
TEST_ERROR(error_string);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
g_sent_packets.clear();
|
|
g_put_item.clear();
|
|
g_put_count = 0;
|
|
|
|
} while (false);
|
|
|
|
// test vector 1
|
|
|
|
// test content
|
|
std::pair<char const*, int> test_content("12:Hello World!", 15);
|
|
// test salt
|
|
std::pair<char const*, int> test_salt("foobar", 6);
|
|
|
|
from_hex("77ff84905a91936367c01360803104f92432fcd904a43511876df5cdf3e7e548", 64, public_key);
|
|
from_hex("e06d3183d14159228433ed599221b80bd0a5ce8352e4bdf0262f76786ef1c74d"
|
|
"b7e7a9fea2c0eb269d61e3b38e450a22e754941ac78479d6c54e1faf6037881d", 128, private_key);
|
|
|
|
sign_mutable_item(test_content, empty_salt, 1, public_key
|
|
, private_key, signature);
|
|
|
|
TEST_EQUAL(to_hex(std::string(signature, 64))
|
|
, "305ac8aeb6c9c151fa120f120ea2cfb923564e11552d06a5d856091e5e853cff"
|
|
"1260d3f39e4999684aa92eb73ffd136e6f4f3ecbfda0ce53a1608ecd7ae21f01");
|
|
|
|
sha1_hash target_id = item_target_id(empty_salt, public_key);
|
|
TEST_EQUAL(to_hex(target_id.to_string()), "4a533d47ec9c7d95b1ad75f576cffc641853b750");
|
|
|
|
// test vector 2 (the keypair is the same as test 1)
|
|
|
|
sign_mutable_item(test_content, test_salt, 1, public_key
|
|
, private_key, signature);
|
|
|
|
TEST_EQUAL(to_hex(std::string(signature, 64))
|
|
, "6834284b6b24c3204eb2fea824d82f88883a3d95e8b4a21b8c0ded553d17d17d"
|
|
"df9a8a7104b1258f30bed3787e6cb896fca78c58f8e03b5f18f14951a87d9a08");
|
|
|
|
target_id = item_target_id(test_salt, public_key);
|
|
TEST_EQUAL(to_hex(target_id.to_string()), "411eba73b6f087ca51a3795d9c8c938d365e32c1");
|
|
|
|
// test vector 3
|
|
|
|
target_id = item_target_id(test_content);
|
|
TEST_EQUAL(to_hex(target_id.to_string()), "e5f96f6f38320f0f33959cb4d3d656452117aadb");
|
|
}
|
|
|
|
#endif
|
|
|