// Copyright (c) 2009-2010 Satoshi Nakamoto

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

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

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

#include "net_processing.h"

#include "addrman.h"

#include "arith_uint256.h"

#include "blockencodings.h"

#include "chainparams.h"

#include "consensus/validation.h"

#include "hash.h"

#include "init.h"

#include "validation.h"

#include "merkleblock.h"

#include "net.h"

#include "netmessagemaker.h"

#include "netbase.h"

#include "policy/fees.h"

#include "policy/policy.h"

#include "primitives/block.h"

#include "primitives/transaction.h"

#include "random.h"

#include "reverse_iterator.h"

#include "tinyformat.h"

#include "txmempool.h"

#include "ui_interface.h"

#include "util.h"

#include "utilmoneystr.h"

#include "utilstrencodings.h"

#include "validationinterface.h"

#if defined(NDEBUG)

# error "Bitcoin cannot be compiled without assertions."

#endif

std::atomic<int64_t> nTimeBestReceived(0); // Used only to inform the wallet of when we last received a block

struct IteratorComparator

{

template<typename I>

bool operator()(const I& a, const I& b)

{

return &(*a) < &(*b);

}

};

struct COrphanTx {

// When modifying, adapt the copy of this definition in tests/DoS_tests.

CTransactionRef tx;

NodeId fromPeer;

int64_t nTimeExpire;

};

std::map<uint256, COrphanTx> mapOrphanTransactions GUARDED_BY(cs_main);

std::map<COutPoint, std::set<std::map<uint256, COrphanTx>::iterator, IteratorComparator>> mapOrphanTransactionsByPrev GUARDED_BY(cs_main);

void EraseOrphansFor(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

static size_t vExtraTxnForCompactIt = 0;

static std::vector<std::pair<uint256, CTransactionRef>> vExtraTxnForCompact GUARDED_BY(cs_main);

static const uint64_t RANDOMIZER_ID_ADDRESS_RELAY = 0x3cac0035b5866b90ULL; // SHA256("main address relay")[0:8]

// Internal stuff

namespace {

/** Number of nodes with fSyncStarted. */

int nSyncStarted = 0;

/**

* Sources of received blocks, saved to be able to send them reject

* messages or ban them when processing happens afterwards. Protected by

* cs_main.

* Set mapBlockSource[hash].second to false if the node should not be

* punished if the block is invalid.

*/

std::map<uint256, std::pair<NodeId, bool>> mapBlockSource;

/**

* Filter for transactions that were recently rejected by

* AcceptToMemoryPool. These are not rerequested until the chain tip

* changes, at which point the entire filter is reset. Protected by

* cs_main.

*

* Without this filter we'd be re-requesting txs from each of our peers,

* increasing bandwidth consumption considerably. For instance, with 100

* peers, half of which relay a tx we don't accept, that might be a 50x

* bandwidth increase. A flooding attacker attempting to roll-over the

* filter using minimum-sized, 60byte, transactions might manage to send

* 1000/sec if we have fast peers, so we pick 120,000 to give our peers a

* two minute window to send invs to us.

*

* Decreasing the false positive rate is fairly cheap, so we pick one in a

* million to make it highly unlikely for users to have issues with this

* filter.

*

* Memory used: 1.3 MB

*/

std::unique_ptr<CRollingBloomFilter> recentRejects;

uint256 hashRecentRejectsChainTip;

/** Blocks that are in flight, and that are in the queue to be downloaded. Protected by cs_main. */

struct QueuedBlock {

uint256 hash;

const CBlockIndex* pindex; //!< Optional.

bool fValidatedHeaders; //!< Whether this block has validated headers at the time of request.

std::unique_ptr<PartiallyDownloadedBlock> partialBlock; //!< Optional, used for CMPCTBLOCK downloads

};

std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> > mapBlocksInFlight;

/** Stack of nodes which we have set to announce using compact blocks */

std::list<NodeId> lNodesAnnouncingHeaderAndIDs;

/** Number of preferable block download peers. */

int nPreferredDownload = 0;

/** Number of peers from which we're downloading blocks. */

int nPeersWithValidatedDownloads = 0;

/** Relay map, protected by cs_main. */

typedef std::map<uint256, CTransactionRef> MapRelay;

MapRelay mapRelay;

/** Expiration-time ordered list of (expire time, relay map entry) pairs, protected by cs_main). */

std::deque<std::pair<int64_t, MapRelay::iterator>> vRelayExpiration;

} // namespace

//////////////////////////////////////////////////////////////////////////////

//

// Registration of network node signals.

//

namespace {

struct CBlockReject {

unsigned char chRejectCode;

std::string strRejectReason;

uint256 hashBlock;

};

/**

* Maintain validation-specific state about nodes, protected by cs_main, instead

* by CNode's own locks. This simplifies asynchronous operation, where

* processing of incoming data is done after the ProcessMessage call returns,

* and we're no longer holding the node's locks.

*/

struct CNodeState {

//! The peer's address

const CService address;

//! Whether we have a fully established connection.

bool fCurrentlyConnected;

//! Accumulated misbehaviour score for this peer.

int nMisbehavior;

//! Whether this peer should be disconnected and banned (unless whitelisted).

bool fShouldBan;

//! String name of this peer (debugging/logging purposes).

const std::string name;

//! List of asynchronously-determined block rejections to notify this peer about.

std::vector<CBlockReject> rejects;

//! The best known block we know this peer has announced.

const CBlockIndex *pindexBestKnownBlock;

//! The hash of the last unknown block this peer has announced.

uint256 hashLastUnknownBlock;

//! The last full block we both have.

const CBlockIndex *pindexLastCommonBlock;

//! The best header we have sent our peer.

const CBlockIndex *pindexBestHeaderSent;

//! Length of current-streak of unconnecting headers announcements

int nUnconnectingHeaders;

//! Whether we've started headers synchronization with this peer.

bool fSyncStarted;

//! When to potentially disconnect peer for stalling headers download

int64_t nHeadersSyncTimeout;

//! Since when we're stalling block download progress (in microseconds), or 0.

int64_t nStallingSince;

std::list<QueuedBlock> vBlocksInFlight;

//! When the first entry in vBlocksInFlight started downloading. Don't care when vBlocksInFlight is empty.

int64_t nDownloadingSince;

int nBlocksInFlight;

int nBlocksInFlightValidHeaders;

//! Whether we consider this a preferred download peer.

bool fPreferredDownload;

//! Whether this peer wants invs or headers (when possible) for block announcements.

bool fPreferHeaders;

//! Whether this peer wants invs or cmpctblocks (when possible) for block announcements.

bool fPreferHeaderAndIDs;

/**

* Whether this peer will send us cmpctblocks if we request them.

* This is not used to gate request logic, as we really only care about fSupportsDesiredCmpctVersion,

* but is used as a flag to "lock in" the version of compact blocks (fWantsCmpctWitness) we send.

*/

bool fProvidesHeaderAndIDs;

//! Whether this peer can give us witnesses

bool fHaveWitness;

//! Whether this peer wants witnesses in cmpctblocks/blocktxns

bool fWantsCmpctWitness;

/**

* If we've announced NODE_WITNESS to this peer: whether the peer sends witnesses in cmpctblocks/blocktxns,

* otherwise: whether this peer sends non-witnesses in cmpctblocks/blocktxns.

*/

bool fSupportsDesiredCmpctVersion;

CNodeState(CAddress addrIn, std::string addrNameIn) : address(addrIn), name(addrNameIn) {

fCurrentlyConnected = false;

nMisbehavior = 0;

fShouldBan = false;

pindexBestKnownBlock = NULL;

hashLastUnknownBlock.SetNull();

pindexLastCommonBlock = NULL;

pindexBestHeaderSent = NULL;

nUnconnectingHeaders = 0;

fSyncStarted = false;

nHeadersSyncTimeout = 0;

nStallingSince = 0;

nDownloadingSince = 0;

nBlocksInFlight = 0;

nBlocksInFlightValidHeaders = 0;

fPreferredDownload = false;

fPreferHeaders = false;

fPreferHeaderAndIDs = false;

fProvidesHeaderAndIDs = false;

fHaveWitness = false;

fWantsCmpctWitness = false;

fSupportsDesiredCmpctVersion = false;

}

};

/** Map maintaining per-node state. Requires cs_main. */

std::map<NodeId, CNodeState> mapNodeState;

// Requires cs_main.

CNodeState *State(NodeId pnode) {

std::map<NodeId, CNodeState>::iterator it = mapNodeState.find(pnode);

if (it == mapNodeState.end())

return NULL;

return &it->second;

}

void UpdatePreferredDownload(CNode* node, CNodeState* state)

{

nPreferredDownload -= state->fPreferredDownload;

// Whether this node should be marked as a preferred download node.

state->fPreferredDownload = (!node->fInbound || node->fWhitelisted) && !node->fOneShot && !node->fClient;

nPreferredDownload += state->fPreferredDownload;

}

void PushNodeVersion(CNode *pnode, CConnman& connman, int64_t nTime)

{

ServiceFlags nLocalNodeServices = pnode->GetLocalServices();

uint64_t nonce = pnode->GetLocalNonce();

int nNodeStartingHeight = pnode->GetMyStartingHeight();

NodeId nodeid = pnode->GetId();

CAddress addr = pnode->addr;

CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService(), addr.nServices));

CAddress addrMe = CAddress(CService(), nLocalNodeServices);

connman.PushMessage(pnode, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::VERSION, PROTOCOL_VERSION, (uint64_t)nLocalNodeServices, nTime, addrYou, addrMe,

nonce, strSubVersion, nNodeStartingHeight, ::fRelayTxes));

if (fLogIPs) {

LogPrint(BCLog::NET, "send version message: version %d, blocks=%d, us=%s, them=%s, peer=%d\n", PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), addrYou.ToString(), nodeid);

} else {

LogPrint(BCLog::NET, "send version message: version %d, blocks=%d, us=%s, peer=%d\n", PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), nodeid);

}

}

void InitializeNode(CNode *pnode, CConnman& connman) {

CAddress addr = pnode->addr;

std::string addrName = pnode->GetAddrName();

NodeId nodeid = pnode->GetId();

{

LOCK(cs_main);

mapNodeState.emplace_hint(mapNodeState.end(), std::piecewise_construct, std::forward_as_tuple(nodeid), std::forward_as_tuple(addr, std::move(addrName)));

}

if(!pnode->fInbound)

PushNodeVersion(pnode, connman, GetTime());

}

void FinalizeNode(NodeId nodeid, bool& fUpdateConnectionTime) {

fUpdateConnectionTime = false;

LOCK(cs_main);

CNodeState *state = State(nodeid);

if (state->fSyncStarted)

nSyncStarted--;

if (state->nMisbehavior == 0 && state->fCurrentlyConnected) {

fUpdateConnectionTime = true;

}

for (const QueuedBlock& entry : state->vBlocksInFlight) {

mapBlocksInFlight.erase(entry.hash);

}

EraseOrphansFor(nodeid);

nPreferredDownload -= state->fPreferredDownload;

nPeersWithValidatedDownloads -= (state->nBlocksInFlightValidHeaders != 0);

assert(nPeersWithValidatedDownloads >= 0);

mapNodeState.erase(nodeid);

if (mapNodeState.empty()) {

// Do a consistency check after the last peer is removed.

assert(mapBlocksInFlight.empty());

assert(nPreferredDownload == 0);

assert(nPeersWithValidatedDownloads == 0);

}

LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid);

}

// Requires cs_main.

// Returns a bool indicating whether we requested this block.

// Also used if a block was /not/ received and timed out or started with another peer

bool MarkBlockAsReceived(const uint256& hash) {

std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> >::iterator itInFlight = mapBlocksInFlight.find(hash);

if (itInFlight != mapBlocksInFlight.end()) {

CNodeState *state = State(itInFlight->second.first);

state->nBlocksInFlightValidHeaders -= itInFlight->second.second->fValidatedHeaders;

if (state->nBlocksInFlightValidHeaders == 0 && itInFlight->second.second->fValidatedHeaders) {

// Last validated block on the queue was received.

nPeersWithValidatedDownloads--;

}

if (state->vBlocksInFlight.begin() == itInFlight->second.second) {

// First block on the queue was received, update the start download time for the next one

state->nDownloadingSince = std::max(state->nDownloadingSince, GetTimeMicros());

}

state->vBlocksInFlight.erase(itInFlight->second.second);

state->nBlocksInFlight--;

state->nStallingSince = 0;

mapBlocksInFlight.erase(itInFlight);

return true;

}

return false;

}

// Requires cs_main.

// returns false, still setting pit, if the block was already in flight from the same peer

// pit will only be valid as long as the same cs_main lock is being held

bool MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const CBlockIndex* pindex = NULL, std::list<QueuedBlock>::iterator** pit = NULL) {

CNodeState *state = State(nodeid);

assert(state != NULL);

// Short-circuit most stuff in case its from the same node

std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> >::iterator itInFlight = mapBlocksInFlight.find(hash);

if (itInFlight != mapBlocksInFlight.end() && itInFlight->second.first == nodeid) {

if (pit) {

*pit = &itInFlight->second.second;

}

return false;

}

// Make sure it's not listed somewhere already.

MarkBlockAsReceived(hash);

std::list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(state->vBlocksInFlight.end(),

{hash, pindex, pindex != NULL, std::unique_ptr<PartiallyDownloadedBlock>(pit ? new PartiallyDownloadedBlock(&mempool) : NULL)});

state->nBlocksInFlight++;

state->nBlocksInFlightValidHeaders += it->fValidatedHeaders;

if (state->nBlocksInFlight == 1) {

// We're starting a block download (batch) from this peer.

state->nDownloadingSince = GetTimeMicros();

}

if (state->nBlocksInFlightValidHeaders == 1 && pindex != NULL) {

nPeersWithValidatedDownloads++;

}

itInFlight = mapBlocksInFlight.insert(std::make_pair(hash, std::make_pair(nodeid, it))).first;

if (pit)

*pit = &itInFlight->second.second;

return true;

}

/** Check whether the last unknown block a peer advertised is not yet known. */

void ProcessBlockAvailability(NodeId nodeid) {

CNodeState *state = State(nodeid);

assert(state != NULL);

if (!state->hashLastUnknownBlock.IsNull()) {

BlockMap::iterator itOld = mapBlockIndex.find(state->hashLastUnknownBlock);

if (itOld != mapBlockIndex.end() && itOld->second->nChainWork > 0) {

if (state->pindexBestKnownBlock == NULL || itOld->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)

state->pindexBestKnownBlock = itOld->second;

state->hashLastUnknownBlock.SetNull();

}

}

}

/** Update tracking information about which blocks a peer is assumed to have. */

void UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {

CNodeState *state = State(nodeid);

assert(state != NULL);

ProcessBlockAvailability(nodeid);

BlockMap::iterator it = mapBlockIndex.find(hash);

if (it != mapBlockIndex.end() && it->second->nChainWork > 0) {

// An actually better block was announced.

if (state->pindexBestKnownBlock == NULL || it->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)

state->pindexBestKnownBlock = it->second;

} else {

// An unknown block was announced; just assume that the latest one is the best one.

state->hashLastUnknownBlock = hash;

}

}

void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid, CConnman& connman) {

AssertLockHeld(cs_main);

CNodeState* nodestate = State(nodeid);

if (!nodestate || !nodestate->fSupportsDesiredCmpctVersion) {

// Never ask from peers who can't provide witnesses.

return;

}

if (nodestate->fProvidesHeaderAndIDs) {

for (std::list<NodeId>::iterator it = lNodesAnnouncingHeaderAndIDs.begin(); it != lNodesAnnouncingHeaderAndIDs.end(); it++) {

if (*it == nodeid) {

lNodesAnnouncingHeaderAndIDs.erase(it);

lNodesAnnouncingHeaderAndIDs.push_back(nodeid);

return;

}

}

connman.ForNode(nodeid, [&connman](CNode* pfrom){

bool fAnnounceUsingCMPCTBLOCK = false;

uint64_t nCMPCTBLOCKVersion = (pfrom->GetLocalServices() & NODE_WITNESS) ? 2 : 1;

if (lNodesAnnouncingHeaderAndIDs.size() >= 3) {

// As per BIP152, we only get 3 of our peers to announce

// blocks using compact encodings.

connman.ForNode(lNodesAnnouncingHeaderAndIDs.front(), [&connman, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion](CNode* pnodeStop){

connman.PushMessage(pnodeStop, CNetMsgMaker(pnodeStop->GetSendVersion()).Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion));

return true;

});

lNodesAnnouncingHeaderAndIDs.pop_front();

}

fAnnounceUsingCMPCTBLOCK = true;

connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion));

lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId());

return true;

});

}

}

// Requires cs_main

bool CanDirectFetch(const Consensus::Params &consensusParams)

{

return chainActive.Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20;

}

// Requires cs_main

bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex)

{

if (state->pindexBestKnownBlock && pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight))

return true;

if (state->pindexBestHeaderSent && pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight))

return true;

return false;

}

/** Update pindexLastCommonBlock and add not-in-flight missing successors to vBlocks, until it has

* at most count entries. */

void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, NodeId& nodeStaller, const Consensus::Params& consensusParams) {

if (count == 0)

return;

vBlocks.reserve(vBlocks.size() + count);

CNodeState *state = State(nodeid);

assert(state != NULL);

// Make sure pindexBestKnownBlock is up to date, we'll need it.

ProcessBlockAvailability(nodeid);

if (state->pindexBestKnownBlock == NULL || state->pindexBestKnownBlock->nChainWork < chainActive.Tip()->nChainWork || state->pindexBestKnownBlock->nChainWork < UintToArith256(consensusParams.nMinimumChainWork)) {

// This peer has nothing interesting.

//printf("nothing interesting best.%p\n",state->pindexBestKnownBlock);

return;

}

if (state->pindexLastCommonBlock == NULL) {

// Bootstrap quickly by guessing a parent of our best tip is the forking point.

// Guessing wrong in either direction is not a problem.

state->pindexLastCommonBlock = chainActive[std::min(state->pindexBestKnownBlock->nHeight, chainActive.Height())];

}

// If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor

// of its current tip anymore. Go back enough to fix that.

state->pindexLastCommonBlock = LastCommonAncestor(state->pindexLastCommonBlock, state->pindexBestKnownBlock);

if (state->pindexLastCommonBlock == state->pindexBestKnownBlock)

return;

std::vector<const CBlockIndex*> vToFetch;

const CBlockIndex *pindexWalk = state->pindexLastCommonBlock;

// Never fetch further than the best block we know the peer has, or more than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last

// linked block we have in common with this peer. The +1 is so we can detect stalling, namely if we would be able to

// download that next block if the window were 1 larger.

int nWindowEnd = state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;

int nMaxHeight = std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);

NodeId waitingfor = -1;

while (pindexWalk->nHeight < nMaxHeight) {

// Read up to 128 (or more, if more blocks than that are needed) successors of pindexWalk (towards

// pindexBestKnownBlock) into vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as expensive

// as iterating over ~100 CBlockIndex* entries anyway.

int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight, std::max<int>(count - vBlocks.size(), 128));

vToFetch.resize(nToFetch);

pindexWalk = state->pindexBestKnownBlock->GetAncestor(pindexWalk->nHeight + nToFetch);

vToFetch[nToFetch - 1] = pindexWalk;

for (unsigned int i = nToFetch - 1; i > 0; i--) {

vToFetch[i - 1] = vToFetch[i]->pprev;

}

// Iterate over those blocks in vToFetch (in forward direction), adding the ones that

// are not yet downloaded and not in flight to vBlocks. In the mean time, update

// pindexLastCommonBlock as long as all ancestors are already downloaded, or if it's

// already part of our chain (and therefore don't need it even if pruned).

for (const CBlockIndex* pindex : vToFetch) {

if (!pindex->IsValid(BLOCK_VALID_TREE)) {

// We consider the chain that this peer is on invalid.

return;

}

if (!State(nodeid)->fHaveWitness && IsWitnessEnabled(pindex->pprev, consensusParams)) {

// We wouldn't download this block or its descendants from this peer.

return;

}

if (pindex->nStatus & BLOCK_HAVE_DATA || chainActive.Contains(pindex)) {

if (pindex->nChainTx)

state->pindexLastCommonBlock = pindex;

} else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {

// The block is not already downloaded, and not yet in flight.

if (pindex->nHeight > nWindowEnd) {

// We reached the end of the window.

if (vBlocks.size() == 0 && waitingfor != nodeid) {

// We aren't able to fetch anything, but we would be if the download window was one larger.

nodeStaller = waitingfor;

}

return;

}

vBlocks.push_back(pindex);

if (vBlocks.size() == count) {

return;

}

} else if (waitingfor == -1) {

// This is the first already-in-flight block.

waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;

}

}

}

}

} // namespace

bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {

LOCK(cs_main);

CNodeState *state = State(nodeid);

if (state == NULL)

return false;

stats.nMisbehavior = state->nMisbehavior;

stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->nHeight : -1;

stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->nHeight : -1;

for (const QueuedBlock& queue : state->vBlocksInFlight) {

if (queue.pindex)

stats.vHeightInFlight.push_back(queue.pindex->nHeight);

}

return true;

}

void RegisterNodeSignals(CNodeSignals& nodeSignals)

{

nodeSignals.ProcessMessages.connect(&ProcessMessages);

nodeSignals.SendMessages.connect(&SendMessages);

nodeSignals.InitializeNode.connect(&InitializeNode);

nodeSignals.FinalizeNode.connect(&FinalizeNode);

}

void UnregisterNodeSignals(CNodeSignals& nodeSignals)

{

nodeSignals.ProcessMessages.disconnect(&ProcessMessages);

nodeSignals.SendMessages.disconnect(&SendMessages);

nodeSignals.InitializeNode.disconnect(&InitializeNode);

nodeSignals.FinalizeNode.disconnect(&FinalizeNode);

}

//////////////////////////////////////////////////////////////////////////////

//

// mapOrphanTransactions

//

void AddToCompactExtraTransactions(const CTransactionRef& tx)

{

size_t max_extra_txn = GetArg("-blockreconstructionextratxn", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN);

if (max_extra_txn <= 0)

return;

if (!vExtraTxnForCompact.size())

vExtraTxnForCompact.resize(max_extra_txn);

vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetWitnessHash(), tx);

vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn;

}

bool AddOrphanTx(const CTransactionRef& tx, NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

const uint256& hash = tx->GetHash();

if (mapOrphanTransactions.count(hash))

return false;

// Ignore big transactions, to avoid a

// send-big-orphans memory exhaustion attack. If a peer has a legitimate

// large transaction with a missing parent then we assume

// it will rebroadcast it later, after the parent transaction(s)

// have been mined or received.

// 100 orphans, each of which is at most 99,999 bytes big is

// at most 10 megabytes of orphans and somewhat more byprev index (in the worst case):

unsigned int sz = GetTransactionWeight(*tx);

if (sz >= MAX_STANDARD_TX_WEIGHT)

{

LogPrint(BCLog::MEMPOOL, "ignoring large orphan tx (size: %u, hash: %s)\n", sz, hash.ToString());

return false;

}

auto ret = mapOrphanTransactions.emplace(hash, COrphanTx{tx, peer, GetTime() + ORPHAN_TX_EXPIRE_TIME});

assert(ret.second);

for (const CTxIn& txin : tx->vin) {

mapOrphanTransactionsByPrev[txin.prevout].insert(ret.first);

}

AddToCompactExtraTransactions(tx);

LogPrint(BCLog::MEMPOOL, "stored orphan tx %s (mapsz %u outsz %u)\n", hash.ToString(),

mapOrphanTransactions.size(), mapOrphanTransactionsByPrev.size());

return true;

}

int static EraseOrphanTx(uint256 hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

std::map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.find(hash);

if (it == mapOrphanTransactions.end())

return 0;

for (const CTxIn& txin : it->second.tx->vin)

{

auto itPrev = mapOrphanTransactionsByPrev.find(txin.prevout);

if (itPrev == mapOrphanTransactionsByPrev.end())

continue;

itPrev->second.erase(it);

if (itPrev->second.empty())

mapOrphanTransactionsByPrev.erase(itPrev);

}

mapOrphanTransactions.erase(it);

return 1;

}

void EraseOrphansFor(NodeId peer)

{

int nErased = 0;

std::map<uint256, COrphanTx>::iterator iter = mapOrphanTransactions.begin();

while (iter != mapOrphanTransactions.end())

{

std::map<uint256, COrphanTx>::iterator maybeErase = iter++; // increment to avoid iterator becoming invalid

if (maybeErase->second.fromPeer == peer)

{

nErased += EraseOrphanTx(maybeErase->second.tx->GetHash());

}

}

if (nErased > 0) LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx from peer=%d\n", nErased, peer);

}

unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

unsigned int nEvicted = 0;

static int64_t nNextSweep;

int64_t nNow = GetTime();

if (nNextSweep <= nNow) {

// Sweep out expired orphan pool entries:

int nErased = 0;

int64_t nMinExpTime = nNow + ORPHAN_TX_EXPIRE_TIME - ORPHAN_TX_EXPIRE_INTERVAL;

std::map<uint256, COrphanTx>::iterator iter = mapOrphanTransactions.begin();

while (iter != mapOrphanTransactions.end())

{

std::map<uint256, COrphanTx>::iterator maybeErase = iter++;

if (maybeErase->second.nTimeExpire <= nNow) {

nErased += EraseOrphanTx(maybeErase->second.tx->GetHash());

} else {

nMinExpTime = std::min(maybeErase->second.nTimeExpire, nMinExpTime);

}

}

// Sweep again 5 minutes after the next entry that expires in order to batch the linear scan.

nNextSweep = nMinExpTime + ORPHAN_TX_EXPIRE_INTERVAL;

if (nErased > 0) LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx due to expiration\n", nErased);

}

while (mapOrphanTransactions.size() > nMaxOrphans)

{

// Evict a random orphan:

uint256 randomhash = GetRandHash();

std::map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.lower_bound(randomhash);

if (it == mapOrphanTransactions.end())

it = mapOrphanTransactions.begin();

EraseOrphanTx(it->first);

++nEvicted;

}

return nEvicted;

}

// Requires cs_main.

void Misbehaving(NodeId pnode, int howmuch)

{

if (howmuch == 0)

return;

CNodeState *state = State(pnode);

if (state == NULL)

return;

state->nMisbehavior += howmuch;

int banscore = GetArg("-banscore", DEFAULT_BANSCORE_THRESHOLD);

if (state->nMisbehavior >= banscore && state->nMisbehavior - howmuch < banscore)

{

LogPrintf("%s: %s peer=%d (%d -> %d) BAN THRESHOLD EXCEEDED\n", __func__, state->name, pnode, state->nMisbehavior-howmuch, state->nMisbehavior);

state->fShouldBan = true;

} else

LogPrintf("%s: %s peer=%d (%d -> %d)\n", __func__, state->name, pnode, state->nMisbehavior-howmuch, state->nMisbehavior);

}

//////////////////////////////////////////////////////////////////////////////

//

// blockchain -> download logic notification

//

PeerLogicValidation::PeerLogicValidation(CConnman* connmanIn) : connman(connmanIn) {

// Initialize global variables that cannot be constructed at startup.

recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));

}

void PeerLogicValidation::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex, const std::vector<CTransactionRef>& vtxConflicted) {

LOCK(cs_main);

std::vector<uint256> vOrphanErase;

for (const CTransactionRef& ptx : pblock->vtx) {

const CTransaction& tx = *ptx;

// Which orphan pool entries must we evict?

for (const auto& txin : tx.vin) {

auto itByPrev = mapOrphanTransactionsByPrev.find(txin.prevout);

if (itByPrev == mapOrphanTransactionsByPrev.end()) continue;

for (auto mi = itByPrev->second.begin(); mi != itByPrev->second.end(); ++mi) {

const CTransaction& orphanTx = *(*mi)->second.tx;

const uint256& orphanHash = orphanTx.GetHash();

vOrphanErase.push_back(orphanHash);

}

}

}

// Erase orphan transactions include or precluded by this block

if (vOrphanErase.size()) {

int nErased = 0;

for (uint256 &orphanHash : vOrphanErase) {

nErased += EraseOrphanTx(orphanHash);

}

LogPrint(BCLog::MEMPOOL, "Erased %d orphan tx included or conflicted by block\n", nErased);

}

}

// All of the following cache a recent block, and are protected by cs_most_recent_block

static CCriticalSection cs_most_recent_block;

static std::shared_ptr<const CBlock> most_recent_block;

static std::shared_ptr<const CBlockHeaderAndShortTxIDs> most_recent_compact_block;

static uint256 most_recent_block_hash;

static bool fWitnessesPresentInMostRecentCompactBlock;

void PeerLogicValidation::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) {

std::shared_ptr<const CBlockHeaderAndShortTxIDs> pcmpctblock = std::make_shared<const CBlockHeaderAndShortTxIDs> (*pblock, true);

const CNetMsgMaker msgMaker(PROTOCOL_VERSION);

LOCK(cs_main);

static int nHighestFastAnnounce = 0;

if (pindex->nHeight <= nHighestFastAnnounce)

return;

nHighestFastAnnounce = pindex->nHeight;

bool fWitnessEnabled = IsWitnessEnabled(pindex->pprev, Params().GetConsensus());

uint256 hashBlock(pblock->GetHash());

{

LOCK(cs_most_recent_block);

most_recent_block_hash = hashBlock;

most_recent_block = pblock;

most_recent_compact_block = pcmpctblock;

fWitnessesPresentInMostRecentCompactBlock = fWitnessEnabled;

}

connman->ForEachNode([this, &pcmpctblock, pindex, &msgMaker, fWitnessEnabled, &hashBlock](CNode* pnode) {

// TODO: Avoid the repeated-serialization here

if (pnode->nVersion < INVALID_CB_NO_BAN_VERSION || pnode->fDisconnect)

return;

ProcessBlockAvailability(pnode->GetId());

CNodeState &state = *State(pnode->GetId());

// If the peer has, or we announced to them the previous block already,

// but we don't think they have this one, go ahead and announce it

if (state.fPreferHeaderAndIDs && (!fWitnessEnabled || state.fWantsCmpctWitness) &&

!PeerHasHeader(&state, pindex) && PeerHasHeader(&state, pindex->pprev)) {

LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", "PeerLogicValidation::NewPoWValidBlock",

hashBlock.ToString(), pnode->GetId());

connman->PushMessage(pnode, msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock));

state.pindexBestHeaderSent = pindex;

}

});

}

void PeerLogicValidation::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {

const int nNewHeight = pindexNew->nHeight;

connman->SetBestHeight(nNewHeight);

if (!fInitialDownload) {

// Find the hashes of all blocks that weren't previously in the best chain.

std::vector<uint256> vHashes;

const CBlockIndex *pindexToAnnounce = pindexNew;

while (pindexToAnnounce != pindexFork) {

vHashes.push_back(pindexToAnnounce->GetBlockHash());

pindexToAnnounce = pindexToAnnounce->pprev;

if (vHashes.size() == MAX_BLOCKS_TO_ANNOUNCE) {

// Limit announcements in case of a huge reorganization.

// Rely on the peer's synchronization mechanism in that case.

break;

}

}

// Relay inventory, but don't relay old inventory during initial block download.

connman->ForEachNode([nNewHeight, &vHashes](CNode* pnode) {

if (nNewHeight > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : 0)) {

for (const uint256& hash : reverse_iterate(vHashes)) {

pnode->PushBlockHash(hash);

}

}

});

connman->WakeMessageHandler();

}

nTimeBestReceived = GetTime();

}

void PeerLogicValidation::BlockChecked(const CBlock& block, const CValidationState& state) {

LOCK(cs_main);

const uint256 hash(block.GetHash());

std::map<uint256, std::pair<NodeId, bool>>::iterator it = mapBlockSource.find(hash);

int nDoS = 0;

if (state.IsInvalid(nDoS)) {

// Don't send reject message with code 0 or an internal reject code.

if (it != mapBlockSource.end() && State(it->second.first) && state.GetRejectCode() > 0 && state.GetRejectCode() < REJECT_INTERNAL) {

CBlockReject reject = {(unsigned char)state.GetRejectCode(), state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH), hash};

State(it->second.first)->rejects.push_back(reject);

if (nDoS > 0 && it->second.second)

Misbehaving(it->second.first, nDoS);

}

}

// Check that:

// 1. The block is valid

// 2. We're not in initial block download

// 3. This is currently the best block we're aware of. We haven't updated

// the tip yet so we have no way to check this directly here. Instead we

// just check that there are currently no other blocks in flight.

else if (state.IsValid() &&

!IsInitialBlockDownload() &&

mapBlocksInFlight.count(hash) == mapBlocksInFlight.size()) {

if (it != mapBlockSource.end()) {

MaybeSetPeerAsAnnouncingHeaderAndIDs(it->second.first, *connman);

}

}

if (it != mapBlockSource.end())

mapBlockSource.erase(it);

}

//////////////////////////////////////////////////////////////////////////////

//

// Messages

//

bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

switch (inv.type)

{

case MSG_TX:

case MSG_WITNESS_TX:

{

assert(recentRejects);

if (chainActive.Tip()->GetBlockHash() != hashRecentRejectsChainTip)

{

// If the chain tip has changed previously rejected transactions

// might be now valid, e.g. due to a nLockTime'd tx becoming valid,

// or a double-spend. Reset the rejects filter and give those

// txs a second chance.

hashRecentRejectsChainTip = chainActive.Tip()->GetBlockHash();

recentRejects->reset();

}

return recentRejects->contains(inv.hash) ||

mempool.exists(inv.hash) ||

mapOrphanTransactions.count(inv.hash) ||

pcoinsTip->HaveCoinInCache(COutPoint(inv.hash, 0)) || // Best effort: only try output 0 and 1

pcoinsTip->HaveCoinInCache(COutPoint(inv.hash, 1));

}

case MSG_BLOCK:

case MSG_WITNESS_BLOCK:

return mapBlockIndex.count(inv.hash);

}

// Don't know what it is, just say we already got one

return true;

}

static void RelayTransaction(const CTransaction& tx, CConnman& connman)

{

CInv inv(MSG_TX, tx.GetHash());

connman.ForEachNode([&inv](CNode* pnode)

{

pnode->PushInventory(inv);

});

}

static void RelayAddress(const CAddress& addr, bool fReachable, CConnman& connman)

{

unsigned int nRelayNodes = fReachable ? 2 : 1; // limited relaying of addresses outside our network(s)

// Relay to a limited number of other nodes

// Use deterministic randomness to send to the same nodes for 24 hours

// at a time so the addrKnowns of the chosen nodes prevent repeats

uint64_t hashAddr = addr.GetHash();

const CSipHasher hasher = connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY).Write(hashAddr << 32).Write((GetTime() + hashAddr) / (24*60*60));

FastRandomContext insecure_rand;

std::array<std::pair<uint64_t, CNode*>,2> best{{{0, nullptr}, {0, nullptr}}};

assert(nRelayNodes <= best.size());

auto sortfunc = [&best, &hasher, nRelayNodes](CNode* pnode) {

if (pnode->nVersion >= CADDR_TIME_VERSION) {

uint64_t hashKey = CSipHasher(hasher).Write(pnode->GetId()).Finalize();

for (unsigned int i = 0; i < nRelayNodes; i++) {

if (hashKey > best[i].first) {

std::copy(best.begin() + i, best.begin() + nRelayNodes - 1, best.begin() + i + 1);

best[i] = std::make_pair(hashKey, pnode);

break;

}

}

}

};

auto pushfunc = [&addr, &best, nRelayNodes, &insecure_rand] {

for (unsigned int i = 0; i < nRelayNodes && best[i].first != 0; i++) {

best[i].second->PushAddress(addr, insecure_rand);

}

};

connman.ForEachNodeThen(std::move(sortfunc), std::move(pushfunc));

}

void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParams, CConnman& connman, const std::atomic<bool>& interruptMsgProc)

{

std::deque<CInv>::iterator it = pfrom->vRecvGetData.begin();

std::vector<CInv> vNotFound;

const CNetMsgMaker msgMaker(pfrom->GetSendVersion());

LOCK(cs_main);

while (it != pfrom->vRecvGetData.end()) {

// Don't bother if send buffer is too full to respond anyway

if (pfrom->fPauseSend)

break;

const CInv &inv = *it;

{

if (interruptMsgProc)

return;

it++;

if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK || inv.type == MSG_CMPCT_BLOCK || inv.type == MSG_WITNESS_BLOCK)

{

bool send = false;

BlockMap::iterator mi = mapBlockIndex.find(inv.hash);

std::shared_ptr<const CBlock> a_recent_block;

std::shared_ptr<const CBlockHeaderAndShortTxIDs> a_recent_compact_block;

bool fWitnessesPresentInARecentCompactBlock;

{

LOCK(cs_most_recent_block);

a_recent_block = most_recent_block;

a_recent_compact_block = most_recent_compact_block;

fWitnessesPresentInARecentCompactBlock = fWitnessesPresentInMostRecentCompactBlock;

}

if (mi != mapBlockIndex.end())

{

if (mi->second->nChainTx && !mi->second->IsValid(BLOCK_VALID_SCRIPTS) &&

mi->second->IsValid(BLOCK_VALID_TREE)) {

// If we have the block and all of its parents, but have not yet validated it,

// we might be in the middle of connecting it (ie in the unlock of cs_main

// before ActivateBestChain but after AcceptBlock).

// In this case, we need to run ActivateBestChain prior to checking the relay

// conditions below.

CValidationState dummy;