{

typedef bool result_type;

template<typename I>

bool operator()(I first, I last) const

{

while (first != last) {

if (!(*first)) return false;

++first;

}

return true;

}

{

boost::signals2::signal<int ()> GetHeight;

boost::signals2::signal<bool (CNode*), CombinerAll> ProcessMessages;

boost::signals2::signal<bool (CNode*), CombinerAll> SendMessages;

boost::signals2::signal<void (NodeId, const CNode*)> InitializeNode;

boost::signals2::signal<void (NodeId)> FinalizeNode;

{

NodeId nodeid;

ServiceFlags nServices;

bool fRelayTxes;

int64_t nLastSend;

int64_t nLastRecv;

int64_t nTimeConnected;

int64_t nTimeOffset;

std::string addrName;

int nVersion;

std::string cleanSubVer;

bool fInbound;

int nStartingHeight;

uint64_t nSendBytes;

mapMsgCmdSize mapSendBytesPerMsgCmd;

uint64_t nRecvBytes;

mapMsgCmdSize mapRecvBytesPerMsgCmd;

bool fWhitelisted;

double dPingTime;

double dPingWait;

double dPingMin;

std::string addrLocal;

bool in_data; // parsing header (false) or data (true)

CDataStream hdrbuf; // partially received header

CMessageHeader hdr; // complete header

unsigned int nHdrPos;

CDataStream vRecv; // received message data

unsigned int nDataPos;

int64_t nTime; // time (in microseconds) of message receipt.

CNetMessage(const CMessageHeader::MessageStartChars& pchMessageStartIn, int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn), vRecv(nTypeIn, nVersionIn) {

hdrbuf.resize(24);

in_data = false;

nHdrPos = 0;

nDataPos = 0;

nTime = 0;

}

bool complete() const

{

if (!in_data)

return false;

return (hdr.nMessageSize == nDataPos);

}

void SetVersion(int nVersionIn)

{

hdrbuf.SetVersion(nVersionIn);

vRecv.SetVersion(nVersionIn);

}

int readHeader(const char *pch, unsigned int nBytes);

int readData(const char *pch, unsigned int nBytes);

{

BanReasonUnknown = 0,

BanReasonNodeMisbehaving = 1,

BanReasonManuallyAdded = 2

{

static const int CURRENT_VERSION=1;

int nVersion;

int64_t nCreateTime;

int64_t nBanUntil;

uint8_t banReason;

CBanEntry()

{

SetNull();

}

CBanEntry(int64_t nCreateTimeIn)

{

SetNull();

nCreateTime = nCreateTimeIn;

}

ADD_SERIALIZE_METHODS;

template <typename Stream, typename Operation>

inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {

READWRITE(this->nVersion);

nVersion = this->nVersion;

READWRITE(nCreateTime);

READWRITE(nBanUntil);

READWRITE(banReason);

}

void SetNull()

{

nVersion = CBanEntry::CURRENT_VERSION;

nCreateTime = 0;

nBanUntil = 0;

banReason = BanReasonUnknown;

}

std::string banReasonToString()

{

switch (banReason) {

case BanReasonNodeMisbehaving:

return "node misbehaving";

case BanReasonManuallyAdded:

return "manually added";

default:

return "unknown";

}

}

{

// socket

ServiceFlags nServices;

ServiceFlags nServicesExpected;

SOCKET hSocket;

CDataStream ssSend;

size_t nSendSize; // total size of all vSendMsg entries

size_t nSendOffset; // offset inside the first vSendMsg already sent

uint64_t nSendBytes;

std::deque<CSerializeData> vSendMsg;

CCriticalSection cs_vSend;

std::deque<CInv> vRecvGetData;

std::deque<CNetMessage> vRecvMsg;

CCriticalSection cs_vRecvMsg;

uint64_t nRecvBytes;

int nRecvVersion;

int64_t nLastSend;

int64_t nLastRecv;

int64_t nTimeConnected;

int64_t nTimeOffset;

const CAddress addr;

std::string addrName;

CService addrLocal;

int nVersion;

// strSubVer is whatever byte array we read from the wire. However, this field is intended

// to be printed out, displayed to humans in various forms and so on. So we sanitize it and

// store the sanitized version in cleanSubVer. The original should be used when dealing with

// the network or wire types and the cleaned string used when displayed or logged.

std::string strSubVer, cleanSubVer;

bool fWhitelisted; // This peer can bypass DoS banning.

bool fFeeler; // If true this node is being used as a short lived feeler.

bool fOneShot;

bool fClient;

bool fInbound;

bool fNetworkNode;

bool fSuccessfullyConnected;

bool fDisconnect;

// We use fRelayTxes for two purposes -

// a) it allows us to not relay tx invs before receiving the peer's version message

// b) the peer may tell us in its version message that we should not relay tx invs

// unless it loads a bloom filter.

bool fRelayTxes; //protected by cs_filter

bool fSentAddr;

CSemaphoreGrant grantOutbound;

CCriticalSection cs_filter;

CBloomFilter* pfilter;

int nRefCount;

NodeId id;

const uint64_t nKeyedNetGroup;

// Denial-of-service detection/prevention

// Key is IP address, value is banned-until-time

static banmap_t setBanned;

static CCriticalSection cs_setBanned;

static bool setBannedIsDirty;

// Whitelisted ranges. Any node connecting from these is automatically

// whitelisted (as well as those connecting to whitelisted binds).

static std::vector<CSubNet> vWhitelistedRange;

static CCriticalSection cs_vWhitelistedRange;

mapMsgCmdSize mapSendBytesPerMsgCmd;

mapMsgCmdSize mapRecvBytesPerMsgCmd;

// Basic fuzz-testing

void Fuzz(int nChance); // modifies ssSend

uint256 hashContinue;

int nStartingHeight;

// flood relay

std::vector<CAddress> vAddrToSend;

CRollingBloomFilter addrKnown;

bool fGetAddr;

std::set<uint256> setKnown;

int64_t nNextAddrSend;

int64_t nNextLocalAddrSend;

uint256 hashCheckpointKnown;

// inventory based relay

CRollingBloomFilter filterInventoryKnown;

// Set of transaction ids we still have to announce.

// They are sorted by the mempool before relay, so the order is not important.

std::set<uint256> setInventoryTxToSend;

// List of block ids we still have announce.

// There is no final sorting before sending, as they are always sent immediately

// and in the order requested.

std::vector<uint256> vInventoryBlockToSend;

CCriticalSection cs_inventory;

std::set<uint256> setAskFor;

std::multimap<int64_t, CInv> mapAskFor;

int64_t nNextInvSend;

// Used for headers announcements - unfiltered blocks to relay

// Also protected by cs_inventory

std::vector<uint256> vBlockHashesToAnnounce;

// Used for BIP35 mempool sending, also protected by cs_inventory

bool fSendMempool;

// Last time a "MEMPOOL" request was serviced.

std::atomic<int64_t> timeLastMempoolReq;

// Block and TXN accept times

std::atomic<int64_t> nLastBlockTime;

std::atomic<int64_t> nLastTXTime;

// Ping time measurement:

// The pong reply we're expecting, or 0 if no pong expected.

uint64_t nPingNonceSent;

// Time (in usec) the last ping was sent, or 0 if no ping was ever sent.

int64_t nPingUsecStart;

// Last measured round-trip time.

int64_t nPingUsecTime;

// Best measured round-trip time.

int64_t nMinPingUsecTime;

// Whether a ping is requested.

bool fPingQueued;

// Minimum fee rate with which to filter inv's to this node

CAmount minFeeFilter;

CCriticalSection cs_feeFilter;

CAmount lastSentFeeFilter;

int64_t nextSendTimeFeeFilter;

CNode(SOCKET hSocketIn, const CAddress &addrIn, const std::string &addrNameIn = "", bool fInboundIn = false);

~CNode();

// Network usage totals

static CCriticalSection cs_totalBytesRecv;

static CCriticalSection cs_totalBytesSent;

static uint64_t nTotalBytesRecv;

static uint64_t nTotalBytesSent;

// outbound limit & stats

static uint64_t nMaxOutboundTotalBytesSentInCycle;

static uint64_t nMaxOutboundCycleStartTime;

static uint64_t nMaxOutboundLimit;

static uint64_t nMaxOutboundTimeframe;

CNode(const CNode&);

void operator=(const CNode&);

static uint64_t CalculateKeyedNetGroup(const CAddress& ad);

NodeId GetId() const {

return id;

}

int GetRefCount()

{

assert(nRefCount >= 0);

return nRefCount;

}

// requires LOCK(cs_vRecvMsg)

unsigned int GetTotalRecvSize()

{

unsigned int total = 0;

BOOST_FOREACH(const CNetMessage &msg, vRecvMsg)

total += msg.vRecv.size() + 24;

return total;

}

// requires LOCK(cs_vRecvMsg)

bool ReceiveMsgBytes(const char *pch, unsigned int nBytes);

// requires LOCK(cs_vRecvMsg)

void SetRecvVersion(int nVersionIn)

{

nRecvVersion = nVersionIn;

BOOST_FOREACH(CNetMessage &msg, vRecvMsg)

msg.SetVersion(nVersionIn);

}

CNode* AddRef()

{

nRefCount++;

return this;

}

void Release()

{

nRefCount--;

}

void AddAddressKnown(const CAddress& addr)

{

addrKnown.insert(addr.GetKey());

}

void PushAddress(const CAddress& addr)

{

// Known checking here is only to save space from duplicates.

// SendMessages will filter it again for knowns that were added

// after addresses were pushed.

if (addr.IsValid() && !addrKnown.contains(addr.GetKey())) {

if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {

vAddrToSend[insecure_rand() % vAddrToSend.size()] = addr;

} else {

vAddrToSend.push_back(addr);

}

}

}

void AddInventoryKnown(const CInv& inv)

{

{

LOCK(cs_inventory);

filterInventoryKnown.insert(inv.hash);

}

}

void PushInventory(const CInv& inv)

{

LOCK(cs_inventory);

if (inv.type == MSG_TX) {

if (!filterInventoryKnown.contains(inv.hash)) {

setInventoryTxToSend.insert(inv.hash);

}

} else if (inv.type == MSG_BLOCK) {

vInventoryBlockToSend.push_back(inv.hash);

}

}

void PushBlockHash(const uint256 &hash)

{

LOCK(cs_inventory);

vBlockHashesToAnnounce.push_back(hash);

}

void AskFor(const CInv& inv);

// TODO: Document the postcondition of this function. Is cs_vSend locked?

void BeginMessage(const char* pszCommand) EXCLUSIVE_LOCK_FUNCTION(cs_vSend);

// TODO: Document the precondition of this function. Is cs_vSend locked?

void AbortMessage() UNLOCK_FUNCTION(cs_vSend);

// TODO: Document the precondition of this function. Is cs_vSend locked?

void EndMessage(const char* pszCommand) UNLOCK_FUNCTION(cs_vSend);

void PushVersion();

void PushMessage(const char* pszCommand)

{

try

{

BeginMessage(pszCommand);

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1>

void PushMessage(const char* pszCommand, const T1& a1)

{

try

{

BeginMessage(pszCommand);

ssSend << a1;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

/** Send a message containing a1, serialized with flag flag. */

template<typename T1>

void PushMessageWithFlag(int flag, const char* pszCommand, const T1& a1)

{

try

{

BeginMessage(pszCommand);

WithOrVersion(&ssSend, flag) << a1;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4, typename T5>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4 << a5;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4 << a5 << a6;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>

void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9)

{

try

{

BeginMessage(pszCommand);

ssSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;

EndMessage(pszCommand);

}

catch (...)

{

AbortMessage();

throw;

}

}

void CloseSocketDisconnect();

// Denial-of-service detection/prevention

// The idea is to detect peers that are behaving

// badly and disconnect/ban them, but do it in a

// one-coding-mistake-won't-shatter-the-entire-network

// way.

// IMPORTANT: There should be nothing I can give a

// node that it will forward on that will make that

// node's peers drop it. If there is, an attacker

// can isolate a node and/or try to split the network.

// Dropping a node for sending stuff that is invalid

// now but might be valid in a later version is also

// dangerous, because it can cause a network split

// between nodes running old code and nodes running

// new code.

static void ClearBanned(); // needed for unit testing

static bool IsBanned(CNetAddr ip);

static bool IsBanned(CSubNet subnet);

static void Ban(const CNetAddr &ip, const BanReason &banReason, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);

static void Ban(const CSubNet &subNet, const BanReason &banReason, int64_t bantimeoffset = 0, bool sinceUnixEpoch = false);

static bool Unban(const CNetAddr &ip);

static bool Unban(const CSubNet &ip);

static void GetBanned(banmap_t &banmap);

static void SetBanned(const banmap_t &banmap);

//!check is the banlist has unwritten changes

static bool BannedSetIsDirty();

//!set the "dirty" flag for the banlist

static void SetBannedSetDirty(bool dirty=true);

//!clean unused entries (if bantime has expired)

static void SweepBanned();

void copyStats(CNodeStats &stats);

static bool IsWhitelistedRange(const CNetAddr &ip);

static void AddWhitelistedRange(const CSubNet &subnet);

// Network stats

static void RecordBytesRecv(uint64_t bytes);

static void RecordBytesSent(uint64_t bytes);

static uint64_t GetTotalBytesRecv();

static uint64_t GetTotalBytesSent();

//!set the max outbound target in bytes

static void SetMaxOutboundTarget(uint64_t limit);

static uint64_t GetMaxOutboundTarget();

//!set the timeframe for the max outbound target

static void SetMaxOutboundTimeframe(uint64_t timeframe);

static uint64_t GetMaxOutboundTimeframe();

//!check if the outbound target is reached

// if param historicalBlockServingLimit is set true, the function will

// response true if the limit for serving historical blocks has been reached

static bool OutboundTargetReached(bool historicalBlockServingLimit);

//!response the bytes left in the current max outbound cycle

// in case of no limit, it will always response 0

static uint64_t GetOutboundTargetBytesLeft();

//!response the time in second left in the current max outbound cycle

// in case of no limit, it will always response 0

static uint64_t GetMaxOutboundTimeLeftInCycle();

{

boost::filesystem::path pathAddr;

CAddrDB();

bool Write(const CAddrMan& addr);

bool Read(CAddrMan& addr);

bool Read(CAddrMan& addr, CDataStream& ssPeers);

{

boost::filesystem::path pathBanlist;

CBanDB();

bool Write(const banmap_t& banSet);

bool Read(banmap_t& banSet);

{

std::string strAddedNode;

CService resolvedAddress;

bool fConnected;

bool fInbound;