{

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

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

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

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

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

{

NodeId nodeid;

uint64_t nServices;

int64_t nLastSend;

int64_t nLastRecv;

int64_t nTimeConnected;

std::string addrName;

int nVersion;

std::string cleanSubVer;

bool fInbound;

int nStartingHeight;

uint64_t nSendBytes;

uint64_t nRecvBytes;

bool fSyncNode;

double dPingTime;

double dPingWait;

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;

CNetMessage(int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), vRecv(nTypeIn, nVersionIn) {

hdrbuf.resize(24);

in_data = false;

nHdrPos = 0;

nDataPos = 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);

{

// socket

uint64_t nServices;

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;

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 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 their version message that we should not relay tx invs

// until they have initialized their bloom filter.

bool fRelayTxes;

CSemaphoreGrant grantOutbound;

CCriticalSection cs_filter;

CBloomFilter* pfilter;

int nRefCount;

NodeId id;

// Denial-of-service detection/prevention

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

static std::map<CNetAddr, int64_t> setBanned;

static CCriticalSection cs_setBanned;

// Basic fuzz-testing

void Fuzz(int nChance); // modifies ssSend

uint256 hashContinue;

CBlockIndex* pindexLastGetBlocksBegin;

uint256 hashLastGetBlocksEnd;

int nStartingHeight;

bool fStartSync;

// flood relay

std::vector<CAddress> vAddrToSend;

mruset<CAddress> setAddrKnown;

bool fGetAddr;

std::set<uint256> setKnown;

// inventory based relay

mruset<CInv> setInventoryKnown;

std::vector<CInv> vInventoryToSend;

CCriticalSection cs_inventory;

std::multimap<int64_t, CInv> mapAskFor;

// 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;

// Whether a ping is requested.

bool fPingQueued;

CNode(SOCKET hSocketIn, CAddress addrIn, std::string addrNameIn = "", bool fInboundIn=false) : ssSend(SER_NETWORK, INIT_PROTO_VERSION), setAddrKnown(5000)

{

nServices = 0;

hSocket = hSocketIn;

nRecvVersion = INIT_PROTO_VERSION;

nLastSend = 0;

nLastRecv = 0;

nSendBytes = 0;

nRecvBytes = 0;

nTimeConnected = GetTime();

addr = addrIn;

addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;

nVersion = 0;

strSubVer = "";

fOneShot = false;

fClient = false; // set by version message

fInbound = fInboundIn;

fNetworkNode = false;

fSuccessfullyConnected = false;

fDisconnect = false;

nRefCount = 0;

nSendSize = 0;

nSendOffset = 0;

hashContinue = 0;

pindexLastGetBlocksBegin = 0;

hashLastGetBlocksEnd = 0;

nStartingHeight = -1;

fStartSync = false;

fGetAddr = false;

fRelayTxes = false;

setInventoryKnown.max_size(SendBufferSize() / 1000);

pfilter = new CBloomFilter();

nPingNonceSent = 0;

nPingUsecStart = 0;

nPingUsecTime = 0;

fPingQueued = false;

{

LOCK(cs_nLastNodeId);

id = nLastNodeId++;

}

// Be shy and don't send version until we hear

if (hSocket != INVALID_SOCKET && !fInbound)

PushVersion();

GetNodeSignals().InitializeNode(GetId(), this);

}

~CNode()

{

if (hSocket != INVALID_SOCKET)

{

closesocket(hSocket);

hSocket = INVALID_SOCKET;

}

if (pfilter)

delete pfilter;

GetNodeSignals().FinalizeNode(GetId());

}

// Network usage totals

static CCriticalSection cs_totalBytesRecv;

static CCriticalSection cs_totalBytesSent;

static uint64_t nTotalBytesRecv;

static uint64_t nTotalBytesSent;

CNode(const CNode&);

void operator=(const CNode&);

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)

{

setAddrKnown.insert(addr);

}

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() && !setAddrKnown.count(addr))

vAddrToSend.push_back(addr);

}

void AddInventoryKnown(const CInv& inv)

{

{

LOCK(cs_inventory);

setInventoryKnown.insert(inv);

}

}

void PushInventory(const CInv& inv)

{

{

LOCK(cs_inventory);

if (!setInventoryKnown.count(inv))

vInventoryToSend.push_back(inv);

}

}

void AskFor(const CInv& inv)

{

// We're using mapAskFor as a priority queue,

// the key is the earliest time the request can be sent

int64_t nRequestTime;

limitedmap<CInv, int64_t>::const_iterator it = mapAlreadyAskedFor.find(inv);

if (it != mapAlreadyAskedFor.end())

nRequestTime = it->second;

else

nRequestTime = 0;

LogPrint("net", "askfor %s %d (%s)\n", inv.ToString(), nRequestTime, DateTimeStrFormat("%H:%M:%S", nRequestTime/1000000).c_str());

// Make sure not to reuse time indexes to keep things in the same order

int64_t nNow = GetTimeMicros() - 1000000;

static int64_t nLastTime;

++nLastTime;

nNow = std::max(nNow, nLastTime);

nLastTime = nNow;

// Each retry is 2 minutes after the last

nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);

if (it != mapAlreadyAskedFor.end())

mapAlreadyAskedFor.update(it, nRequestTime);

else

mapAlreadyAskedFor.insert(std::make_pair(inv, nRequestTime));

mapAskFor.insert(std::make_pair(nRequestTime, inv));

}

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

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

{

ENTER_CRITICAL_SECTION(cs_vSend);

assert(ssSend.size() == 0);

ssSend << CMessageHeader(pszCommand, 0);

LogPrint("net", "sending: %s ", pszCommand);

}

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

void AbortMessage() UNLOCK_FUNCTION(cs_vSend)

{

ssSend.clear();

LEAVE_CRITICAL_SECTION(cs_vSend);

LogPrint("net", "(aborted)\n");

}

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

void EndMessage() UNLOCK_FUNCTION(cs_vSend)

{

// The -*messagestest options are intentionally not documented in the help message,

// since they are only used during development to debug the networking code and are

// not intended for end-users.

if (mapArgs.count("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 2)) == 0)

{

LogPrint("net", "dropmessages DROPPING SEND MESSAGE\n");

AbortMessage();

return;

}

if (mapArgs.count("-fuzzmessagestest"))

Fuzz(GetArg("-fuzzmessagestest", 10));

if (ssSend.size() == 0)

return;

// Set the size

unsigned int nSize = ssSend.size() - CMessageHeader::HEADER_SIZE;

memcpy((char*)&ssSend[CMessageHeader::MESSAGE_SIZE_OFFSET], &nSize, sizeof(nSize));

// Set the checksum

uint256 hash = Hash(ssSend.begin() + CMessageHeader::HEADER_SIZE, ssSend.end());

unsigned int nChecksum = 0;

memcpy(&nChecksum, &hash, sizeof(nChecksum));

assert(ssSend.size () >= CMessageHeader::CHECKSUM_OFFSET + sizeof(nChecksum));

memcpy((char*)&ssSend[CMessageHeader::CHECKSUM_OFFSET], &nChecksum, sizeof(nChecksum));

LogPrint("net", "(%d bytes)\n", nSize);

std::deque<CSerializeData>::iterator it = vSendMsg.insert(vSendMsg.end(), CSerializeData());

ssSend.GetAndClear(*it);

nSendSize += (*it).size();

// If write queue empty, attempt "optimistic write"

if (it == vSendMsg.begin())

SocketSendData(this);

LEAVE_CRITICAL_SECTION(cs_vSend);

}

void PushVersion();

void PushMessage(const char* pszCommand)

{

try

{

BeginMessage(pszCommand);

EndMessage();

}

catch (...)

{

AbortMessage();

throw;

}

}

template<typename T1>

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

{

try

{

BeginMessage(pszCommand);

ssSend << a1;

EndMessage();

}

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();

}

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();

}

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();

}

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();

}

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();

}

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();

}

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();

}

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();

}

catch (...)

{

AbortMessage();

throw;

}

}

bool IsSubscribed(unsigned int nChannel);

void Subscribe(unsigned int nChannel, unsigned int nHops=0);

void CancelSubscribe(unsigned int nChannel);

void CloseSocketDisconnect();

void Cleanup();

// 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 Ban(const CNetAddr &ip);

void copyStats(CNodeStats &stats);

// Network stats

static void RecordBytesRecv(uint64_t bytes);

static void RecordBytesSent(uint64_t bytes);

static uint64_t GetTotalBytesRecv();

static uint64_t GetTotalBytesSent();

{

boost::filesystem::path pathAddr;

CAddrDB();

bool Write(const CAddrMan& addr);

bool Read(CAddrMan& addr);