Updating and selecting peer candidates

751                } else {
752                    break;
753                }
754            }
755        }
756
757        // If the bucket is entirely empty, start over with a (likely) different one.
758        if (i == ADDRMAN_BUCKET_SIZE) continue;
759
760        // Find the entry to return.
761        const auto it_found{mapInfo.find(node_id)};
762        assert(it_found != mapInfo.end());
763        const AddrInfo& info{it_found->second};
764
765        // With probability GetChance() * chance_factor, return the entry.
766        if (insecure_rand.randbits<30>() < chance_factor * info.GetChance() * (1 << 30)) {
767            LogDebug(BCLog::ADDRMAN, "Selected %s from %s\n", info.ToStringAddrPort(), search_tried ? "tried" : "new");
768            return {info, info.m_last_try};
769        }
770
771        // Otherwise start over with a (likely) different bucket, and increased chance factor.
772        chance_factor *= 1.2;
773    }
774}
775
776nid_type AddrManImpl::GetEntry(bool use_tried, size_t bucket, size_t position) const
777{
778    AssertLockHeld(cs);
779
780    if (use_tried) {
781        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_TRIED_BUCKET_COUNT)) {
782            return vvTried[bucket][position];
783        }
784    } else {
785        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_NEW_BUCKET_COUNT)) {
786            return vvNew[bucket][position];
787        }
788    }
789
790    return -1;
791}
792
793std::vector<CAddress> AddrManImpl::GetAddr_(size_t max_addresses, size_t max_pct, std::optional<Network> network, const bool filtered) const
794{
795    AssertLockHeld(cs);
796    Assume(max_pct <= 100);
797
798    size_t nNodes = vRandom.size();
799    if (max_pct != 0) {
800        max_pct = std::min(max_pct, size_t{100});
801        nNodes = max_pct * nNodes / 100;
802    }
803    if (max_addresses != 0) {
804        nNodes = std::min(nNodes, max_addresses);
805    }
806
807    // gather a list of random nodes, skipping those of low quality
808    const auto now{Now<NodeSeconds>()};
809    std::vector<CAddress> addresses;
810    addresses.reserve(nNodes);
811    for (unsigned int n = 0; n < vRandom.size(); n++) {
812        if (addresses.size() >= nNodes)
813            break;
814
815        int nRndPos = insecure_rand.randrange(vRandom.size() - n) + n;
816        SwapRandom(n, nRndPos);
817        const auto it{mapInfo.find(vRandom[n])};
818        assert(it != mapInfo.end());
819
820        const AddrInfo& ai{it->second};
821
822        // Filter by network (optional)
823        if (network != std::nullopt && ai.GetNetClass() != network) continue;
824
825        // Filter for quality
826        if (ai.IsTerrible(now) && filtered) continue;
827
828        addresses.push_back(ai);
829    }
830    LogDebug(BCLog::ADDRMAN, "GetAddr returned %d random addresses\n", addresses.size());
831    return addresses;
832}
833
834std::vector<std::pair<AddrInfo, AddressPosition>> AddrManImpl::GetEntries_(bool from_tried) const
835{
836    AssertLockHeld(cs);
837
838    const int bucket_count = from_tried ? ADDRMAN_TRIED_BUCKET_COUNT : ADDRMAN_NEW_BUCKET_COUNT;
839    std::vector<std::pair<AddrInfo, AddressPosition>> infos;
840    for (int bucket = 0; bucket < bucket_count; ++bucket) {
841        for (int position = 0; position < ADDRMAN_BUCKET_SIZE; ++position) {
842            nid_type id = GetEntry(from_tried, bucket, position);
843            if (id >= 0) {
844                AddrInfo info = mapInfo.at(id);
845                AddressPosition location = AddressPosition(
846                    from_tried,
847                    /*multiplicity_in=*/from_tried ? 1 : info.nRefCount,
848                    bucket,
849                    position);
850                infos.emplace_back(info, location);
851            }
852        }
853    }
854
855    return infos;
856}
857
858void AddrManImpl::Connected_(const CService& addr, NodeSeconds time)
859{
860    AssertLockHeld(cs);
861
862    AddrInfo* pinfo = Find(addr);
863
864    // if not found, bail out
865    if (!pinfo)
866        return;
867
868    AddrInfo& info = *pinfo;
869
870    // update info
871    const auto update_interval{20min};
872    if (time - info.nTime > update_interval) {
873        info.nTime = time;
874    }
875}
876
877void AddrManImpl::SetServices_(const CService& addr, ServiceFlags nServices)
878{
879    AssertLockHeld(cs);
880
881    AddrInfo* pinfo = Find(addr);
882
883    // if not found, bail out
884    if (!pinfo)
885        return;
886
887    AddrInfo& info = *pinfo;
888
889    // update info
890    info.nServices = nServices;
891}
892
893void AddrManImpl::ResolveCollisions_()
894{
895    AssertLockHeld(cs);
896
897    for (std::set<nid_type>::iterator it = m_tried_collisions.begin(); it != m_tried_collisions.end();) {
898        nid_type id_new = *it;
899
900        bool erase_collision = false;
901
902        // If id_new not found in mapInfo remove it from m_tried_collisions
903        if (!mapInfo.contains(id_new)) {
904            erase_collision = true;
905        } else {
906            AddrInfo& info_new = mapInfo[id_new];
907
908            // Which tried bucket to move the entry to.
909            int tried_bucket = info_new.GetTriedBucket(nKey, m_netgroupman);
910            int tried_bucket_pos = info_new.GetBucketPosition(nKey, false, tried_bucket);
911            if (!info_new.IsValid()) { // id_new may no longer map to a valid address
912                erase_collision = true;
913            } else {
914                // A pending tried collision implies that the destination tried slot
915                // remains occupied until we resolve it.
916                Assume(vvTried[tried_bucket][tried_bucket_pos] != -1);
917
918                // Get the to-be-evicted address that is being tested
919                nid_type id_old = vvTried[tried_bucket][tried_bucket_pos];
920                AddrInfo& info_old = mapInfo[id_old];
921
922                const auto current_time{Now<NodeSeconds>()};
923
924                // Has successfully connected in last X hours
925                if (current_time - info_old.m_last_success < ADDRMAN_REPLACEMENT) {
926                    erase_collision = true;
927                } else if (current_time - info_old.m_last_try < ADDRMAN_REPLACEMENT) { // attempted to connect and failed in last X hours
928
929                    // Give address at least 60 seconds to successfully connect
930                    if (current_time - info_old.m_last_try > 60s) {
931                        LogDebug(BCLog::ADDRMAN, "Replacing %s with %s in tried table\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
932
933                        // Replaces an existing address already in the tried table with the new address
934                        Good_(info_new, false, current_time);
935                        erase_collision = true;
936                    }
937                } else if (current_time - info_new.m_last_success > ADDRMAN_TEST_WINDOW) {
938                    // If the collision hasn't resolved in some reasonable amount of time,
939                    // just evict the old entry -- we must not be able to
940                    // connect to it for some reason.
941                    LogDebug(BCLog::ADDRMAN, "Unable to test; replacing %s with %s in tried table anyway\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
942                    Good_(info_new, false, current_time);
943                    erase_collision = true;
944                }
945            }
946        }
947
948        if (erase_collision) {
949            m_tried_collisions.erase(it++);
950        } else {
951            it++;
952        }
953    }
954}
955
956std::pair<CAddress, NodeSeconds> AddrManImpl::SelectTriedCollision_()
957{
958    AssertLockHeld(cs);
959
960    if (m_tried_collisions.size() == 0) return {};
961
962    std::set<nid_type>::iterator it = m_tried_collisions.begin();
963
964    // Selects a random element from m_tried_collisions
965    std::advance(it, insecure_rand.randrange(m_tried_collisions.size()));
966    nid_type id_new = *it;
967
968    // If id_new not found in mapInfo remove it from m_tried_collisions
969    if (!mapInfo.contains(id_new)) {
970        m_tried_collisions.erase(it);
971        return {};
972    }
973
974    const AddrInfo& newInfo = mapInfo[id_new];
975
976    // which tried bucket to move the entry to
977    int tried_bucket = newInfo.GetTriedBucket(nKey, m_netgroupman);
978    int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket);
979
980    Assume(vvTried[tried_bucket][tried_bucket_pos] != -1);
981    const AddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]];
982    return {info_old, info_old.m_last_try};
983}
984
985std::optional<AddressPosition> AddrManImpl::FindAddressEntry_(const CAddress& addr)
986{
987    AssertLockHeld(cs);
988
989    AddrInfo* addr_info = Find(addr);
990
991    if (!addr_info) return std::nullopt;
992
993    if(addr_info->fInTried) {
994        int bucket{addr_info->GetTriedBucket(nKey, m_netgroupman)};
995        return AddressPosition(/*tried_in=*/true,
996                               /*multiplicity_in=*/1,
997                               /*bucket_in=*/bucket,
998                               /*position_in=*/addr_info->GetBucketPosition(nKey, false, bucket));
999    } else {
1000        int bucket{addr_info->GetNewBucket(nKey, m_netgroupman)};