addrman_tests.cpp

// Copyright (c) 2012-2016 The Bitcoin Core developers
// Copyright (c) 2017-2019 The Raven Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "addrman.h"
#include "test/test_raven.h"
#include <string>
#include <boost/test/unit_test.hpp>

#include "hash.h"
#include "netbase.h"
#include "random.h"

class CAddrManTest : public CAddrMan
{
    uint64_t state;

public:
    explicit CAddrManTest(bool makeDeterministic = true)
    {
        state = 1;

        if (makeDeterministic)
        {
            //  Set addrman addr placement to be deterministic.
            MakeDeterministic();
        }
    }

    //! Ensure that bucket placement is always the same for testing purposes.
    void MakeDeterministic()
    {
        nKey.SetNull();
        insecure_rand = FastRandomContext(true);
    }

    int RandomInt(int nMax) override
    {
        state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();
        return (unsigned int) (state % nMax);
    }

    CAddrInfo *Find(const CNetAddr &addr, int *pnId = nullptr)
    {
        return CAddrMan::Find(addr, pnId);
    }

    CAddrInfo *Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId = nullptr)
    {
        return CAddrMan::Create(addr, addrSource, pnId);
    }

    void Delete(int nId)
    {
        CAddrMan::Delete(nId);
    }
};

static CNetAddr ResolveIP(const char *ip)
{
    CNetAddr addr;
    BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false), strprintf("failed to resolve: %s", ip));
    return addr;
}

static CNetAddr ResolveIP(std::string ip)
{
    return ResolveIP(ip.c_str());
}

static CService ResolveService(const char *ip, int port = 0)
{
    CService serv;
    BOOST_CHECK_MESSAGE(Lookup(ip, serv, port, false), strprintf("failed to resolve: %s:%i", ip, port));
    return serv;
}

static CService ResolveService(std::string ip, int port = 0)
{
    return ResolveService(ip.c_str(), port);
}

BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)

    BOOST_AUTO_TEST_CASE(addrman_simple_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Simple Test");

        CAddrManTest addrman;

        CNetAddr source = ResolveIP("252.2.2.2");

        // Test: Does Addrman respond correctly when empty.
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);
        CAddrInfo addr_null = addrman.Select();
        BOOST_CHECK_EQUAL(addr_null.ToString(), "[::]:0");

        // Test: Does Addrman::Add work as expected.
        CService addr1 = ResolveService("250.1.1.1", 8767);
        BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);
        CAddrInfo addr_ret1 = addrman.Select();
        BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8767");

        // Test: Does IP address deduplication work correctly.
        //  Expected dup IP should not be added.
        CService addr1_dup = ResolveService("250.1.1.1", 8767);
        BOOST_CHECK(!addrman.Add(CAddress(addr1_dup, NODE_NONE), source));
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);


        // Test: New table has one addr and we add a diff addr we should
        //  have at least one addr.
        // Note that addrman's size cannot be tested reliably after insertion, as
        // hash collisions may occur. But we can always be sure of at least one
        // success.

        CService addr2 = ResolveService("250.1.1.2", 8767);
        BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
        BOOST_CHECK(addrman.size() >= 1);

        // Test: AddrMan::Clear() should empty the new table.
        addrman.Clear();
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);
        CAddrInfo addr_null2 = addrman.Select();
        BOOST_CHECK_EQUAL(addr_null2.ToString(), "[::]:0");

        // Test: AddrMan::Add multiple addresses works as expected
        std::vector<CAddress> vAddr;
        vAddr.push_back(CAddress(ResolveService("250.1.1.3", 8767), NODE_NONE));
        vAddr.push_back(CAddress(ResolveService("250.1.1.4", 8767), NODE_NONE));
        BOOST_CHECK(addrman.Add(vAddr, source));
        BOOST_CHECK(addrman.size() >= 1);
    }

    BOOST_AUTO_TEST_CASE(addrman_ports_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Ports Test");

        CAddrManTest addrman;

        CNetAddr source = ResolveIP("252.2.2.2");

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        // Test 7; Addr with same IP but diff port does not replace existing addr.
        CService addr1 = ResolveService("250.1.1.1", 8767);
        addrman.Add(CAddress(addr1, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);

        CService addr1_port = ResolveService("250.1.1.1", 8334);
        addrman.Add(CAddress(addr1_port, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);
        CAddrInfo addr_ret2 = addrman.Select();
        BOOST_CHECK_EQUAL(addr_ret2.ToString(), "250.1.1.1:8767");

        // Test: Add same IP but diff port to tried table, it doesn't get added.
        //  Perhaps this is not ideal behavior but it is the current behavior.
        addrman.Good(CAddress(addr1_port, NODE_NONE));
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);
        bool newOnly = true;
        CAddrInfo addr_ret3 = addrman.Select(newOnly);
        BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8767");
    }


    BOOST_AUTO_TEST_CASE(addrman_select_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Select Test");

        CAddrManTest addrman;

        CNetAddr source = ResolveIP("252.2.2.2");

        // Test: Select from new with 1 addr in new.
        CService addr1 = ResolveService("250.1.1.1", 8767);
        addrman.Add(CAddress(addr1, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);

        bool newOnly = true;
        CAddrInfo addr_ret1 = addrman.Select(newOnly);
        BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8767");

        // Test: move addr to tried, select from new expected nothing returned.
        addrman.Good(CAddress(addr1, NODE_NONE));
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);
        CAddrInfo addr_ret2 = addrman.Select(newOnly);
        BOOST_CHECK_EQUAL(addr_ret2.ToString(), "[::]:0");

        CAddrInfo addr_ret3 = addrman.Select();
        BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8767");

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);


        // Add three addresses to new table.
        CService addr2 = ResolveService("250.3.1.1", 8767);
        CService addr3 = ResolveService("250.3.2.2", 9999);
        CService addr4 = ResolveService("250.3.3.3", 9999);

        addrman.Add(CAddress(addr2, NODE_NONE), ResolveService("250.3.1.1", 8767));
        addrman.Add(CAddress(addr3, NODE_NONE), ResolveService("250.3.1.1", 8767));
        addrman.Add(CAddress(addr4, NODE_NONE), ResolveService("250.4.1.1", 8767));

        // Add three addresses to tried table.
        CService addr5 = ResolveService("250.4.4.4", 8767);
        CService addr6 = ResolveService("250.4.5.5", 7777);
        CService addr7 = ResolveService("250.4.6.6", 8767);

        addrman.Add(CAddress(addr5, NODE_NONE), ResolveService("250.3.1.1", 8767));
        addrman.Good(CAddress(addr5, NODE_NONE));
        addrman.Add(CAddress(addr6, NODE_NONE), ResolveService("250.3.1.1", 8767));
        addrman.Good(CAddress(addr6, NODE_NONE));
        addrman.Add(CAddress(addr7, NODE_NONE), ResolveService("250.1.1.3", 8767));
        addrman.Good(CAddress(addr7, NODE_NONE));

        // Test: 6 addrs + 1 addr from last test = 7.
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)7);

        // Test: Select pulls from new and tried regardless of port number.
        std::set<uint16_t> ports;
        for (int i = 0; i < 20; ++i)
        {
            ports.insert(addrman.Select().GetPort());
        }
        BOOST_CHECK_EQUAL(ports.size(), (uint64_t)3);
    }

    BOOST_AUTO_TEST_CASE(addrman_new_collisions_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman New Collisions Test");

        CAddrManTest addrman;

        CNetAddr source = ResolveIP("252.2.2.2");

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        for (unsigned int i = 1; i < 18; i++)
        {
            CService addr = ResolveService("250.1.1." + boost::to_string(i));
            addrman.Add(CAddress(addr, NODE_NONE), source);

            //Test: No collision in new table yet.
            BOOST_CHECK_EQUAL(addrman.size(), i);
        }

        //Test: new table collision!
        CService addr1 = ResolveService("250.1.1.18");
        addrman.Add(CAddress(addr1, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)17);

        CService addr2 = ResolveService("250.1.1.19");
        addrman.Add(CAddress(addr2, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)18);
    }

    BOOST_AUTO_TEST_CASE(addrman_tried_collisions_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Tried Collisions Test");

        CAddrManTest addrman;

        CNetAddr source = ResolveIP("252.2.2.2");

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        for (unsigned int i = 1; i < 80; i++)
        {
            CService addr = ResolveService("250.1.1." + boost::to_string(i));
            addrman.Add(CAddress(addr, NODE_NONE), source);
            addrman.Good(CAddress(addr, NODE_NONE));

            //Test: No collision in tried table yet.
            BOOST_CHECK_EQUAL(addrman.size(), i);
        }

        //Test: tried table collision!
        CService addr1 = ResolveService("250.1.1.80");
        addrman.Add(CAddress(addr1, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)79);

        CService addr2 = ResolveService("250.1.1.81");
        addrman.Add(CAddress(addr2, NODE_NONE), source);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)80);
    }

    BOOST_AUTO_TEST_CASE(addrman_find_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Find Test");

        CAddrManTest addrman;

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8767), NODE_NONE);
        CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
        CAddress addr3 = CAddress(ResolveService("251.255.2.1", 8767), NODE_NONE);

        CNetAddr source1 = ResolveIP("250.1.2.1");
        CNetAddr source2 = ResolveIP("250.1.2.2");

        addrman.Add(addr1, source1);
        addrman.Add(addr2, source2);
        addrman.Add(addr3, source1);

        // Test: ensure Find returns an IP matching what we searched on.
        CAddrInfo *info1 = addrman.Find(addr1);
        BOOST_REQUIRE(info1);
        BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8767");

        // Test 18; Find does not discriminate by port number.
        CAddrInfo *info2 = addrman.Find(addr2);
        BOOST_REQUIRE(info2);
        BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString());

        // Test: Find returns another IP matching what we searched on.
        CAddrInfo *info3 = addrman.Find(addr3);
        BOOST_REQUIRE(info3);
        BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8767");
    }

    BOOST_AUTO_TEST_CASE(addrman_create_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Create Test");

        CAddrManTest addrman;

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8767), NODE_NONE);
        CNetAddr source1 = ResolveIP("250.1.2.1");

        int nId;
        CAddrInfo *pinfo = addrman.Create(addr1, source1, &nId);

        // Test: The result should be the same as the input addr.
        BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8767");

        CAddrInfo *info2 = addrman.Find(addr1);
        BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8767");
    }


    BOOST_AUTO_TEST_CASE(addrman_delete_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman Delete Test");

        CAddrManTest addrman;

        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);

        CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8767), NODE_NONE);
        CNetAddr source1 = ResolveIP("250.1.2.1");

        int nId;
        addrman.Create(addr1, source1, &nId);

        // Test: Delete should actually delete the addr.
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)1);
        addrman.Delete(nId);
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);
        CAddrInfo *info2 = addrman.Find(addr1);
        BOOST_CHECK(info2 == nullptr);
    }

    BOOST_AUTO_TEST_CASE(addrman_getaddr_test)
    {
        BOOST_TEST_MESSAGE("Running Addrman GetAddr Test");

        CAddrManTest addrman;

        // Test: Sanity check, GetAddr should never return anything if addrman
        //  is empty.
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)0);
        std::vector<CAddress> vAddr1 = addrman.GetAddr();
        BOOST_CHECK_EQUAL(vAddr1.size(), (uint64_t)0);

        CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8767), NODE_NONE);
        addr1.nTime = GetAdjustedTime(); // Set time so isTerrible = false
        CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
        addr2.nTime = GetAdjustedTime();
        CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8767), NODE_NONE);
        addr3.nTime = GetAdjustedTime();
        CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8767), NODE_NONE);
        addr4.nTime = GetAdjustedTime();
        CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8767), NODE_NONE);
        addr5.nTime = GetAdjustedTime();
        CNetAddr source1 = ResolveIP("250.1.2.1");
        CNetAddr source2 = ResolveIP("250.2.3.3");

        // Test: Ensure GetAddr works with new addresses.
        addrman.Add(addr1, source1);
        addrman.Add(addr2, source2);
        addrman.Add(addr3, source1);
        addrman.Add(addr4, source2);
        addrman.Add(addr5, source1);

        // GetAddr returns 23% of addresses, 23% of 5 is 1 rounded down.
        BOOST_CHECK_EQUAL(addrman.GetAddr().size(), (uint64_t)1);

        // Test: Ensure GetAddr works with new and tried addresses.
        addrman.Good(CAddress(addr1, NODE_NONE));
        addrman.Good(CAddress(addr2, NODE_NONE));
        BOOST_CHECK_EQUAL(addrman.GetAddr().size(), (uint64_t)1);

        // Test: Ensure GetAddr still returns 23% when addrman has many addrs.
        for (unsigned int i = 1; i < (8 * 256); i++)
        {
            int octet1 = i % 256;
            int octet2 = i >> 8 % 256;
            std::string strAddr = boost::to_string(octet1) + "." + boost::to_string(octet2) + ".1.23";
            CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);

            // Ensure that for all addrs in addrman, isTerrible == false.
            addr.nTime = GetAdjustedTime();
            addrman.Add(addr, ResolveIP(strAddr));
            if (i % 8 == 0)
                addrman.Good(addr);
        }
        std::vector<CAddress> vAddr = addrman.GetAddr();

        size_t percent23 = (addrman.size() * 23) / 100;
        BOOST_CHECK_EQUAL(vAddr.size(), percent23);
        BOOST_CHECK_EQUAL(vAddr.size(), (uint64_t)461);
        // (Addrman.size() < number of addresses added) due to address collisions.
        BOOST_CHECK_EQUAL(addrman.size(), (uint64_t)2006);
    }


    BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_test)
    {
        BOOST_TEST_MESSAGE("Running cAddrInfo Get Tried Bucket Test");

        CAddrManTest addrman;

        CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8767), NODE_NONE);
        CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);

        CNetAddr source1 = ResolveIP("250.1.1.1");


        CAddrInfo info1 = CAddrInfo(addr1, source1);

        uint256 nKey1 = (uint256) (CHashWriter(SER_GETHASH, 0) << 1).GetHash();
        uint256 nKey2 = (uint256) (CHashWriter(SER_GETHASH, 0) << 2).GetHash();


        BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1), 62);

        // Test: Make sure key actually randomizes bucket placement. A fail on
        //  this test could be a security issue.
        BOOST_CHECK(info1.GetTriedBucket(nKey1) != info1.GetTriedBucket(nKey2));

        // Test: Two addresses with same IP but different ports can map to
        //  different buckets because they have different keys.
        CAddrInfo info2 = CAddrInfo(addr2, source1);

        BOOST_CHECK(info1.GetKey() != info2.GetKey());
        BOOST_CHECK(info1.GetTriedBucket(nKey1) != info2.GetTriedBucket(nKey1));

        std::set<int> buckets;
        for (int i = 0; i < 255; i++)
        {
            CAddrInfo infoi = CAddrInfo(
                    CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
                    ResolveIP("250.1.1." + boost::to_string(i)));
            int bucket = infoi.GetTriedBucket(nKey1);
            buckets.insert(bucket);
        }
        // Test: IP addresses in the same group (\16 prefix for IPv4) should
        //  never get more than 8 buckets
        BOOST_CHECK_EQUAL(buckets.size(), (uint64_t)8);

        buckets.clear();
        for (int j = 0; j < 255; j++)
        {
            CAddrInfo infoj = CAddrInfo(
                    CAddress(ResolveService("250." + boost::to_string(j) + ".1.1"), NODE_NONE),
                    ResolveIP("250." + boost::to_string(j) + ".1.1"));
            int bucket = infoj.GetTriedBucket(nKey1);
            buckets.insert(bucket);
        }
        // Test: IP addresses in the different groups should map to more than
        //  8 buckets.
        BOOST_CHECK_EQUAL(buckets.size(), (uint64_t)160);
    }

    BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_test)
    {
        BOOST_TEST_MESSAGE("Running cAddrInfo Get New Bucket Test");

        CAddrManTest addrman;

        CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8767), NODE_NONE);
        CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);

        CNetAddr source1 = ResolveIP("250.1.2.1");

        CAddrInfo info1 = CAddrInfo(addr1, source1);

        uint256 nKey1 = (uint256) (CHashWriter(SER_GETHASH, 0) << 1).GetHash();
        uint256 nKey2 = (uint256) (CHashWriter(SER_GETHASH, 0) << 2).GetHash();

        // Test: Make sure the buckets are what we expect
        BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), 786);
        BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1), 786);

        // Test: Make sure key actually randomizes bucket placement. A fail on
        //  this test could be a security issue.
        BOOST_CHECK(info1.GetNewBucket(nKey1) != info1.GetNewBucket(nKey2));

        // Test: Ports should not effect bucket placement in the addr
        CAddrInfo info2 = CAddrInfo(addr2, source1);
        BOOST_CHECK(info1.GetKey() != info2.GetKey());
        BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), info2.GetNewBucket(nKey1));

        std::set<int> buckets;
        for (int i = 0; i < 255; i++)
        {
            CAddrInfo infoi = CAddrInfo(
                    CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
                    ResolveIP("250.1.1." + boost::to_string(i)));
            int bucket = infoi.GetNewBucket(nKey1);
            buckets.insert(bucket);
        }
        // Test: IP addresses in the same group (\16 prefix for IPv4) should
        //  always map to the same bucket.
        BOOST_CHECK_EQUAL(buckets.size(), (uint64_t)1);

        buckets.clear();
        for (int j = 0; j < 4 * 255; j++)
        {
            CAddrInfo infoj = CAddrInfo(CAddress(
                    ResolveService(
                            boost::to_string(250 + (j / 255)) + "." + boost::to_string(j % 256) + ".1.1"), NODE_NONE),
                                        ResolveIP("251.4.1.1"));
            int bucket = infoj.GetNewBucket(nKey1);
            buckets.insert(bucket);
        }
        // Test: IP addresses in the same source groups should map to no more
        //  than 64 buckets.
        BOOST_CHECK(buckets.size() <= 64);

        buckets.clear();
        for (int p = 0; p < 255; p++)
        {
            CAddrInfo infoj = CAddrInfo(
                    CAddress(ResolveService("250.1.1.1"), NODE_NONE),
                    ResolveIP("250." + boost::to_string(p) + ".1.1"));
            int bucket = infoj.GetNewBucket(nKey1);
            buckets.insert(bucket);
        }
        // Test: IP addresses in the different source groups should map to more
        //  than 64 buckets.
        BOOST_CHECK(buckets.size() > 64);
    }

BOOST_AUTO_TEST_SUITE_END()