X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Faddrman.h;h=9aa167b3a00112f7080afef2166b237e051eb039;hb=5af8418fee23af1be2065382dda14a97034fdf56;hp=7af6afd78f099118d1b526ea7d5ab958bf662ab2;hpb=84a4a7763f386934da90e2bd1e355b70023fa9ca;p=novacoin.git diff --git a/src/addrman.h b/src/addrman.h index 7af6afd..9aa167b 100644 --- a/src/addrman.h +++ b/src/addrman.h @@ -24,10 +24,10 @@ private: CNetAddr source; // last successful connection by us - int64 nLastSuccess; + int64_t nLastSuccess; // last try whatsoever by us: - // int64 CAddress::nLastTry + // int64_t CAddress::nLastTry // connection attempts since last successful attempt int nAttempts; @@ -86,10 +86,10 @@ public: } // Determine whether the statistics about this entry are bad enough so that it can just be deleted - bool IsTerrible(int64 nNow = GetAdjustedTime()) const; + bool IsTerrible(int64_t nNow = GetAdjustedTime()) const; // Calculate the relative chance this entry should be given when selecting nodes to connect to - double GetChance(int64 nNow = GetAdjustedTime()) const; + double GetChance(int64_t nNow = GetAdjustedTime()) const; }; @@ -220,13 +220,13 @@ protected: void MakeTried(CAddrInfo& info, int nId, int nOrigin); // Mark an entry "good", possibly moving it from "new" to "tried". - void Good_(const CService &addr, int64 nTime); + void Good_(const CService &addr, int64_t nTime); // Add an entry to the "new" table. - bool Add_(const CAddress &addr, const CNetAddr& source, int64 nTimePenalty); + bool Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty); // Mark an entry as attempted to connect. - void Attempt_(const CService &addr, int64 nTime); + void Attempt_(const CService &addr, int64_t nTime); // Select an address to connect to. // nUnkBias determines how much to favor new addresses over tried ones (min=0, max=100) @@ -239,12 +239,14 @@ protected: // Select several addresses at once. void GetAddr_(std::vector &vAddr); + void GetOnlineAddr_(std::vector &vAddr); // Mark an entry as currently-connected-to. - void Connected_(const CService &addr, int64 nTime); + void Connected_(const CService &addr, int64_t nTime); public: +#ifndef _MSC_VER IMPLEMENT_SERIALIZE (({ // serialized format: @@ -378,7 +380,183 @@ public: } } });) +#else + IMPLEMENT_SERIALIZE + ( + LOCK(cs); + unsigned char + nVersion = 0; + + READWRITE(nVersion); + READWRITE(nKey); + READWRITE(nNew); + READWRITE(nTried); + + CAddrMan + *am = const_cast(this); + + if (fWrite) + { + int + nUBuckets = ADDRMAN_NEW_BUCKET_COUNT; + + READWRITE(nUBuckets); +/************ + std::map + mapUnkIds; +************/ + int + nIds = 0; + for (std::map::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) + { + if (nIds == nNew) + break; // this means nNew was wrong, oh ow + mapUnkIds[(*it).first] = nIds; + + CAddrInfo + &info = (*it).second; + + if (info.nRefCount) + { + READWRITE(info); + nIds++; + } + } + nIds = 0; + for (std::map::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) + { + if (nIds == nTried) + break; /* this means nTried was wrong, oh ow */ + + CAddrInfo + &info = (*it).second; + + if (info.fInTried) + { + READWRITE(info); + nIds++; + } + } + for ( + std::vector >::iterator it = am->vvNew.begin(); + it != am->vvNew.end(); + it++ + ) + { + std::set + &vNew = (*it); + + int + nSize = int( vNew.size() ); + + READWRITE(nSize); + for (std::set::iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) + { + int + nIndex = mapUnkIds[*it2]; + READWRITE(nIndex); + } + } + } + else + { + int + nUBuckets = 0; + + READWRITE(nUBuckets); + am->nIdCount = 0; + am->mapInfo.clear(); + am->mapAddr.clear(); + am->vRandom.clear(); + am->vvTried = + std::vector >( + ADDRMAN_TRIED_BUCKET_COUNT, + std::vector(0) + ); + am->vvNew = + std::vector >( + ADDRMAN_NEW_BUCKET_COUNT, + std::set() + ); + for (int n = 0; n < am->nNew; n++) + { + CAddrInfo + &info = am->mapInfo[n]; + + READWRITE(info); + am->mapAddr[info] = n; + info.nRandomPos = int( vRandom.size() ); + am->vRandom.push_back(n); + if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT) + { + am->vvNew[info.GetNewBucket(am->nKey)].insert(n); + info.nRefCount++; + } + } + am->nIdCount = am->nNew; + + int + nLost = 0; + + for (int n = 0; n < am->nTried; n++) + { + CAddrInfo + info; + + READWRITE(info); + + std::vector + &vTried = am->vvTried[info.GetTriedBucket(am->nKey)]; + + if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) + { + info.nRandomPos = int( vRandom.size() ); + info.fInTried = true; + am->vRandom.push_back(am->nIdCount); + am->mapInfo[am->nIdCount] = info; + am->mapAddr[info] = am->nIdCount; + vTried.push_back(am->nIdCount); + am->nIdCount++; + } + else + { + nLost++; + } + } + am->nTried -= nLost; + for (int b = 0; b < nUBuckets; b++) + { + std::set + &vNew = am->vvNew[b]; + int + nSize = 0; + + READWRITE(nSize); + for (int n = 0; n < nSize; n++) + { + int + nIndex = 0; + + READWRITE(nIndex); + + CAddrInfo + &info = am->mapInfo[nIndex]; + + if ( + (nUBuckets == ADDRMAN_NEW_BUCKET_COUNT) && + (info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS) + ) + { + info.nRefCount++; + vNew.insert(nIndex); + } + } + } + } + ) + +#endif //_MSC_VER CAddrMan() : vRandom(0), vvTried(ADDRMAN_TRIED_BUCKET_COUNT, std::vector(0)), vvNew(ADDRMAN_NEW_BUCKET_COUNT, std::set()) { nKey.resize(32); @@ -392,7 +570,7 @@ public: // Return the number of (unique) addresses in all tables. int size() { - return vRandom.size(); + return (int) vRandom.size(); } // Consistency check @@ -409,7 +587,7 @@ public: } // Add a single address. - bool Add(const CAddress &addr, const CNetAddr& source, int64 nTimePenalty = 0) + bool Add(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty = 0) { bool fRet = false; { @@ -424,7 +602,7 @@ public: } // Add multiple addresses. - bool Add(const std::vector &vAddr, const CNetAddr& source, int64 nTimePenalty = 0) + bool Add(const std::vector &vAddr, const CNetAddr& source, int64_t nTimePenalty = 0) { int nAdd = 0; { @@ -440,7 +618,7 @@ public: } // Mark an entry as accessible. - void Good(const CService &addr, int64 nTime = GetAdjustedTime()) + void Good(const CService &addr, int64_t nTime = GetAdjustedTime()) { { LOCK(cs); @@ -451,7 +629,7 @@ public: } // Mark an entry as connection attempted to. - void Attempt(const CService &addr, int64 nTime = GetAdjustedTime()) + void Attempt(const CService &addr, int64_t nTime = GetAdjustedTime()) { { LOCK(cs); @@ -488,8 +666,20 @@ public: return vAddr; } + std::vector GetOnlineAddr() + { + Check(); + std::vector vAddr; + { + LOCK(cs); + GetOnlineAddr_(vAddr); + } + Check(); + return vAddr; + } + // Mark an entry as currently-connected-to. - void Connected(const CService &addr, int64 nTime = GetAdjustedTime()) + void Connected(const CService &addr, int64_t nTime = GetAdjustedTime()) { { LOCK(cs);