// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2017 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#if defined(HAVE_CONFIG_H)

#include <config/bitcoin-config.h>

#endif

#include <net.h>

#include <chainparams.h>

#include <clientversion.h>

#include <consensus/consensus.h>

#include <crypto/common.h>

#include <crypto/sha256.h>

#include <primitives/transaction.h>

#include <netbase.h>

#include <scheduler.h>

#include <ui_interface.h>

#include <utilstrencodings.h>

#ifdef WIN32

#include <string.h>

#else

#include <fcntl.h>

#endif

#ifdef USE_UPNP

#include <miniupnpc/miniupnpc.h>

#include <miniupnpc/miniwget.h>

#include <miniupnpc/upnpcommands.h>

#include <miniupnpc/upnperrors.h>

#endif

#include <math.h>

// Dump addresses to peers.dat and banlist.dat every 15 minutes (900s)

#define DUMP_ADDRESSES_INTERVAL 900

// We add a random period time (0 to 1 seconds) to feeler connections to prevent synchronization.

#define FEELER_SLEEP_WINDOW 1

#if !defined(HAVE_MSG_NOSIGNAL)

#define MSG_NOSIGNAL 0

#endif

// MSG_DONTWAIT is not available on some platforms, if it doesn't exist define it as 0

#if !defined(HAVE_MSG_DONTWAIT)

#define MSG_DONTWAIT 0

#endif

// Fix for ancient MinGW versions, that don't have defined these in ws2tcpip.h.

// Todo: Can be removed when our pull-tester is upgraded to a modern MinGW version.

#ifdef WIN32

#ifndef PROTECTION_LEVEL_UNRESTRICTED

#define PROTECTION_LEVEL_UNRESTRICTED 10

#endif

#ifndef IPV6_PROTECTION_LEVEL

#define IPV6_PROTECTION_LEVEL 23

#endif

#endif

/** Used to pass flags to the Bind() function */

enum BindFlags {

BF_NONE = 0,

BF_EXPLICIT = (1U << 0),

BF_REPORT_ERROR = (1U << 1),

BF_WHITELIST = (1U << 2),

};

const static std::string NET_MESSAGE_COMMAND_OTHER = "*other*";

static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]

static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]

//

// Global state variables

//

bool fDiscover = true;

bool fListen = true;

bool fRelayTxes = true;

CCriticalSection cs_mapLocalHost;

std::map<CNetAddr, LocalServiceInfo> mapLocalHost;

static bool vfLimited[NET_MAX] = {};

std::string strSubVersion;

limitedmap<uint256, int64_t> mapAlreadyAskedFor(MAX_INV_SZ);

void CConnman::AddOneShot(const std::string& strDest)

{

LOCK(cs_vOneShots);

vOneShots.push_back(strDest);

}

unsigned short GetListenPort()

{

return (unsigned short)(gArgs.GetArg("-port", Params().GetDefaultPort()));

}

// find 'best' local address for a particular peer

bool GetLocal(CService& addr, const CNetAddr *paddrPeer)

{

if (!fListen)

return false;

int nBestScore = -1;

int nBestReachability = -1;

{

LOCK(cs_mapLocalHost);

for (const auto& entry : mapLocalHost)

{

int nScore = entry.second.nScore;

int nReachability = entry.first.GetReachabilityFrom(paddrPeer);

if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))

{

addr = CService(entry.first, entry.second.nPort);

nBestReachability = nReachability;

nBestScore = nScore;

}

}

}

return nBestScore >= 0;

}

//! Convert the pnSeeds6 array into usable address objects.

static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &vSeedsIn)

{

// It'll only connect to one or two seed nodes because once it connects,

// it'll get a pile of addresses with newer timestamps.

// Seed nodes are given a random 'last seen time' of between one and two

// weeks ago.

const int64_t nOneWeek = 7*24*60*60;

std::vector<CAddress> vSeedsOut;

vSeedsOut.reserve(vSeedsIn.size());

for (const auto& seed_in : vSeedsIn) {

struct in6_addr ip;

memcpy(&ip, seed_in.addr, sizeof(ip));

CAddress addr(CService(ip, seed_in.port), GetDesirableServiceFlags(NODE_NONE));

addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;

vSeedsOut.push_back(addr);

}

return vSeedsOut;

}

// get best local address for a particular peer as a CAddress

// Otherwise, return the unroutable 0.0.0.0 but filled in with

// the normal parameters, since the IP may be changed to a useful

// one by discovery.

CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices)

{

CAddress ret(CService(CNetAddr(),GetListenPort()), nLocalServices);

CService addr;

if (GetLocal(addr, paddrPeer))

{

ret = CAddress(addr, nLocalServices);

}

ret.nTime = GetAdjustedTime();

return ret;

}

int GetnScore(const CService& addr)

{

LOCK(cs_mapLocalHost);

if (mapLocalHost.count(addr) == LOCAL_NONE)

return 0;

return mapLocalHost[addr].nScore;

}

// Is our peer's addrLocal potentially useful as an external IP source?

bool IsPeerAddrLocalGood(CNode *pnode)

{

CService addrLocal = pnode->GetAddrLocal();

return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&

!IsLimited(addrLocal.GetNetwork());

}

// pushes our own address to a peer

void AdvertiseLocal(CNode *pnode)

{

if (fListen && pnode->fSuccessfullyConnected)

{

CAddress addrLocal = GetLocalAddress(&pnode->addr, pnode->GetLocalServices());

// If discovery is enabled, sometimes give our peer the address it

// tells us that it sees us as in case it has a better idea of our

// address than we do.

if (IsPeerAddrLocalGood(pnode) && (!addrLocal.IsRoutable() ||

GetRand((GetnScore(addrLocal) > LOCAL_MANUAL) ? 8:2) == 0))

{

addrLocal.SetIP(pnode->GetAddrLocal());

}

if (addrLocal.IsRoutable())

{

LogPrint(BCLog::NET, "AdvertiseLocal: advertising address %s\n", addrLocal.ToString());

FastRandomContext insecure_rand;

pnode->PushAddress(addrLocal, insecure_rand);

}

}

}

// learn a new local address

bool AddLocal(const CService& addr, int nScore)

{

if (!addr.IsRoutable())

return false;

if (!fDiscover && nScore < LOCAL_MANUAL)

return false;

if (IsLimited(addr))

return false;

LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);

{

LOCK(cs_mapLocalHost);

bool fAlready = mapLocalHost.count(addr) > 0;

LocalServiceInfo &info = mapLocalHost[addr];

if (!fAlready || nScore >= info.nScore) {

info.nScore = nScore + (fAlready ? 1 : 0);

info.nPort = addr.GetPort();

}

}

return true;

}

bool AddLocal(const CNetAddr &addr, int nScore)

{

return AddLocal(CService(addr, GetListenPort()), nScore);

}

bool RemoveLocal(const CService& addr)

{

LOCK(cs_mapLocalHost);

LogPrintf("RemoveLocal(%s)\n", addr.ToString());

mapLocalHost.erase(addr);

return true;

}

/** Make a particular network entirely off-limits (no automatic connects to it) */

void SetLimited(enum Network net, bool fLimited)

{

if (net == NET_UNROUTABLE || net == NET_INTERNAL)

return;

LOCK(cs_mapLocalHost);

vfLimited[net] = fLimited;

}

bool IsLimited(enum Network net)

{

LOCK(cs_mapLocalHost);

return vfLimited[net];

}

bool IsLimited(const CNetAddr &addr)

{

return IsLimited(addr.GetNetwork());

}

/** vote for a local address */

bool SeenLocal(const CService& addr)

{

{

LOCK(cs_mapLocalHost);

if (mapLocalHost.count(addr) == 0)

return false;

mapLocalHost[addr].nScore++;

}

return true;

}

/** check whether a given address is potentially local */

bool IsLocal(const CService& addr)

{

LOCK(cs_mapLocalHost);

return mapLocalHost.count(addr) > 0;

}

/** check whether a given network is one we can probably connect to */

bool IsReachable(enum Network net)

{

LOCK(cs_mapLocalHost);

return !vfLimited[net];

}

/** check whether a given address is in a network we can probably connect to */

bool IsReachable(const CNetAddr& addr)

{

enum Network net = addr.GetNetwork();

return IsReachable(net);

}

CNode* CConnman::FindNode(const CNetAddr& ip)

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if ((CNetAddr)pnode->addr == ip) {

return pnode;

}

}

return nullptr;

}

CNode* CConnman::FindNode(const CSubNet& subNet)

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if (subNet.Match((CNetAddr)pnode->addr)) {

return pnode;

}

}

return nullptr;

}

CNode* CConnman::FindNode(const std::string& addrName)

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if (pnode->GetAddrName() == addrName) {

return pnode;

}

}

return nullptr;

}

CNode* CConnman::FindNode(const CService& addr)

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if ((CService)pnode->addr == addr) {

return pnode;

}

}

return nullptr;

}

bool CConnman::CheckIncomingNonce(uint64_t nonce)

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if (!pnode->fSuccessfullyConnected && !pnode->fInbound && pnode->GetLocalNonce() == nonce)

return false;

}

return true;

}

/** Get the bind address for a socket as CAddress */

static CAddress GetBindAddress(SOCKET sock)

{

CAddress addr_bind;

struct sockaddr_storage sockaddr_bind;

socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);

if (sock != INVALID_SOCKET) {

if (!getsockname(sock, (struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {

addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind);

} else {

LogPrint(BCLog::NET, "Warning: getsockname failed\n");

}

}

return addr_bind;

}

CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure)

{

if (pszDest == nullptr) {

if (IsLocal(addrConnect))

return nullptr;

// Look for an existing connection

CNode* pnode = FindNode((CService)addrConnect);

if (pnode)

{

LogPrintf("Failed to open new connection, already connected\n");

return nullptr;

}

}

/// debug print

LogPrint(BCLog::NET, "trying connection %s lastseen=%.1fhrs\n",

pszDest ? pszDest : addrConnect.ToString(),

pszDest ? 0.0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);

// Resolve

const int default_port = Params().GetDefaultPort();

if (pszDest) {

std::vector<CService> resolved;

if (Lookup(pszDest, resolved, default_port, fNameLookup && !HaveNameProxy(), 256) && !resolved.empty()) {

addrConnect = CAddress(resolved[GetRand(resolved.size())], NODE_NONE);

if (!addrConnect.IsValid()) {

LogPrint(BCLog::NET, "Resolver returned invalid address %s for %s", addrConnect.ToString(), pszDest);

return nullptr;

}

// It is possible that we already have a connection to the IP/port pszDest resolved to.

// In that case, drop the connection that was just created, and return the existing CNode instead.

// Also store the name we used to connect in that CNode, so that future FindNode() calls to that

// name catch this early.

LOCK(cs_vNodes);

CNode* pnode = FindNode((CService)addrConnect);

if (pnode)

{

pnode->MaybeSetAddrName(std::string(pszDest));

LogPrintf("Failed to open new connection, already connected\n");

return nullptr;

}

}

}

// Connect

bool connected = false;

SOCKET hSocket = INVALID_SOCKET;

proxyType proxy;

if (addrConnect.IsValid()) {

bool proxyConnectionFailed = false;

if (GetProxy(addrConnect.GetNetwork(), proxy)) {

hSocket = CreateSocket(proxy.proxy);

if (hSocket == INVALID_SOCKET) {

return nullptr;

}

connected = ConnectThroughProxy(proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), hSocket, nConnectTimeout, &proxyConnectionFailed);

} else {

// no proxy needed (none set for target network)

hSocket = CreateSocket(addrConnect);

if (hSocket == INVALID_SOCKET) {

return nullptr;

}

connected = ConnectSocketDirectly(addrConnect, hSocket, nConnectTimeout);

}

if (!proxyConnectionFailed) {

// If a connection to the node was attempted, and failure (if any) is not caused by a problem connecting to

// the proxy, mark this as an attempt.

addrman.Attempt(addrConnect, fCountFailure);

}

} else if (pszDest && GetNameProxy(proxy)) {

hSocket = CreateSocket(proxy.proxy);

if (hSocket == INVALID_SOCKET) {

return nullptr;

}

std::string host;

int port = default_port;

SplitHostPort(std::string(pszDest), port, host);

connected = ConnectThroughProxy(proxy, host, port, hSocket, nConnectTimeout, nullptr);

}

if (!connected) {

CloseSocket(hSocket);

return nullptr;

}

// Add node

NodeId id = GetNewNodeId();

uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();

CAddress addr_bind = GetBindAddress(hSocket);

CNode* pnode = new CNode(id, nLocalServices, GetBestHeight(), hSocket, addrConnect, CalculateKeyedNetGroup(addrConnect), nonce, addr_bind, pszDest ? pszDest : "", false);

pnode->AddRef();

return pnode;

}

void CConnman::DumpBanlist()

{

SweepBanned(); // clean unused entries (if bantime has expired)

if (!BannedSetIsDirty())

return;

int64_t nStart = GetTimeMillis();

CBanDB bandb;

banmap_t banmap;

GetBanned(banmap);

if (bandb.Write(banmap)) {

SetBannedSetDirty(false);

}

LogPrint(BCLog::NET, "Flushed %d banned node ips/subnets to banlist.dat %dms\n",

banmap.size(), GetTimeMillis() - nStart);

}

void CNode::CloseSocketDisconnect()

{

fDisconnect = true;

LOCK(cs_hSocket);

if (hSocket != INVALID_SOCKET)

{

LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);

CloseSocket(hSocket);

}

}

void CConnman::ClearBanned()

{

{

LOCK(cs_setBanned);

setBanned.clear();

setBannedIsDirty = true;

}

DumpBanlist(); //store banlist to disk

if(clientInterface)

clientInterface->BannedListChanged();

}

bool CConnman::IsBanned(CNetAddr ip)

{

LOCK(cs_setBanned);

for (const auto& it : setBanned) {

CSubNet subNet = it.first;

CBanEntry banEntry = it.second;

if (subNet.Match(ip) && GetTime() < banEntry.nBanUntil) {

return true;

}

}

return false;

}

bool CConnman::IsBanned(CSubNet subnet)

{

LOCK(cs_setBanned);

banmap_t::iterator i = setBanned.find(subnet);

if (i != setBanned.end())

{

CBanEntry banEntry = (*i).second;

if (GetTime() < banEntry.nBanUntil) {

return true;

}

}

return false;

}

void CConnman::Ban(const CNetAddr& addr, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {

CSubNet subNet(addr);

Ban(subNet, banReason, bantimeoffset, sinceUnixEpoch);

}

void CConnman::Ban(const CSubNet& subNet, const BanReason &banReason, int64_t bantimeoffset, bool sinceUnixEpoch) {

CBanEntry banEntry(GetTime());

banEntry.banReason = banReason;

if (bantimeoffset <= 0)

{

bantimeoffset = gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME);

sinceUnixEpoch = false;

}

banEntry.nBanUntil = (sinceUnixEpoch ? 0 : GetTime() )+bantimeoffset;

{

LOCK(cs_setBanned);

if (setBanned[subNet].nBanUntil < banEntry.nBanUntil) {

setBanned[subNet] = banEntry;

setBannedIsDirty = true;

}

else

return;

}

if(clientInterface)

clientInterface->BannedListChanged();

{

LOCK(cs_vNodes);

for (CNode* pnode : vNodes) {

if (subNet.Match((CNetAddr)pnode->addr))

pnode->fDisconnect = true;

}

}

if(banReason == BanReasonManuallyAdded)

DumpBanlist(); //store banlist to disk immediately if user requested ban

}

bool CConnman::Unban(const CNetAddr &addr) {

CSubNet subNet(addr);

return Unban(subNet);

}

bool CConnman::Unban(const CSubNet &subNet) {

{

LOCK(cs_setBanned);

if (!setBanned.erase(subNet))

return false;

setBannedIsDirty = true;

}

if(clientInterface)

clientInterface->BannedListChanged();

DumpBanlist(); //store banlist to disk immediately

return true;

}

void CConnman::GetBanned(banmap_t &banMap)

{

LOCK(cs_setBanned);

// Sweep the banlist so expired bans are not returned

SweepBanned();

banMap = setBanned; //create a thread safe copy

}

void CConnman::SetBanned(const banmap_t &banMap)

{

LOCK(cs_setBanned);

setBanned = banMap;

setBannedIsDirty = true;

}

void CConnman::SweepBanned()

{

int64_t now = GetTime();

bool notifyUI = false;

{

LOCK(cs_setBanned);

banmap_t::iterator it = setBanned.begin();

while(it != setBanned.end())

{

CSubNet subNet = (*it).first;

CBanEntry banEntry = (*it).second;

if(now > banEntry.nBanUntil)

{

setBanned.erase(it++);

setBannedIsDirty = true;

notifyUI = true;

LogPrint(BCLog::NET, "%s: Removed banned node ip/subnet from banlist.dat: %s\n", __func__, subNet.ToString());

}

else

++it;

}

}

// update UI

if(notifyUI && clientInterface) {

clientInterface->BannedListChanged();

}

}

bool CConnman::BannedSetIsDirty()

{

LOCK(cs_setBanned);

return setBannedIsDirty;

}

void CConnman::SetBannedSetDirty(bool dirty)

{

LOCK(cs_setBanned); //reuse setBanned lock for the isDirty flag

setBannedIsDirty = dirty;

}

bool CConnman::IsWhitelistedRange(const CNetAddr &addr) {

for (const CSubNet& subnet : vWhitelistedRange) {

if (subnet.Match(addr))

return true;

}

return false;

}

std::string CNode::GetAddrName() const {

LOCK(cs_addrName);

return addrName;

}

void CNode::MaybeSetAddrName(const std::string& addrNameIn) {

LOCK(cs_addrName);

if (addrName.empty()) {

addrName = addrNameIn;

}

}

CService CNode::GetAddrLocal() const {

LOCK(cs_addrLocal);

return addrLocal;

}

void CNode::SetAddrLocal(const CService& addrLocalIn) {

LOCK(cs_addrLocal);

if (addrLocal.IsValid()) {

error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToString(), addrLocalIn.ToString());

} else {

addrLocal = addrLocalIn;

}

}

#undef X

#define X(name) stats.name = name

void CNode::copyStats(CNodeStats &stats)

{

stats.nodeid = this->GetId();

X(nServices);

X(addr);

X(addrBind);

{

LOCK(cs_filter);

X(fRelayTxes);

}

X(nLastSend);

X(nLastRecv);

X(nTimeConnected);

X(nTimeOffset);

stats.addrName = GetAddrName();

X(nVersion);

{

LOCK(cs_SubVer);

X(cleanSubVer);

}

X(fInbound);

X(m_manual_connection);

X(nStartingHeight);

{

LOCK(cs_vSend);

X(mapSendBytesPerMsgCmd);

X(nSendBytes);

}

{

LOCK(cs_vRecv);

X(mapRecvBytesPerMsgCmd);

X(nRecvBytes);

}

X(fWhitelisted);

// It is common for nodes with good ping times to suddenly become lagged,

// due to a new block arriving or other large transfer.

// Merely reporting pingtime might fool the caller into thinking the node was still responsive,

// since pingtime does not update until the ping is complete, which might take a while.

// So, if a ping is taking an unusually long time in flight,

// the caller can immediately detect that this is happening.

int64_t nPingUsecWait = 0;

if ((0 != nPingNonceSent) && (0 != nPingUsecStart)) {

nPingUsecWait = GetTimeMicros() - nPingUsecStart;

}

// Raw ping time is in microseconds, but show it to user as whole seconds (Bitcoin users should be well used to small numbers with many decimal places by now :)

stats.dPingTime = (((double)nPingUsecTime) / 1e6);

stats.dMinPing = (((double)nMinPingUsecTime) / 1e6);

stats.dPingWait = (((double)nPingUsecWait) / 1e6);

// Leave string empty if addrLocal invalid (not filled in yet)

CService addrLocalUnlocked = GetAddrLocal();

stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";

}

#undef X

bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete)

{

complete = false;

int64_t nTimeMicros = GetTimeMicros();

LOCK(cs_vRecv);

nLastRecv = nTimeMicros / 1000000;

nRecvBytes += nBytes;

while (nBytes > 0) {

// get current incomplete message, or create a new one

if (vRecvMsg.empty() ||

vRecvMsg.back().complete())

vRecvMsg.push_back(CNetMessage(Params().MessageStart(), SER_NETWORK, INIT_PROTO_VERSION));

CNetMessage& msg = vRecvMsg.back();

// absorb network data

int handled;

if (!msg.in_data)

handled = msg.readHeader(pch, nBytes);

else

handled = msg.readData(pch, nBytes);

if (handled < 0)

return false;

if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {

LogPrint(BCLog::NET, "Oversized message from peer=%i, disconnecting\n", GetId());

return false;

}

pch += handled;

nBytes -= handled;

if (msg.complete()) {

//store received bytes per message command

//to prevent a memory DOS, only allow valid commands

mapMsgCmdSize::iterator i = mapRecvBytesPerMsgCmd.find(msg.hdr.pchCommand);

if (i == mapRecvBytesPerMsgCmd.end())

i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER);

assert(i != mapRecvBytesPerMsgCmd.end());

i->second += msg.hdr.nMessageSize + CMessageHeader::HEADER_SIZE;

msg.nTime = nTimeMicros;

complete = true;

}

}

return true;

}

void CNode::SetSendVersion(int nVersionIn)

{

// Send version may only be changed in the version message, and

// only one version message is allowed per session. We can therefore

// treat this value as const and even atomic as long as it's only used

// once a version message has been successfully processed. Any attempt to

// set this twice is an error.

if (nSendVersion != 0) {

error("Send version already set for node: %i. Refusing to change from %i to %i", id, nSendVersion, nVersionIn);

} else {

nSendVersion = nVersionIn;

}

}

int CNode::GetSendVersion() const

{

// The send version should always be explicitly set to

// INIT_PROTO_VERSION rather than using this value until SetSendVersion

// has been called.

if (nSendVersion == 0) {

error("Requesting unset send version for node: %i. Using %i", id, INIT_PROTO_VERSION);

return INIT_PROTO_VERSION;

}

return nSendVersion;

}

int CNetMessage::readHeader(const char *pch, unsigned int nBytes)

{

// copy data to temporary parsing buffer

unsigned int nRemaining = 24 - nHdrPos;

unsigned int nCopy = std::min(nRemaining, nBytes);

memcpy(&hdrbuf[nHdrPos], pch, nCopy);

nHdrPos += nCopy;

// if header incomplete, exit

if (nHdrPos < 24)

return nCopy;

// deserialize to CMessageHeader

try {

hdrbuf >> hdr;

}

catch (const std::exception&) {

return -1;

}

// reject messages larger than MAX_SIZE

if (hdr.nMessageSize > MAX_SIZE)

return -1;

// switch state to reading message data

in_data = true;

return nCopy;

}

int CNetMessage::readData(const char *pch, unsigned int nBytes)

{

unsigned int nRemaining = hdr.nMessageSize - nDataPos;

unsigned int nCopy = std::min(nRemaining, nBytes);

if (vRecv.size() < nDataPos + nCopy) {

// Allocate up to 256 KiB ahead, but never more than the total message size.

vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));

}

hasher.Write((const unsigned char*)pch, nCopy);

memcpy(&vRecv[nDataPos], pch, nCopy);

nDataPos += nCopy;

return nCopy;

}

const uint256& CNetMessage::GetMessageHash() const

{

assert(complete());

if (data_hash.IsNull())

hasher.Finalize(data_hash.begin());

return data_hash;

}

// requires LOCK(cs_vSend)

size_t CConnman::SocketSendData(CNode *pnode) const

{

auto it = pnode->vSendMsg.begin();

size_t nSentSize = 0;

while (it != pnode->vSendMsg.end()) {

const auto &data = *it;

assert(data.size() > pnode->nSendOffset);

int nBytes = 0;

{

LOCK(pnode->cs_hSocket);

if (pnode->hSocket == INVALID_SOCKET)

break;

nBytes = send(pnode->hSocket, reinterpret_cast<const char*>(data.data()) + pnode->nSendOffset, data.size() - pnode->nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);

}

if (nBytes > 0) {

pnode->nLastSend = GetSystemTimeInSeconds();

pnode->nSendBytes += nBytes;

pnode->nSendOffset += nBytes;

nSentSize += nBytes;

if (pnode->nSendOffset == data.size()) {

pnode->nSendOffset = 0;

pnode->nSendSize -= data.size();

pnode->fPauseSend = pnode->nSendSize > nSendBufferMaxSize;

it++;

} else {

// could not send full message; stop sending more

break;

}

} else {

if (nBytes < 0) {

// error

int nErr = WSAGetLastError();

if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)

{

LogPrintf("socket send error %s\n", NetworkErrorString(nErr));

pnode->CloseSocketDisconnect();

}

}

// couldn't send anything at all

break;

}

}

if (it == pnode->vSendMsg.end()) {

assert(pnode->nSendOffset == 0);

assert(pnode->nSendSize == 0);

}

pnode->vSendMsg.erase(pnode->vSendMsg.begin(), it);

return nSentSize;

}

struct NodeEvictionCandidate

{

NodeId id;

int64_t nTimeConnected;

int64_t nMinPingUsecTime;

int64_t nLastBlockTime;

int64_t nLastTXTime;

bool fRelevantServices;

bool fRelayTxes;

bool fBloomFilter;

CAddress addr;

uint64_t nKeyedNetGroup;

};

static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)

{

return a.nMinPingUsecTime > b.nMinPingUsecTime;

}

static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)

{

return a.nTimeConnected > b.nTimeConnected;

}

static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) {

return a.nKeyedNetGroup < b.nKeyedNetGroup;

}

static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)

{

// There is a fall-through here because it is common for a node to have many peers which have not yet relayed a block.

if (a.nLastBlockTime != b.nLastBlockTime) return a.nLastBlockTime < b.nLastBlockTime;

if (a.fRelevantServices != b.fRelevantServices) return b.fRelevantServices;

return a.nTimeConnected > b.nTimeConnected;

}

static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b)

{

// There is a fall-through here because it is common for a node to have more than a few peers that have not yet relayed txn.

if (a.nLastTXTime != b.nLastTXTime) return a.nLastTXTime < b.nLastTXTime;

if (a.fRelayTxes != b.fRelayTxes) return b.fRelayTxes;

if (a.fBloomFilter != b.fBloomFilter) return a.fBloomFilter;

return a.nTimeConnected > b.nTimeConnected;

}

//! Sort an array by the specified comparator, then erase the last K elements.

template<typename T, typename Comparator>

static void EraseLastKElements(std::vector<T> &elements, Comparator comparator, size_t k)

{

std::sort(elements.begin(), elements.end(), comparator);

size_t eraseSize = std::min(k, elements.size());

elements.erase(elements.end() - eraseSize, elements.end());

}

/** Try to find a connection to evict when the node is full.

* Extreme care must be taken to avoid opening the node to attacker

* triggered network partitioning.

* The strategy used here is to protect a small number of peers

* for each of several distinct characteristics which are difficult

* to forge. In order to partition a node the attacker must be

* simultaneously better at all of them than honest peers.

*/

bool CConnman::AttemptToEvictConnection()

{

std::vector<NodeEvictionCandidate> vEvictionCandidates;

{

LOCK(cs_vNodes);