501        AddrInfo& infoOld = mapInfo[nIdEvict];
502
503        // Remove the to-be-evicted item from the tried set.
504        infoOld.fInTried = false;
505        vvTried[nKBucket][nKBucketPos] = -1;
506        nTried--;
507        m_network_counts[infoOld.GetNetwork()].n_tried--;
508
509        // find which new bucket it belongs to
510        int nUBucket = infoOld.GetNewBucket(nKey, m_netgroupman);
511        int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);
512        ClearNew(nUBucket, nUBucketPos);
513        assert(vvNew[nUBucket][nUBucketPos] == -1);
514
515        // Enter it into the new set again.
516        infoOld.nRefCount = 1;
517        vvNew[nUBucket][nUBucketPos] = nIdEvict;
518        nNew++;
519        m_network_counts[infoOld.GetNetwork()].n_new++;
520        LogDebug(BCLog::ADDRMAN, "Moved %s from tried[%i][%i] to new[%i][%i] to make space\n",
521                 infoOld.ToStringAddrPort(), nKBucket, nKBucketPos, nUBucket, nUBucketPos);
522    }
523    assert(vvTried[nKBucket][nKBucketPos] == -1);
524
525    vvTried[nKBucket][nKBucketPos] = nId;
526    nTried++;
527    info.fInTried = true;
528    m_network_counts[info.GetNetwork()].n_tried++;
529}
530
531bool AddrManImpl::AddSingle(const CAddress& addr, const CNetAddr& source, std::chrono::seconds time_penalty)
532{
533    AssertLockHeld(cs);
534
535    if (!addr.IsRoutable())
536        return false;
537
538    nid_type nId;
539    AddrInfo* pinfo = Find(addr, &nId);
540
541    // Do not set a penalty for a source's self-announcement
542    if (addr == source) {
543        time_penalty = 0s;
544    }
545
546    if (pinfo) {
547        // periodically update nTime
548        const bool currently_online{NodeClock::now() - addr.nTime < 24h};
549        const auto update_interval{currently_online ? 1h : 24h};
550        if (pinfo->nTime < addr.nTime - update_interval - time_penalty) {
551            pinfo->nTime = std::max(NodeSeconds{0s}, addr.nTime - time_penalty);
552        }
553
554        // add services
555        pinfo->nServices = ServiceFlags(pinfo->nServices | addr.nServices);
556
557        // do not update if no new information is present
558        if (addr.nTime <= pinfo->nTime) {
559            return false;
560        }
561
562        // do not update if the entry was already in the "tried" table
563        if (pinfo->fInTried)
564            return false;
565
566        // do not update if the max reference count is reached
567        if (pinfo->nRefCount == ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
568            return false;
569
570        // stochastic test: previous nRefCount == N: 2^N times harder to increase it
571        if (pinfo->nRefCount > 0) {
572            const int nFactor{1 << pinfo->nRefCount};
573            if (insecure_rand.randrange(nFactor) != 0) return false;
574        }
575    } else {
576        pinfo = Create(addr, source, &nId);
577        pinfo->nTime = std::max(NodeSeconds{0s}, pinfo->nTime - time_penalty);
578    }
579
580    int nUBucket = pinfo->GetNewBucket(nKey, source, m_netgroupman);
581    int nUBucketPos = pinfo->GetBucketPosition(nKey, true, nUBucket);
582    bool fInsert = vvNew[nUBucket][nUBucketPos] == -1;
583    if (vvNew[nUBucket][nUBucketPos] != nId) {
584        if (!fInsert) {
585            AddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]];
586            if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) {
587                // Overwrite the existing new table entry.
588                fInsert = true;
589            }
590        }
591        if (fInsert) {
592            ClearNew(nUBucket, nUBucketPos);
593            pinfo->nRefCount++;
594            vvNew[nUBucket][nUBucketPos] = nId;
595            const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
596            LogDebug(BCLog::ADDRMAN, "Added %s%s to new[%i][%i]\n",
597                     addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), nUBucket, nUBucketPos);
598        } else {
599            if (pinfo->nRefCount == 0) {
600                Delete(nId);
601            }
602        }
603    }
604    return fInsert;
605}
606
607bool AddrManImpl::Good_(const CService& addr, bool test_before_evict, NodeSeconds time)
608{
609    AssertLockHeld(cs);
610
611    nid_type nId;
612
613    m_last_good = time;
614
615    AddrInfo* pinfo = Find(addr, &nId);
616
617    // if not found, bail out
618    if (!pinfo) return false;
619
620    AddrInfo& info = *pinfo;
621
622    // update info
623    info.m_last_success = time;
624    info.m_last_try = time;
625    info.nAttempts = 0;
626    // nTime is not updated here, to avoid leaking information about
627    // currently-connected peers.
628
629    // if it is already in the tried set, don't do anything else
630    if (info.fInTried) return false;
631
632    // if it is not in new, something bad happened
633    if (!Assume(info.nRefCount > 0)) return false;
634
635
636    // which tried bucket to move the entry to
637    int tried_bucket = info.GetTriedBucket(nKey, m_netgroupman);
638    int tried_bucket_pos = info.GetBucketPosition(nKey, false, tried_bucket);
639
640    // Will moving this address into tried evict another entry?
641    if (test_before_evict && (vvTried[tried_bucket][tried_bucket_pos] != -1)) {
642        if (m_tried_collisions.size() < ADDRMAN_SET_TRIED_COLLISION_SIZE) {
643            m_tried_collisions.insert(nId);
644        }
645        // Output the entry we'd be colliding with, for debugging purposes
646        auto colliding_entry = mapInfo.find(vvTried[tried_bucket][tried_bucket_pos]);
647        LogDebug(BCLog::ADDRMAN, "Collision with %s while attempting to move %s to tried table. Collisions=%d",
648                 colliding_entry != mapInfo.end() ? colliding_entry->second.ToStringAddrPort() : "<unknown-addr>",
649                 addr.ToStringAddrPort(),
650                 m_tried_collisions.size());
651        return false;
652    } else {
653        // move nId to the tried tables
654        MakeTried(info, nId);
655        const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
656        LogDebug(BCLog::ADDRMAN, "Moved %s%s to tried[%i][%i]\n",
657                 addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), tried_bucket, tried_bucket_pos);
658        return true;
659    }
660}
661
662bool AddrManImpl::Add_(const std::vector<CAddress>& vAddr, const CNetAddr& source, std::chrono::seconds time_penalty)
663{
664    int added{0};
665    for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++) {
666        added += AddSingle(*it, source, time_penalty) ? 1 : 0;
667    }
668    if (added > 0) {
669        LogDebug(BCLog::ADDRMAN, "Added %i addresses (of %i) from %s: %i tried, %i new\n", added, vAddr.size(), source.ToStringAddr(), nTried, nNew);
670    }
671    return added > 0;
672}
673
674void AddrManImpl::Attempt_(const CService& addr, bool fCountFailure, NodeSeconds time)
675{
676    AssertLockHeld(cs);
677
678    AddrInfo* pinfo = Find(addr);
679
680    // if not found, bail out
681    if (!pinfo)
682        return;
683
684    AddrInfo& info = *pinfo;
685
686    // update info
687    info.m_last_try = time;
688    if (fCountFailure && info.m_last_count_attempt < m_last_good) {
689        info.m_last_count_attempt = time;
690        info.nAttempts++;
691    }
692}
693
694std::pair<CAddress, NodeSeconds> AddrManImpl::Select_(bool new_only, const std::unordered_set<Network>& networks) const
695{
696    AssertLockHeld(cs);
697
698    if (vRandom.empty()) return {};
699
700    size_t new_count = nNew;
701    size_t tried_count = nTried;
702
703    if (!networks.empty()) {
704        new_count = 0;
705        tried_count = 0;
706        for (auto& network : networks) {
707            auto it = m_network_counts.find(network);
708            if (it == m_network_counts.end()) {
709                continue;
710            }
711            auto counts = it->second;
712            new_count += counts.n_new;
713            tried_count += counts.n_tried;
714        }
715    }
716
717    if (new_only && new_count == 0) return {};
718    if (new_count + tried_count == 0) return {};
719
720    // Decide if we are going to search the new or tried table
721    // If either option is viable, use a 50% chance to choose
722    bool search_tried;
723    if (new_only || tried_count == 0) {
724        search_tried = false;
725    } else if (new_count == 0) {
726        search_tried = true;
727    } else {
728        search_tried = insecure_rand.randbool();
729    }
730
731    const int bucket_count{search_tried ? ADDRMAN_TRIED_BUCKET_COUNT : ADDRMAN_NEW_BUCKET_COUNT};
732
733    // Loop through the addrman table until we find an appropriate entry
734    double chance_factor = 1.0;
735    while (1) {
736        // Pick a bucket, and an initial position in that bucket.
737        int bucket = insecure_rand.randrange(bucket_count);
738        int initial_position = insecure_rand.randrange(ADDRMAN_BUCKET_SIZE);
739
740        // Iterate over the positions of that bucket, starting at the initial one,
741        // and looping around.
742        int i, position;
743        nid_type node_id;
744        for (i = 0; i < ADDRMAN_BUCKET_SIZE; ++i) {
745            position = (initial_position + i) % ADDRMAN_BUCKET_SIZE;
746            node_id = GetEntry(search_tried, bucket, position);
747            if (node_id != -1) {
748                if (!networks.empty()) {
749                    const auto it{mapInfo.find(node_id)};
750                    if (Assume(it != mapInfo.end()) && networks.contains(it->second.GetNetwork())) break;