Updating and selecting peer candidates

1001        return AddressPosition(/*tried_in=*/false,
1002                               /*multiplicity_in=*/addr_info->nRefCount,
1003                               /*bucket_in=*/bucket,
1004                               /*position_in=*/addr_info->GetBucketPosition(nKey, true, bucket));
1005    }
1006}
1007
1008size_t AddrManImpl::Size_(std::optional<Network> net, std::optional<bool> in_new) const
1009{
1010    AssertLockHeld(cs);
1011
1012    if (!net.has_value()) {
1013        if (in_new.has_value()) {
1014            return *in_new ? nNew : nTried;
1015        } else {
1016            return vRandom.size();
1017        }
1018    }
1019    if (auto it = m_network_counts.find(*net); it != m_network_counts.end()) {
1020        auto net_count = it->second;
1021        if (in_new.has_value()) {
1022            return *in_new ? net_count.n_new : net_count.n_tried;
1023        } else {
1024            return net_count.n_new + net_count.n_tried;
1025        }
1026    }
1027    return 0;
1028}
1029
1030void AddrManImpl::Check() const
1031{
1032    AssertLockHeld(cs);
1033
1034    // Run consistency checks 1 in m_consistency_check_ratio times if enabled
1035    if (m_consistency_check_ratio == 0) return;
1036    if (insecure_rand.randrange(m_consistency_check_ratio) >= 1) return;
1037
1038    const int err{CheckAddrman()};
1039    if (err) {
1040        LogError("ADDRMAN CONSISTENCY CHECK FAILED!!! err=%i", err);
1041        assert(false);
1042    }
1043}
1044
1045int AddrManImpl::CheckAddrman() const
1046{
1047    AssertLockHeld(cs);
1048
1049    LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
1050        strprintf("new %i, tried %i, total %u", nNew, nTried, vRandom.size()), BCLog::ADDRMAN);
1051
1052    std::unordered_set<nid_type> setTried;
1053    std::unordered_map<nid_type, int> mapNew;
1054    std::unordered_map<Network, NewTriedCount> local_counts;
1055
1056    if (vRandom.size() != (size_t)(nTried + nNew))
1057        return -7;
1058
1059    for (const auto& entry : mapInfo) {
1060        nid_type n = entry.first;
1061        const AddrInfo& info = entry.second;
1062        if (info.fInTried) {
1063            if (!TicksSinceEpoch<std::chrono::seconds>(info.m_last_success)) {
1064                return -1;
1065            }
1066            if (info.nRefCount)
1067                return -2;
1068            setTried.insert(n);
1069            local_counts[info.GetNetwork()].n_tried++;
1070        } else {
1071            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
1072                return -3;
1073            if (!info.nRefCount)
1074                return -4;
1075            mapNew[n] = info.nRefCount;
1076            local_counts[info.GetNetwork()].n_new++;
1077        }
1078        const auto it{mapAddr.find(info)};
1079        if (it == mapAddr.end() || it->second != n) {
1080            return -5;
1081        }
1082        if (info.nRandomPos < 0 || (size_t)info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
1083            return -14;
1084        if (info.m_last_try < NodeSeconds{0s}) {
1085            return -6;
1086        }
1087        if (info.m_last_success < NodeSeconds{0s}) {
1088            return -8;
1089        }
1090    }
1091
1092    if (setTried.size() != (size_t)nTried)
1093        return -9;
1094    if (mapNew.size() != (size_t)nNew)
1095        return -10;
1096
1097    for (int n = 0; n < ADDRMAN_TRIED_BUCKET_COUNT; n++) {
1098        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
1099            if (vvTried[n][i] != -1) {
1100                if (!setTried.contains(vvTried[n][i]))
1101                    return -11;
1102                const auto it{mapInfo.find(vvTried[n][i])};
1103                if (it == mapInfo.end() || it->second.GetTriedBucket(nKey, m_netgroupman) != n) {
1104                    return -17;
1105                }
1106                if (it->second.GetBucketPosition(nKey, false, n) != i) {
1107                    return -18;
1108                }
1109                setTried.erase(vvTried[n][i]);
1110            }
1111        }
1112    }
1113
1114    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; n++) {
1115        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
1116            if (vvNew[n][i] != -1) {
1117                if (!mapNew.contains(vvNew[n][i]))
1118                    return -12;
1119                const auto it{mapInfo.find(vvNew[n][i])};
1120                if (it == mapInfo.end() || it->second.GetBucketPosition(nKey, true, n) != i) {
1121                    return -19;
1122                }
1123                if (--mapNew[vvNew[n][i]] == 0)
1124                    mapNew.erase(vvNew[n][i]);
1125            }
1126        }
1127    }
1128
1129    if (setTried.size())
1130        return -13;
1131    if (mapNew.size())
1132        return -15;
1133    if (nKey.IsNull())
1134        return -16;
1135
1136    // It's possible that m_network_counts may have all-zero entries that local_counts
1137    // doesn't have if addrs from a network were being added and then removed again in the past.
1138    if (m_network_counts.size() < local_counts.size()) {
1139        return -20;
1140    }
1141    for (const auto& [net, count] : m_network_counts) {
1142        if (local_counts[net].n_new != count.n_new || local_counts[net].n_tried != count.n_tried) {
1143            return -21;
1144        }
1145    }
1146
1147    return 0;
1148}
1149
1150size_t AddrManImpl::Size(std::optional<Network> net, std::optional<bool> in_new) const
1151{
1152    LOCK(cs);
1153    Check();
1154    auto ret = Size_(net, in_new);
1155    Check();
1156    return ret;
1157}
1158
1159bool AddrManImpl::Add(const std::vector<CAddress>& vAddr, const CNetAddr& source, std::chrono::seconds time_penalty)
1160{
1161    LOCK(cs);
1162    Check();
1163    auto ret = Add_(vAddr, source, time_penalty);
1164    Check();
1165    return ret;
1166}
1167
1168bool AddrManImpl::Good(const CService& addr, NodeSeconds time)
1169{
1170    LOCK(cs);
1171    Check();
1172    auto ret = Good_(addr, /*test_before_evict=*/true, time);
1173    Check();
1174    return ret;
1175}
1176
1177void AddrManImpl::Attempt(const CService& addr, bool fCountFailure, NodeSeconds time)
1178{
1179    LOCK(cs);
1180    Check();
1181    Attempt_(addr, fCountFailure, time);
1182    Check();
1183}
1184
1185void AddrManImpl::ResolveCollisions()
1186{
1187    LOCK(cs);
1188    Check();
1189    ResolveCollisions_();
1190    Check();
1191}
1192
1193std::pair<CAddress, NodeSeconds> AddrManImpl::SelectTriedCollision()
1194{
1195    LOCK(cs);
1196    Check();
1197    auto ret = SelectTriedCollision_();
1198    Check();
1199    return ret;
1200}
1201
1202std::pair<CAddress, NodeSeconds> AddrManImpl::Select(bool new_only, const std::unordered_set<Network>& networks) const
1203{
1204    LOCK(cs);
1205    Check();
1206    auto addrRet = Select_(new_only, networks);
1207    Check();
1208    return addrRet;
1209}
1210
1211std::vector<CAddress> AddrManImpl::GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered) const
1212{
1213    LOCK(cs);
1214    Check();
1215    auto addresses = GetAddr_(max_addresses, max_pct, network, filtered);
1216    Check();
1217    return addresses;
1218}
1219
1220std::vector<std::pair<AddrInfo, AddressPosition>> AddrManImpl::GetEntries(bool from_tried) const
1221{
1222    LOCK(cs);
1223    Check();
1224    auto addrInfos = GetEntries_(from_tried);
1225    Check();
1226    return addrInfos;
1227}
1228
1229void AddrManImpl::Connected(const CService& addr, NodeSeconds time)
1230{
1231    LOCK(cs);
1232    Check();
1233    Connected_(addr, time);
1234    Check();
1235}
1236
1237void AddrManImpl::SetServices(const CService& addr, ServiceFlags nServices)
1238{
1239    LOCK(cs);
1240    Check();
1241    SetServices_(addr, nServices);
1242    Check();
1243}
1244
1245std::optional<AddressPosition> AddrManImpl::FindAddressEntry(const CAddress& addr)
1246{
1247    LOCK(cs);
1248    Check();
1249    auto entry = FindAddressEntry_(addr);
1250    Check();