foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-13 11:25:02 -05:00
Code Issues Activity

scripted-diff: Rename CAddrInfo to AddrInfo

Browse source 
-BEGIN VERIFY SCRIPT-
git grep -l CAddrInfo src/ | xargs sed -i 's/CAddrInfo/AddrInfo/g'
-END VERIFY SCRIPT-
This commit is contained in:
Amiti Uttarwar 2021-09-10 18:33:25 -06:00
parent dd8f7f2500
commit 375750387e
5 changed files with 77 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
src/addrman.cpp
View file

@ -41,7 +41,7 @@ static constexpr size_t ADDRMAN_SET_TRIED_COLLISION_SIZE{10};
/** The maximum time we'll spend trying to resolve a tried table collision, in seconds */ /** The maximum time we'll spend trying to resolve a tried table collision, in seconds */
static constexpr int64_t ADDRMAN_TEST_WINDOW{40*60}; // 40 minutes static constexpr int64_t ADDRMAN_TEST_WINDOW{40*60}; // 40 minutes
int CAddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap) const int AddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap) const
{ {
uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetKey()).GetCheapHash(); 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(); uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();
@ -51,7 +51,7 @@ int CAddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asma
return tried_bucket; return tried_bucket;
} }
int CAddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool> &asmap) const int AddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std::vector<bool> &asmap) const
{ {
std::vector<unsigned char> vchSourceGroupKey = src.GetGroup(asmap); std::vector<unsigned char> vchSourceGroupKey = src.GetGroup(asmap);
uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << vchSourceGroupKey).GetCheapHash(); uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetGroup(asmap) << vchSourceGroupKey).GetCheapHash();
@ -62,13 +62,13 @@ int CAddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src, const std:
return new_bucket; return new_bucket;
} }
int CAddrInfo::GetBucketPosition(const uint256 &nKey, bool fNew, int nBucket) const int AddrInfo::GetBucketPosition(const uint256 &nKey, bool fNew, int nBucket) const
{ {
uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << nBucket << GetKey()).GetCheapHash(); uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << nBucket << GetKey()).GetCheapHash();
return hash1 % ADDRMAN_BUCKET_SIZE; return hash1 % ADDRMAN_BUCKET_SIZE;
} }
bool CAddrInfo::IsTerrible(int64_t nNow) const bool AddrInfo::IsTerrible(int64_t nNow) const
{ {
if (nLastTry && nLastTry >= nNow - 60) // never remove things tried in the last minute if (nLastTry && nLastTry >= nNow - 60) // never remove things tried in the last minute
return false; return false;
@ -88,7 +88,7 @@ bool CAddrInfo::IsTerrible(int64_t nNow) const
return false; return false;
} }
double CAddrInfo::GetChance(int64_t nNow) const double AddrInfo::GetChance(int64_t nNow) const
{ {
double fChance = 1.0; double fChance = 1.0;
int64_t nSinceLastTry = std::max<int64_t>(nNow - nLastTry, 0); int64_t nSinceLastTry = std::max<int64_t>(nNow - nLastTry, 0);
@ -190,7 +190,7 @@ void AddrManImpl::Serialize(Stream& s_) const
int nIds = 0; int nIds = 0;
for (const auto& entry : mapInfo) { for (const auto& entry : mapInfo) {
mapUnkIds[entry.first] = nIds; mapUnkIds[entry.first] = nIds;
const CAddrInfo &info = entry.second; const AddrInfo &info = entry.second;
if (info.nRefCount) { if (info.nRefCount) {
assert(nIds != nNew); // this means nNew was wrong, oh ow assert(nIds != nNew); // this means nNew was wrong, oh ow
s << info; s << info;
@ -199,7 +199,7 @@ void AddrManImpl::Serialize(Stream& s_) const
} }
nIds = 0; nIds = 0;
for (const auto& entry : mapInfo) { for (const auto& entry : mapInfo) {
const CAddrInfo &info = entry.second; const AddrInfo &info = entry.second;
if (info.fInTried) { if (info.fInTried) {
assert(nIds != nTried); // this means nTried was wrong, oh ow assert(nIds != nTried); // this means nTried was wrong, oh ow
s << info; s << info;
@ -283,7 +283,7 @@ void AddrManImpl::Unserialize(Stream& s_)
// Deserialize entries from the new table. // Deserialize entries from the new table.
for (int n = 0; n < nNew; n++) { for (int n = 0; n < nNew; n++) {
CAddrInfo &info = mapInfo[n]; AddrInfo &info = mapInfo[n];
s >> info; s >> info;
mapAddr[info] = n; mapAddr[info] = n;
info.nRandomPos = vRandom.size(); info.nRandomPos = vRandom.size();
@ -294,7 +294,7 @@ void AddrManImpl::Unserialize(Stream& s_)
// Deserialize entries from the tried table. // Deserialize entries from the tried table.
int nLost = 0; int nLost = 0;
for (int n = 0; n < nTried; n++) { for (int n = 0; n < nTried; n++) {
CAddrInfo info; AddrInfo info;
s >> info; s >> info;
int nKBucket = info.GetTriedBucket(nKey, m_asmap); int nKBucket = info.GetTriedBucket(nKey, m_asmap);
int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket); int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
@ -351,7 +351,7 @@ void AddrManImpl::Unserialize(Stream& s_)
for (auto bucket_entry : bucket_entries) { for (auto bucket_entry : bucket_entries) {
int bucket{bucket_entry.first}; int bucket{bucket_entry.first};
const int entry_index{bucket_entry.second}; const int entry_index{bucket_entry.second};
CAddrInfo& info = mapInfo[entry_index]; AddrInfo& info = mapInfo[entry_index];
// Don't store the entry in the new bucket if it's not a valid address for our addrman // Don't store the entry in the new bucket if it's not a valid address for our addrman
if (!info.IsValid()) continue; if (!info.IsValid()) continue;
@ -401,7 +401,7 @@ void AddrManImpl::Unserialize(Stream& s_)
} }
} }
CAddrInfo* AddrManImpl::Find(const CNetAddr& addr, int* pnId) AddrInfo* AddrManImpl::Find(const CNetAddr& addr, int* pnId)
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
@ -416,12 +416,12 @@ CAddrInfo* AddrManImpl::Find(const CNetAddr& addr, int* pnId)
return nullptr; return nullptr;
} }
CAddrInfo* AddrManImpl::Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId) AddrInfo* AddrManImpl::Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId)
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
int nId = nIdCount++; int nId = nIdCount++;
mapInfo[nId] = CAddrInfo(addr, addrSource); mapInfo[nId] = AddrInfo(addr, addrSource);
mapAddr[addr] = nId; mapAddr[addr] = nId;
mapInfo[nId].nRandomPos = vRandom.size(); mapInfo[nId].nRandomPos = vRandom.size();
vRandom.push_back(nId); vRandom.push_back(nId);
@ -459,7 +459,7 @@ void AddrManImpl::Delete(int nId)
AssertLockHeld(cs); AssertLockHeld(cs);
assert(mapInfo.count(nId) != 0); assert(mapInfo.count(nId) != 0);
CAddrInfo& info = mapInfo[nId]; AddrInfo& info = mapInfo[nId];
assert(!info.fInTried); assert(!info.fInTried);
assert(info.nRefCount == 0); assert(info.nRefCount == 0);
@ -477,7 +477,7 @@ void AddrManImpl::ClearNew(int nUBucket, int nUBucketPos)
// if there is an entry in the specified bucket, delete it. // if there is an entry in the specified bucket, delete it.
if (vvNew[nUBucket][nUBucketPos] != -1) { if (vvNew[nUBucket][nUBucketPos] != -1) {
int nIdDelete = vvNew[nUBucket][nUBucketPos]; int nIdDelete = vvNew[nUBucket][nUBucketPos];
CAddrInfo& infoDelete = mapInfo[nIdDelete]; AddrInfo& infoDelete = mapInfo[nIdDelete];
assert(infoDelete.nRefCount > 0); assert(infoDelete.nRefCount > 0);
infoDelete.nRefCount--; infoDelete.nRefCount--;
vvNew[nUBucket][nUBucketPos] = -1; vvNew[nUBucket][nUBucketPos] = -1;
@ -487,7 +487,7 @@ void AddrManImpl::ClearNew(int nUBucket, int nUBucketPos)
} }
} }
void AddrManImpl::MakeTried(CAddrInfo& info, int nId) void AddrManImpl::MakeTried(AddrInfo& info, int nId)
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
@ -515,7 +515,7 @@ void AddrManImpl::MakeTried(CAddrInfo& info, int nId)
// find an item to evict // find an item to evict
int nIdEvict = vvTried[nKBucket][nKBucketPos]; int nIdEvict = vvTried[nKBucket][nKBucketPos];
assert(mapInfo.count(nIdEvict) == 1); assert(mapInfo.count(nIdEvict) == 1);
CAddrInfo& infoOld = mapInfo[nIdEvict]; AddrInfo& infoOld = mapInfo[nIdEvict];
// Remove the to-be-evicted item from the tried set. // Remove the to-be-evicted item from the tried set.
infoOld.fInTried = false; infoOld.fInTried = false;
@ -548,13 +548,13 @@ void AddrManImpl::Good_(const CService& addr, bool test_before_evict, int64_t nT
nLastGood = nTime; nLastGood = nTime;
CAddrInfo* pinfo = Find(addr, &nId); AddrInfo* pinfo = Find(addr, &nId);
// if not found, bail out // if not found, bail out
if (!pinfo) if (!pinfo)
return; return;
CAddrInfo& info = *pinfo; AddrInfo& info = *pinfo;
// check whether we are talking about the exact same CService (including same port) // check whether we are talking about the exact same CService (including same port)
if (info != addr) if (info != addr)
@ -605,7 +605,7 @@ bool AddrManImpl::Add_(const CAddress& addr, const CNetAddr& source, int64_t nTi
bool fNew = false; bool fNew = false;
int nId; int nId;
CAddrInfo* pinfo = Find(addr, &nId); AddrInfo* pinfo = Find(addr, &nId);
// Do not set a penalty for a source's self-announcement // Do not set a penalty for a source's self-announcement
if (addr == source) { if (addr == source) {
@ -652,7 +652,7 @@ bool AddrManImpl::Add_(const CAddress& addr, const CNetAddr& source, int64_t nTi
if (vvNew[nUBucket][nUBucketPos] != nId) { if (vvNew[nUBucket][nUBucketPos] != nId) {
bool fInsert = vvNew[nUBucket][nUBucketPos] == -1; bool fInsert = vvNew[nUBucket][nUBucketPos] == -1;
if (!fInsert) { if (!fInsert) {
CAddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]]; AddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]];
if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) { if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) {
// Overwrite the existing new table entry. // Overwrite the existing new table entry.
fInsert = true; fInsert = true;
@ -675,13 +675,13 @@ void AddrManImpl::Attempt_(const CService& addr, bool fCountFailure, int64_t nTi
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
CAddrInfo* pinfo = Find(addr); AddrInfo* pinfo = Find(addr);
// if not found, bail out // if not found, bail out
if (!pinfo) if (!pinfo)
return; return;
CAddrInfo& info = *pinfo; AddrInfo& info = *pinfo;
// check whether we are talking about the exact same CService (including same port) // check whether we are talking about the exact same CService (including same port)
if (info != addr) if (info != addr)
@ -718,7 +718,7 @@ std::pair<CAddress, int64_t> AddrManImpl::Select_(bool newOnly) const
int nId = vvTried[nKBucket][nKBucketPos]; int nId = vvTried[nKBucket][nKBucketPos];
const auto it_found{mapInfo.find(nId)}; const auto it_found{mapInfo.find(nId)};
assert(it_found != mapInfo.end()); assert(it_found != mapInfo.end());
const CAddrInfo& info{it_found->second}; const AddrInfo& info{it_found->second};
if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) { if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) {
return {info, info.nLastTry}; return {info, info.nLastTry};
} }
@ -737,7 +737,7 @@ std::pair<CAddress, int64_t> AddrManImpl::Select_(bool newOnly) const
int nId = vvNew[nUBucket][nUBucketPos]; int nId = vvNew[nUBucket][nUBucketPos];
const auto it_found{mapInfo.find(nId)}; const auto it_found{mapInfo.find(nId)};
assert(it_found != mapInfo.end()); assert(it_found != mapInfo.end());
const CAddrInfo& info{it_found->second}; const AddrInfo& info{it_found->second};
if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) { if (insecure_rand.randbits(30) < fChanceFactor * info.GetChance() * (1 << 30)) {
return {info, info.nLastTry}; return {info, info.nLastTry};
} }
@ -770,7 +770,7 @@ std::vector<CAddress> AddrManImpl::GetAddr_(size_t max_addresses, size_t max_pct
const auto it{mapInfo.find(vRandom[n])}; const auto it{mapInfo.find(vRandom[n])};
assert(it != mapInfo.end()); assert(it != mapInfo.end());
const CAddrInfo& ai{it->second}; const AddrInfo& ai{it->second};
// Filter by network (optional) // Filter by network (optional)
if (network != std::nullopt && ai.GetNetClass() != network) continue; if (network != std::nullopt && ai.GetNetClass() != network) continue;
@ -788,13 +788,13 @@ void AddrManImpl::Connected_(const CService& addr, int64_t nTime)
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
CAddrInfo* pinfo = Find(addr); AddrInfo* pinfo = Find(addr);
// if not found, bail out // if not found, bail out
if (!pinfo) if (!pinfo)
return; return;
CAddrInfo& info = *pinfo; AddrInfo& info = *pinfo;
// check whether we are talking about the exact same CService (including same port) // check whether we are talking about the exact same CService (including same port)
if (info != addr) if (info != addr)
@ -810,13 +810,13 @@ void AddrManImpl::SetServices_(const CService& addr, ServiceFlags nServices)
{ {
AssertLockHeld(cs); AssertLockHeld(cs);
CAddrInfo* pinfo = Find(addr); AddrInfo* pinfo = Find(addr);
// if not found, bail out // if not found, bail out
if (!pinfo) if (!pinfo)
return; return;
CAddrInfo& info = *pinfo; AddrInfo& info = *pinfo;
// check whether we are talking about the exact same CService (including same port) // check whether we are talking about the exact same CService (including same port)
if (info != addr) if (info != addr)
@ -839,7 +839,7 @@ void AddrManImpl::ResolveCollisions_()
if (mapInfo.count(id_new) != 1) { if (mapInfo.count(id_new) != 1) {
erase_collision = true; erase_collision = true;
} else { } else {
CAddrInfo& info_new = mapInfo[id_new]; AddrInfo& info_new = mapInfo[id_new];
// Which tried bucket to move the entry to. // Which tried bucket to move the entry to.
int tried_bucket = info_new.GetTriedBucket(nKey, m_asmap); int tried_bucket = info_new.GetTriedBucket(nKey, m_asmap);
@ -850,7 +850,7 @@ void AddrManImpl::ResolveCollisions_()
// Get the to-be-evicted address that is being tested // Get the to-be-evicted address that is being tested
int id_old = vvTried[tried_bucket][tried_bucket_pos]; int id_old = vvTried[tried_bucket][tried_bucket_pos];
CAddrInfo& info_old = mapInfo[id_old]; AddrInfo& info_old = mapInfo[id_old];
// Has successfully connected in last X hours // Has successfully connected in last X hours
if (GetAdjustedTime() - info_old.nLastSuccess < ADDRMAN_REPLACEMENT_HOURS*(60*60)) { if (GetAdjustedTime() - info_old.nLastSuccess < ADDRMAN_REPLACEMENT_HOURS*(60*60)) {
@ -905,13 +905,13 @@ std::pair<CAddress, int64_t> AddrManImpl::SelectTriedCollision_()
return {}; return {};
} }
const CAddrInfo& newInfo = mapInfo[id_new]; const AddrInfo& newInfo = mapInfo[id_new];
// which tried bucket to move the entry to // which tried bucket to move the entry to
int tried_bucket = newInfo.GetTriedBucket(nKey, m_asmap); int tried_bucket = newInfo.GetTriedBucket(nKey, m_asmap);
int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket); int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket);
const CAddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]]; const AddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]];
return {info_old, info_old.nLastTry}; return {info_old, info_old.nLastTry};
} }
@ -944,7 +944,7 @@ int AddrManImpl::ForceCheckAddrman() const
for (const auto& entry : mapInfo) { for (const auto& entry : mapInfo) {
int n = entry.first; int n = entry.first;
const CAddrInfo& info = entry.second; const AddrInfo& info = entry.second;
if (info.fInTried) { if (info.fInTried) {
if (!info.nLastSuccess) if (!info.nLastSuccess)
return -1; return -1;

16
src/addrman_impl.h
View file

@ -33,7 +33,7 @@ static constexpr int ADDRMAN_BUCKET_SIZE{1 << ADDRMAN_BUCKET_SIZE_LOG2};
/** /**
* Extended statistics about a CAddress * Extended statistics about a CAddress
*/ */
class CAddrInfo : public CAddress class AddrInfo : public CAddress
{ {
public: public:
//! last try whatsoever by us (memory only) //! last try whatsoever by us (memory only)
@ -60,17 +60,17 @@ public:
//! position in vRandom //! position in vRandom
mutable int nRandomPos{-1}; mutable int nRandomPos{-1};
SERIALIZE_METHODS(CAddrInfo, obj) SERIALIZE_METHODS(AddrInfo, obj)
{ {
READWRITEAS(CAddress, obj); READWRITEAS(CAddress, obj);
READWRITE(obj.source, obj.nLastSuccess, obj.nAttempts); READWRITE(obj.source, obj.nLastSuccess, obj.nAttempts);
} }
CAddrInfo(const CAddress &addrIn, const CNetAddr &addrSource) : CAddress(addrIn), source(addrSource) AddrInfo(const CAddress &addrIn, const CNetAddr &addrSource) : CAddress(addrIn), source(addrSource)
{ {
} }
CAddrInfo() : CAddress(), source() AddrInfo() : CAddress(), source()
{ {
} }
@ -177,7 +177,7 @@ private:
int nIdCount GUARDED_BY(cs){0}; int nIdCount GUARDED_BY(cs){0};
//! table with information about all nIds //! table with information about all nIds
std::unordered_map<int, CAddrInfo> mapInfo GUARDED_BY(cs); std::unordered_map<int, AddrInfo> mapInfo GUARDED_BY(cs);
//! find an nId based on its network address //! find an nId based on its network address
std::unordered_map<CNetAddr, int, CNetAddrHash> mapAddr GUARDED_BY(cs); std::unordered_map<CNetAddr, int, CNetAddrHash> mapAddr GUARDED_BY(cs);
@ -225,10 +225,10 @@ private:
const std::vector<bool> m_asmap; const std::vector<bool> m_asmap;
//! Find an entry. //! Find an entry.
CAddrInfo* Find(const CNetAddr& addr, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs); AddrInfo* Find(const CNetAddr& addr, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
//! Create a new entry and add it to the internal data structures mapInfo, mapAddr and vRandom. //! Create a new entry and add it to the internal data structures mapInfo, mapAddr and vRandom.
CAddrInfo* Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs); AddrInfo* Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
//! Swap two elements in vRandom. //! Swap two elements in vRandom.
void SwapRandom(unsigned int nRandomPos1, unsigned int nRandomPos2) const EXCLUSIVE_LOCKS_REQUIRED(cs); void SwapRandom(unsigned int nRandomPos1, unsigned int nRandomPos2) const EXCLUSIVE_LOCKS_REQUIRED(cs);
@ -240,7 +240,7 @@ private:
void ClearNew(int nUBucket, int nUBucketPos) EXCLUSIVE_LOCKS_REQUIRED(cs); void ClearNew(int nUBucket, int nUBucketPos) EXCLUSIVE_LOCKS_REQUIRED(cs);
//! Move an entry from the "new" table(s) to the "tried" table //! Move an entry from the "new" table(s) to the "tried" table
void MakeTried(CAddrInfo& info, int nId) EXCLUSIVE_LOCKS_REQUIRED(cs); void MakeTried(AddrInfo& info, int nId) EXCLUSIVE_LOCKS_REQUIRED(cs);
void Good_(const CService &addr, bool test_before_evict, int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs); void Good_(const CService &addr, bool test_before_evict, int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs);

56
src/test/addrman_tests.cpp
View file

@ -62,7 +62,7 @@ public:
CAddress addr = CAddress(serv, NODE_NONE); CAddress addr = CAddress(serv, NODE_NONE);
CNetAddr resolved; CNetAddr resolved;
BOOST_CHECK(LookupHost("252.2.2.2", resolved, false)); BOOST_CHECK(LookupHost("252.2.2.2", resolved, false));
CAddrInfo info = CAddrInfo(addr, resolved); AddrInfo info = AddrInfo(addr, resolved);
s << info; s << info;
} }
}; };
@ -89,13 +89,13 @@ public:
deterministic = makeDeterministic; deterministic = makeDeterministic;
} }
CAddrInfo* Find(const CNetAddr& addr, int* pnId = nullptr) AddrInfo* Find(const CNetAddr& addr, int* pnId = nullptr)
{ {
LOCK(m_impl->cs); LOCK(m_impl->cs);
return m_impl->Find(addr, pnId); return m_impl->Find(addr, pnId);
} }
CAddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId = nullptr) AddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId = nullptr)
{ {
LOCK(m_impl->cs); LOCK(m_impl->cs);
return m_impl->Create(addr, addrSource, pnId); return m_impl->Create(addr, addrSource, pnId);
@ -373,17 +373,17 @@ BOOST_AUTO_TEST_CASE(addrman_find)
BOOST_CHECK(addrman.Add({addr3}, source1)); BOOST_CHECK(addrman.Add({addr3}, source1));
// Test: ensure Find returns an IP matching what we searched on. // Test: ensure Find returns an IP matching what we searched on.
CAddrInfo* info1 = addrman.Find(addr1); AddrInfo* info1 = addrman.Find(addr1);
BOOST_REQUIRE(info1); BOOST_REQUIRE(info1);
BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8333"); BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8333");
// Test 18; Find does not discriminate by port number. // Test 18; Find does not discriminate by port number.
CAddrInfo* info2 = addrman.Find(addr2); AddrInfo* info2 = addrman.Find(addr2);
BOOST_REQUIRE(info2); BOOST_REQUIRE(info2);
BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString()); BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString());
// Test: Find returns another IP matching what we searched on. // Test: Find returns another IP matching what we searched on.
CAddrInfo* info3 = addrman.Find(addr3); AddrInfo* info3 = addrman.Find(addr3);
BOOST_REQUIRE(info3); BOOST_REQUIRE(info3);
BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8333"); BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8333");
} }
@ -398,12 +398,12 @@ BOOST_AUTO_TEST_CASE(addrman_create)
CNetAddr source1 = ResolveIP("250.1.2.1"); CNetAddr source1 = ResolveIP("250.1.2.1");
int nId; int nId;
CAddrInfo* pinfo = addrman.Create(addr1, source1, &nId); AddrInfo* pinfo = addrman.Create(addr1, source1, &nId);
// Test: The result should be the same as the input addr. // Test: The result should be the same as the input addr.
BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8333"); BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8333");
CAddrInfo* info2 = addrman.Find(addr1); AddrInfo* info2 = addrman.Find(addr1);
BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8333"); BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8333");
} }
@ -424,7 +424,7 @@ BOOST_AUTO_TEST_CASE(addrman_delete)
BOOST_CHECK_EQUAL(addrman.size(), 1U); BOOST_CHECK_EQUAL(addrman.size(), 1U);
addrman.Delete(nId); addrman.Delete(nId);
BOOST_CHECK_EQUAL(addrman.size(), 0U); BOOST_CHECK_EQUAL(addrman.size(), 0U);
CAddrInfo* info2 = addrman.Find(addr1); AddrInfo* info2 = addrman.Find(addr1);
BOOST_CHECK(info2 == nullptr); BOOST_CHECK(info2 == nullptr);
} }
@ -498,7 +498,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_legacy)
CNetAddr source1 = ResolveIP("250.1.1.1"); CNetAddr source1 = ResolveIP("250.1.1.1");
CAddrInfo info1 = CAddrInfo(addr1, source1); AddrInfo info1 = AddrInfo(addr1, source1);
uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash(); uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash(); uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
@ -513,14 +513,14 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_legacy)
// Test: Two addresses with same IP but different ports can map to // Test: Two addresses with same IP but different ports can map to
// different buckets because they have different keys. // different buckets because they have different keys.
CAddrInfo info2 = CAddrInfo(addr2, source1); AddrInfo info2 = AddrInfo(addr2, source1);
BOOST_CHECK(info1.GetKey() != info2.GetKey()); BOOST_CHECK(info1.GetKey() != info2.GetKey());
BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) != info2.GetTriedBucket(nKey1, asmap)); BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) != info2.GetTriedBucket(nKey1, asmap));
std::set<int> buckets; std::set<int> buckets;
for (int i = 0; i < 255; i++) { for (int i = 0; i < 255; i++) {
CAddrInfo infoi = CAddrInfo( AddrInfo infoi = AddrInfo(
CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE), CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
ResolveIP("250.1.1." + ToString(i))); ResolveIP("250.1.1." + ToString(i)));
int bucket = infoi.GetTriedBucket(nKey1, asmap); int bucket = infoi.GetTriedBucket(nKey1, asmap);
@ -532,7 +532,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket_legacy)
buckets.clear(); buckets.clear();
for (int j = 0; j < 255; j++) { for (int j = 0; j < 255; j++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE), CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
ResolveIP("250." + ToString(j) + ".1.1")); ResolveIP("250." + ToString(j) + ".1.1"));
int bucket = infoj.GetTriedBucket(nKey1, asmap); int bucket = infoj.GetTriedBucket(nKey1, asmap);
@ -552,7 +552,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy)
CNetAddr source1 = ResolveIP("250.1.2.1"); CNetAddr source1 = ResolveIP("250.1.2.1");
CAddrInfo info1 = CAddrInfo(addr1, source1); AddrInfo info1 = AddrInfo(addr1, source1);
uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash(); uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash(); uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
@ -568,13 +568,13 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy)
BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) != info1.GetNewBucket(nKey2, asmap)); BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) != info1.GetNewBucket(nKey2, asmap));
// Test: Ports should not affect bucket placement in the addr // Test: Ports should not affect bucket placement in the addr
CAddrInfo info2 = CAddrInfo(addr2, source1); AddrInfo info2 = AddrInfo(addr2, source1);
BOOST_CHECK(info1.GetKey() != info2.GetKey()); BOOST_CHECK(info1.GetKey() != info2.GetKey());
BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), info2.GetNewBucket(nKey1, asmap)); BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), info2.GetNewBucket(nKey1, asmap));
std::set<int> buckets; std::set<int> buckets;
for (int i = 0; i < 255; i++) { for (int i = 0; i < 255; i++) {
CAddrInfo infoi = CAddrInfo( AddrInfo infoi = AddrInfo(
CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE), CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
ResolveIP("250.1.1." + ToString(i))); ResolveIP("250.1.1." + ToString(i)));
int bucket = infoi.GetNewBucket(nKey1, asmap); int bucket = infoi.GetNewBucket(nKey1, asmap);
@ -586,7 +586,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy)
buckets.clear(); buckets.clear();
for (int j = 0; j < 4 * 255; j++) { for (int j = 0; j < 4 * 255; j++) {
CAddrInfo infoj = CAddrInfo(CAddress( AddrInfo infoj = AddrInfo(CAddress(
ResolveService( ResolveService(
ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE), ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE),
ResolveIP("251.4.1.1")); ResolveIP("251.4.1.1"));
@ -599,7 +599,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket_legacy)
buckets.clear(); buckets.clear();
for (int p = 0; p < 255; p++) { for (int p = 0; p < 255; p++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("250.1.1.1"), NODE_NONE), CAddress(ResolveService("250.1.1.1"), NODE_NONE),
ResolveIP("250." + ToString(p) + ".1.1")); ResolveIP("250." + ToString(p) + ".1.1"));
int bucket = infoj.GetNewBucket(nKey1, asmap); int bucket = infoj.GetNewBucket(nKey1, asmap);
@ -631,7 +631,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
CNetAddr source1 = ResolveIP("250.1.1.1"); CNetAddr source1 = ResolveIP("250.1.1.1");
CAddrInfo info1 = CAddrInfo(addr1, source1); AddrInfo info1 = AddrInfo(addr1, source1);
uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash(); uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash(); uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
@ -646,14 +646,14 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
// Test: Two addresses with same IP but different ports can map to // Test: Two addresses with same IP but different ports can map to
// different buckets because they have different keys. // different buckets because they have different keys.
CAddrInfo info2 = CAddrInfo(addr2, source1); AddrInfo info2 = AddrInfo(addr2, source1);
BOOST_CHECK(info1.GetKey() != info2.GetKey()); BOOST_CHECK(info1.GetKey() != info2.GetKey());
BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) != info2.GetTriedBucket(nKey1, asmap)); BOOST_CHECK(info1.GetTriedBucket(nKey1, asmap) != info2.GetTriedBucket(nKey1, asmap));
std::set<int> buckets; std::set<int> buckets;
for (int j = 0; j < 255; j++) { for (int j = 0; j < 255; j++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("101." + ToString(j) + ".1.1"), NODE_NONE), CAddress(ResolveService("101." + ToString(j) + ".1.1"), NODE_NONE),
ResolveIP("101." + ToString(j) + ".1.1")); ResolveIP("101." + ToString(j) + ".1.1"));
int bucket = infoj.GetTriedBucket(nKey1, asmap); int bucket = infoj.GetTriedBucket(nKey1, asmap);
@ -665,7 +665,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
buckets.clear(); buckets.clear();
for (int j = 0; j < 255; j++) { for (int j = 0; j < 255; j++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE), CAddress(ResolveService("250." + ToString(j) + ".1.1"), NODE_NONE),
ResolveIP("250." + ToString(j) + ".1.1")); ResolveIP("250." + ToString(j) + ".1.1"));
int bucket = infoj.GetTriedBucket(nKey1, asmap); int bucket = infoj.GetTriedBucket(nKey1, asmap);
@ -685,7 +685,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
CNetAddr source1 = ResolveIP("250.1.2.1"); CNetAddr source1 = ResolveIP("250.1.2.1");
CAddrInfo info1 = CAddrInfo(addr1, source1); AddrInfo info1 = AddrInfo(addr1, source1);
uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash(); uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash(); uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
@ -701,13 +701,13 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) != info1.GetNewBucket(nKey2, asmap)); BOOST_CHECK(info1.GetNewBucket(nKey1, asmap) != info1.GetNewBucket(nKey2, asmap));
// Test: Ports should not affect bucket placement in the addr // Test: Ports should not affect bucket placement in the addr
CAddrInfo info2 = CAddrInfo(addr2, source1); AddrInfo info2 = AddrInfo(addr2, source1);
BOOST_CHECK(info1.GetKey() != info2.GetKey()); BOOST_CHECK(info1.GetKey() != info2.GetKey());
BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), info2.GetNewBucket(nKey1, asmap)); BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, asmap), info2.GetNewBucket(nKey1, asmap));
std::set<int> buckets; std::set<int> buckets;
for (int i = 0; i < 255; i++) { for (int i = 0; i < 255; i++) {
CAddrInfo infoi = CAddrInfo( AddrInfo infoi = AddrInfo(
CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE), CAddress(ResolveService("250.1.1." + ToString(i)), NODE_NONE),
ResolveIP("250.1.1." + ToString(i))); ResolveIP("250.1.1." + ToString(i)));
int bucket = infoi.GetNewBucket(nKey1, asmap); int bucket = infoi.GetNewBucket(nKey1, asmap);
@ -719,7 +719,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
buckets.clear(); buckets.clear();
for (int j = 0; j < 4 * 255; j++) { for (int j = 0; j < 4 * 255; j++) {
CAddrInfo infoj = CAddrInfo(CAddress( AddrInfo infoj = AddrInfo(CAddress(
ResolveService( ResolveService(
ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE), ToString(250 + (j / 255)) + "." + ToString(j % 256) + ".1.1"), NODE_NONE),
ResolveIP("251.4.1.1")); ResolveIP("251.4.1.1"));
@ -732,7 +732,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
buckets.clear(); buckets.clear();
for (int p = 0; p < 255; p++) { for (int p = 0; p < 255; p++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("250.1.1.1"), NODE_NONE), CAddress(ResolveService("250.1.1.1"), NODE_NONE),
ResolveIP("101." + ToString(p) + ".1.1")); ResolveIP("101." + ToString(p) + ".1.1"));
int bucket = infoj.GetNewBucket(nKey1, asmap); int bucket = infoj.GetNewBucket(nKey1, asmap);
@ -744,7 +744,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
buckets.clear(); buckets.clear();
for (int p = 0; p < 255; p++) { for (int p = 0; p < 255; p++) {
CAddrInfo infoj = CAddrInfo( AddrInfo infoj = AddrInfo(
CAddress(ResolveService("250.1.1.1"), NODE_NONE), CAddress(ResolveService("250.1.1.1"), NODE_NONE),
ResolveIP("250." + ToString(p) + ".1.1")); ResolveIP("250." + ToString(p) + ".1.1"));
int bucket = infoj.GetNewBucket(nKey1, asmap); int bucket = infoj.GetNewBucket(nKey1, asmap);

10
src/test/fuzz/addrman.cpp
View file

@ -142,24 +142,24 @@ public:
// Check that all values in `mapInfo` are equal to all values in `other.mapInfo`. // Check that all values in `mapInfo` are equal to all values in `other.mapInfo`.
// Keys may be different. // Keys may be different.
using CAddrInfoHasher = std::function<size_t(const CAddrInfo&)>; using AddrInfoHasher = std::function<size_t(const AddrInfo&)>;
using CAddrInfoEq = std::function<bool(const CAddrInfo&, const CAddrInfo&)>; using AddrInfoEq = std::function<bool(const AddrInfo&, const AddrInfo&)>;
CNetAddrHash netaddr_hasher; CNetAddrHash netaddr_hasher;
CAddrInfoHasher addrinfo_hasher = [&netaddr_hasher](const CAddrInfo& a) { AddrInfoHasher addrinfo_hasher = [&netaddr_hasher](const AddrInfo& a) {
return netaddr_hasher(static_cast<CNetAddr>(a)) ^ netaddr_hasher(a.source) ^ return netaddr_hasher(static_cast<CNetAddr>(a)) ^ netaddr_hasher(a.source) ^
a.nLastSuccess ^ a.nAttempts ^ a.nRefCount ^ a.fInTried; a.nLastSuccess ^ a.nAttempts ^ a.nRefCount ^ a.fInTried;
}; };
CAddrInfoEq addrinfo_eq = [](const CAddrInfo& lhs, const CAddrInfo& rhs) { AddrInfoEq addrinfo_eq = [](const AddrInfo& lhs, const AddrInfo& rhs) {
return static_cast<CNetAddr>(lhs) == static_cast<CNetAddr>(rhs) && return static_cast<CNetAddr>(lhs) == static_cast<CNetAddr>(rhs) &&
lhs.source == rhs.source && lhs.nLastSuccess == rhs.nLastSuccess && lhs.source == rhs.source && lhs.nLastSuccess == rhs.nLastSuccess &&
lhs.nAttempts == rhs.nAttempts && lhs.nRefCount == rhs.nRefCount && lhs.nAttempts == rhs.nAttempts && lhs.nRefCount == rhs.nRefCount &&
lhs.fInTried == rhs.fInTried; lhs.fInTried == rhs.fInTried;
}; };
using Addresses = std::unordered_set<CAddrInfo, CAddrInfoHasher, CAddrInfoEq>; using Addresses = std::unordered_set<AddrInfo, AddrInfoHasher, AddrInfoEq>;
const size_t num_addresses{m_impl->mapInfo.size()}; const size_t num_addresses{m_impl->mapInfo.size()};

2
src/test/fuzz/deserialize.cpp
View file

@ -105,7 +105,7 @@ FUZZ_TARGET_DESERIALIZE(block_filter_deserialize, {
DeserializeFromFuzzingInput(buffer, block_filter); DeserializeFromFuzzingInput(buffer, block_filter);
}) })
FUZZ_TARGET_DESERIALIZE(addr_info_deserialize, { FUZZ_TARGET_DESERIALIZE(addr_info_deserialize, {
CAddrInfo addr_info; AddrInfo addr_info;
DeserializeFromFuzzingInput(buffer, addr_info); DeserializeFromFuzzingInput(buffer, addr_info);
}) })
FUZZ_TARGET_DESERIALIZE(block_file_info_deserialize, { FUZZ_TARGET_DESERIALIZE(block_file_info_deserialize, {