Inside Bitcoin

751    // Test: IP addresses in the same /16 prefix
752    // usually map to the same bucket.
753    BOOST_CHECK_EQUAL(buckets.size(), 1U);
754
755    buckets.clear();
756    for (int j = 0; j < 4 * 255; j++) {
757        AddrInfo infoj = AddrInfo(CAddress(
758                                        ResolveService(
759                                            ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE),
760            ResolveIP("251.4.1.1"));
761        int bucket = infoj.GetNewBucket(nKey1, ngm_asmap);
762        buckets.insert(bucket);
763    }
764    // Test: IP addresses in the same source /16 prefix should not map to more
765    // than 64 buckets.
766    BOOST_CHECK(buckets.size() <= 64);
767
768    buckets.clear();
769    for (int p = 0; p < 255; p++) {
770        AddrInfo infoj = AddrInfo(
771            CAddress(ResolveService("250.1.1.1"), NODE_NONE),
772            ResolveIP("101." + ToString(p) + ".1.1"));
773        int bucket = infoj.GetNewBucket(nKey1, ngm_asmap);
774        buckets.insert(bucket);
775    }
776    // Test: IP addresses in the different source /16 prefixes usually map to MORE
777    // than 1 bucket.
778    BOOST_CHECK(buckets.size() > 1);
779
780    buckets.clear();
781    for (int p = 0; p < 255; p++) {
782        AddrInfo infoj = AddrInfo(
783            CAddress(ResolveService("250.1.1.1"), NODE_NONE),
784            ResolveIP("250." + ToString(p) + ".1.1"));
785        int bucket = infoj.GetNewBucket(nKey1, ngm_asmap);
786        buckets.insert(bucket);
787    }
788    // Test: IP addresses in the different source /16 prefixes sometimes map to NO MORE
789    // than 1 bucket.
790    BOOST_CHECK(buckets.size() == 1);
791}
792
793BOOST_AUTO_TEST_CASE(addrman_serialization)
794{
795    auto netgroupman{NetGroupManager::WithEmbeddedAsmap(test::data::asmap)};
796
797    const auto ratio = GetCheckRatio(m_node);
798    auto addrman_asmap1 = std::make_unique<AddrMan>(netgroupman, DETERMINISTIC, ratio);
799    auto addrman_asmap1_dup = std::make_unique<AddrMan>(netgroupman, DETERMINISTIC, ratio);
800    auto addrman_noasmap = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, ratio);
801
802    DataStream stream{};
803
804    CAddress addr = CAddress(ResolveService("250.1.1.1"), NODE_NONE);
805    CNetAddr default_source;
806
807    addrman_asmap1->Add({addr}, default_source);
808
809    stream << *addrman_asmap1;
810    // serizalizing/deserializing addrman with the same asmap
811    stream >> *addrman_asmap1_dup;
812
813    AddressPosition addr_pos1 = addrman_asmap1->FindAddressEntry(addr).value();
814    AddressPosition addr_pos2 = addrman_asmap1_dup->FindAddressEntry(addr).value();
815    BOOST_CHECK(addr_pos1.multiplicity != 0);
816    BOOST_CHECK(addr_pos2.multiplicity != 0);
817
818    BOOST_CHECK(addr_pos1 == addr_pos2);
819
820    // deserializing asmaped peers.dat to non-asmaped addrman
821    stream << *addrman_asmap1;
822    stream >> *addrman_noasmap;
823    AddressPosition addr_pos3 = addrman_noasmap->FindAddressEntry(addr).value();
824    BOOST_CHECK(addr_pos3.multiplicity != 0);
825    BOOST_CHECK(addr_pos1.bucket != addr_pos3.bucket);
826    BOOST_CHECK(addr_pos1.position != addr_pos3.position);
827
828    // deserializing non-asmaped peers.dat to asmaped addrman
829    addrman_asmap1 = std::make_unique<AddrMan>(netgroupman, DETERMINISTIC, ratio);
830    addrman_noasmap = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, ratio);
831    addrman_noasmap->Add({addr}, default_source);
832    stream << *addrman_noasmap;
833    stream >> *addrman_asmap1;
834
835    AddressPosition addr_pos4 = addrman_asmap1->FindAddressEntry(addr).value();
836    BOOST_CHECK(addr_pos4.multiplicity != 0);
837    BOOST_CHECK(addr_pos4.bucket != addr_pos3.bucket);
838    BOOST_CHECK(addr_pos4 == addr_pos2);
839
840    // used to map to different buckets, now maps to the same bucket.
841    addrman_asmap1 = std::make_unique<AddrMan>(netgroupman, DETERMINISTIC, ratio);
842    addrman_noasmap = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, ratio);
843    CAddress addr1 = CAddress(ResolveService("250.1.1.1"), NODE_NONE);
844    CAddress addr2 = CAddress(ResolveService("250.2.1.1"), NODE_NONE);
845    addrman_noasmap->Add({addr, addr2}, default_source);
846    AddressPosition addr_pos5 = addrman_noasmap->FindAddressEntry(addr1).value();
847    AddressPosition addr_pos6 = addrman_noasmap->FindAddressEntry(addr2).value();
848    BOOST_CHECK(addr_pos5.bucket != addr_pos6.bucket);
849    stream << *addrman_noasmap;
850    stream >> *addrman_asmap1;
851    AddressPosition addr_pos7 = addrman_asmap1->FindAddressEntry(addr1).value();
852    AddressPosition addr_pos8 = addrman_asmap1->FindAddressEntry(addr2).value();
853    BOOST_CHECK(addr_pos7.bucket == addr_pos8.bucket);
854    BOOST_CHECK(addr_pos7.position != addr_pos8.position);
855}
856
857BOOST_AUTO_TEST_CASE(remove_invalid)
858{
859    // Confirm that invalid addresses are ignored in unserialization.
860
861    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
862    DataStream stream{};
863
864    const CAddress new1{ResolveService("5.5.5.5"), NODE_NONE};
865    const CAddress new2{ResolveService("6.6.6.6"), NODE_NONE};
866    const CAddress tried1{ResolveService("7.7.7.7"), NODE_NONE};
867    const CAddress tried2{ResolveService("8.8.8.8"), NODE_NONE};
868
869    addrman->Add({new1, tried1, new2, tried2}, CNetAddr{});
870    addrman->Good(tried1);
871    addrman->Good(tried2);
872    BOOST_REQUIRE_EQUAL(addrman->Size(), 4);
873
874    stream << *addrman;
875
876    const std::string str{stream.str()};
877    size_t pos;
878
879    const char new2_raw[]{6, 6, 6, 6};
880    const uint8_t new2_raw_replacement[]{0, 0, 0, 0}; // 0.0.0.0 is !IsValid()
881    pos = str.find(new2_raw, 0, sizeof(new2_raw));
882    BOOST_REQUIRE(pos != std::string::npos);
883    BOOST_REQUIRE(pos + sizeof(new2_raw_replacement) <= stream.size());
884    memcpy(stream.data() + pos, new2_raw_replacement, sizeof(new2_raw_replacement));
885
886    const char tried2_raw[]{8, 8, 8, 8};
887    const uint8_t tried2_raw_replacement[]{255, 255, 255, 255}; // 255.255.255.255 is !IsValid()
888    pos = str.find(tried2_raw, 0, sizeof(tried2_raw));
889    BOOST_REQUIRE(pos != std::string::npos);
890    BOOST_REQUIRE(pos + sizeof(tried2_raw_replacement) <= stream.size());
891    memcpy(stream.data() + pos, tried2_raw_replacement, sizeof(tried2_raw_replacement));
892
893    addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
894    stream >> *addrman;
895    BOOST_CHECK_EQUAL(addrman->Size(), 2);
896}
897
898BOOST_AUTO_TEST_CASE(addrman_selecttriedcollision)
899{
900    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
901
902    BOOST_CHECK(addrman->Size() == 0);
903
904    // Empty addrman should return blank addrman info.
905    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
906
907    // Add twenty two addresses.
908    CNetAddr source = ResolveIP("252.2.2.2");
909    for (unsigned int i = 1; i < 23; i++) {
910        CService addr = ResolveService("250.1.1." + ToString(i));
911        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
912
913        // No collisions in tried.
914        BOOST_CHECK(addrman->Good(addr));
915        BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
916    }
917
918    // Ensure Good handles duplicates well.
919    // If an address is a duplicate, Good will return false but will not count it as a collision.
920    for (unsigned int i = 1; i < 23; i++) {
921        CService addr = ResolveService("250.1.1." + ToString(i));
922
923        // Unable to add duplicate address to tried table.
924        BOOST_CHECK(!addrman->Good(addr));
925
926        // Verify duplicate address not marked as a collision.
927        BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
928    }
929}
930
931BOOST_AUTO_TEST_CASE(addrman_noevict)
932{
933    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
934
935    // Add 35 addresses.
936    CNetAddr source = ResolveIP("252.2.2.2");
937    for (unsigned int i = 1; i < 36; i++) {
938        CService addr = ResolveService("250.1.1." + ToString(i));
939        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
940
941        // No collision yet.
942        BOOST_CHECK(addrman->Good(addr));
943    }
944
945    // Collision in tried table between 36 and 19.
946    CService addr36 = ResolveService("250.1.1.36");
947    BOOST_CHECK(addrman->Add({CAddress(addr36, NODE_NONE)}, source));
948    BOOST_CHECK(!addrman->Good(addr36));
949    BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(), "250.1.1.19:0");
950
951    // 36 should be discarded and 19 not evicted.
952    // This means we keep 19 in the tried table and
953    // 36 stays in the new table.
954    addrman->ResolveCollisions();
955    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
956
957    // Lets create two collisions.
958    for (unsigned int i = 37; i < 59; i++) {
959        CService addr = ResolveService("250.1.1." + ToString(i));
960        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
961        BOOST_CHECK(addrman->Good(addr));
962    }
963
964    // Cause a collision in the tried table.
965    CService addr59 = ResolveService("250.1.1.59");
966    BOOST_CHECK(addrman->Add({CAddress(addr59, NODE_NONE)}, source));
967    BOOST_CHECK(!addrman->Good(addr59));
968
969    BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(), "250.1.1.10:0");
970
971    // Cause a second collision in the new table.
972    BOOST_CHECK(!addrman->Add({CAddress(addr36, NODE_NONE)}, source));
973
974    // 36 still cannot be moved from new to tried due to colliding with 19
975    BOOST_CHECK(!addrman->Good(addr36));
976    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() != "[::]:0");
977
978    // Resolve all collisions.
979    addrman->ResolveCollisions();
980    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
981}
982
983BOOST_AUTO_TEST_CASE(addrman_evictionworks)
984{
985    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
986
987    BOOST_CHECK(addrman->Size() == 0);
988
989    // Empty addrman should return blank addrman info.
990    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
991
992    // Add 35 addresses
993    CNetAddr source = ResolveIP("252.2.2.2");
994    for (unsigned int i = 1; i < 36; i++) {
995        CService addr = ResolveService("250.1.1." + ToString(i));
996        BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
997
998        // No collision yet.
999        BOOST_CHECK(addrman->Good(addr));
1000    }