8 #include <chainparams.h>
13 #include <test/data/asmap.raw.h>
18 #include <boost/test/unit_test.hpp>
23 using namespace std::literals;
31 return std::clamp<int32_t>(node_ctx.
args->
GetIntArg(
"-checkaddrman", 100), 0, 1000000);
36 const std::optional<CNetAddr> addr{
LookupHost(
ip,
false)};
37 BOOST_CHECK_MESSAGE(addr.has_value(),
strprintf(
"failed to resolve: %s",
ip));
43 const std::optional<CService> serv{
Lookup(
ip, port,
false)};
44 BOOST_CHECK_MESSAGE(serv.has_value(),
strprintf(
"failed to resolve: %s:%i",
ip, port));
51 std::vector<bool> result(vector_size);
52 for (
int byte_i = 0; byte_i < vector_size / 8; ++byte_i) {
53 unsigned char cur_byte =
source[byte_i];
54 for (
int bit_i = 0; bit_i < 8; ++bit_i) {
55 result[byte_i * 8 + bit_i] = (cur_byte >> bit_i) & 1;
71 auto addr_null = addrman->Select().first;
78 auto addr_ret1 = addrman->Select().first;
100 std::vector<CAddress> vAddr;
123 auto addr_ret2 = addrman->Select().first;
124 BOOST_CHECK(addr_ret2.ToStringAddrPort() ==
"250.1.1.1:8333" || addr_ret2.ToStringAddrPort() ==
"250.1.1.1:8334");
130 bool new_only =
true;
131 auto addr_ret3 = addrman->Select(new_only).first;
138 BOOST_CHECK(!addrman->Select(
false).first.IsValid());
139 BOOST_CHECK(!addrman->Select(
true).first.IsValid());
155 BOOST_CHECK(!addrman->Select(
true).first.IsValid());
176 BOOST_CHECK(addrman->Add({CAddress(addr5, NODE_NONE)}, addr3));
178 BOOST_CHECK(addrman->Add({CAddress(addr6, NODE_NONE)}, addr3));
187 std::set<uint16_t> ports;
188 for (
int i = 0; i < 20; ++i) {
189 ports.insert(addrman->Select().first.GetPort());
216 i2p_addr.
SetSpecial(
"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p");
234 i2p_addr2.
SetSpecial(
"c4gfnttsuwqomiygupdqqqyy5y5emnk5c73hrfvatri67prd7vyq.b32.i2p");
240 bool new_selected{
false};
241 bool tried_selected{
false};
244 while (--counter > 0 && (!new_selected || !tried_selected)) {
246 BOOST_REQUIRE(selected == i2p_addr || selected == i2p_addr2);
247 if (selected == i2p_addr) {
248 tried_selected =
true;
267 i2p_addr.
SetSpecial(
"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p");
287 uint32_t num_addrs{0};
291 while (num_addrs < 22) {
301 uint32_t collisions{1};
314 const auto start_time{Now<NodeSeconds>()};
315 addr.
nTime = start_time;
318 for (
unsigned int i = 1; i < 20; ++i) {
319 std::string addr_ip{
ToString(i % 256) +
"." +
ToString(i >> 8 % 256) +
".1.1"};
321 addrman->Add({addr},
source);
330 for (
unsigned int i = 1; i < 400; ++i) {
331 std::string addr_ip{
ToString(i % 256) +
"." +
ToString(i >> 8 % 256) +
".1.1"};
333 addr.nTime = start_time + std::chrono::seconds{i};
334 addrman->Add({addr},
source);
336 AddressPosition addr_pos_multi = addrman->FindAddressEntry(addr).value();
348 uint32_t num_addrs{0};
352 while (num_addrs < 35) {
380 std::vector<CAddress> vAddr1 = addrman->GetAddr(0, 0, std::nullopt);
384 addr1.nTime = Now<NodeSeconds>();
386 addr2.nTime = Now<NodeSeconds>();
388 addr3.
nTime = Now<NodeSeconds>();
390 addr4.
nTime = Now<NodeSeconds>();
392 addr5.
nTime = Now<NodeSeconds>();
397 BOOST_CHECK(addrman->Add({addr1, addr3, addr5}, source1));
398 BOOST_CHECK(addrman->Add({addr2, addr4}, source2));
411 for (
unsigned int i = 1; i < (8 * 256); i++) {
412 int octet1 = i % 256;
413 int octet2 = i >> 8 % 256;
418 addr.
nTime = Now<NodeSeconds>();
419 addrman->Add({addr},
ResolveIP(strAddr));
423 std::vector<CAddress> vAddr = addrman->GetAddr(2500, 23, std::nullopt);
425 size_t percent23 = (addrman->Size() * 23) / 100;
438 addr1.nTime = Now<NodeSeconds>();
477 std::set<int> buckets;
478 for (
int i = 0; i < 255; i++) {
483 buckets.insert(bucket);
490 for (
int j = 0; j < 255; j++) {
495 buckets.insert(bucket);
527 std::set<int> buckets;
528 for (
int i = 0; i < 255; i++) {
533 buckets.insert(bucket);
540 for (
int j = 0; j < 4 * 255; j++) {
546 buckets.insert(bucket);
553 for (
int p = 0; p < 255; p++) {
558 buckets.insert(bucket);
578 std::vector<bool> asmap =
FromBytes(asmap_raw,
sizeof(asmap_raw) * 8);
605 std::set<int> buckets;
606 for (
int j = 0; j < 255; j++) {
611 buckets.insert(bucket);
618 for (
int j = 0; j < 255; j++) {
623 buckets.insert(bucket);
632 std::vector<bool> asmap =
FromBytes(asmap_raw,
sizeof(asmap_raw) * 8);
658 std::set<int> buckets;
659 for (
int i = 0; i < 255; i++) {
664 buckets.insert(bucket);
671 for (
int j = 0; j < 4 * 255; j++) {
677 buckets.insert(bucket);
684 for (
int p = 0; p < 255; p++) {
689 buckets.insert(bucket);
696 for (
int p = 0; p < 255; p++) {
701 buckets.insert(bucket);
710 std::vector<bool> asmap1 =
FromBytes(asmap_raw,
sizeof(asmap_raw) * 8);
714 auto addrman_asmap1 = std::make_unique<AddrMan>(netgroupman,
DETERMINISTIC, ratio);
715 auto addrman_asmap1_dup = std::make_unique<AddrMan>(netgroupman,
DETERMINISTIC, ratio);
723 addrman_asmap1->Add({addr}, default_source);
725 stream << *addrman_asmap1;
727 stream >> *addrman_asmap1_dup;
729 AddressPosition addr_pos1 = addrman_asmap1->FindAddressEntry(addr).value();
730 AddressPosition addr_pos2 = addrman_asmap1_dup->FindAddressEntry(addr).value();
737 stream << *addrman_asmap1;
738 stream >> *addrman_noasmap;
739 AddressPosition addr_pos3 = addrman_noasmap->FindAddressEntry(addr).value();
745 addrman_asmap1 = std::make_unique<AddrMan>(netgroupman,
DETERMINISTIC, ratio);
747 addrman_noasmap->Add({addr}, default_source);
748 stream << *addrman_noasmap;
749 stream >> *addrman_asmap1;
751 AddressPosition addr_pos4 = addrman_asmap1->FindAddressEntry(addr).value();
757 addrman_asmap1 = std::make_unique<AddrMan>(netgroupman,
DETERMINISTIC, ratio);
761 addrman_noasmap->Add({addr,
addr2}, default_source);
765 stream << *addrman_noasmap;
766 stream >> *addrman_asmap1;
785 addrman->Add({new1, tried1, new2, tried2},
CNetAddr{});
786 addrman->Good(tried1);
787 addrman->Good(tried2);
788 BOOST_REQUIRE_EQUAL(addrman->Size(), 4);
792 const std::string str{stream.str()};
795 const char new2_raw[]{6, 6, 6, 6};
796 const uint8_t new2_raw_replacement[]{0, 0, 0, 0};
797 pos = str.find(new2_raw, 0,
sizeof(new2_raw));
798 BOOST_REQUIRE(pos != std::string::npos);
799 BOOST_REQUIRE(pos +
sizeof(new2_raw_replacement) <= stream.size());
800 memcpy(stream.data() + pos, new2_raw_replacement,
sizeof(new2_raw_replacement));
802 const char tried2_raw[]{8, 8, 8, 8};
803 const uint8_t tried2_raw_replacement[]{255, 255, 255, 255};
804 pos = str.find(tried2_raw, 0,
sizeof(tried2_raw));
805 BOOST_REQUIRE(pos != std::string::npos);
806 BOOST_REQUIRE(pos +
sizeof(tried2_raw_replacement) <= stream.size());
807 memcpy(stream.data() + pos, tried2_raw_replacement,
sizeof(tried2_raw_replacement));
821 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
825 for (
unsigned int i = 1; i < 23; i++) {
831 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
836 for (
unsigned int i = 1; i < 23; i++) {
843 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
853 for (
unsigned int i = 1; i < 36; i++) {
865 BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(),
"250.1.1.19:0");
870 addrman->ResolveCollisions();
871 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
874 for (
unsigned int i = 37; i < 59; i++) {
885 BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(),
"250.1.1.10:0");
892 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() !=
"[::]:0");
895 addrman->ResolveCollisions();
896 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
906 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
910 for (
unsigned int i = 1; i < 36; i++) {
923 auto info = addrman->SelectTriedCollision().first;
929 addrman->Attempt(info,
false, Now<NodeSeconds>() - 61s);
932 addrman->ResolveCollisions();
933 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
942 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
948 BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(),
"250.1.1.36:0");
952 addrman->ResolveCollisions();
953 BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() ==
"[::]:0");
965 ssPeersIn << addrman;
973 std::optional<CService>
addr1,
addr2, addr3, addr4;
978 addr3 =
Lookup(
"250.7.3.3", 9999,
false);
980 addr3 =
Lookup(
"250.7.3.3"s, 9999,
false);
982 addr4 =
Lookup(
"250.7.3.3\0example.com"s, 9999,
false);
986 const std::optional<CService>
source{
Lookup(
"252.5.1.1", 8333,
false)};
994 bool exceptionThrown =
false;
999 unsigned char pchMsgTmp[4];
1000 ssPeers1 >> pchMsgTmp;
1001 ssPeers1 >> addrman1;
1002 }
catch (
const std::exception&) {
1003 exceptionThrown =
true;
1024 unsigned char nVersion = 1;
1026 s << ((
unsigned char)32);
1034 const std::optional<CService> serv{
Lookup(
"252.1.1.1", 7777,
false)};
1035 BOOST_REQUIRE(serv.has_value());
1037 std::optional<CNetAddr> resolved{
LookupHost(
"252.2.2.2",
false)};
1038 BOOST_REQUIRE(resolved.has_value());
1049 bool exceptionThrown =
false;
1053 unsigned char pchMsgTmp[4];
1054 ssPeers1 >> pchMsgTmp;
1055 ssPeers1 >> addrman1;
1056 }
catch (
const std::exception&) {
1057 exceptionThrown =
true;
1076 const auto start_time{Now<NodeSeconds>() - 10000s};
1077 addr.
nTime = start_time;
1083 addr_diff_port.
nTime = start_time;
1084 addrman->Connected(addr_diff_port);
1086 std::vector<CAddress> vAddr1{addrman->GetAddr(0, 0, std::nullopt)};
1092 addrman->Connected(addr);
1094 std::vector<CAddress> vAddr2 = addrman->GetAddr(0, 0, std::nullopt);
1096 BOOST_CHECK(vAddr2.at(0).nTime >= start_time + 10000s);
1101 addr_v2.
nTime = start_time;
1103 std::vector<CAddress> vAddr3{addrman->GetAddr(0, 0, std::nullopt)};
1109 std::vector<CAddress> vAddr4{addrman->GetAddr(0, 0, std::nullopt)};
1115 std::vector<CAddress> vAddr5{addrman->GetAddr(0, 0, std::nullopt)};
1121 std::vector<CAddress> vAddr6{addrman->GetAddr(0, 0, std::nullopt)};
1153 i2p_addr.
SetSpecial(
"UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P");
void ReadFromStream(AddrMan &addr, DataStream &ssPeers)
Only used by tests.
static constexpr int ADDRMAN_NEW_BUCKET_COUNT
static NetGroupManager EMPTY_NETGROUPMAN
static CService ResolveService(const std::string &ip, uint16_t port=0)
static int32_t GetCheckRatio(const NodeContext &node_ctx)
static auto AddrmanToStream(const AddrMan &addrman)
static const bool DETERMINISTIC
BOOST_AUTO_TEST_CASE(addrman_simple)
static auto MakeCorruptPeersDat()
static std::vector< bool > FromBytes(const unsigned char *source, int vector_size)
static CNetAddr ResolveIP(const std::string &ip)
const CChainParams & Params()
Return the currently selected parameters.
Extended statistics about a CAddress.
int GetNewBucket(const uint256 &nKey, const CNetAddr &src, const NetGroupManager &netgroupman) const
Calculate in which "new" bucket this entry belongs, given a certain source.
int GetTriedBucket(const uint256 &nKey, const NetGroupManager &netgroupman) const
Calculate in which "tried" bucket this entry belongs.
Stochastic address manager.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
A CService with information about it as peer.
NodeSeconds nTime
Always included in serialization. The behavior is unspecified if the value is not representable as ui...
static constexpr SerParams V1_DISK
const MessageStartChars & MessageStart() const
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
A combination of a network address (CNetAddr) and a (TCP) port.
std::vector< unsigned char > GetKey() const
Double ended buffer combining vector and stream-like interfaces.
A writer stream (for serialization) that computes a 256-bit hash.
BOOST_AUTO_TEST_SUITE_END()
static CService ip(uint32_t i)
static const std::string addr1
static const std::string addr2
@ NET_ONION
TOR (v2 or v3)
std::vector< CService > Lookup(const std::string &name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function)
Resolve a service string to its corresponding service.
std::vector< CNetAddr > LookupHost(const std::string &name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
#define BOOST_CHECK_THROW(stmt, excMatch)
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Location information for an address in AddrMan.
NodeContext struct containing references to chain state and connection state.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
std::chrono::time_point< NodeClock, std::chrono::seconds > NodeSeconds