Inside Bitcoin

1001
1002    // Collision between 36 and 19.
1003    CService addr = ResolveService("250.1.1.36");
1004    BOOST_CHECK(addrman->Add({CAddress(addr, NODE_NONE)}, source));
1005    BOOST_CHECK(!addrman->Good(addr));
1006
1007    auto info = addrman->SelectTriedCollision().first;
1008    BOOST_CHECK_EQUAL(info.ToStringAddrPort(), "250.1.1.19:0");
1009
1010    // Ensure test of address fails, so that it is evicted.
1011    // Update entry in tried by setting last good connection in the deep past.
1012    BOOST_CHECK(!addrman->Good(info, NodeSeconds{1s}));
1013    addrman->Attempt(info, /*fCountFailure=*/false, Now<NodeSeconds>() - 61s);
1014
1015    // Should swap 36 for 19.
1016    addrman->ResolveCollisions();
1017    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
1018    AddressPosition addr_pos{addrman->FindAddressEntry(CAddress(addr, NODE_NONE)).value()};
1019    BOOST_CHECK(addr_pos.tried);
1020
1021    // If 36 was swapped for 19, then adding 36 to tried should fail because we
1022    // are attempting to add a duplicate.
1023    // We check this by verifying Good() returns false and also verifying that
1024    // we have no collisions.
1025    BOOST_CHECK(!addrman->Good(addr));
1026    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
1027
1028    // 19 should fail as a collision (not a duplicate) if we now attempt to move
1029    // it to the tried table.
1030    CService addr19 = ResolveService("250.1.1.19");
1031    BOOST_CHECK(!addrman->Good(addr19));
1032    BOOST_CHECK_EQUAL(addrman->SelectTriedCollision().first.ToStringAddrPort(), "250.1.1.36:0");
1033
1034    // Eviction is also successful if too much time has passed since last try
1035    FakeNodeClock clock{};
1036    clock += 4h;
1037    addrman->ResolveCollisions();
1038    BOOST_CHECK(addrman->SelectTriedCollision().first.ToStringAddrPort() == "[::]:0");
1039    //Now 19 is in tried again, and 36 back to new
1040    AddressPosition addr_pos19{addrman->FindAddressEntry(CAddress(addr19, NODE_NONE)).value()};
1041    BOOST_CHECK(addr_pos19.tried);
1042    AddressPosition addr_pos36{addrman->FindAddressEntry(CAddress(addr, NODE_NONE)).value()};
1043    BOOST_CHECK(!addr_pos36.tried);
1044}
1045
1046static auto AddrmanToStream(const AddrMan& addrman)
1047{
1048    DataStream ssPeersIn{};
1049    ssPeersIn << Params().MessageStart();
1050    ssPeersIn << addrman;
1051    return ssPeersIn;
1052}
1053
1054BOOST_AUTO_TEST_CASE(load_addrman)
1055{
1056    AddrMan addrman{EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node)};
1057
1058    std::optional<CService> addr1, addr2, addr3, addr4;
1059    addr1 = Lookup("250.7.1.1", 8333, false);
1060    BOOST_CHECK(addr1.has_value());
1061    addr2 = Lookup("250.7.2.2", 9999, false);
1062    BOOST_CHECK(addr2.has_value());
1063    addr3 = Lookup("250.7.3.3", 9999, false);
1064    BOOST_CHECK(addr3.has_value());
1065    addr3 = Lookup("250.7.3.3"s, 9999, false);
1066    BOOST_CHECK(addr3.has_value());
1067    addr4 = Lookup("250.7.3.3\0example.com"s, 9999, false);
1068    BOOST_CHECK(!addr4.has_value());
1069
1070    // Add three addresses to new table.
1071    const std::optional<CService> source{Lookup("252.5.1.1", 8333, false)};
1072    BOOST_CHECK(source.has_value());
1073    std::vector<CAddress> addresses{CAddress(addr1.value(), NODE_NONE), CAddress(addr2.value(), NODE_NONE), CAddress(addr3.value(), NODE_NONE)};
1074    BOOST_CHECK(addrman.Add(addresses, source.value()));
1075    BOOST_CHECK(addrman.Size() == 3);
1076
1077    // Test that the de-serialization does not throw an exception.
1078    auto ssPeers1{AddrmanToStream(addrman)};
1079    AddrMan addrman1{EMPTY_NETGROUPMAN, !DETERMINISTIC, GetCheckRatio(m_node)};
1080
1081    BOOST_CHECK(addrman1.Size() == 0);
1082    {
1083        unsigned char pchMsgTmp[4];
1084        BOOST_CHECK_NO_THROW(ssPeers1 >> pchMsgTmp >> addrman1);
1085    }
1086
1087    BOOST_CHECK(addrman1.Size() == 3);
1088
1089    // Test that ReadFromStream creates an addrman with the correct number of addrs.
1090    DataStream ssPeers2 = AddrmanToStream(addrman);
1091
1092    AddrMan addrman2{EMPTY_NETGROUPMAN, !DETERMINISTIC, GetCheckRatio(m_node)};
1093    BOOST_CHECK(addrman2.Size() == 0);
1094    ReadFromStream(addrman2, ssPeers2);
1095    BOOST_CHECK(addrman2.Size() == 3);
1096}
1097
1098// Produce a corrupt peers.dat that claims 20 addrs when it only has one addr.
1099static auto MakeCorruptPeersDat()
1100{
1101    DataStream s{};
1102    s << ::Params().MessageStart();
1103
1104    unsigned char nVersion = 1;
1105    s << nVersion;
1106    s << ((unsigned char)32);
1107    s << uint256::ONE;
1108    s << 10; // nNew
1109    s << 10; // nTried
1110
1111    int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);
1112    s << nUBuckets;
1113
1114    const std::optional<CService> serv{Lookup("252.1.1.1", 7777, false)};
1115    BOOST_REQUIRE(serv.has_value());
1116    CAddress addr = CAddress(serv.value(), NODE_NONE);
1117    std::optional<CNetAddr> resolved{LookupHost("252.2.2.2", false)};
1118    BOOST_REQUIRE(resolved.has_value());
1119    AddrInfo info = AddrInfo(addr, resolved.value());
1120    s << CAddress::V1_DISK(info);
1121
1122    return s;
1123}
1124
1125BOOST_AUTO_TEST_CASE(load_addrman_corrupted)
1126{
1127    // Test that the de-serialization of corrupted peers.dat throws an exception.
1128    auto ssPeers1{MakeCorruptPeersDat()};
1129    AddrMan addrman1{EMPTY_NETGROUPMAN, !DETERMINISTIC, GetCheckRatio(m_node)};
1130    BOOST_CHECK(addrman1.Size() == 0);
1131    BOOST_CHECK_EXCEPTION([&]
1132    {
1133        unsigned char pchMsgTmp[4];
1134        ssPeers1 >> pchMsgTmp;
1135        ssPeers1 >> addrman1;
1136    }(), std::ios_base::failure, HasReason{"end of data"});
1137
1138    // Test that ReadFromStream fails if peers.dat is corrupt
1139    auto ssPeers2{MakeCorruptPeersDat()};
1140
1141    AddrMan addrman2{EMPTY_NETGROUPMAN, !DETERMINISTIC, GetCheckRatio(m_node)};
1142    BOOST_CHECK(addrman2.Size() == 0);
1143    BOOST_CHECK_THROW(ReadFromStream(addrman2, ssPeers2), std::ios_base::failure);
1144}
1145
1146BOOST_AUTO_TEST_CASE(addrman_update_address)
1147{
1148    // Tests updating nTime via Connected() and nServices via SetServices() and Add()
1149    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
1150    CNetAddr source{ResolveIP("252.2.2.2")};
1151    CAddress addr{CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE)};
1152
1153    const auto start_time{Now<NodeSeconds>() - 10000s};
1154    addr.nTime = start_time;
1155    BOOST_CHECK(addrman->Add({addr}, source));
1156    BOOST_CHECK_EQUAL(addrman->Size(), 1U);
1157
1158    // Updating an addrman entry with a different port doesn't change it
1159    CAddress addr_diff_port{CAddress(ResolveService("250.1.1.1", 8334), NODE_NONE)};
1160    addr_diff_port.nTime = start_time;
1161    addrman->Connected(addr_diff_port);
1162    addrman->SetServices(addr_diff_port, NODE_NETWORK_LIMITED);
1163    std::vector<CAddress> vAddr1{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
1164    BOOST_CHECK_EQUAL(vAddr1.size(), 1U);
1165    BOOST_CHECK(vAddr1.at(0).nTime == start_time);
1166    BOOST_CHECK_EQUAL(vAddr1.at(0).nServices, NODE_NONE);
1167
1168    // Updating an addrman entry with the correct port is successful
1169    addrman->Connected(addr);
1170    addrman->SetServices(addr, NODE_NETWORK_LIMITED);
1171    std::vector<CAddress> vAddr2 = addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt);
1172    BOOST_CHECK_EQUAL(vAddr2.size(), 1U);
1173    BOOST_CHECK(vAddr2.at(0).nTime >= start_time + 10000s);
1174    BOOST_CHECK_EQUAL(vAddr2.at(0).nServices, NODE_NETWORK_LIMITED);
1175
1176    // Updating an existing addr through Add() (used in gossip relay) can add additional services but can't remove existing ones.
1177    CAddress addr_v2{CAddress(ResolveService("250.1.1.1", 8333), NODE_P2P_V2)};
1178    addr_v2.nTime = start_time;
1179    BOOST_CHECK(!addrman->Add({addr_v2}, source));
1180    std::vector<CAddress> vAddr3{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
1181    BOOST_CHECK_EQUAL(vAddr3.size(), 1U);
1182    BOOST_CHECK_EQUAL(vAddr3.at(0).nServices, NODE_P2P_V2 | NODE_NETWORK_LIMITED);
1183
1184    // SetServices() (used when we connected to them) overwrites existing service flags
1185    addrman->SetServices(addr, NODE_NETWORK);
1186    std::vector<CAddress> vAddr4{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
1187    BOOST_CHECK_EQUAL(vAddr4.size(), 1U);
1188    BOOST_CHECK_EQUAL(vAddr4.at(0).nServices, NODE_NETWORK);
1189
1190    // Promoting to Tried does not affect the service flags
1191    BOOST_CHECK(addrman->Good(addr)); // addr has NODE_NONE
1192    std::vector<CAddress> vAddr5{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
1193    BOOST_CHECK_EQUAL(vAddr5.size(), 1U);
1194    BOOST_CHECK_EQUAL(vAddr5.at(0).nServices, NODE_NETWORK);
1195
1196    // Adding service flags even works when the addr is in Tried
1197    BOOST_CHECK(!addrman->Add({addr_v2}, source));
1198    std::vector<CAddress> vAddr6{addrman->GetAddr(/*max_addresses=*/0, /*max_pct=*/0, /*network=*/std::nullopt)};
1199    BOOST_CHECK_EQUAL(vAddr6.size(), 1U);
1200    BOOST_CHECK_EQUAL(vAddr6.at(0).nServices, NODE_NETWORK | NODE_P2P_V2);
1201}
1202
1203BOOST_AUTO_TEST_CASE(addrman_size)
1204{
1205    auto addrman = std::make_unique<AddrMan>(EMPTY_NETGROUPMAN, DETERMINISTIC, GetCheckRatio(m_node));
1206    const CNetAddr source = ResolveIP("252.2.2.2");
1207
1208    // empty addrman
1209    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/std::nullopt), 0U);
1210    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/std::nullopt), 0U);
1211    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/true), 0U);
1212    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/false), 0U);
1213
1214    // add two ipv4 addresses, one to tried and new
1215    const CAddress addr1{ResolveService("250.1.1.1", 8333), NODE_NONE};
1216    BOOST_CHECK(addrman->Add({addr1}, source));
1217    BOOST_CHECK(addrman->Good(addr1));
1218    const CAddress addr2{ResolveService("250.1.1.2", 8333), NODE_NONE};
1219    BOOST_CHECK(addrman->Add({addr2}, source));
1220
1221    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/std::nullopt), 2U);
1222    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/std::nullopt), 2U);
1223    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/true), 1U);
1224    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/false), 1U);
1225    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/true), 1U);
1226    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/false), 1U);
1227
1228    // add one i2p address to new
1229    CService i2p_addr;
1230    i2p_addr.SetSpecial("UDHDrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.I2P");
1231    const CAddress addr3{i2p_addr, NODE_NONE};
1232    BOOST_CHECK(addrman->Add({addr3}, source));
1233    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/std::nullopt), 3U);
1234    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_IPV4, /*in_new=*/std::nullopt), 2U);
1235    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_I2P, /*in_new=*/std::nullopt), 1U);
1236    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/NET_I2P, /*in_new=*/true), 1U);
1237    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/true), 2U);
1238    BOOST_CHECK_EQUAL(addrman->Size(/*net=*/std::nullopt, /*in_new=*/false), 1U);
1239}
1240
1241BOOST_AUTO_TEST_SUITE_END()
1242