kvazar/kevacoin
1
0
Fork 0
mirror of https://github.com/kvazar-network/kevacoin.git synced 2025-01-10 15:18:09 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #4933

Browse Source 
20e01b1 Apply clang-format on some infrequently-updated files (Pieter Wuille)
This commit is contained in:
Pieter Wuille 2014-09-21 01:03:32 +02:00
commit 934b153a2c
No known key found for this signature in database
GPG Key ID: 8F653255C87992E0
30 changed files with 845 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
src/addrman.cpp
View File

@ -64,8 +64,10 @@ double CAddrInfo::GetChance(int64_t nNow) const
int64_t nSinceLastSeen = nNow - nTime;
int64_t nSinceLastTry = nNow - nLastTry;
if (nSinceLastSeen < 0) nSinceLastSeen = 0;
if (nSinceLastTry < 0) nSinceLastTry = 0;
if (nSinceLastSeen < 0)
nSinceLastSeen = 0;
if (nSinceLastTry < 0)
nSinceLastTry = 0;
fChance *= 600.0 / (600.0 + nSinceLastSeen);
@ -133,8 +135,7 @@ int CAddrMan::SelectTried(int nKBucket)
// find the least recently tried among them
int64_t nOldest = -1;
int nOldestPos = -1;
for (unsigned int i = 0; i < ADDRMAN_TRIED_ENTRIES_INSPECT_ON_EVICT && i < vTried.size(); i++)
{
for (unsigned int i = 0; i < ADDRMAN_TRIED_ENTRIES_INSPECT_ON_EVICT && i < vTried.size(); i++) {
int nPos = GetRandInt(vTried.size() - i) + i;
int nTemp = vTried[nPos];
vTried[nPos] = vTried[i];
@ -155,14 +156,11 @@ int CAddrMan::ShrinkNew(int nUBucket)
std::set<int>& vNew = vvNew[nUBucket];
// first look for deletable items
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
{
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
assert(mapInfo.count(*it));
CAddrInfo& info = mapInfo[*it];
if (info.IsTerrible())
{
if (--info.nRefCount == 0)
{
if (info.IsTerrible()) {
if (--info.nRefCount == 0) {
SwapRandom(info.nRandomPos, vRandom.size() - 1);
vRandom.pop_back();
mapAddr.erase(info);
@ -178,10 +176,8 @@ int CAddrMan::ShrinkNew(int nUBucket)
int n[4] = {GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size()), GetRandInt(vNew.size())};
int nI = 0;
int nOldest = -1;
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
{
if (nI == n[0] || nI == n[1] || nI == n[2] || nI == n[3])
{
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
if (nI == n[0] || nI == n[1] || nI == n[2] || nI == n[3]) {
assert(nOldest == -1 || mapInfo.count(*it) == 1);
if (nOldest == -1 || mapInfo[*it].nTime < mapInfo[nOldest].nTime)
nOldest = *it;
@ -190,8 +186,7 @@ int CAddrMan::ShrinkNew(int nUBucket)
}
assert(mapInfo.count(nOldest) == 1);
CAddrInfo& info = mapInfo[nOldest];
if (--info.nRefCount == 0)
{
if (--info.nRefCount == 0) {
SwapRandom(info.nRandomPos, vRandom.size() - 1);
vRandom.pop_back();
mapAddr.erase(info);
@ -208,8 +203,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
assert(vvNew[nOrigin].count(nId) == 1);
// remove the entry from all new buckets
for (std::vector<std::set<int> >::iterator it = vvNew.begin(); it != vvNew.end(); it++)
{
for (std::vector<std::set<int> >::iterator it = vvNew.begin(); it != vvNew.end(); it++) {
if ((*it).erase(nId))
info.nRefCount--;
}
@ -222,8 +216,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
std::vector<int>& vTried = vvTried[nKBucket];
// first check whether there is place to just add it
if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE)
{
if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) {
vTried.push_back(nId);
nTried++;
info.fInTried = true;
@ -245,8 +238,7 @@ void CAddrMan::MakeTried(CAddrInfo& info, int nId, int nOrigin)
// do not update nTried, as we are going to move something else there immediately
// check whether there is place in that one,
if (vNew.size() < ADDRMAN_NEW_BUCKET_SIZE)
{
if (vNew.size() < ADDRMAN_NEW_BUCKET_SIZE) {
// if so, move it back there
vNew.insert(vTried[nPos]);
} else {
@ -289,12 +281,10 @@ void CAddrMan::Good_(const CService &addr, int64_t nTime)
// find a bucket it is in now
int nRnd = GetRandInt(vvNew.size());
int nUBucket = -1;
for (unsigned int n = 0; n < vvNew.size(); n++)
{
for (unsigned int n = 0; n < vvNew.size(); n++) {
int nB = (n + nRnd) % vvNew.size();
std::set<int>& vNew = vvNew[nB];
if (vNew.count(nId))
{
if (vNew.count(nId)) {
nUBucket = nB;
break;
}
@ -302,7 +292,8 @@ void CAddrMan::Good_(const CService &addr, int64_t nTime)
// if no bucket is found, something bad happened;
// TODO: maybe re-add the node, but for now, just bail out
if (nUBucket == -1) return;
if (nUBucket == -1)
return;
LogPrint("addrman", "Moving %s to tried\n", addr.ToString());
@ -319,8 +310,7 @@ bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimeP
int nId;
CAddrInfo* pinfo = Find(addr, &nId);
if (pinfo)
{
if (pinfo) {
// periodically update nTime
bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
int64_t nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
@ -357,8 +347,7 @@ bool CAddrMan::Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimeP
int nUBucket = pinfo->GetNewBucket(nKey, source);
std::set<int>& vNew = vvNew[nUBucket];
if (!vNew.count(nId))
{
if (!vNew.count(nId)) {
pinfo->nRefCount++;
if (vNew.size() == ADDRMAN_NEW_BUCKET_SIZE)
ShrinkNew(nUBucket);
@ -393,15 +382,14 @@ CAddress CAddrMan::Select_(int nUnkBias)
double nCorTried = sqrt(nTried) * (100.0 - nUnkBias);
double nCorNew = sqrt(nNew) * nUnkBias;
if ((nCorTried + nCorNew)*GetRandInt(1<<30)/(1<<30) < nCorTried)
{
if ((nCorTried + nCorNew) * GetRandInt(1 << 30) / (1 << 30) < nCorTried) {
// use a tried node
double fChanceFactor = 1.0;
while(1)
{
while (1) {
int nKBucket = GetRandInt(vvTried.size());
std::vector<int>& vTried = vvTried[nKBucket];
if (vTried.size() == 0) continue;
if (vTried.size() == 0)
continue;
int nPos = GetRandInt(vTried.size());
assert(mapInfo.count(vTried[nPos]) == 1);
CAddrInfo& info = mapInfo[vTried[nPos]];
@ -412,11 +400,11 @@ CAddress CAddrMan::Select_(int nUnkBias)
} else {
// use a new node
double fChanceFactor = 1.0;
while(1)
{
while (1) {
int nUBucket = GetRandInt(vvNew.size());
std::set<int>& vNew = vvNew[nUBucket];
if (vNew.size() == 0) continue;
if (vNew.size() == 0)
continue;
int nPos = GetRandInt(vNew.size());
std::set<int>::iterator it = vNew.begin();
while (nPos--)
@ -436,55 +424,63 @@ int CAddrMan::Check_()
std::set<int> setTried;
std::map<int, int> mapNew;
if (vRandom.size() != nTried + nNew) return -7;
if (vRandom.size() != nTried + nNew)
return -7;
for (std::map<int, CAddrInfo>::iterator it = mapInfo.begin(); it != mapInfo.end(); it++)
{
for (std::map<int, CAddrInfo>::iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
int n = (*it).first;
CAddrInfo& info = (*it).second;
if (info.fInTried)
{
if (!info.nLastSuccess) return -1;
if (info.nRefCount) return -2;
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) return -3;
if (!info.nRefCount) return -4;
if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
return -3;
if (!info.nRefCount)
return -4;
mapNew[n] = info.nRefCount;
}
if (mapAddr[info] != n) return -5;
if (info.nRandomPos<0 || info.nRandomPos>=vRandom.size() || vRandom[info.nRandomPos] != n) return -14;
if (info.nLastTry < 0) return -6;
if (info.nLastSuccess < 0) return -8;
if (mapAddr[info] != n)
return -5;
if (info.nRandomPos < 0 || info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
return -14;
if (info.nLastTry < 0)
return -6;
if (info.nLastSuccess < 0)
return -8;
}
if (setTried.size() != nTried) return -9;
if (mapNew.size() != nNew) return -10;
if (setTried.size() != nTried)
return -9;
if (mapNew.size() != nNew)
return -10;
for (int n=0; n<vvTried.size(); n++)
{
for (int n = 0; n < vvTried.size(); n++) {
std::vector<int>& vTried = vvTried[n];
for (std::vector<int>::iterator it = vTried.begin(); it != vTried.end(); it++)
{
if (!setTried.count(*it)) return -11;
for (std::vector<int>::iterator it = vTried.begin(); it != vTried.end(); it++) {
if (!setTried.count(*it))
return -11;
setTried.erase(*it);
}
}
for (int n=0; n<vvNew.size(); n++)
{
for (int n = 0; n < vvNew.size(); n++) {
std::set<int>& vNew = vvNew[n];
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++)
{
if (!mapNew.count(*it)) return -12;
for (std::set<int>::iterator it = vNew.begin(); it != vNew.end(); it++) {
if (!mapNew.count(*it))
return -12;
if (--mapNew[*it] == 0)
mapNew.erase(*it);
}
}
if (setTried.size()) return -13;
if (mapNew.size()) return -15;
if (setTried.size())
return -13;
if (mapNew.size())
return -15;
return 0;
}
@ -497,8 +493,7 @@ void CAddrMan::GetAddr_(std::vector<CAddress> &vAddr)
nNodes = ADDRMAN_GETADDR_MAX;
// gather a list of random nodes, skipping those of low quality
for (unsigned int n = 0; n < vRandom.size(); n++)
{
for (unsigned int n = 0; n < vRandom.size(); n++) {
if (vAddr.size() >= nNodes)
break;

1
src/allocators.cpp
View File

@ -64,4 +64,3 @@ bool MemoryPageLocker::Unlock(const void *addr, size_t len)
LockedPageManager::LockedPageManager() : LockedPageManagerBase<MemoryPageLocker>(GetSystemPageSize())
{
}

58
src/allocators.h
View File

@ -26,11 +26,11 @@
* small objects that span up to a few pages, mostly smaller than a page. To support large allocations,
* something like an interval tree would be the preferred data structure.
*/
template <class Locker> class LockedPageManagerBase
template <class Locker>
class LockedPageManagerBase
{
public:
LockedPageManagerBase(size_t page_size):
page_size(page_size)
LockedPageManagerBase(size_t page_size) : page_size(page_size)
{
// Determine bitmask for extracting page from address
assert(!(page_size & (page_size - 1))); // size must be power of two
@ -47,19 +47,18 @@ public:
void LockRange(void* p, size_t size)
{
boost::mutex::scoped_lock lock(mutex);
if(!size) return;
if (!size)
return;
const size_t base_addr = reinterpret_cast<size_t>(p);
const size_t start_page = base_addr & page_mask;
const size_t end_page = (base_addr + size - 1) & page_mask;
for(size_t page = start_page; page <= end_page; page += page_size)
{
for (size_t page = start_page; page <= end_page; page += page_size) {
Histogram::iterator it = histogram.find(page);
if (it == histogram.end()) // Newly locked page
{
locker.Lock(reinterpret_cast<void*>(page), page_size);
histogram.insert(std::make_pair(page, 1));
}
else // Page was already locked; increase counter
} else // Page was already locked; increase counter
{
it->second += 1;
}
@ -70,12 +69,12 @@ public:
void UnlockRange(void* p, size_t size)
{
boost::mutex::scoped_lock lock(mutex);
if(!size) return;
if (!size)
return;
const size_t base_addr = reinterpret_cast<size_t>(p);
const size_t start_page = base_addr & page_mask;
const size_t end_page = (base_addr + size - 1) & page_mask;
for(size_t page = start_page; page <= end_page; page += page_size)
{
for (size_t page = start_page; page <= end_page; page += page_size) {
Histogram::iterator it = histogram.find(page);
assert(it != histogram.end()); // Cannot unlock an area that was not locked
// Decrease counter for page, when it is zero, the page will be unlocked
@ -165,11 +164,15 @@ private:
// Functions for directly locking/unlocking memory objects.
// Intended for non-dynamically allocated structures.
//
template<typename T> void LockObject(const T &t) {
template <typename T>
void LockObject(const T& t)
{
LockedPageManager::Instance().LockRange((void*)(&t), sizeof(T));
}
template<typename T> void UnlockObject(const T &t) {
template <typename T>
void UnlockObject(const T& t)
{
OPENSSL_cleanse((void*)(&t), sizeof(T));
LockedPageManager::Instance().UnlockRange((void*)(&t), sizeof(T));
}
@ -179,8 +182,7 @@ template<typename T> void UnlockObject(const T &t) {
// out of memory and clears its contents before deletion.
//
template <typename T>
struct secure_allocator : public std::allocator<T>
{
struct secure_allocator : public std::allocator<T> {
// MSVC8 default copy constructor is broken
typedef std::allocator<T> base;
typedef typename base::size_type size_type;
@ -193,10 +195,14 @@ struct secure_allocator : public std::allocator<T>
secure_allocator() throw() {}
secure_allocator(const secure_allocator& a) throw() : base(a) {}
template <typename U>
secure_allocator(const secure_allocator<U>& a) throw() : base(a) {}
secure_allocator(const secure_allocator<U>& a) throw() : base(a)
{
}
~secure_allocator() throw() {}
template<typename _Other> struct rebind
{ typedef secure_allocator<_Other> other; };
template <typename _Other>
struct rebind {
typedef secure_allocator<_Other> other;
};
T* allocate(std::size_t n, const void* hint = 0)
{
@ -209,8 +215,7 @@ struct secure_allocator : public std::allocator<T>
void deallocate(T* p, std::size_t n)
{
if (p != NULL)
{
if (p != NULL) {
OPENSSL_cleanse(p, sizeof(T) * n);
LockedPageManager::Instance().UnlockRange(p, sizeof(T) * n);
}
@ -223,8 +228,7 @@ struct secure_allocator : public std::allocator<T>
// Allocator that clears its contents before deletion.
//
template <typename T>
struct zero_after_free_allocator : public std::allocator<T>
{
struct zero_after_free_allocator : public std::allocator<T> {
// MSVC8 default copy constructor is broken
typedef std::allocator<T> base;
typedef typename base::size_type size_type;
@ -237,10 +241,14 @@ struct zero_after_free_allocator : public std::allocator<T>
zero_after_free_allocator() throw() {}
zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {}
template <typename U>
zero_after_free_allocator(const zero_after_free_allocator<U>& a) throw() : base(a) {}
zero_after_free_allocator(const zero_after_free_allocator<U>& a) throw() : base(a)
{
}
~zero_after_free_allocator() throw() {}
template<typename _Other> struct rebind
{ typedef zero_after_free_allocator<_Other> other; };
template <typename _Other>
struct rebind {
typedef zero_after_free_allocator<_Other> other;
};
void deallocate(T* p, std::size_t n)
{

107
src/base58.cpp
View File

@ -18,7 +18,8 @@
/* All alphanumeric characters except for "0", "I", "O", and "l" */
static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
bool DecodeBase58(const char *psz, std::vector<unsigned char>& vch) {
bool DecodeBase58(const char* psz, std::vector<unsigned char>& vch)
{
// Skip leading spaces.
while (*psz && isspace(*psz))
psz++;
@ -63,7 +64,8 @@ bool DecodeBase58(const char *psz, std::vector<unsigned char>& vch) {
return true;
}
std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend) {
std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
{
// Skip & count leading zeroes.
int zeroes = 0;
while (pbegin != pend && *pbegin == 0) {
@ -97,15 +99,18 @@ std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
return str;
}
std::string EncodeBase58(const std::vector<unsigned char>& vch) {
std::string EncodeBase58(const std::vector<unsigned char>& vch)
{
return EncodeBase58(&vch[0], &vch[0] + vch.size());
}
bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet) {
bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58(str.c_str(), vchRet);
}
std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn) {
std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
{
// add 4-byte hash check to the end
std::vector<unsigned char> vch(vchIn);
uint256 hash = Hash(vch.begin(), vch.end());
@ -113,17 +118,16 @@ std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn) {
return EncodeBase58(vch);
}
bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet) {
if (!DecodeBase58(psz, vchRet) ||
(vchRet.size() < 4))
bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
{
if (!DecodeBase58(psz, vchRet) ||
(vchRet.size() < 4)) {
vchRet.clear();
return false;
}
// re-calculate the checksum, insure it matches the included 4-byte checksum
uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);
if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
{
if (memcmp(&hash, &vchRet.end()[-4], 4) != 0) {
vchRet.clear();
return false;
}
@ -131,27 +135,32 @@ bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet) {
return true;
}
bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet) {
bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58Check(str.c_str(), vchRet);
}
CBase58Data::CBase58Data() {
CBase58Data::CBase58Data()
{
vchVersion.clear();
vchData.clear();
}
void CBase58Data::SetData(const std::vector<unsigned char> &vchVersionIn, const void* pdata, size_t nSize) {
void CBase58Data::SetData(const std::vector<unsigned char>& vchVersionIn, const void* pdata, size_t nSize)
{
vchVersion = vchVersionIn;
vchData.resize(nSize);
if (!vchData.empty())
memcpy(&vchData[0], pdata, nSize);
}
void CBase58Data::SetData(const std::vector<unsigned char> &vchVersionIn, const unsigned char *pbegin, const unsigned char *pend) {
void CBase58Data::SetData(const std::vector<unsigned char>& vchVersionIn, const unsigned char* pbegin, const unsigned char* pend)
{
SetData(vchVersionIn, (void*)pbegin, pend - pbegin);
}
bool CBase58Data::SetString(const char* psz, unsigned int nVersionBytes) {
bool CBase58Data::SetString(const char* psz, unsigned int nVersionBytes)
{
std::vector<unsigned char> vchTemp;
bool rc58 = DecodeBase58Check(psz, vchTemp);
if ((!rc58) || (vchTemp.size() < nVersionBytes)) {
@ -167,29 +176,38 @@ bool CBase58Data::SetString(const char* psz, unsigned int nVersionBytes) {
return true;
}
bool CBase58Data::SetString(const std::string& str) {
bool CBase58Data::SetString(const std::string& str)
{
return SetString(str.c_str());
}
std::string CBase58Data::ToString() const {
std::string CBase58Data::ToString() const
{
std::vector<unsigned char> vch = vchVersion;
vch.insert(vch.end(), vchData.begin(), vchData.end());
return EncodeBase58Check(vch);
}
int CBase58Data::CompareTo(const CBase58Data& b58) const {
if (vchVersion < b58.vchVersion) return -1;
if (vchVersion > b58.vchVersion) return 1;
if (vchData < b58.vchData) return -1;
if (vchData > b58.vchData) return 1;
int CBase58Data::CompareTo(const CBase58Data& b58) const
{
if (vchVersion < b58.vchVersion)
return -1;
if (vchVersion > b58.vchVersion)
return 1;
if (vchData < b58.vchData)
return -1;
if (vchData > b58.vchData)
return 1;
return 0;
}
namespace {
class CBitcoinAddressVisitor : public boost::static_visitor<bool> {
namespace
{
class CBitcoinAddressVisitor : public boost::static_visitor<bool>
{
private:
CBitcoinAddress* addr;
public:
CBitcoinAddressVisitor(CBitcoinAddress* addrIn) : addr(addrIn) {}
@ -200,32 +218,38 @@ namespace {
} // anon namespace
bool CBitcoinAddress::Set(const CKeyID &id) {
bool CBitcoinAddress::Set(const CKeyID& id)
{
SetData(Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS), &id, 20);
return true;
}
bool CBitcoinAddress::Set(const CScriptID &id) {
bool CBitcoinAddress::Set(const CScriptID& id)
{
SetData(Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS), &id, 20);
return true;
}
bool CBitcoinAddress::Set(const CTxDestination &dest) {
bool CBitcoinAddress::Set(const CTxDestination& dest)
{
return boost::apply_visitor(CBitcoinAddressVisitor(this), dest);
}
bool CBitcoinAddress::IsValid() const {
bool CBitcoinAddress::IsValid() const
{
return IsValid(Params());
}
bool CBitcoinAddress::IsValid(const CChainParams &params) const {
bool CBitcoinAddress::IsValid(const CChainParams& params) const
{
bool fCorrectSize = vchData.size() == 20;
bool fKnownVersion = vchVersion == params.Base58Prefix(CChainParams::PUBKEY_ADDRESS) ||
vchVersion == params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
return fCorrectSize && fKnownVersion;
}
CTxDestination CBitcoinAddress::Get() const {
CTxDestination CBitcoinAddress::Get() const
{
if (!IsValid())
return CNoDestination();
uint160 id;
@ -238,7 +262,8 @@ CTxDestination CBitcoinAddress::Get() const {
return CNoDestination();
}
bool CBitcoinAddress::GetKeyID(CKeyID &keyID) const {
bool CBitcoinAddress::GetKeyID(CKeyID& keyID) const
{
if (!IsValid() || vchVersion != Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
return false;
uint160 id;
@ -247,33 +272,39 @@ bool CBitcoinAddress::GetKeyID(CKeyID &keyID) const {
return true;
}
bool CBitcoinAddress::IsScript() const {
bool CBitcoinAddress::IsScript() const
{
return IsValid() && vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS);
}
void CBitcoinSecret::SetKey(const CKey& vchSecret) {
void CBitcoinSecret::SetKey(const CKey& vchSecret)
{
assert(vchSecret.IsValid());
SetData(Params().Base58Prefix(CChainParams::SECRET_KEY), vchSecret.begin(), vchSecret.size());
if (vchSecret.IsCompressed())
vchData.push_back(1);
}
CKey CBitcoinSecret::GetKey() {
CKey CBitcoinSecret::GetKey()
{
CKey ret;
ret.Set(&vchData[0], &vchData[32], vchData.size() > 32 && vchData[32] == 1);
return ret;
}
bool CBitcoinSecret::IsValid() const {
bool CBitcoinSecret::IsValid() const
{
bool fExpectedFormat = vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1);
bool fCorrectVersion = vchVersion == Params().Base58Prefix(CChainParams::SECRET_KEY);
return fExpectedFormat && fCorrectVersion;
}
bool CBitcoinSecret::SetString(const char* pszSecret) {
bool CBitcoinSecret::SetString(const char* pszSecret)
{
return CBase58Data::SetString(pszSecret) && IsValid();
}
bool CBitcoinSecret::SetString(const std::string& strSecret) {
bool CBitcoinSecret::SetString(const std::string& strSecret)
{
return SetString(strSecret.c_str());
}

30
src/chainparamsbase.cpp
View File

@ -17,9 +17,11 @@ using namespace boost::assign;
// Main network
//
class CBaseMainParams : public CBaseChainParams {
class CBaseMainParams : public CBaseChainParams
{
public:
CBaseMainParams() {
CBaseMainParams()
{
networkID = CBaseChainParams::MAIN;
nRPCPort = 8332;
}
@ -29,9 +31,11 @@ static CBaseMainParams mainParams;
//
// Testnet (v3)
//
class CBaseTestNetParams : public CBaseMainParams {
class CBaseTestNetParams : public CBaseMainParams
{
public:
CBaseTestNetParams() {
CBaseTestNetParams()
{
networkID = CBaseChainParams::TESTNET;
nRPCPort = 18332;
strDataDir = "testnet3";
@ -42,9 +46,11 @@ static CBaseTestNetParams testNetParams;
//
// Regression test
//
class CBaseRegTestParams : public CBaseTestNetParams {
class CBaseRegTestParams : public CBaseTestNetParams
{
public:
CBaseRegTestParams() {
CBaseRegTestParams()
{
networkID = CBaseChainParams::REGTEST;
strDataDir = "regtest";
}
@ -53,12 +59,14 @@ static CBaseRegTestParams regTestParams;
static CBaseChainParams* pCurrentBaseParams = 0;
const CBaseChainParams &BaseParams() {
const CBaseChainParams& BaseParams()
{
assert(pCurrentBaseParams);
return *pCurrentBaseParams;
}
void SelectBaseParams(CBaseChainParams::Network network) {
void SelectBaseParams(CBaseChainParams::Network network)
{
switch (network) {
case CBaseChainParams::MAIN:
pCurrentBaseParams = &mainParams;
@ -75,7 +83,8 @@ void SelectBaseParams(CBaseChainParams::Network network) {
}
}
bool SelectBaseParamsFromCommandLine() {
bool SelectBaseParamsFromCommandLine()
{
bool fRegTest = GetBoolArg("-regtest", false);
bool fTestNet = GetBoolArg("-testnet", false);
@ -93,6 +102,7 @@ bool SelectBaseParamsFromCommandLine() {
return true;
}
bool AreBaseParamsConfigured() {
bool AreBaseParamsConfigured()
{
return pCurrentBaseParams != NULL;
}

1
src/chainparamsbase.h
View File

@ -26,6 +26,7 @@ public:
const std::string& DataDir() const { return strDataDir; }
int RPCPort() const { return nRPCPort; }
Network NetworkID() const { return networkID; }
protected:
CBaseChainParams() {}

4
src/checkpoints.h
View File

@ -13,8 +13,8 @@ class uint256;
/** Block-chain checkpoints are compiled-in sanity checks.
* They are updated every release or three.
*/
namespace Checkpoints {
namespace Checkpoints
{
// Returns true if block passes checkpoint checks
bool CheckBlock(int nHeight, const uint256& hash);

41
src/checkqueue.h
View File

@ -13,7 +13,8 @@
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
template<typename T> class CCheckQueueControl;
template <typename T>
class CCheckQueueControl;
/** Queue for verifications that have to be performed.
* The verifications are represented by a type T, which must provide an
@ -24,7 +25,9 @@ template<typename T> class CCheckQueueControl;
* the master is done adding work, it temporarily joins the worker pool
* as an N'th worker, until all jobs are done.
*/
template<typename T> class CCheckQueue {
template <typename T>
class CCheckQueue
{
private:
// Mutex to protect the inner state
boost::mutex mutex;
@ -60,7 +63,8 @@ private:
unsigned int nBatchSize;
// Internal function that does bulk of the verification work.
bool Loop(bool fMaster = false) {
bool Loop(bool fMaster = false)
{
boost::condition_variable& cond = fMaster ? condMaster : condWorker;
std::vector<T> vChecks;
vChecks.reserve(nBatchSize);
@ -121,21 +125,23 @@ private:
public:
// Create a new check queue
CCheckQueue(unsigned int nBatchSizeIn) :
nIdle(0), nTotal(0), fAllOk(true), nTodo(0), fQuit(false), nBatchSize(nBatchSizeIn) {}
CCheckQueue(unsigned int nBatchSizeIn) : nIdle(0), nTotal(0), fAllOk(true), nTodo(0), fQuit(false), nBatchSize(nBatchSizeIn) {}
// Worker thread
void Thread() {
void Thread()
{
Loop();
}
// Wait until execution finishes, and return whether all evaluations where succesful.
bool Wait() {
bool Wait()
{
return Loop(true);
}
// Add a batch of checks to the queue
void Add(std::vector<T> &vChecks) {
void Add(std::vector<T>& vChecks)
{
boost::unique_lock<boost::mutex> lock(mutex);
BOOST_FOREACH (T& check, vChecks) {
queue.push_back(T());
@ -148,7 +154,8 @@ public:
condWorker.notify_all();
}
~CCheckQueue() {
~CCheckQueue()
{
}
friend class CCheckQueueControl<T>;
@ -157,13 +164,16 @@ public:
/** RAII-style controller object for a CCheckQueue that guarantees the passed
* queue is finished before continuing.
*/
template<typename T> class CCheckQueueControl {
template <typename T>
class CCheckQueueControl
{
private:
CCheckQueue<T>* pqueue;
bool fDone;
public:
CCheckQueueControl(CCheckQueue<T> *pqueueIn) : pqueue(pqueueIn), fDone(false) {
CCheckQueueControl(CCheckQueue<T>* pqueueIn) : pqueue(pqueueIn), fDone(false)
{
// passed queue is supposed to be unused, or NULL
if (pqueue != NULL) {
assert(pqueue->nTotal == pqueue->nIdle);
@ -172,7 +182,8 @@ public:
}
}
bool Wait() {
bool Wait()
{
if (pqueue == NULL)
return true;
bool fRet = pqueue->Wait();
@ -180,12 +191,14 @@ public:
return fRet;
}
void Add(std::vector<T> &vChecks) {
void Add(std::vector<T>& vChecks)
{
if (pqueue != NULL)
pqueue->Add(vChecks);
}
~CCheckQueueControl() {
~CCheckQueueControl()
{
if (!fDone)
Wait();
}

1
src/coincontrol.h
View File

@ -57,7 +57,6 @@ public:
private:
std::set<COutPoint> setSelected;
};
#endif // COINCONTROL_H

84
src/db.cpp
View File

@ -30,7 +30,6 @@ using namespace boost;
unsigned int nWalletDBUpdated;
//
// CDB
//
@ -160,30 +159,27 @@ CDBEnv::VerifyResult CDBEnv::Verify(std::string strFile, bool (*recoverFunc)(CDB
return (fRecovered ? RECOVER_OK : RECOVER_FAIL);
}
bool CDBEnv::Salvage(std::string strFile, bool fAggressive,
std::vector<CDBEnv::KeyValPair >& vResult)
bool CDBEnv::Salvage(std::string strFile, bool fAggressive, std::vector<CDBEnv::KeyValPair>& vResult)
{
LOCK(cs_db);
assert(mapFileUseCount.count(strFile) == 0);
u_int32_t flags = DB_SALVAGE;
if (fAggressive) flags |= DB_AGGRESSIVE;
if (fAggressive)
flags |= DB_AGGRESSIVE;
stringstream strDump;
Db db(&dbenv, 0);
int result = db.verify(strFile.c_str(), NULL, &strDump, flags);
if (result == DB_VERIFY_BAD)
{
if (result == DB_VERIFY_BAD) {
LogPrintf("CDBEnv::Salvage : Database salvage found errors, all data may not be recoverable.\n");
if (!fAggressive)
{
if (!fAggressive) {
LogPrintf("CDBEnv::Salvage : Rerun with aggressive mode to ignore errors and continue.\n");
return false;
}
}
if (result != 0 && result != DB_VERIFY_BAD)
{
if (result != 0 && result != DB_VERIFY_BAD) {
LogPrintf("CDBEnv::Salvage : Database salvage failed with result %d.\n", result);
return false;
}
@ -201,11 +197,9 @@ bool CDBEnv::Salvage(std::string strFile, bool fAggressive,
getline(strDump, strLine); // Skip past header
std::string keyHex, valueHex;
while (!strDump.eof() && keyHex != "DATA=END")
{
while (!strDump.eof() && keyHex != "DATA=END") {
getline(strDump, keyHex);
if (keyHex != "DATA_END")
{
if (keyHex != "DATA_END") {
getline(strDump, valueHex);
vResult.push_back(make_pair(ParseHex(keyHex), ParseHex(valueHex)));
}
@ -224,8 +218,7 @@ void CDBEnv::CheckpointLSN(const std::string& strFile)
}
CDB::CDB(const std::string& strFilename, const char* pszMode) :
pdb(NULL), activeTxn(NULL)
CDB::CDB(const std::string& strFilename, const char* pszMode) : pdb(NULL), activeTxn(NULL)
{
int ret;
fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
@ -245,13 +238,11 @@ CDB::CDB(const std::string& strFilename, const char* pszMode) :
strFile = strFilename;
++bitdb.mapFileUseCount[strFile];
pdb = bitdb.mapDb[strFile];
if (pdb == NULL)
{
if (pdb == NULL) {
pdb = new Db(&bitdb.dbenv, 0);
bool fMockDb = bitdb.IsMock();
if (fMockDb)
{
if (fMockDb) {
DbMpoolFile* mpf = pdb->get_mpf();
ret = mpf->set_flags(DB_MPOOL_NOFILE, 1);
if (ret != 0)
@ -265,8 +256,7 @@ CDB::CDB(const std::string& strFilename, const char* pszMode) :
nFlags, // Flags
0);
if (ret != 0)
{
if (ret != 0) {
delete pdb;
pdb = NULL;
--bitdb.mapFileUseCount[strFile];
@ -274,8 +264,7 @@ CDB::CDB(const std::string& strFilename, const char* pszMode) :
throw runtime_error(strprintf("CDB : Error %d, can't open database %s", ret, strFile));
}
if (fCreate && !Exists(string("version")))
{
if (fCreate && !Exists(string("version"))) {
bool fTmp = fReadOnly;
fReadOnly = false;
WriteVersion(CLIENT_VERSION);
@ -321,8 +310,7 @@ void CDBEnv::CloseDb(const string& strFile)
{
{
LOCK(cs_db);
if (mapDb[strFile] != NULL)
{
if (mapDb[strFile] != NULL) {
// Close the database handle
Db* pdb = mapDb[strFile];
pdb->close(0);
@ -343,12 +331,10 @@ bool CDBEnv::RemoveDb(const string& strFile)
bool CDB::Rewrite(const string& strFile, const char* pszSkip)
{
while (true)
{
while (true) {
{
LOCK(bitdb.cs_db);
if (!bitdb.mapFileUseCount.count(strFile) || bitdb.mapFileUseCount[strFile] == 0)
{
if (!bitdb.mapFileUseCount.count(strFile) || bitdb.mapFileUseCount[strFile] == 0) {
// Flush log data to the dat file
bitdb.CloseDb(strFile);
bitdb.CheckpointLSN(strFile);
@ -367,26 +353,21 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
DB_BTREE, // Database type
DB_CREATE, // Flags
0);
if (ret > 0)
{
if (ret > 0) {
LogPrintf("CDB::Rewrite : Can't create database file %s\n", strFileRes);
fSuccess = false;
}
Dbc* pcursor = db.GetCursor();
if (pcursor)
while (fSuccess)
{
while (fSuccess) {
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
CDataStream ssValue(SER_DISK, CLIENT_VERSION);
int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT);
if (ret == DB_NOTFOUND)
{
if (ret == DB_NOTFOUND) {
pcursor->close();
break;
}
else if (ret != 0)
{
} else if (ret != 0) {
pcursor->close();
fSuccess = false;
break;
@ -394,8 +375,7 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
if (pszSkip &&
strncmp(&ssKey[0], pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0)
continue;
if (strncmp(&ssKey[0], "\x07version", 8) == 0)
{
if (strncmp(&ssKey[0], "\x07version", 8) == 0) {
// Update version:
ssValue.clear();
ssValue << CLIENT_VERSION;
@ -406,8 +386,7 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
if (ret2 > 0)
fSuccess = false;
}
if (fSuccess)
{
if (fSuccess) {
db.Close();
bitdb.CloseDb(strFile);
if (pdbCopy->close(0))
@ -415,8 +394,7 @@ bool CDB::Rewrite(const string& strFile, const char* pszSkip)
delete pdbCopy;
}
}
if (fSuccess)
{
if (fSuccess) {
Db dbA(&bitdb.dbenv, 0);
if (dbA.remove(strFile.c_str(), NULL, 0))
fSuccess = false;
@ -445,13 +423,11 @@ void CDBEnv::Flush(bool fShutdown)
{
LOCK(cs_db);
map<string, int>::iterator mi = mapFileUseCount.begin();
while (mi != mapFileUseCount.end())
{
while (mi != mapFileUseCount.end()) {
string strFile = (*mi).first;
int nRefCount = (*mi).second;
LogPrint("db", "CDBEnv::Flush : Flushing %s (refcount = %d)...\n", strFile, nRefCount);
if (nRefCount == 0)
{
if (nRefCount == 0) {
// Move log data to the dat file
CloseDb(strFile);
LogPrint("db", "CDBEnv::Flush : %s checkpoint\n", strFile);
@ -461,16 +437,13 @@ void CDBEnv::Flush(bool fShutdown)
dbenv.lsn_reset(strFile.c_str(), 0);
LogPrint("db", "CDBEnv::Flush : %s closed\n", strFile);
mapFileUseCount.erase(mi++);
}
else
} else
mi++;
}
LogPrint("db", "CDBEnv::Flush : Flush(%s)%s took %15dms\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " database not started", GetTimeMillis() - nStart);
if (fShutdown)
{
if (fShutdown) {
char** listp;
if (mapFileUseCount.empty())
{
if (mapFileUseCount.empty()) {
dbenv.log_archive(&listp, DB_ARCH_REMOVE);
Close();
if (!fMockDb)
@ -479,4 +452,3 @@ void CDBEnv::Flush(bool fShutdown)
}
}
}

13
src/db.h
View File

@ -54,7 +54,9 @@ public:
* This must be called BEFORE strFile is opened.
* Returns true if strFile is OK.
*/
enum VerifyResult { VERIFY_OK, RECOVER_OK, RECOVER_FAIL };
enum VerifyResult { VERIFY_OK,
RECOVER_OK,
RECOVER_FAIL };
VerifyResult Verify(std::string strFile, bool (*recoverFunc)(CDBEnv& dbenv, std::string strFile));
/*
* Salvage data from a file that Verify says is bad.
@ -132,8 +134,7 @@ protected:
try {
CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK, CLIENT_VERSION);
ssValue >> value;
}
catch (const std::exception &) {
} catch (const std::exception&) {
return false;
}
@ -229,14 +230,12 @@ protected:
{
// Read at cursor
Dbt datKey;
if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
{
if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE) {
datKey.set_data(&ssKey[0]);
datKey.set_size(ssKey.size());
}
Dbt datValue;
if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
{
if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE) {
datValue.set_data(&ssValue[0]);
datValue.set_size(ssValue.size());
}

20
src/hash.cpp
View File

@ -18,8 +18,7 @@ unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char
// body
const uint32_t* blocks = (const uint32_t*)(&vDataToHash[0] + nblocks * 4);
for(int i = -nblocks; i; i++)
{
for (int i = -nblocks; i; i++) {
uint32_t k1 = blocks[i];
k1 *= c1;
@ -37,12 +36,17 @@ unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char
uint32_t k1 = 0;
switch(vDataToHash.size() & 3)
{
case 3: k1 ^= tail[2] << 16;
case 2: k1 ^= tail[1] << 8;
case 1: k1 ^= tail[0];
k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
switch (vDataToHash.size() & 3) {
case 3:
k1 ^= tail[2] << 16;
case 2:
k1 ^= tail[1] << 8;
case 1:
k1 ^= tail[0];
k1 *= c1;
k1 = ROTL32(k1, 15);
k1 *= c2;
h1 ^= k1;
};
//----------

6
src/init.h
View File

@ -10,7 +10,8 @@
class CWallet;
namespace boost {
namespace boost
{
class thread_group;
} // namespace boost
@ -22,8 +23,7 @@ void Shutdown();
bool AppInit2(boost::thread_group& threadGroup);
/* The help message mode determines what help message to show */
enum HelpMessageMode
{
enum HelpMessageMode {
HMM_BITCOIND,
HMM_BITCOIN_QT
};

79
src/key.h
View File

@ -39,14 +39,16 @@ public:
};
/** An encapsulated public key. */
class CPubKey {
class CPubKey
{
private:
// Just store the serialized data.
// Its length can very cheaply be computed from the first byte.
unsigned char vch[65];
// Compute the length of a pubkey with a given first byte.
unsigned int static GetLen(unsigned char chHeader) {
unsigned int static GetLen(unsigned char chHeader)
{
if (chHeader == 2 || chHeader == 3)
return 33;
if (chHeader == 4 || chHeader == 6 || chHeader == 7)
@ -55,19 +57,22 @@ private:
}
// Set this key data to be invalid
void Invalidate() {
void Invalidate()
{
vch[0] = 0xFF;
}
public:
// Construct an invalid public key.
CPubKey() {
CPubKey()
{
Invalidate();
}
// Initialize a public key using begin/end iterators to byte data.
template <typename T>
void Set(const T pbegin, const T pend) {
void Set(const T pbegin, const T pend)
{
int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
if (len && len == (pend - pbegin))
memcpy(vch, (unsigned char*)&pbegin[0], len);
@ -77,12 +82,14 @@ public:
// Construct a public key using begin/end iterators to byte data.
template <typename T>
CPubKey(const T pbegin, const T pend) {
CPubKey(const T pbegin, const T pend)
{
Set(pbegin, pend);
}
// Construct a public key from a byte vector.
CPubKey(const std::vector<unsigned char> &vch) {
CPubKey(const std::vector<unsigned char>& vch)
{
Set(vch.begin(), vch.end());
}
@ -93,28 +100,36 @@ public:
const unsigned char& operator[](unsigned int pos) const { return vch[pos]; }
// Comparator implementation.
friend bool operator==(const CPubKey &a, const CPubKey &b) {
friend bool operator==(const CPubKey& a, const CPubKey& b)
{
return a.vch[0] == b.vch[0] &&
memcmp(a.vch, b.vch, a.size()) == 0;
}
friend bool operator!=(const CPubKey &a, const CPubKey &b) {
friend bool operator!=(const CPubKey& a, const CPubKey& b)
{
return !(a == b);
}
friend bool operator<(const CPubKey &a, const CPubKey &b) {
friend bool operator<(const CPubKey& a, const CPubKey& b)
{
return a.vch[0] < b.vch[0] ||
(a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) < 0);
}
// Implement serialization, as if this was a byte vector.
unsigned int GetSerializeSize(int nType, int nVersion) const {
unsigned int GetSerializeSize(int nType, int nVersion) const
{
return size() + 1;
}
template<typename Stream> void Serialize(Stream &s, int nType, int nVersion) const {
template <typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const
{
unsigned int len = size();
::WriteCompactSize(s, len);
s.write((char*)vch, len);
}
template<typename Stream> void Unserialize(Stream &s, int nType, int nVersion) {
template <typename Stream>
void Unserialize(Stream& s, int nType, int nVersion)
{
unsigned int len = ::ReadCompactSize(s);
if (len <= 65) {
s.read((char*)vch, len);
@ -128,19 +143,22 @@ public:
}
// Get the KeyID of this public key (hash of its serialization)
CKeyID GetID() const {
CKeyID GetID() const
{
return CKeyID(Hash160(vch, vch + size()));
}
// Get the 256-bit hash of this public key.
uint256 GetHash() const {
uint256 GetHash() const
{
return Hash(vch, vch + size());
}
// Check syntactic correctness.
//
// Note that this is consensus critical as CheckSig() calls it!
bool IsValid() const {
bool IsValid() const
{
return size() > 0;
}
@ -148,7 +166,8 @@ public:
bool IsFullyValid() const;
// Check whether this is a compressed public key.
bool IsCompressed() const {
bool IsCompressed() const
{
return size() == 33;
}
@ -172,7 +191,8 @@ public:
typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
/** An encapsulated private key. */
class CKey {
class CKey
{
private:
// Whether this private key is valid. We check for correctness when modifying the key
// data, so fValid should always correspond to the actual state.
@ -186,32 +206,37 @@ private:
// Check whether the 32-byte array pointed to be vch is valid keydata.
bool static Check(const unsigned char* vch);
public:
public:
// Construct an invalid private key.
CKey() : fValid(false), fCompressed(false) {
CKey() : fValid(false), fCompressed(false)
{
LockObject(vch);
}
// Copy constructor. This is necessary because of memlocking.
CKey(const CKey &secret) : fValid(secret.fValid), fCompressed(secret.fCompressed) {
CKey(const CKey& secret) : fValid(secret.fValid), fCompressed(secret.fCompressed)
{
LockObject(vch);
memcpy(vch, secret.vch, sizeof(vch));
}
// Destructor (again necessary because of memlocking).
~CKey() {
~CKey()
{
UnlockObject(vch);
}
friend bool operator==(const CKey &a, const CKey &b) {
friend bool operator==(const CKey& a, const CKey& b)
{
return a.fCompressed == b.fCompressed && a.size() == b.size() &&
memcmp(&a.vch[0], &b.vch[0], a.size()) == 0;
}
// Initialize using begin and end iterators to byte data.
template <typename T>
void Set(const T pbegin, const T pend, bool fCompressedIn) {
void Set(const T pbegin, const T pend, bool fCompressedIn)
{
if (pend - pbegin != 32) {
fValid = false;
return;
@ -277,7 +302,8 @@ struct CExtPubKey {
unsigned char vchChainCode[32];
CPubKey pubkey;
friend bool operator==(const CExtPubKey &a, const CExtPubKey &b) {
friend bool operator==(const CExtPubKey& a, const CExtPubKey& b)
{
return a.nDepth == b.nDepth && memcmp(&a.vchFingerprint[0], &b.vchFingerprint[0], 4) == 0 && a.nChild == b.nChild &&
memcmp(&a.vchChainCode[0], &b.vchChainCode[0], 32) == 0 && a.pubkey == b.pubkey;
}
@ -294,7 +320,8 @@ struct CExtKey {
unsigned char vchChainCode[32];
CKey key;
friend bool operator==(const CExtKey &a, const CExtKey &b) {
friend bool operator==(const CExtKey& a, const CExtKey& b)
{
return a.nDepth == b.nDepth && memcmp(&a.vchFingerprint[0], &b.vchFingerprint[0], 4) == 0 && a.nChild == b.nChild &&
memcmp(&a.vchChainCode[0], &b.vchChainCode[0], 32) == 0 && a.key == b.key;
}

15
src/leveldbwrapper.cpp
View File

@ -12,7 +12,8 @@
#include <leveldb/filter_policy.h>
#include <memenv.h>
void HandleError(const leveldb::Status &status) throw(leveldb_error) {
void HandleError(const leveldb::Status& status) throw(leveldb_error)
{
if (status.ok())
return;
LogPrintf("%s\n", status.ToString());
@ -25,7 +26,8 @@ void HandleError(const leveldb::Status &status) throw(leveldb_error) {
throw leveldb_error("Unknown database error");
}
static leveldb::Options GetOptions(size_t nCacheSize) {
static leveldb::Options GetOptions(size_t nCacheSize)
{
leveldb::Options options;
options.block_cache = leveldb::NewLRUCache(nCacheSize / 2);
options.write_buffer_size = nCacheSize / 4; // up to two write buffers may be held in memory simultaneously
@ -40,7 +42,8 @@ static leveldb::Options GetOptions(size_t nCacheSize) {
return options;
}
CLevelDBWrapper::CLevelDBWrapper(const boost::filesystem::path &path, size_t nCacheSize, bool fMemory, bool fWipe) {
CLevelDBWrapper::CLevelDBWrapper(const boost::filesystem::path& path, size_t nCacheSize, bool fMemory, bool fWipe)
{
penv = NULL;
readoptions.verify_checksums = true;
iteroptions.verify_checksums = true;
@ -64,7 +67,8 @@ CLevelDBWrapper::CLevelDBWrapper(const boost::filesystem::path &path, size_t nCa
LogPrintf("Opened LevelDB successfully\n");
}
CLevelDBWrapper::~CLevelDBWrapper() {
CLevelDBWrapper::~CLevelDBWrapper()
{
delete pdb;
pdb = NULL;
delete options.filter_policy;
@ -75,7 +79,8 @@ CLevelDBWrapper::~CLevelDBWrapper() {
options.env = NULL;
}
bool CLevelDBWrapper::WriteBatch(CLevelDBBatch &batch, bool fSync) throw(leveldb_error) {
bool CLevelDBWrapper::WriteBatch(CLevelDBBatch& batch, bool fSync) throw(leveldb_error)
{
leveldb::Status status = pdb->Write(fSync ? syncoptions : writeoptions, &batch.batch);
HandleError(status);
return true;

33
src/leveldbwrapper.h
View File

@ -31,7 +31,9 @@ private:
leveldb::WriteBatch batch;
public:
template<typename K, typename V> void Write(const K& key, const V& value) {
template <typename K, typename V>
void Write(const K& key, const V& value)
{
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key;
@ -45,7 +47,9 @@ public:
batch.Put(slKey, slValue);
}
template<typename K> void Erase(const K& key) {
template <typename K>
void Erase(const K& key)
{
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key;
@ -83,7 +87,9 @@ public:
CLevelDBWrapper(const boost::filesystem::path& path, size_t nCacheSize, bool fMemory = false, bool fWipe = false);
~CLevelDBWrapper();
template<typename K, typename V> bool Read(const K& key, V& value) const throw(leveldb_error) {
template <typename K, typename V>
bool Read(const K& key, V& value) const throw(leveldb_error)
{
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key;
@ -106,13 +112,17 @@ public:
return true;
}
template<typename K, typename V> bool Write(const K& key, const V& value, bool fSync = false) throw(leveldb_error) {
template <typename K, typename V>
bool Write(const K& key, const V& value, bool fSync = false) throw(leveldb_error)
{
CLevelDBBatch batch;
batch.Write(key, value);
return WriteBatch(batch, fSync);
}
template<typename K> bool Exists(const K& key) const throw(leveldb_error) {
template <typename K>
bool Exists(const K& key) const throw(leveldb_error)
{
CDataStream ssKey(SER_DISK, CLIENT_VERSION);
ssKey.reserve(ssKey.GetSerializeSize(key));
ssKey << key;
@ -129,7 +139,9 @@ public:
return true;
}
template<typename K> bool Erase(const K& key, bool fSync = false) throw(leveldb_error) {
template <typename K>
bool Erase(const K& key, bool fSync = false) throw(leveldb_error)
{
CLevelDBBatch batch;
batch.Erase(key);
return WriteBatch(batch, fSync);
@ -138,17 +150,20 @@ public:
bool WriteBatch(CLevelDBBatch& batch, bool fSync = false) throw(leveldb_error);
// not available for LevelDB; provide for compatibility with BDB
bool Flush() {
bool Flush()
{
return true;
}
bool Sync() throw(leveldb_error) {
bool Sync() throw(leveldb_error)
{
CLevelDBBatch batch;
return WriteBatch(batch, true);
}
// not exactly clean encapsulation, but it's easiest for now
leveldb::Iterator *NewIterator() {
leveldb::Iterator* NewIterator()
{
return pdb->NewIterator(iteroptions);
}
};

18
src/limitedmap.h
View File

@ -9,7 +9,8 @@
#include <map>
/** STL-like map container that only keeps the N elements with the highest value. */
template <typename K, typename V> class limitedmap
template <typename K, typename V>
class limitedmap
{
public:
typedef K key_type;
@ -36,10 +37,8 @@ public:
void insert(const value_type& x)
{
std::pair<iterator, bool> ret = map.insert(x);
if (ret.second)
{
if (nMaxSize && map.size() == nMaxSize)
{
if (ret.second) {
if (nMaxSize && map.size() == nMaxSize) {
map.erase(rmap.begin()->second);
rmap.erase(rmap.begin());
}
@ -54,8 +53,7 @@ public:
return;
std::pair<rmap_iterator, rmap_iterator> itPair = rmap.equal_range(itTarget->second);
for (rmap_iterator it = itPair.first; it != itPair.second; ++it)
if (it->second == itTarget)
{
if (it->second == itTarget) {
rmap.erase(it);
map.erase(itTarget);
return;
@ -72,8 +70,7 @@ public:
return;
std::pair<rmap_iterator, rmap_iterator> itPair = rmap.equal_range(itTarget->second);
for (rmap_iterator it = itPair.first; it != itPair.second; ++it)
if (it->second == itTarget)
{
if (it->second == itTarget) {
rmap.erase(it);
itTarget->second = v;
rmap.insert(make_pair(v, itTarget));
@ -88,8 +85,7 @@ public:
size_type max_size(size_type s)
{
if (s)
while (map.size() > s)
{
while (map.size() > s) {
map.erase(rmap.begin()->second);
rmap.erase(rmap.begin());
}

18
src/mruset.h
View File

@ -10,7 +10,8 @@
#include <utility>
/** STL-like set container that only keeps the most recent N elements. */
template <typename T> class mruset
template <typename T>
class mruset
{
public:
typedef T key_type;
@ -32,17 +33,19 @@ public:
bool empty() const { return set.empty(); }
iterator find(const key_type& k) const { return set.find(k); }
size_type count(const key_type& k) const { return set.count(k); }
void clear() { set.clear(); queue.clear(); }
void clear()
{
set.clear();
queue.clear();
}
bool inline friend operator==(const mruset<T>& a, const mruset<T>& b) { return a.set == b.set; }
bool inline friend operator==(const mruset<T>& a, const std::set<T>& b) { return a.set == b; }
bool inline friend operator<(const mruset<T>& a, const mruset<T>& b) { return a.set < b.set; }
std::pair<iterator, bool> insert(const key_type& x)
{
std::pair<iterator, bool> ret = set.insert(x);
if (ret.second)
{
if (nMaxSize && queue.size() == nMaxSize)
{
if (ret.second) {
if (nMaxSize && queue.size() == nMaxSize) {
set.erase(queue.front());
queue.pop_front();
}
@ -54,8 +57,7 @@ public:
size_type max_size(size_type s)
{
if (s)
while (queue.size() > s)
{
while (queue.size() > s) {
set.erase(queue.front());
queue.pop_front();
}

15
src/protocol.h
View File

@ -38,7 +38,8 @@ class CMessageHeader
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
{
READWRITE(FLATDATA(pchMessageStart));
READWRITE(FLATDATA(pchCommand));
READWRITE(nMessageSize);
@ -63,8 +64,7 @@ class CMessageHeader
};
/** nServices flags */
enum
{
enum {
NODE_NETWORK = (1 << 0),
// Bits 24-31 are reserved for temporary experiments. Just pick a bit that
@ -88,7 +88,8 @@ class CAddress : public CService
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
{
if (ser_action.ForRead())
Init();
if (nType & SER_DISK)
@ -122,7 +123,8 @@ class CInv
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
{
READWRITE(type);
READWRITE(hash);
}
@ -139,8 +141,7 @@ class CInv
uint256 hash;
};
enum
{
enum {
MSG_TX = 1,
MSG_BLOCK,
// Nodes may always request a MSG_FILTERED_BLOCK in a getdata, however,

12
src/random.cpp
View File

@ -60,8 +60,7 @@ void RandAddSeedPerfmon()
long ret = 0;
unsigned long nSize = 0;
const size_t nMaxSize = 10000000; // Bail out at more than 10MB of performance data
while (true)
{
while (true) {
nSize = vData.size();
ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, begin_ptr(vData), &nSize);
if (ret != ERROR_MORE_DATA || vData.size() >= nMaxSize)
@ -69,15 +68,13 @@ void RandAddSeedPerfmon()
vData.resize(std::max((vData.size() * 3) / 2, nMaxSize)); // Grow size of buffer exponentially
}
RegCloseKey(HKEY_PERFORMANCE_DATA);
if (ret == ERROR_SUCCESS)
{
if (ret == ERROR_SUCCESS) {
RAND_add(begin_ptr(vData), nSize, nSize / 100.0);
OPENSSL_cleanse(begin_ptr(vData), nSize);
LogPrint("rand", "%s: %lu bytes\n", __func__, nSize);
} else {
static bool warned = false; // Warn only once
if (!warned)
{
if (!warned) {
LogPrintf("%s: Warning: RegQueryValueExA(HKEY_PERFORMANCE_DATA) failed with code %i\n", __func__, ret);
warned = true;
}
@ -126,8 +123,7 @@ uint32_t insecure_rand_Rw = 11;
void seed_insecure_rand(bool fDeterministic)
{
// The seed values have some unlikely fixed points which we avoid.
if(fDeterministic)
{
if (fDeterministic) {
insecure_rand_Rz = insecure_rand_Rw = 11;
} else {
uint32_t tmp;

36
src/sync.cpp
View File

@ -32,8 +32,7 @@ void PrintLockContention(const char* pszName, const char* pszFile, int nLine)
// Complain if any thread tries to lock in a different order.
//
struct CLockLocation
{
struct CLockLocation {
CLockLocation(const char* pszName, const char* pszFile, int nLine)
{
mutexName = pszName;
@ -65,17 +64,19 @@ static void potential_deadlock_detected(const std::pair<void*, void*>& mismatch,
{
LogPrintf("POTENTIAL DEADLOCK DETECTED\n");
LogPrintf("Previous lock order was:\n");
BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, s2)
{
if (i.first == mismatch.first) LogPrintf(" (1)");
if (i.first == mismatch.second) LogPrintf(" (2)");
BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation) & i, s2) {
if (i.first == mismatch.first)
LogPrintf(" (1)");
if (i.first == mismatch.second)
LogPrintf(" (2)");
LogPrintf(" %s\n", i.second.ToString());
}
LogPrintf("Current lock order is:\n");
BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, s1)
{
if (i.first == mismatch.first) LogPrintf(" (1)");
if (i.first == mismatch.second) LogPrintf(" (2)");
BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation) & i, s1) {
if (i.first == mismatch.first)
LogPrintf(" (1)");
if (i.first == mismatch.second)
LogPrintf(" (2)");
LogPrintf(" %s\n", i.second.ToString());
}
}
@ -92,7 +93,8 @@ static void push_lock(void* c, const CLockLocation& locklocation, bool fTry)
if (!fTry) {
BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation) & i, (*lockstack)) {
if (i.first == c) break;
if (i.first == c)
break;
std::pair<void*, void*> p1 = std::make_pair(i.first, c);
if (lockorders.count(p1))
@ -100,8 +102,7 @@ static void push_lock(void* c, const CLockLocation& locklocation, bool fTry)
lockorders[p1] = (*lockstack);
std::pair<void*, void*> p2 = std::make_pair(c, i.first);
if (lockorders.count(p2))
{
if (lockorders.count(p2)) {
potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]);
break;
}
@ -112,8 +113,7 @@ static void push_lock(void* c, const CLockLocation& locklocation, bool fTry)
static void pop_lock()
{
if (fDebug)
{
if (fDebug) {
const CLockLocation& locklocation = (*lockstack).rbegin()->second;
LogPrint("lock", "Unlocked: %s\n", locklocation.ToString());
}
@ -143,9 +143,9 @@ std::string LocksHeld()
void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
{
BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation) & i, *lockstack)
if (i.first == cs) return;
fprintf(stderr, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s",
pszName, pszFile, nLine, LocksHeld().c_str());
if (i.first == cs)
return;
fprintf(stderr, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld().c_str());
abort();
}

38
src/sync.h
View File

@ -48,7 +48,6 @@ LEAVE_CRITICAL_SECTION(mutex); // no RAII
*/
///////////////////////////////
// //
// THE ACTUAL IMPLEMENTATION //
@ -93,7 +92,9 @@ void LeaveCritical();
std::string LocksHeld();
void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs);
#else
void static inline EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false) {}
void static inline EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false)
{
}
void static inline LeaveCritical() {}
void static inline AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) {}
#endif
@ -114,8 +115,7 @@ private:
{
EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()));
#ifdef DEBUG_LOCKCONTENTION
if (!lock.try_lock())
{
if (!lock.try_lock()) {
PrintLockContention(pszName, pszFile, nLine);
#endif
lock.lock();
@ -182,7 +182,8 @@ private:
public:
CSemaphore(int init) : value(init) {}
void wait() {
void wait()
{
boost::unique_lock<boost::mutex> lock(mutex);
while (value < 1) {
condition.wait(lock);
@ -190,7 +191,8 @@ public:
value--;
}
bool try_wait() {
bool try_wait()
{
boost::unique_lock<boost::mutex> lock(mutex);
if (value < 1)
return false;
@ -198,7 +200,8 @@ public:
return true;
}
void post() {
void post()
{
{
boost::unique_lock<boost::mutex> lock(mutex);
value++;
@ -215,27 +218,31 @@ private:
bool fHaveGrant;
public:
void Acquire() {
void Acquire()
{
if (fHaveGrant)
return;
sem->wait();
fHaveGrant = true;
}
void Release() {
void Release()
{
if (!fHaveGrant)
return;
sem->post();
fHaveGrant = false;
}
bool TryAcquire() {
bool TryAcquire()
{
if (!fHaveGrant && sem->try_wait())
fHaveGrant = true;
return fHaveGrant;
}
void MoveTo(CSemaphoreGrant &grant) {
void MoveTo(CSemaphoreGrant& grant)
{
grant.Release();
grant.sem = sem;
grant.fHaveGrant = fHaveGrant;
@ -245,18 +252,21 @@ public:
CSemaphoreGrant() : sem(NULL), fHaveGrant(false) {}
CSemaphoreGrant(CSemaphore &sema, bool fTry = false) : sem(&sema), fHaveGrant(false) {
CSemaphoreGrant(CSemaphore& sema, bool fTry = false) : sem(&sema), fHaveGrant(false)
{
if (fTry)
TryAcquire();
else
Acquire();
}
~CSemaphoreGrant() {
~CSemaphoreGrant()
{
Release();
}
operator bool() {
operator bool()
{
return fHaveGrant;
}
};

13
src/timedata.h
View File

@ -15,15 +15,16 @@ class CNetAddr;
/** Median filter over a stream of values.
* Returns the median of the last N numbers
*/
template <typename T> class CMedianFilter
template <typename T>
class CMedianFilter
{
private:
std::vector<T> vValues;
std::vector<T> vSorted;
unsigned int nSize;
public:
CMedianFilter(unsigned int size, T initial_value):
nSize(size)
CMedianFilter(unsigned int size, T initial_value) : nSize(size)
{
vValues.reserve(size);
vValues.push_back(initial_value);
@ -32,8 +33,7 @@ public:
void input(T value)
{
if(vValues.size() == nSize)
{
if (vValues.size() == nSize) {
vValues.erase(vValues.begin());
}
vValues.push_back(value);
@ -50,8 +50,7 @@ public:
if (size & 1) // Odd number of elements
{
return vSorted[size / 2];
}
else // Even number of elements
} else // Even number of elements
{
return (vSorted[size / 2 - 1] + vSorted[size / 2]) / 2;
}

51
src/uint256.cpp
View File

@ -113,7 +113,8 @@ base_uint<BITS>& base_uint<BITS>::operator/=(const base_uint& b)
}
template <unsigned int BITS>
int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const {
int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const
{
for (int i = WIDTH - 1; i >= 0; i--) {
if (pn[i] < b.pn[i])
return -1;
@ -124,7 +125,8 @@ int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const {
}
template <unsigned int BITS>
bool base_uint<BITS>::EqualTo(uint64_t b) const {
bool base_uint<BITS>::EqualTo(uint64_t b) const
{
for (int i = WIDTH - 1; i >= 2; i--) {
if (pn[i])
return false;
@ -295,24 +297,43 @@ uint32_t uint256::GetCompact(bool fNegative) const
static void inline HashMix(uint32_t& a, uint32_t& b, uint32_t& c)
{
// Taken from lookup3, by Bob Jenkins.
a -= c; a ^= ((c << 4) | (c >> 28)); c += b;
b -= a; b ^= ((a << 6) | (a >> 26)); a += c;
c -= b; c ^= ((b << 8) | (b >> 24)); b += a;
a -= c; a ^= ((c << 16) | (c >> 16)); c += b;
b -= a; b ^= ((a << 19) | (a >> 13)); a += c;
c -= b; c ^= ((b << 4) | (b >> 28)); b += a;
a -= c;
a ^= ((c << 4) | (c >> 28));
c += b;
b -= a;
b ^= ((a << 6) | (a >> 26));
a += c;
c -= b;
c ^= ((b << 8) | (b >> 24));
b += a;
a -= c;
a ^= ((c << 16) | (c >> 16));
c += b;
b -= a;
b ^= ((a << 19) | (a >> 13));
a += c;
c -= b;
c ^= ((b << 4) | (b >> 28));
b += a;
}
static void inline HashFinal(uint32_t& a, uint32_t& b, uint32_t& c)
{
// Taken from lookup3, by Bob Jenkins.
c ^= b; c -= ((b << 14) | (b >> 18));
a ^= c; a -= ((c << 11) | (c >> 21));
b ^= a; b -= ((a << 25) | (a >> 7));
c ^= b; c -= ((b << 16) | (b >> 16));
a ^= c; a -= ((c << 4) | (c >> 28));
b ^= a; b -= ((a << 14) | (a >> 18));
c ^= b; c -= ((b << 24) | (b >> 8));
c ^= b;
c -= ((b << 14) | (b >> 18));
a ^= c;
a -= ((c << 11) | (c >> 21));
b ^= a;
b -= ((a << 25) | (a >> 7));
c ^= b;
c -= ((b << 16) | (b >> 16));
a ^= c;
a -= ((c << 4) | (c >> 28));
b ^= a;
b -= ((a << 14) | (a >> 18));
c ^= b;
c -= ((b << 24) | (b >> 8));
}
uint64_t uint256::GetHash(const uint256& salt) const