Inside Bitcoin

251
252    // Select pulls from new and tried regardless of port number.
253    std::set<uint16_t> ports;
254    for (int i = 0; i < 20; ++i) {
255        ports.insert(addrman->Select().first.GetPort());
256    }
257    BOOST_CHECK_EQUAL(ports.size(), 3U);
258}
259
260BOOST_AUTO_TEST_CASE(addrman_select_by_network)
261{
262    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
263    BOOST_CHECK(!addrman->Select(/*new_only=*/true, {NET_IPV4}).first.IsValid());
264    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_IPV4}).first.IsValid());
265
266    // add ipv4 address to the new table
267    CNetAddr source = ResolveIP("252.2.2.2");
268    CService addr1 = ResolveService("250.1.1.1", 8333);
269    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
270
271    BOOST_CHECK(addrman->Select(/*new_only=*/true, {NET_IPV4}).first == addr1);
272    BOOST_CHECK(addrman->Select(/*new_only=*/false, {NET_IPV4}).first == addr1);
273    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_IPV6}).first.IsValid());
274    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_ONION}).first.IsValid());
275    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_I2P}).first.IsValid());
276    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_CJDNS}).first.IsValid());
277    BOOST_CHECK(!addrman->Select(/*new_only=*/true, {NET_CJDNS}).first.IsValid());
278    BOOST_CHECK(addrman->Select(/*new_only=*/false).first == addr1);
279
280    // add I2P address to the new table
281    CAddress i2p_addr;
282    i2p_addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p");
283    BOOST_CHECK(addrman->Add({i2p_addr}, source));
284
285    BOOST_CHECK(addrman->Select(/*new_only=*/true, {NET_I2P}).first == i2p_addr);
286    BOOST_CHECK(addrman->Select(/*new_only=*/false, {NET_I2P}).first == i2p_addr);
287    BOOST_CHECK(addrman->Select(/*new_only=*/false, {NET_IPV4}).first == addr1);
288    std::unordered_set<Network> nets_with_entries = {NET_IPV4, NET_I2P};
289    BOOST_CHECK(addrman->Select(/*new_only=*/false, nets_with_entries).first.IsValid());
290    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_IPV6}).first.IsValid());
291    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_ONION}).first.IsValid());
292    BOOST_CHECK(!addrman->Select(/*new_only=*/false, {NET_CJDNS}).first.IsValid());
293    std::unordered_set<Network> nets_without_entries = {NET_IPV6, NET_ONION, NET_CJDNS};
294    BOOST_CHECK(!addrman->Select(/*new_only=*/false, nets_without_entries).first.IsValid());
295
296    // bump I2P address to tried table
297    BOOST_CHECK(addrman->Good(i2p_addr));
298
299    BOOST_CHECK(!addrman->Select(/*new_only=*/true, {NET_I2P}).first.IsValid());
300    BOOST_CHECK(addrman->Select(/*new_only=*/false, {NET_I2P}).first == i2p_addr);
301
302    // add another I2P address to the new table
303    CAddress i2p_addr2;
304    i2p_addr2.SetSpecial("c4gfnttsuwqomiygupdqqqyy5y5emnk5c73hrfvatri67prd7vyq.b32.i2p");
305    BOOST_CHECK(addrman->Add({i2p_addr2}, source));
306
307    BOOST_CHECK(addrman->Select(/*new_only=*/true, {NET_I2P}).first == i2p_addr2);
308
309    // ensure that both new and tried table are selected from
310    bool new_selected{false};
311    bool tried_selected{false};
312    int counter = 256;
313
314    while (--counter > 0 && (!new_selected || !tried_selected)) {
315        const CAddress selected{addrman->Select(/*new_only=*/false, {NET_I2P}).first};
316        BOOST_REQUIRE(selected == i2p_addr || selected == i2p_addr2);
317        if (selected == i2p_addr) {
318            tried_selected = true;
319        } else {
320            new_selected = true;
321        }
322    }
323
324    BOOST_CHECK(new_selected);
325    BOOST_CHECK(tried_selected);
326}
327
328BOOST_AUTO_TEST_CASE(addrman_select_special)
329{
330    // use a non-deterministic addrman to ensure a passing test isn't due to setup
331    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, /*deterministic=*/false, GetCheckRatio(m_node));
332
333    CNetAddr source = ResolveIP("252.2.2.2");
334
335    // add I2P address to the tried table
336    CAddress i2p_addr;
337    i2p_addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p");
338    BOOST_CHECK(addrman->Add({i2p_addr}, source));
339    BOOST_CHECK(addrman->Good(i2p_addr));
340
341    // add ipv4 address to the new table
342    CService addr1 = ResolveService("250.1.1.3", 8333);
343    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
344
345    // since the only ipv4 address is on the new table, ensure that the new
346    // table gets selected even if new_only is false. if the table was being
347    // selected at random, this test will sporadically fail
348    BOOST_CHECK(addrman->Select(/*new_only=*/false, {NET_IPV4}).first == addr1);
349}
350
351BOOST_AUTO_TEST_CASE(addrman_new_collisions)
352{
353    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
354
355    CNetAddr source = ResolveIP("252.2.2.2");
356
357    uint32_t num_addrs{0};
358
359    BOOST_CHECK_EQUAL(addrman->Size(), num_addrs);
360
361    while (num_addrs < 22) { // Magic number! 250.1.1.1 - 250.1.1.22 do not collide with deterministic key = 1
362        CService addr = ResolveService("250.1.1." + ToString(++num_addrs));
363        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
364
365        // Test: No collision in new table yet.
366        BOOST_CHECK_EQUAL(addrman->Size(), num_addrs);
367    }
368
369    // Test: new table collision!
370    CService addr1 = ResolveService("250.1.1." + ToString(++num_addrs));
371    uint32_t collisions{1};
372    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
373    BOOST_CHECK_EQUAL(addrman->Size(), num_addrs - collisions);
374
375    CService addr2 = ResolveService("250.1.1." + ToString(++num_addrs));
376    BOOST_CHECK(addrman->Add({CAddress(addr2, NODE_NONE)}, source));
377    BOOST_CHECK_EQUAL(addrman->Size(), num_addrs - collisions);
378}
379
380BOOST_AUTO_TEST_CASE(addrman_new_multiplicity)
381{
382    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
383    CAddress addr{CAddress(ResolveService("253.3.3.3", 8333), NODE_NONE)};
384    const auto start_time{Now<NodeSeconds>()};
385    addr.nTime = start_time;
386
387    // test that multiplicity stays at 1 if nTime doesn't increase
388    for (unsigned int i = 1; i < 20; ++i) {
389        std::string addr_ip{ToString(i % 256) + "." + ToString(i >> 8 % 256) + ".1.1"};
390        CNetAddr source{ResolveIP(addr_ip)};
391        addrman->Add({addr}, source);
392    }
393    AddressPosition addr_pos = addrman->FindAddressEntry(addr).value();
394    BOOST_CHECK_EQUAL(addr_pos.multiplicity, 1U);
395    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
396
397    // if nTime increases, an addr can occur in up to 8 buckets
398    // The acceptance probability decreases exponentially with existing multiplicity -
399    // choose number of iterations such that it gets to 8 with deterministic addrman.
400    for (unsigned int i = 1; i < 400; ++i) {
401        std::string addr_ip{ToString(i % 256) + "." + ToString(i >> 8 % 256) + ".1.1"};
402        CNetAddr source{ResolveIP(addr_ip)};
403        addr.nTime = start_time + std::chrono::seconds{i};
404        addrman->Add({addr}, source);
405    }
406    AddressPosition addr_pos_multi = addrman->FindAddressEntry(addr).value();
407    BOOST_CHECK_EQUAL(addr_pos_multi.multiplicity, 8U);
408    // multiplicity doesn't affect size
409    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
410}
411
412BOOST_AUTO_TEST_CASE(addrman_tried_collisions)
413{
414    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
415
416    CNetAddr source = ResolveIP("252.2.2.2");
417
418    uint32_t num_addrs{0};
419
420    BOOST_CHECK_EQUAL(addrman->Size(), num_addrs);
421
422    while (num_addrs < 35) { // Magic number! 250.1.1.1 - 250.1.1.35 do not collide in tried with deterministic key = 1
423        CService addr = ResolveService("250.1.1." + ToString(++num_addrs));
424        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
425
426        // Test: Add to tried without collision
427        BOOST_CHECK(addrman->Good(CAddress(addr, NODE_NONE)));
428
429    }
430
431    // Test: Unable to add to tried table due to collision!
432    CService addr1 = ResolveService("250.1.1." + ToString(++num_addrs));
433    BOOST_CHECK(addrman->Add({CAddress(addr1, NODE_NONE)}, source));
434    BOOST_CHECK(!addrman->Good(CAddress(addr1, NODE_NONE)));
435
436    // Test: Add the next address to tried without collision
437    CService addr2 = ResolveService("250.1.1." + ToString(++num_addrs));
438    BOOST_CHECK(addrman->Add({CAddress(addr2, NODE_NONE)}, source));
439    BOOST_CHECK(addrman->Good(CAddress(addr2, NODE_NONE)));
440}
441
442
443BOOST_AUTO_TEST_CASE(addrman_getaddr)
444{
445    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
446
447    // Test: Sanity check, GetAddr should never return anything if addrman
448    //  is empty.
449    BOOST_CHECK_EQUAL(addrman->Size(), 0U);
450    std::vector<CAddress> vAddr1 = addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt);
451    BOOST_CHECK_EQUAL(vAddr1.size(), 0U);
452
453    CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
454    addr1.nTime = Now<NodeSeconds>(); // Set time so isTerrible = false
455    CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
456    addr2.nTime = Now<NodeSeconds>();
457    CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE);
458    addr3.nTime = Now<NodeSeconds>();
459    CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8333), NODE_NONE);
460    addr4.nTime = Now<NodeSeconds>();
461    CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8333), NODE_NONE);
462    addr5.nTime = Now<NodeSeconds>();
463    CNetAddr source1 = ResolveIP("250.1.2.1");
464    CNetAddr source2 = ResolveIP("250.2.3.3");
465
466    // Test: Ensure GetAddr works with new addresses.
467    BOOST_CHECK(addrman->Add({addr1, addr3, addr5}, source1));
468    BOOST_CHECK(addrman->Add({addr2, addr4}, source2));
469
470    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt).size(), 5U);
471    // Net processing asks for 23% of addresses. 23% of 5 is 1 rounded down.
472    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/2500, /*max_pct=*/23, /*network=*/std::nullopt).size(), 1U);
473
474    // Test: Ensure GetAddr works with new and tried addresses.
475    BOOST_CHECK(addrman->Good(CAddress(addr1, NODE_NONE)));
476    BOOST_CHECK(addrman->Good(CAddress(addr2, NODE_NONE)));
477    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt).size(), 5U);
478    BOOST_CHECK_EQUAL(addrman->GetAddr(/*max_addresses=*/2500, /*max_pct=*/23, /*network=*/std::nullopt).size(), 1U);
479
480    // Test: Ensure GetAddr still returns 23% when addrman has many addrs.
481    for (unsigned int i = 1; i < (8 * 256); i++) {
482        int octet1 = i % 256;
483        int octet2 = i >> 8 % 256;
484        std::string strAddr = ToString(octet1) + "." + ToString(octet2) + ".1.23";
485        CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
486
487        // Ensure that for all addrs in addrman, isTerrible == false.
488        addr.nTime = Now<NodeSeconds>();
489        addrman->Add({addr}, ResolveIP(strAddr));
490        if (i % 8 == 0)
491            addrman->Good(addr);
492    }
493    std::vector<CAddress> vAddr = addrman->GetAddr(/*max_addresses=*/2500, /*max_pct=*/23, /*network=*/std::nullopt);
494
495    size_t percent23 = (addrman->Size() * 23) / 100;
496    BOOST_CHECK_EQUAL(vAddr.size(), percent23);
497    BOOST_CHECK_EQUAL(vAddr.size(), 461U);
498    // (addrman.Size() < number of addresses added) due to address collisions.
499    BOOST_CHECK_EQUAL(addrman->Size(), 2006U);
500}