- if [ -n "$PACKAGES" ]; then travis_retry sudo apt-get update; fi

- if [ -n "$PACKAGES" ]; then travis_retry sudo apt-get install --no-install-recommends --no-upgrade -qq $PACKAGES; fi

before_script:

- unset CC; unset CXX

- if [ "$CHECK_DOC" = 1 ]; then contrib/devtools/check-doc.py; fi

- mkdir -p depends/SDKs depends/sdk-sources

continue;

if (node->fDisconnect)

continue;

node->nLastBlockTime, node->nLastTXTime,

(node->nServices & nRelevantServices) == nRelevantServices,

node->fRelayTxes, node->pfilter != NULL, node->addr, node->nKeyedNetGroup};

{

if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)

{

pnode->fDisconnect = true;

}

else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL)

}

else if (!pnode->fSuccessfullyConnected)

{

pnode->fDisconnect = true;

}

}

{

LOCK(cs_vNodes);

for(CNode* pnode : vNodes) {

pnode->fDisconnect = true;

return true;

}

nTimeConnected(GetSystemTimeInSeconds()),

addr(addrIn),

fInbound(fInboundIn),

nKeyedNetGroup(nKeyedNetGroupIn),

addrKnown(5000, 0.001),

filterInventoryKnown(50000, 0.000001),

nLocalHostNonce(nLocalHostNonceIn),

nLocalServices(nLocalServicesIn),

nMyStartingHeight(nMyStartingHeightIn),

{

size_t nMessageSize = msg.data.size();

size_t nTotalSize = nMessageSize + CMessageHeader::HEADER_SIZE;

std::vector<unsigned char> serializedHeader;

serializedHeader.reserve(CMessageHeader::HEADER_SIZE);

CNode* found = nullptr;

LOCK(cs_vNodes);

for (auto&& pnode : vNodes) {

found = pnode;

break;

}

CCriticalSection cs_filter;

CBloomFilter* pfilter;

std::atomic<int> nRefCount;

const uint64_t nKeyedNetGroup;

std::atomic_bool fPauseRecv;

private:

CNode(const CNode&);

void operator=(const CNode&);

const uint64_t nLocalHostNonce;

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

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

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

state.pindexBestHeaderSent = pindex;

}

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

if (pnode->nVersion >= CADDR_TIME_VERSION) {

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

if (req.indexes[i] >= block.vtx.size()) {

LOCK(cs_main);

Misbehaving(pfrom->GetId(), 100);

return;

}

resp.txn[i] = block.vtx[req.indexes[i]];

bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, int64_t nTimeReceived, const CChainParams& chainparams, CConnman& connman, const std::atomic<bool>& interruptMsgProc)

{

if (IsArgSet("-dropmessagestest") && GetRand(GetArg("-dropmessagestest", 0)) == 0)

{

LogPrintf("dropmessagestest DROPPING RECV MESSAGE\n");

}

if (pfrom->nServicesExpected & ~nServices)

{

connman.PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_NONSTANDARD,

strprintf("Expected to offer services %08x", pfrom->nServicesExpected)));

pfrom->fDisconnect = true;

if (nVersion < MIN_PEER_PROTO_VERSION)

{

// disconnect from peers older than this proto version

connman.PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE,

strprintf("Version must be %d or greater", MIN_PEER_PROTO_VERSION)));

pfrom->fDisconnect = true;

LogPrintf("receive version message: %s: version %d, blocks=%d, us=%s, peer=%d%s\n",

cleanSubVer, pfrom->nVersion,

remoteAddr);

int64_t nTimeOffset = nTime - GetTime();

return true;

bool fAlreadyHave = AlreadyHave(inv);

if (inv.type == MSG_TX) {

inv.type |= nFetchFlags;

// we now only provide a getheaders response here. When we receive the headers, we will

// then ask for the blocks we need.

connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexBestHeader), inv.hash));

}

}

else

{

pfrom->AddInventoryKnown(inv);

if (fBlocksOnly) {

} else if (!fAlreadyHave && !fImporting && !fReindex && !IsInitialBlockDownload()) {

pfrom->AskFor(inv);

}

return error("message getdata size() = %u", vInv.size());

}

if (vInv.size() > 0) {

}

pfrom->vRecvGetData.insert(pfrom->vRecvGetData.end(), vInv.begin(), vInv.end());

if (pindex)

pindex = chainActive.Next(pindex);

int nLimit = 500;

for (; pindex; pindex = chainActive.Next(pindex))

{

if (pindex->GetBlockHash() == hashStop)

BlockMap::iterator it = mapBlockIndex.find(req.blockhash);

if (it == mapBlockIndex.end() || !(it->second->nStatus & BLOCK_HAVE_DATA)) {

return true;

}

// might maliciously send lots of getblocktxn requests to trigger

// expensive disk reads, because it will require the peer to

// actually receive all the data read from disk over the network.

CInv inv;

inv.type = State(pfrom->GetId())->fWantsCmpctWitness ? MSG_WITNESS_BLOCK : MSG_BLOCK;

inv.hash = req.blockhash;

LOCK(cs_main);

if (IsInitialBlockDownload() && !pfrom->fWhitelisted) {

return true;

}

// we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx count at the end

std::vector<CBlock> vHeaders;

int nLimit = MAX_HEADERS_RESULTS;

for (; pindex; pindex = chainActive.Next(pindex))

{

vHeaders.push_back(pindex->GetBlockHeader());

// We are in blocks only mode and peer is either not whitelisted or whitelistrelay is off

if (!fRelayTxes && (!pfrom->fWhitelisted || !GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY)))

{

return true;

}

pfrom->nLastTXTime = GetTime();

LogPrint(BCLog::MEMPOOL, "AcceptToMemoryPool: peer=%d: accepted %s (poolsz %u txn, %u kB)\n",

tx.GetHash().ToString(),

mempool.size(), mempool.DynamicMemoryUsage() / 1000);

// case.

int nDoS = 0;

if (!state.IsInvalid(nDoS) || nDoS == 0) {

RelayTransaction(tx, connman);

} else {

}

}

}

if (state.IsInvalid(nDoS))

{

LogPrint(BCLog::MEMPOOLREJ, "%s from peer=%d was not accepted: %s\n", tx.GetHash().ToString(),

FormatStateMessage(state));

if (state.GetRejectCode() > 0 && state.GetRejectCode() < REJECT_INTERNAL) // Never send AcceptToMemoryPool's internal codes over P2P

connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::REJECT, strCommand, (unsigned char)state.GetRejectCode(),

LOCK(cs_main);

Misbehaving(pfrom->GetId(), nDoS);

}

return true;

}

}

if (status == READ_STATUS_INVALID) {

MarkBlockAsReceived(pindex->GetBlockHash()); // Reset in-flight state in case of whitelist

Misbehaving(pfrom->GetId(), 100);

return true;

} else if (status == READ_STATUS_FAILED) {

// Duplicate txindexes, the block is now in-flight, so just request it

std::map<uint256, std::pair<NodeId, std::list<QueuedBlock>::iterator> >::iterator it = mapBlocksInFlight.find(resp.blockhash);

if (it == mapBlocksInFlight.end() || !it->second.second->partialBlock ||

it->second.first != pfrom->GetId()) {

return true;

}

if (status == READ_STATUS_INVALID) {

MarkBlockAsReceived(resp.blockhash); // Reset in-flight state in case of whitelist

Misbehaving(pfrom->GetId(), 100);

return true;

} else if (status == READ_STATUS_FAILED) {

// Might have collided, fall back to getdata now :(

headers[0].GetHash().ToString(),

headers[0].hashPrevBlock.ToString(),

pindexBestHeader->nHeight,

// Set hashLastUnknownBlock for this peer, so that if we

// eventually get the headers - even from a different peer -

// we can use this peer to download.

LOCK(cs_main);

CNodeState *nodestate = State(pfrom->GetId());

if (nodestate->nUnconnectingHeaders > 0) {

}

nodestate->nUnconnectingHeaders = 0;

// Headers message had its maximum size; the peer may have more headers.

// TODO: optimize: if pindexLast is an ancestor of chainActive.Tip or pindexBestHeader, continue

// from there instead.

connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexLast), uint256()));

}

vGetData.push_back(CInv(MSG_BLOCK | nFetchFlags, pindex->GetBlockHash()));

MarkBlockAsInFlight(pfrom->GetId(), pindex->GetBlockHash(), chainparams.GetConsensus(), pindex);

LogPrint(BCLog::NET, "Requesting block %s from peer=%d\n",

}

if (vGetData.size() > 1) {

LogPrint(BCLog::NET, "Downloading blocks toward %s (%d) via headers direct fetch\n",

std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();

vRecv >> *pblock;

// Process all blocks from whitelisted peers, even if not requested,

// unless we're still syncing with the network.

// Making nodes which are behind NAT and can only make outgoing connections ignore

// the getaddr message mitigates the attack.

if (!pfrom->fInbound) {

return true;

}

// Only send one GetAddr response per connection to reduce resource waste

// and discourage addr stamping of INV announcements.

if (pfrom->fSentAddr) {

return true;

}

pfrom->fSentAddr = true;

if (!(sProblem.empty())) {

LogPrint(BCLog::NET, "pong peer=%d: %s, %x expected, %x received, %u bytes\n",

sProblem,

pfrom->nPingNonceSent,

nonce,

LOCK(pfrom->cs_feeFilter);

pfrom->minFeeFilter = newFeeFilter;

}

}

}

else {

// Ignore unknown commands for extensibility

}

msg.SetVersion(pfrom->GetRecvVersion());

// Scan for message start

if (memcmp(msg.hdr.pchMessageStart, chainparams.MessageStart(), CMessageHeader::MESSAGE_START_SIZE) != 0) {

pfrom->fDisconnect = true;

return false;

}

CMessageHeader& hdr = msg.hdr;

if (!hdr.IsValid(chainparams.MessageStart()))

{

return fMoreWork;

}

std::string strCommand = hdr.GetCommand();

}

if (!fRet) {

}

LOCK(cs_main);

got back an empty response. */

if (pindexStart->pprev)

pindexStart = pindexStart->pprev;

connman.PushMessage(pto, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexStart), uint256()));

}

}

(!state.fPreferHeaderAndIDs || pto->vBlockHashesToAnnounce.size() > 1)) ||

pto->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE);

const CBlockIndex *pBestIndex = NULL; // last header queued for delivery

if (!fRevertToInv) {

bool fFoundStartingHeader = false;

// We only send up to 1 block as header-and-ids, as otherwise

// probably means we're doing an initial-ish-sync or they're slow

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

int nSendFlags = state.fWantsCmpctWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;

LogPrint(BCLog::NET, "%s: %u headers, range (%s, %s), to peer=%d\n", __func__,

vHeaders.size(),

vHeaders.front().GetHash().ToString(),

} else {

LogPrint(BCLog::NET, "%s: sending header %s to peer=%d\n", __func__,

}

connman.PushMessage(pto, msgMaker.Make(NetMsgType::HEADERS, vHeaders));

state.pindexBestHeaderSent = pBestIndex;

if (!PeerHasHeader(&state, pindex)) {

pto->PushInventory(CInv(MSG_BLOCK, hashToAnnounce));

LogPrint(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__,

}

}

}

// Stalling only triggers when the block download window cannot move. During normal steady state,

// the download window should be much larger than the to-be-downloaded set of blocks, so disconnection

// should only happen during initial block download.

pto->fDisconnect = true;

return true;

}

QueuedBlock &queuedBlock = state.vBlocksInFlight.front();

int nOtherPeersWithValidatedDownloads = nPeersWithValidatedDownloads - (state.nBlocksInFlightValidHeaders > 0);

if (nNow > state.nDownloadingSince + consensusParams.nPowTargetSpacing * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) {

pto->fDisconnect = true;

return true;

}

vGetData.push_back(CInv(MSG_BLOCK | nFetchFlags, pindex->GetBlockHash()));

MarkBlockAsInFlight(pto->GetId(), pindex->GetBlockHash(), consensusParams, pindex);

LogPrint(BCLog::NET, "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),

}

if (state.nBlocksInFlight == 0 && staller != -1) {

if (State(staller)->nStallingSince == 0) {

const CInv& inv = (*pto->mapAskFor.begin()).second;

if (!AlreadyHave(inv))

{

vGetData.push_back(inv);

if (vGetData.size() >= 1000)

{

import logging

import optparse

import os

import shutil

import tempfile

import time

from .util import (

connect_nodes_bi,

disconnect_nodes,

sync_blocks,

sync_mempools,

)

from .authproxy import JSONRPCException

class BitcoinTestFramework(object):

TEST_EXIT_PASSED = 0

TEST_EXIT_FAILED = 1

self.setup_clean_chain = False

self.nodes = None

def add_options(self, parser):

pass

def setup_chain(self):

self.log.info("Initializing test directory "+self.options.tmpdir)

if self.setup_clean_chain:

else:

def setup_network(self):

self.setup_nodes()

connect_nodes_bi(self.nodes, i, i + 1)

self.sync_all()

def main(self):

if not self.options.noshutdown:

self.log.info("Stopping nodes")

else:

self.log.info("Note: bitcoinds were not stopped and may still be running")

logging.shutdown()

sys.exit(self.TEST_EXIT_FAILED)

def _start_logging(self):

# Add logger and logging handlers

self.log = logging.getLogger('TestFramework')

rpc_handler.setLevel(logging.DEBUG)

rpc_logger.addHandler(rpc_handler)

# Test framework for doing p2p comparison testing, which sets up some bitcoind

# binaries:

# 1 binary: test binary

help="bitcoind binary to use for reference nodes (if any)")

def setup_network(self):

self.num_nodes, self.options.tmpdir,

extra_args=[['-whitelist=127.0.0.1']] * self.num_nodes,

binary=[self.options.testbinary] +

raise # unknown JSON RPC exception

time.sleep(0.25)

def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None, stderr=None):

"""