return true;

}

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

{

// copy data to temporary parsing buffer

LogPrintf("socket sending timeout: %is\n", nTime - pnode->nLastSend);

pnode->fDisconnect = true;

}

{

LogPrintf("socket receive timeout: %is\n", nTime - pnode->nLastRecv);

pnode->fDisconnect = true;

std::deque<CInv> vRecvGetData;

uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};

std::atomic<int64_t> nLastSend{0};

std::atomic<int64_t> nLastRecv{0};

const NodeId id;

const uint64_t nLocalHostNonce;

const ConnectionType m_conn_type;

//! Services offered to this peer.

//!

const ServiceFlags nLocalServices;

const int nMyStartingHeight;

NetPermissionFlags m_permissionFlags{ PF_NONE };

std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread

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

{

}

{

}

CService GetAddrLocal() const;

//! May not be called more than once

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

// blocks using compact encodings.

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

return true;

});

lNodesAnnouncingHeaderAndIDs.pop_front();

}

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

return true;

});

LockAssertion lock(::cs_main);

// TODO: Avoid the repeated-serialization here

return;

ProcessBlockAvailability(pnode->GetId());

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

LogPrint(BCLog::NET, "%s: ignoring request from peer=%i for old block that isn't in the main chain\n", __func__, pfrom.GetId());

}

}

// disconnect node in case we have reached the outbound limit for serving historical blocks

if (send &&

connman.OutboundTargetReached(true) &&

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

std::vector<CInv> vNotFound;

const std::chrono::seconds now = GetTime<std::chrono::seconds>();

// Get last mempool request time

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

}

LOCK(cs_main);

int nSendFlags = State(pfrom.GetId())->fWantsCmpctWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;

m_connman.PushMessage(&pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp));

}

void PeerManager::ProcessHeadersMessage(CNode& pfrom, const std::vector<CBlockHeader>& headers, bool via_compact_block)

{

size_t nCount = headers.size();

if (nCount == 0) {

}

for (const auto& filter : filters) {

.Make(NetMsgType::CFILTER, filter);

connman.PushMessage(&peer, std::move(msg));

}

return;

}

.Make(NetMsgType::CFHEADERS,

filter_type_ser,

stop_index->GetBlockHash(),

}

}

.Make(NetMsgType::CFCHECKPT,

filter_type_ser,

stop_index->GetBlockHash(),

uint64_t nServiceInt;

ServiceFlags nServices;

int nVersion;

std::string cleanSubVer;

int nStartingHeight = -1;

bool fRelay = true;

vRecv >> nVersion >> nServiceInt >> nTime >> addrMe;

nServices = ServiceFlags(nServiceInt);

if (!pfrom.IsInboundConn())

{

if (pfrom.IsInboundConn())

PushNodeVersion(pfrom, m_connman, GetAdjustedTime());

}

pfrom.nServices = nServices;

pfrom.SetAddrLocal(addrMe);

pfrom.m_tx_relay->fRelayTxes = fRelay; // set to true after we get the first filter* message

}

if((nServices & NODE_WITNESS))

{

LOCK(cs_main);

}

// Get recent addresses

pfrom.fGetAddr = true;

// Moves address from New to Tried table in Addrman, resolves

AddTimeData(pfrom.addr, nTimeOffset);

// If the peer is old enough to have the old alert system, send it the final alert.

CDataStream finalAlert(ParseHex("60010000000000000000000000ffffff7f00000000ffffff7ffeffff7f01ffffff7f00000000ffffff7f00ffffff7f002f555247454e543a20416c657274206b657920636f6d70726f6d697365642c2075706772616465207265717569726564004630440220653febd6410f470f6bae11cad19c48413becb1ac2c17f908fd0fd53bdc3abd5202206d0e9c96fe88d4a0f01ed9dedae2b6f9e00da94cad0fecaae66ecf689bf71b50"), SER_NETWORK, PROTOCOL_VERSION);

}

// Feeler connections exist only to verify if address is online.

}

// At this point, the outgoing message serialization version can't change.

if (msg_type == NetMsgType::VERACK)

{

if (!pfrom.IsInboundConn()) {

// Mark this node as currently connected, so we update its timestamp later.

LOCK(cs_main);

pfrom.m_tx_relay == nullptr ? "block-relay" : "full-relay");

}

// Tell our peer we prefer to receive headers rather than inv's

// We send this to non-NODE NETWORK peers as well, because even

// non-NODE NETWORK peers can announce blocks (such as pruning

// nodes)

m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDHEADERS));

}

// Tell our peer we are willing to provide version 1 or 2 cmpctblocks

// However, we do not request new block announcements using

// cmpctblock messages.

pfrom.fDisconnect = true;

return;

}

LOCK(cs_main);

if (!State(pfrom.GetId())->m_wtxid_relay) {

State(pfrom.GetId())->m_wtxid_relay = true;

}

if (msg_type == NetMsgType::PING) {

uint64_t nonce = 0;

vRecv >> nonce;

// Echo the message back with the nonce. This allows for two useful features:

}

CNetMessage& msg(msgs.front());

// Check network magic

if (!msg.m_valid_netmagic) {

LogPrint(BCLog::NET, "PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.m_command), pfrom->GetId());

AssertLockHeld(cs_main);

CNodeState &state = *State(pto.GetId());

if (!state.m_chain_sync.m_protect && pto.IsOutboundOrBlockRelayConn() && state.fSyncStarted) {

// This is an outbound peer subject to disconnection if they don't

return true;

// If we get here, the outgoing message serialization version is set and can't change.

//

// Message: ping

}

pto->fPingQueued = false;

pto->m_ping_start = GetTime<std::chrono::microseconds>();

pto->nPingNonceSent = nonce;

m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::PING, nonce));

} else {

//

// Message: feefilter

//

!pto->HasPermission(PF_FORCERELAY) // peers with the forcerelay permission should not filter txs to us

) {

CAmount currentFilter = m_mempool.GetMinFee(gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000).GetFeePerK();

// Mock an outbound peer

CAddress addr1(ip(0xa0b0c001), NODE_NONE);

CNode dummyNode1(id++, ServiceFlags(NODE_NETWORK | NODE_WITNESS), 0, INVALID_SOCKET, addr1, 0, 0, CAddress(), "", ConnectionType::OUTBOUND_FULL_RELAY);

peerLogic->InitializeNode(&dummyNode1);

dummyNode1.nVersion = 1;

CAddress addr(ip(g_insecure_rand_ctx.randbits(32)), NODE_NONE);

vNodes.emplace_back(new CNode(id++, ServiceFlags(NODE_NETWORK | NODE_WITNESS), 0, INVALID_SOCKET, addr, 0, 0, CAddress(), "", ConnectionType::OUTBOUND_FULL_RELAY));

CNode &node = *vNodes.back();

peerLogic.InitializeNode(&node);

node.nVersion = 1;

banman->ClearBanned();

CAddress addr1(ip(0xa0b0c001), NODE_NONE);

CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 0, 0, CAddress(), "", ConnectionType::INBOUND);

peerLogic->InitializeNode(&dummyNode1);

dummyNode1.nVersion = 1;

dummyNode1.fSuccessfullyConnected = true;

CAddress addr2(ip(0xa0b0c002), NODE_NONE);

CNode dummyNode2(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr2, 1, 1, CAddress(), "", ConnectionType::INBOUND);

peerLogic->InitializeNode(&dummyNode2);

dummyNode2.nVersion = 1;

dummyNode2.fSuccessfullyConnected = true;

CAddress addr(ip(0xa0b0c001), NODE_NONE);

CNode dummyNode(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr, 4, 4, CAddress(), "", ConnectionType::INBOUND);

peerLogic->InitializeNode(&dummyNode);

dummyNode.nVersion = 1;

dummyNode.fSuccessfullyConnected = true;