{

uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetKey()).GetCheapHash();

uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();

return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;

{

std::vector<unsigned char> vchSourceGroupKey = src.GetGroup(asmap);

uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << vchSourceGroupKey).GetCheapHash();

uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey << vchSourceGroupKey << (hash1 % ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP)).GetCheapHash();

return hash2 % ADDRMAN_NEW_BUCKET_COUNT;

{

uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << nBucket << GetKey()).GetCheapHash();

return hash1 % ADDRMAN_BUCKET_SIZE;

{

if (nLastTry && nLastTry >= nNow - 60) // never remove things tried in the last minute

return false;

if (nTime > nNow + 10 * 60) // came in a flying DeLorean

return true;

if (nTime == 0 || nNow - nTime > ADDRMAN_HORIZON_DAYS * 24 * 60 * 60) // not seen in recent history

return true;

if (nLastSuccess == 0 && nAttempts >= ADDRMAN_RETRIES) // tried N times and never a success

return true;

if (nNow - nLastSuccess > ADDRMAN_MIN_FAIL_DAYS * 24 * 60 * 60 && nAttempts >= ADDRMAN_MAX_FAILURES) // N successive failures in the last week

return true;

return false;

{

double fChance = 1.0;

int64_t nSinceLastTry = std::max<int64_t>(nNow - nLastTry, 0);

// deprioritize very recent attempts away

if (nSinceLastTry < 60 * 10)

fChance *= 0.01;

// deprioritize 66% after each failed attempt, but at most 1/28th to avoid the search taking forever or overly penalizing outages.

fChance *= pow(0.66, std::min(nAttempts, 8));

return fChance;

: insecure_rand{deterministic}

, nKey{deterministic ? uint256{1} : insecure_rand.rand256()}

, m_consistency_check_ratio{consistency_check_ratio}

, m_asmap{std::move(asmap)}

{

for (auto& bucket : vvNew) {

for (auto& entry : bucket) {

entry = -1;

}

}

for (auto& bucket : vvTried) {

for (auto& entry : bucket) {

entry = -1;

}

}

{

LOCK(cs);

/**

// Always serialize in the latest version (FILE_FORMAT).

OverrideStream<Stream> s(&s_, s_.GetType(), s_.GetVersion() | ADDRV2_FORMAT);

s << static_cast<uint8_t>(FILE_FORMAT);

// Increment `lowest_compatible` iff a newly introduced format is incompatible with

// the previous one.

static constexpr uint8_t lowest_compatible = Format::V4_MULTIPORT;

s << static_cast<uint8_t>(INCOMPATIBILITY_BASE + lowest_compatible);

s << nKey;

s << nNew;

s << nTried;

int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);

s << nUBuckets;

std::unordered_map<int, int> mapUnkIds;

int nIds = 0;

for (const auto& entry : mapInfo) {

mapUnkIds[entry.first] = nIds;

const AddrInfo& info = entry.second;

if (info.nRefCount) {

assert(nIds != nNew); // this means nNew was wrong, oh ow

s << info;

nIds++;

}

}

nIds = 0;

for (const auto& entry : mapInfo) {

const AddrInfo& info = entry.second;

if (info.fInTried) {

assert(nIds != nTried); // this means nTried was wrong, oh ow

s << info;

nIds++;

}

}

for (int bucket = 0; bucket < ADDRMAN_NEW_BUCKET_COUNT; bucket++) {

int nSize = 0;

for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {

if (vvNew[bucket][i] != -1)

nSize++;

}

s << nSize;

for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {

if (vvNew[bucket][i] != -1) {

int nIndex = mapUnkIds[vvNew[bucket][i]];

s << nIndex;

}

}

}

// Store asmap checksum after bucket entries so that it

// can be ignored by older clients for backward compatibility.

uint256 asmap_checksum;

if (m_asmap.size() != 0) {

asmap_checksum = SerializeHash(m_asmap);

}

s << asmap_checksum;

{

LOCK(cs);

assert(vRandom.empty());

Format format;

s_ >> Using<CustomUintFormatter<1>>(format);

int stream_version = s_.GetVersion();

if (format >= Format::V3_BIP155) {

// Add ADDRV2_FORMAT to the version so that the CNetAddr and CAddress

// unserialize methods know that an address in addrv2 format is coming.

stream_version |= ADDRV2_FORMAT;

}

OverrideStream<Stream> s(&s_, s_.GetType(), stream_version);

uint8_t compat;

s >> compat;

if (compat < INCOMPATIBILITY_BASE) {

throw std::ios_base::failure(strprintf(

"Corrupted addrman database: The compat value (%u) "

"is lower than the expected minimum value %u.",

compat, INCOMPATIBILITY_BASE));

}

const uint8_t lowest_compatible = compat - INCOMPATIBILITY_BASE;

if (lowest_compatible > FILE_FORMAT) {

throw InvalidAddrManVersionError(strprintf(

"Unsupported format of addrman database: %u. It is compatible with formats >=%u, "

"but the maximum supported by this version of %s is %u.",

uint8_t{format}, lowest_compatible, PACKAGE_NAME, uint8_t{FILE_FORMAT}));

}

s >> nKey;

s >> nNew;

s >> nTried;

int nUBuckets = 0;

s >> nUBuckets;

if (format >= Format::V1_DETERMINISTIC) {

nUBuckets ^= (1 << 30);

}

if (nNew > ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nNew < 0) {

throw std::ios_base::failure(

strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",

nNew,

ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));

}

if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {

throw std::ios_base::failure(

strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",

nTried,

ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));

}

// Deserialize entries from the new table.

for (int n = 0; n < nNew; n++) {

AddrInfo& info = mapInfo[n];

s >> info;

mapAddr[info] = n;

info.nRandomPos = vRandom.size();

vRandom.push_back(n);

}

nIdCount = nNew;

// Deserialize entries from the tried table.

int nLost = 0;

for (int n = 0; n < nTried; n++) {

AddrInfo info;

s >> info;

int nKBucket = info.GetTriedBucket(nKey, m_asmap);

int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);

if (info.IsValid()

&& vvTried[nKBucket][nKBucketPos] == -1) {

info.nRandomPos = vRandom.size();

info.fInTried = true;

vRandom.push_back(nIdCount);

mapInfo[nIdCount] = info;

mapAddr[info] = nIdCount;

vvTried[nKBucket][nKBucketPos] = nIdCount;

nIdCount++;

} else {

nLost++;

}

}

nTried -= nLost;

// Store positions in the new table buckets to apply later (if possible).

// An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,

// so we store all bucket-entry_index pairs to iterate through later.

std::vector<std::pair<int, int>> bucket_entries;

for (int bucket = 0; bucket < nUBuckets; ++bucket) {

int num_entries{0};

s >> num_entries;

for (int n = 0; n < num_entries; ++n) {

int entry_index{0};

s >> entry_index;

if (entry_index >= 0 && entry_index < nNew) {

bucket_entries.emplace_back(bucket, entry_index);

}

}

}

// If the bucket count and asmap checksum haven't changed, then attempt

// to restore the entries to the buckets/positions they were in before

// serialization.

uint256 supplied_asmap_checksum;

if (m_asmap.size() != 0) {

supplied_asmap_checksum = SerializeHash(m_asmap);

}

uint256 serialized_asmap_checksum;

if (format >= Format::V2_ASMAP) {

s >> serialized_asmap_checksum;

}

const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&

serialized_asmap_checksum == supplied_asmap_checksum};

if (!restore_bucketing) {

LogPrint(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");

}

for (auto bucket_entry : bucket_entries) {

int bucket{bucket_entry.first};

const int entry_index{bucket_entry.second};

AddrInfo& info = mapInfo[entry_index];

// Don't store the entry in the new bucket if it's not a valid address for our addrman

if (!info.IsValid()) continue;

// The entry shouldn't appear in more than

// ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip

// this bucket_entry.

if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;

int bucket_position = info.GetBucketPosition(nKey, true, bucket);

if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {

// Bucketing has not changed, using existing bucket positions for the new table

vvNew[bucket][bucket_position] = entry_index;

++info.nRefCount;

} else {

// In case the new table data cannot be used (bucket count wrong or new asmap),

// try to give them a reference based on their primary source address.

bucket = info.GetNewBucket(nKey, m_asmap);

bucket_position = info.GetBucketPosition(nKey, true, bucket);

if (vvNew[bucket][bucket_position] == -1) {

vvNew[bucket][bucket_position] = entry_index;

++info.nRefCount;

}

}

}

// Prune new entries with refcount 0 (as a result of collisions or invalid address).

int nLostUnk = 0;

for (auto it = mapInfo.cbegin(); it != mapInfo.cend(); ) {

if (it->second.fInTried == false && it->second.nRefCount == 0) {

const auto itCopy = it++;

Delete(itCopy->first);

++nLostUnk;

} else {

++it;

}

}

if (nLost + nLostUnk > 0) {

LogPrint(BCLog::ADDRMAN, "addrman lost %i new and %i tried addresses due to collisions or invalid addresses\n", nLostUnk, nLost);

}

const int check_code{CheckAddrman()};

if (check_code != 0) {

throw std::ios_base::failure(strprintf(

"Corrupt data. Consistency check failed with code %s",

check_code));

}

{

AssertLockHeld(cs);

if (nRndPos1 == nRndPos2)

return;

assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());

int nId1 = vRandom[nRndPos1];

int nId2 = vRandom[nRndPos2];

const auto it_1{mapInfo.find(nId1)};

const auto it_2{mapInfo.find(nId2)};

assert(it_1 != mapInfo.end());

assert(it_2 != mapInfo.end());

it_1->second.nRandomPos = nRndPos2;

it_2->second.nRandomPos = nRndPos1;

vRandom[nRndPos1] = nId2;

vRandom[nRndPos2] = nId1;

{

AssertLockHeld(cs);

assert(mapInfo.count(nId) != 0);

AddrInfo& info = mapInfo[nId];

assert(!info.fInTried);

assert(info.nRefCount == 0);

SwapRandom(info.nRandomPos, vRandom.size() - 1);

vRandom.pop_back();

mapAddr.erase(info);

mapInfo.erase(nId);

nNew--;

{

AssertLockHeld(cs);

// if there is an entry in the specified bucket, delete it.

if (vvNew[nUBucket][nUBucketPos] != -1) {

int nIdDelete = vvNew[nUBucket][nUBucketPos];

AddrInfo& infoDelete = mapInfo[nIdDelete];

assert(infoDelete.nRefCount > 0);

infoDelete.nRefCount--;

vvNew[nUBucket][nUBucketPos] = -1;

LogPrint(BCLog::ADDRMAN, "Removed %s from new[%i][%i]\n", infoDelete.ToString(), nUBucket, nUBucketPos);

if (infoDelete.nRefCount == 0) {

Delete(nIdDelete);

}

}

{

AssertLockHeld(cs);

// remove the entry from all new buckets

const int start_bucket{info.GetNewBucket(nKey, m_asmap)};

for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; ++n) {

const int bucket{(start_bucket + n) % ADDRMAN_NEW_BUCKET_COUNT};

const int pos{info.GetBucketPosition(nKey, true, bucket)};

if (vvNew[bucket][pos] == nId) {

vvNew[bucket][pos] = -1;

info.nRefCount--;

if (info.nRefCount == 0) break;

}

}

nNew--;

assert(info.nRefCount == 0);

// which tried bucket to move the entry to

int nKBucket = info.GetTriedBucket(nKey, m_asmap);

int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);

// first make space to add it (the existing tried entry there is moved to new, deleting whatever is there).

if (vvTried[nKBucket][nKBucketPos] != -1) {

// find an item to evict

int nIdEvict = vvTried[nKBucket][nKBucketPos];

assert(mapInfo.count(nIdEvict) == 1);

AddrInfo& infoOld = mapInfo[nIdEvict];

// Remove the to-be-evicted item from the tried set.

infoOld.fInTried = false;

vvTried[nKBucket][nKBucketPos] = -1;

nTried--;

// find which new bucket it belongs to

int nUBucket = infoOld.GetNewBucket(nKey, m_asmap);

int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);

ClearNew(nUBucket, nUBucketPos);

assert(vvNew[nUBucket][nUBucketPos] == -1);

// Enter it into the new set again.

infoOld.nRefCount = 1;

vvNew[nUBucket][nUBucketPos] = nIdEvict;

nNew++;

LogPrint(BCLog::ADDRMAN, "Moved %s from tried[%i][%i] to new[%i][%i] to make space\n",

infoOld.ToString(), nKBucket, nKBucketPos, nUBucket, nUBucketPos);

}

assert(vvTried[nKBucket][nKBucketPos] == -1);

vvTried[nKBucket][nKBucketPos] = nId;

nTried++;

info.fInTried = true;

{

AssertLockHeld(cs);

if (!addr.IsRoutable())

return false;

int nId;

AddrInfo* pinfo = Find(addr, &nId);

// Do not set a penalty for a source's self-announcement

if (addr == source) {

nTimePenalty = 0;

}

if (pinfo) {

// periodically update nTime

bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);

int64_t nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);

if (addr.nTime && (!pinfo->nTime || pinfo->nTime < addr.nTime - nUpdateInterval - nTimePenalty))

pinfo->nTime = std::max((int64_t)0, addr.nTime - nTimePenalty);

// add services

pinfo->nServices = ServiceFlags(pinfo->nServices | addr.nServices);

// do not update if no new information is present

if (!addr.nTime || (pinfo->nTime && addr.nTime <= pinfo->nTime))

return false;

// do not update if the entry was already in the "tried" table

if (pinfo->fInTried)

return false;

// do not update if the max reference count is reached

if (pinfo->nRefCount == ADDRMAN_NEW_BUCKETS_PER_ADDRESS)

return false;

// stochastic test: previous nRefCount == N: 2^N times harder to increase it

int nFactor = 1;

for (int n = 0; n < pinfo->nRefCount; n++)

nFactor *= 2;

if (nFactor > 1 && (insecure_rand.randrange(nFactor) != 0))

return false;

} else {

pinfo = Create(addr, source, &nId);

pinfo->nTime = std::max((int64_t)0, (int64_t)pinfo->nTime - nTimePenalty);

nNew++;

}

int nUBucket = pinfo->GetNewBucket(nKey, source, m_asmap);

int nUBucketPos = pinfo->GetBucketPosition(nKey, true, nUBucket);

bool fInsert = vvNew[nUBucket][nUBucketPos] == -1;

if (vvNew[nUBucket][nUBucketPos] != nId) {

if (!fInsert) {

AddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]];

if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) {

// Overwrite the existing new table entry.

fInsert = true;

}

}

if (fInsert) {

ClearNew(nUBucket, nUBucketPos);

pinfo->nRefCount++;

vvNew[nUBucket][nUBucketPos] = nId;

LogPrint(BCLog::ADDRMAN, "Added %s mapped to AS%i to new[%i][%i]\n",

addr.ToString(), addr.GetMappedAS(m_asmap), nUBucket, nUBucketPos);

} else {

if (pinfo->nRefCount == 0) {

Delete(nId);

}

}

}

return fInsert;

{

AssertLockHeld(cs);

int nId;

nLastGood = nTime;

AddrInfo* pinfo = Find(addr, &nId);

// if not found, bail out

if (!pinfo) return false;

AddrInfo& info = *pinfo;

// update info

info.nLastSuccess = nTime;

info.nLastTry = nTime;

info.nAttempts = 0;

// nTime is not updated here, to avoid leaking information about

// currently-connected peers.

// if it is already in the tried set, don't do anything else

if (info.fInTried) return false;

// if it is not in new, something bad happened

if (!Assume(info.nRefCount > 0)) return false;

// which tried bucket to move the entry to

int tried_bucket = info.GetTriedBucket(nKey, m_asmap);

int tried_bucket_pos = info.GetBucketPosition(nKey, false, tried_bucket);

// Will moving this address into tried evict another entry?

if (test_before_evict && (vvTried[tried_bucket][tried_bucket_pos] != -1)) {

if (m_tried_collisions.size() < ADDRMAN_SET_TRIED_COLLISION_SIZE) {

m_tried_collisions.insert(nId);

}

// Output the entry we'd be colliding with, for debugging purposes

auto colliding_entry = mapInfo.find(vvTried[tried_bucket][tried_bucket_pos]);

LogPrint(BCLog::ADDRMAN, "Collision with %s while attempting to move %s to tried table. Collisions=%d\n",

colliding_entry != mapInfo.end() ? colliding_entry->second.ToString() : "",

addr.ToString(),

m_tried_collisions.size());

return false;

} else {

// move nId to the tried tables

MakeTried(info, nId);

LogPrint(BCLog::ADDRMAN, "Moved %s mapped to AS%i to tried[%i][%i]\n",

addr.ToString(), addr.GetMappedAS(m_asmap), tried_bucket, tried_bucket_pos);

return true;

}

{

int added{0};

for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++) {

added += AddSingle(*it, source, nTimePenalty) ? 1 : 0;

}

if (added > 0) {

LogPrint(BCLog::ADDRMAN, "Added %i addresses (of %i) from %s: %i tried, %i new\n", added, vAddr.size(), source.ToString(), nTried, nNew);

}

return added > 0;

{

AssertLockHeld(cs);

AddrInfo* pinfo = Find(addr);

// if not found, bail out

if (!pinfo)

return;

AddrInfo& info = *pinfo;

// update info

info.nLastTry = nTime;

if (fCountFailure && info.nLastCountAttempt < nLastGood) {

info.nLastCountAttempt = nTime;

info.nAttempts++;

}

{

AssertLockHeld(cs);

if (vRandom.empty()) return {};

if (newOnly && nNew == 0) return {};

// Use a 50% chance for choosing between tried and new table entries.

if (!newOnly &&

(nTried > 0 && (nNew == 0 || insecure_rand.randbool() == 0))) {

// use a tried node

double fChanceFactor = 1.0;

while (1) {

// Pick a tried bucket, and an initial position in that bucket.

int nKBucket = insecure_rand.randrange(ADDRMAN_TRIED_BUCKET_COUNT);

int nKBucketPos = insecure_rand.randrange(ADDRMAN_BUCKET_SIZE);

// Iterate over the positions of that bucket, starting at the initial one,

// and looping around.

int i;

for (i = 0; i < ADDRMAN_BUCKET_SIZE; ++i) {

if (vvTried[nKBucket][(nKBucketPos + i) % ADDRMAN_BUCKET_SIZE] != -1) break;

}

// If the bucket is entirely empty, start over with a (likely) different one.

if (i == ADDRMAN_BUCKET_SIZE) continue;

// Find the entry to return.

int nId = vvTried[nKBucket][(nKBucketPos + i) % ADDRMAN_BUCKET_SIZE];

const auto it_found{mapInfo.find(nId)};

assert(it_found != mapInfo.end());

const AddrInfo& info{it_found->second};

// With probability GetChance() * fChanceFactor, return the entry.

if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) {

LogPrint(BCLog::ADDRMAN, "Selected %s from tried\n", info.ToString());

return {info, info.nLastTry};

}

// Otherwise start over with a (likely) different bucket, and increased chance factor.

fChanceFactor *= 1.2;

}

} else {

// use a new node

double fChanceFactor = 1.0;

while (1) {

// Pick a new bucket, and an initial position in that bucket.

int nUBucket = insecure_rand.randrange(ADDRMAN_NEW_BUCKET_COUNT);

int nUBucketPos = insecure_rand.randrange(ADDRMAN_BUCKET_SIZE);

// Iterate over the positions of that bucket, starting at the initial one,

// and looping around.

int i;

for (i = 0; i < ADDRMAN_BUCKET_SIZE; ++i) {

if (vvNew[nUBucket][(nUBucketPos + i) % ADDRMAN_BUCKET_SIZE] != -1) break;

}

// If the bucket is entirely empty, start over with a (likely) different one.

if (i == ADDRMAN_BUCKET_SIZE) continue;

// Find the entry to return.

int nId = vvNew[nUBucket][(nUBucketPos + i) % ADDRMAN_BUCKET_SIZE];

const auto it_found{mapInfo.find(nId)};

assert(it_found != mapInfo.end());

const AddrInfo& info{it_found->second};

// With probability GetChance() * fChanceFactor, return the entry.

if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) {

LogPrint(BCLog::ADDRMAN, "Selected %s from new\n", info.ToString());

return {info, info.nLastTry};

}

// Otherwise start over with a (likely) different bucket, and increased chance factor.

fChanceFactor *= 1.2;

}

}

{

AssertLockHeld(cs);

size_t nNodes = vRandom.size();

if (max_pct != 0) {

nNodes = max_pct * nNodes / 100;

}

if (max_addresses != 0) {

nNodes = std::min(nNodes, max_addresses);

}

// gather a list of random nodes, skipping those of low quality

const int64_t now{GetAdjustedTime()};

std::vector<CAddress> addresses;

for (unsigned int n = 0; n < vRandom.size(); n++) {

if (addresses.size() >= nNodes)

break;

int nRndPos = insecure_rand.randrange(vRandom.size() - n) + n;

SwapRandom(n, nRndPos);

const auto it{mapInfo.find(vRandom[n])};

assert(it != mapInfo.end());

const AddrInfo& ai{it->second};

// Filter by network (optional)

if (network != std::nullopt && ai.GetNetClass() != network) continue;

// Filter for quality

if (ai.IsTerrible(now)) continue;

addresses.push_back(ai);

}

LogPrint(BCLog::ADDRMAN, "GetAddr returned %d random addresses\n", addresses.size());

return addresses;

{

AssertLockHeld(cs);

AddrInfo* pinfo = Find(addr);

// if not found, bail out

if (!pinfo)

return;

AddrInfo& info = *pinfo;

// update info

int64_t nUpdateInterval = 20 * 60;

if (nTime - info.nTime > nUpdateInterval)

info.nTime = nTime;

{

AssertLockHeld(cs);

AddrInfo* pinfo = Find(addr);

// if not found, bail out

if (!pinfo)

return;

AddrInfo& info = *pinfo;

// update info

info.nServices = nServices;

{

AssertLockHeld(cs);

for (std::set<int>::iterator it = m_tried_collisions.begin(); it != m_tried_collisions.end();) {

int id_new = *it;

bool erase_collision = false;

// If id_new not found in mapInfo remove it from m_tried_collisions

if (mapInfo.count(id_new) != 1) {

erase_collision = true;

} else {

AddrInfo& info_new = mapInfo[id_new];

// Which tried bucket to move the entry to.

int tried_bucket = info_new.GetTriedBucket(nKey, m_asmap);

int tried_bucket_pos = info_new.GetBucketPosition(nKey, false, tried_bucket);

if (!info_new.IsValid()) { // id_new may no longer map to a valid address

erase_collision = true;

} else if (vvTried[tried_bucket][tried_bucket_pos] != -1) { // The position in the tried bucket is not empty

// Get the to-be-evicted address that is being tested

int id_old = vvTried[tried_bucket][tried_bucket_pos];

AddrInfo& info_old = mapInfo[id_old];

// Has successfully connected in last X hours

if (GetAdjustedTime() - info_old.nLastSuccess < ADDRMAN_REPLACEMENT_HOURS*(60*60)) {

erase_collision = true;

} else if (GetAdjustedTime() - info_old.nLastTry < ADDRMAN_REPLACEMENT_HOURS*(60*60)) { // attempted to connect and failed in last X hours

// Give address at least 60 seconds to successfully connect

if (GetAdjustedTime() - info_old.nLastTry > 60) {

LogPrint(BCLog::ADDRMAN, "Replacing %s with %s in tried table\n", info_old.ToString(), info_new.ToString());

// Replaces an existing address already in the tried table with the new address

Good_(info_new, false, GetAdjustedTime());

erase_collision = true;

}

} else if (GetAdjustedTime() - info_new.nLastSuccess > ADDRMAN_TEST_WINDOW) {

// If the collision hasn't resolved in some reasonable amount of time,

// just evict the old entry -- we must not be able to

// connect to it for some reason.

LogPrint(BCLog::ADDRMAN, "Unable to test; replacing %s with %s in tried table anyway\n", info_old.ToString(), info_new.ToString());

Good_(info_new, false, GetAdjustedTime());

erase_collision = true;

}

} else { // Collision is not actually a collision anymore

Good_(info_new, false, GetAdjustedTime());

erase_collision = true;

}

}

if (erase_collision) {

m_tried_collisions.erase(it++);

} else {

it++;

}

}

{

AssertLockHeld(cs);

if (m_tried_collisions.size() == 0) return {};

std::set<int>::iterator it = m_tried_collisions.begin();

// Selects a random element from m_tried_collisions

std::advance(it, insecure_rand.randrange(m_tried_collisions.size()));

int id_new = *it;

// If id_new not found in mapInfo remove it from m_tried_collisions

if (mapInfo.count(id_new) != 1) {

m_tried_collisions.erase(it);

return {};

}

const AddrInfo& newInfo = mapInfo[id_new];

// which tried bucket to move the entry to

int tried_bucket = newInfo.GetTriedBucket(nKey, m_asmap);

int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket);

const AddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]];

return {info_old, info_old.nLastTry};

{

AssertLockHeld(cs);

AddrInfo* addr_info = Find(addr);

if (!addr_info) return std::nullopt;

if(addr_info->fInTried) {

int bucket{addr_info->GetTriedBucket(nKey, m_asmap)};

return AddressPosition(/*tried_in=*/true,

/*multiplicity_in=*/1,

/*bucket_in=*/bucket,

/*position_in=*/addr_info->GetBucketPosition(nKey, false, bucket));

} else {

int bucket{addr_info->GetNewBucket(nKey, m_asmap)};

return AddressPosition(/*tried_in=*/false,

/*multiplicity_in=*/addr_info->nRefCount,

/*bucket_in=*/bucket,

/*position_in=*/addr_info->GetBucketPosition(nKey, true, bucket));

}

{

AssertLockHeld(cs);

// Run consistency checks 1 in m_consistency_check_ratio times if enabled

if (m_consistency_check_ratio == 0) return;

if (insecure_rand.randrange(m_consistency_check_ratio) >= 1) return;

const int err{CheckAddrman()};

if (err) {

LogPrintf("ADDRMAN CONSISTENCY CHECK FAILED!!! err=%i\n", err);

assert(false);

}

{

AssertLockHeld(cs);

LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(

strprintf("new %i, tried %i, total %u", nNew, nTried, vRandom.size()), BCLog::ADDRMAN);

std::unordered_set<int> setTried;

std::unordered_map<int, int> mapNew;

if (vRandom.size() != (size_t)(nTried + nNew))

return -7;

for (const auto& entry : mapInfo) {

int n = entry.first;

const AddrInfo& info = entry.second;

if (info.fInTried) {

if (!info.nLastSuccess)

return -1;

if (info.nRefCount)

return -2;

setTried.insert(n);

} else {

if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)