Inside Bitcoin

1// Copyright (c) 2012-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <addrdb.h>
6#include <addrman.h>
7#include <addrman_impl.h>
8#include <chainparams.h>
9#include <clientversion.h>
10#include <hash.h>
11#include <netbase.h>
12#include <netgroup.h>
13#include <random.h>
14#include <test/data/asmap.raw.h>
15#include <test/util/common.h>
16#include <test/util/setup_common.h>
17#include <test/util/time.h>
18#include <util/asmap.h>
19#include <util/string.h>
20
21#include <boost/test/unit_test.hpp>
22
23#include <cstdint>
24#include <optional>
25#include <string>
26
27using namespace std::literals;
28using node::NodeContext;
29using util::ToString;
30
31static auto EMPTY_NETGROUPMAN{NetGroupManager::NoAsmap()};
32static const bool DETERMINISTIC{true};
33
34static int32_t GetCheckRatio(const NodeContext& node_ctx)
35{
36    return std::clamp<int32_t>(node_ctx.args->GetIntArg("-checkaddrman", 100), 0, 1000000);
37}
38
39static CNetAddr ResolveIP(const std::string& ip)
40{
41    const std::optional<CNetAddr> addr{LookupHost(ip, false)};
42    BOOST_CHECK_MESSAGE(addr.has_value(), strprintf("failed to resolve: %s", ip));
43    return addr.value_or(CNetAddr{});
44}
45
46static CService ResolveService(const std::string& ip, uint16_t port = 0)
47{
48    const std::optional<CService> serv{Lookup(ip, port, false)};
49    BOOST_CHECK_MESSAGE(serv.has_value(), strprintf("failed to resolve: %s:%i", ip, port));
50    return serv.value_or(CService{});
51}
52
53BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)
54
55BOOST_AUTO_TEST_CASE(addrman_simple)
56{
57    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
58
59    CNetAddr source = ResolveIP("252.2.2.2");
60
61    // Test: Does Addrman respond correctly when empty.
62    BOOST_CHECK_EQUAL(addrman->Size(), 0U);
63    auto addr_null = addrman->Select().first;
64    BOOST_CHECK_EQUAL(addr_null.ToStringAddrPort(), "[::]:0");
65
66    // Test: Does Addrman::Add work as expected.
67    CService addr1 = ResolveService("250.1.1.1", 8333);
68    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
69    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
70    auto addr_ret1 = addrman->Select().first;
71    BOOST_CHECK_EQUAL(addr_ret1.ToStringAddrPort(), "250.1.1.1:8333");
72
73    // Test: Does IP address deduplication work correctly.
74    //  Expected dup IP should not be added.
75    CService addr1_dup = ResolveService("250.1.1.1", 8333);
76    BOOST_CHECK(!addrman->Add({CAddress(addr1_dup, NODE_NONE)}, source));
77    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
78
79
80    // Test: New table has one addr and we add a diff addr we should
81    //  have at least one addr.
82    // Note that addrman's size cannot be tested reliably after insertion, as
83    // hash collisions may occur. But we can always be sure of at least one
84    // success.
85
86    CService addr2 = ResolveService("250.1.1.2", 8333);
87    BOOST_CHECK(addrman->Add({CAddress(addr2, NODE_NONE)}, source));
88    BOOST_CHECK(addrman->Size() >= 1);
89
90    // Test: reset addrman and test AddrMan::Add multiple addresses works as expected
91    addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
92    std::vector<CAddress> vAddr;
93    vAddr.emplace_back(ResolveService("250.1.1.3", 8333), NODE_NONE);
94    vAddr.emplace_back(ResolveService("250.1.1.4", 8333), NODE_NONE);
95    BOOST_CHECK(addrman->Add(vAddr, source));
96    BOOST_CHECK(addrman->Size() >= 1);
97}
98
99
100BOOST_AUTO_TEST_CASE(addrman_terrible_many_failures)
101{
102    FakeNodeClock clock{};
103
104    auto addrman{std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node))};
105
106    CNetAddr source{ResolveIP("250.1.2.1")};
107    CAddress addr{CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE)};
108    addr.nTime = Now<NodeSeconds>();
109
110    BOOST_CHECK(addrman->Add({addr}, source));
111    BOOST_CHECK(addrman->Good(addr));
112
113    clock += ADDRMAN_MIN_FAIL + 24h;
114
115    CAddress addr_helper{CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE)};
116    addr_helper.nTime = Now<NodeSeconds>();
117    BOOST_CHECK(addrman->Add({addr_helper}, source));
118    BOOST_CHECK(addrman->Good(addr_helper));
119
120    for (int i = 0; i < ADDRMAN_MAX_FAILURES; ++i) {
121        // Use a time > 60s ago so IsTerrible doesn't bail out at the "tried in the last minute" check
122        addrman->Attempt(addr, /*fCountFailure=*/true, Now<NodeSeconds>() - 61s);
123    }
124
125    std::vector<CAddress> filtered{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
126    BOOST_CHECK_EQUAL(filtered.size(), 1U);
127    BOOST_CHECK_EQUAL(filtered[0].ToStringAddrPort(), "251.252.2.3:8333");
128
129    std::vector<CAddress> unfiltered{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt, /*filtered=*/false)};
130    BOOST_CHECK_EQUAL(unfiltered.size(), 2U);
131}
132
133
134BOOST_AUTO_TEST_CASE(addrman_penalty_self_announcement)
135{
136    FakeNodeClock clock{};
137    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
138
139    const auto base_time{Now<NodeSeconds>() - 10000s};
140    CService addr1 = ResolveService("250.1.1.1", 8333);
141    CNetAddr source1 = ResolveIP("250.1.1.1"); // Same as addr1 - self announcement
142
143    CAddress caddr1(addr1, NODE_NONE);
144    caddr1.nTime = base_time;
145
146    const auto time_penalty{3600s};
147
148    BOOST_CHECK(addrman->Add({caddr1}, source1, time_penalty));
149
150    auto addr_pos1{addrman->FindAddressEntry(caddr1)};
151    BOOST_REQUIRE(addr_pos1.has_value());
152
153    std::vector<CAddress> addresses{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
154    BOOST_REQUIRE_EQUAL(addresses.size(), 1U);
155
156    BOOST_CHECK(addresses[0].nTime == base_time);
157
158    CService addr2{ResolveService("250.1.1.2", 8333)};
159    CNetAddr source2{ResolveIP("250.1.1.3")}; // Different from addr2 - not self announcement
160
161    CAddress caddr2(addr2, NODE_NONE);
162    caddr2.nTime = base_time;
163
164    BOOST_CHECK(addrman->Add({caddr2}, source2, time_penalty));
165
166    addresses = addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt);
167    BOOST_REQUIRE_EQUAL(addresses.size(), 2U);
168
169    CAddress retrieved_addr2{addresses[0]};
170    BOOST_CHECK(retrieved_addr2.nTime == base_time - time_penalty);
171}
172
173BOOST_AUTO_TEST_CASE(addrman_ports)
174{
175    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
176
177    CNetAddr source = ResolveIP("252.2.2.2");
178
179    BOOST_CHECK_EQUAL(addrman->Size(), 0U);
180
181    // Test 7; Addr with same IP but diff port does not replace existing addr.
182    CService addr1 = ResolveService("250.1.1.1", 8333);
183    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
184    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
185
186    CService addr1_port = ResolveService("250.1.1.1", 8334);
187    BOOST_CHECK(addrman->Add({CAddress(addr1_port, NODE_NONE)}, source));
188    BOOST_CHECK_EQUAL(addrman->Size(), 2U);
189    auto addr_ret2 = addrman->Select().first;
190    BOOST_CHECK(addr_ret2.ToStringAddrPort() == "250.1.1.1:8333" || addr_ret2.ToStringAddrPort() == "250.1.1.1:8334");
191
192    // Test: Add same IP but diff port to tried table; this converts the entry with
193    // the specified port to tried, but not the other.
194    addrman->Good(CAddress(addr1_port, NODE_NONE));
195    BOOST_CHECK_EQUAL(addrman->Size(), 2U);
196    bool new_only = true;
197    auto addr_ret3 = addrman->Select(new_only).first;
198    BOOST_CHECK_EQUAL(addr_ret3.ToStringAddrPort(), "250.1.1.1:8333");
199}
200
201BOOST_AUTO_TEST_CASE(addrman_select)
202{
203    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
204    BOOST_CHECK(!addrman->Select(false).first.IsValid());
205    BOOST_CHECK(!addrman->Select(true).first.IsValid());
206
207    CNetAddr source = ResolveIP("252.2.2.2");
208
209    // Add 1 address to the new table
210    CService addr1 = ResolveService("250.1.1.1", 8333);
211    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
212    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
213
214    BOOST_CHECK(addrman->Select(/*new_only=*/true).first == addr1);
215    BOOST_CHECK(addrman->Select(/*new_only=*/false).first == addr1);
216
217    // Move address to the tried table
218    BOOST_CHECK(addrman->Good(CAddress(addr1, NODE_NONE)));
219
220    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
221    BOOST_CHECK(!addrman->Select(/*new_only=*/true).first.IsValid());
222    BOOST_CHECK(addrman->Select().first == addr1);
223    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
224
225    // Add one address to the new table
226    CService addr2 = ResolveService("250.3.1.1", 8333);
227    BOOST_CHECK(addrman->Add({CAddress(addr2, NODE_NONE)}, addr2));
228    BOOST_CHECK(addrman->Select(/*new_only=*/true).first == addr2);
229
230    // Add two more addresses to the new table
231    CService addr3 = ResolveService("250.3.2.2", 9999);
232    CService addr4 = ResolveService("250.3.3.3", 9999);
233
234    BOOST_CHECK(addrman->Add({CAddress(addr3, NODE_NONE)}, addr2));
235    BOOST_CHECK(addrman->Add({CAddress(addr4, NODE_NONE)}, ResolveService("250.4.1.1", 8333)));
236
237    // Add three addresses to tried table.
238    CService addr5 = ResolveService("250.4.4.4", 8333);
239    CService addr6 = ResolveService("250.4.5.5", 7777);
240    CService addr7 = ResolveService("250.4.6.6", 8333);
241
242    BOOST_CHECK(addrman->Add({CAddress(addr5, NODE_NONE)}, addr3));
243    BOOST_CHECK(addrman->Good(CAddress(addr5, NODE_NONE)));
244    BOOST_CHECK(addrman->Add({CAddress(addr6, NODE_NONE)}, addr3));
245    BOOST_CHECK(addrman->Good(CAddress(addr6, NODE_NONE)));
246    BOOST_CHECK(addrman->Add({CAddress(addr7, NODE_NONE)}, ResolveService("250.1.1.3", 8333)));
247    BOOST_CHECK(addrman->Good(CAddress(addr7, NODE_NONE)));
248
249    // 6 addrs + 1 addr from last test = 7.
250    BOOST_CHECK_EQUAL(addrman->Size(), 7U);