mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-17 13:07:54 +02:00
Merge a52837b9e9 into merged_master (Bitcoin PR bitcoin/bitcoin#29575)
This commit is contained in:
ivanlele
commit
5631e834ac
10 changed files with 100 additions and 170 deletions
|
|
@ -131,8 +131,6 @@ static constexpr double BLOCK_DOWNLOAD_TIMEOUT_BASE = 1;
|
|||
static constexpr double BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 0.5;
|
||||
/** Maximum number of headers to announce when relaying blocks with headers message.*/
|
||||
static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8;
|
||||
/** Maximum number of unconnecting headers announcements before DoS score */
|
||||
static const int MAX_NUM_UNCONNECTING_HEADERS_MSGS = 10;
|
||||
/** Minimum blocks required to signal NODE_NETWORK_LIMITED */
|
||||
static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;
|
||||
/** Window, in blocks, for connecting to NODE_NETWORK_LIMITED peers */
|
||||
|
|
@ -226,8 +224,6 @@ struct Peer {
|
|||
|
||||
/** Protects misbehavior data members */
|
||||
Mutex m_misbehavior_mutex;
|
||||
/** Accumulated misbehavior score for this peer */
|
||||
int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0};
|
||||
/** Whether this peer should be disconnected and marked as discouraged (unless it has NetPermissionFlags::NoBan permission). */
|
||||
bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false};
|
||||
|
||||
|
|
@ -386,9 +382,6 @@ struct Peer {
|
|||
/** Whether we've sent our peer a sendheaders message. **/
|
||||
std::atomic<bool> m_sent_sendheaders{false};
|
||||
|
||||
/** Length of current-streak of unconnecting headers announcements */
|
||||
int m_num_unconnecting_headers_msgs GUARDED_BY(NetEventsInterface::g_msgproc_mutex){0};
|
||||
|
||||
/** When to potentially disconnect peer for stalling headers download */
|
||||
std::chrono::microseconds m_headers_sync_timeout GUARDED_BY(NetEventsInterface::g_msgproc_mutex){0us};
|
||||
|
||||
|
|
@ -530,7 +523,7 @@ public:
|
|||
m_best_height = height;
|
||||
m_best_block_time = time;
|
||||
};
|
||||
void UnitTestMisbehaving(NodeId peer_id, int howmuch) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex) { Misbehaving(*Assert(GetPeerRef(peer_id)), howmuch, ""); };
|
||||
void UnitTestMisbehaving(NodeId peer_id) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex) { Misbehaving(*Assert(GetPeerRef(peer_id)), ""); };
|
||||
void ProcessMessage(CNode& pfrom, const std::string& msg_type, DataStream& vRecv,
|
||||
const std::chrono::microseconds time_received, const std::atomic<bool>& interruptMsgProc) override
|
||||
EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, !m_recent_confirmed_transactions_mutex, !m_most_recent_block_mutex, !m_headers_presync_mutex, g_msgproc_mutex);
|
||||
|
|
@ -555,11 +548,9 @@ private:
|
|||
* May return an empty shared_ptr if the Peer object can't be found. */
|
||||
PeerRef RemovePeer(NodeId id) EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
|
||||
|
||||
/**
|
||||
* Increment peer's misbehavior score. If the new value >= DISCOURAGEMENT_THRESHOLD, mark the node
|
||||
* to be discouraged, meaning the peer might be disconnected and added to the discouragement filter.
|
||||
*/
|
||||
void Misbehaving(Peer& peer, int howmuch, const std::string& message);
|
||||
/** Mark a peer as misbehaving, which will cause it to be disconnected and its
|
||||
* address discouraged. */
|
||||
void Misbehaving(Peer& peer, const std::string& message);
|
||||
|
||||
/**
|
||||
* Potentially mark a node discouraged based on the contents of a BlockValidationState object
|
||||
|
|
@ -568,19 +559,15 @@ private:
|
|||
* punish peers differently depending on whether the data was provided in a compact
|
||||
* block message or not. If the compact block had a valid header, but contained invalid
|
||||
* txs, the peer should not be punished. See BIP 152.
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
*/
|
||||
bool MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
void MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message = "")
|
||||
EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
|
||||
|
||||
/**
|
||||
* Potentially disconnect and discourage a node based on the contents of a TxValidationState object
|
||||
*
|
||||
* @return Returns true if the peer was punished (probably disconnected)
|
||||
*/
|
||||
bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state)
|
||||
void MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
|
||||
|
||||
/** Maybe disconnect a peer and discourage future connections from its address.
|
||||
|
|
@ -671,10 +658,10 @@ private:
|
|||
bool CheckHeadersPoW(const std::vector<CBlockHeader>& headers, const Consensus::Params& consensusParams, Peer& peer);
|
||||
/** Calculate an anti-DoS work threshold for headers chains */
|
||||
arith_uint256 GetAntiDoSWorkThreshold();
|
||||
/** Deal with state tracking and headers sync for peers that send the
|
||||
* occasional non-connecting header (this can happen due to BIP 130 headers
|
||||
/** Deal with state tracking and headers sync for peers that send
|
||||
* non-connecting headers (this can happen due to BIP 130 headers
|
||||
* announcements for blocks interacting with the 2hr (MAX_FUTURE_BLOCK_TIME) rule). */
|
||||
void HandleFewUnconnectingHeaders(CNode& pfrom, Peer& peer, const std::vector<CBlockHeader>& headers) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);
|
||||
void HandleUnconnectingHeaders(CNode& pfrom, Peer& peer, const std::vector<CBlockHeader>& headers) EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex);
|
||||
/** Return true if the headers connect to each other, false otherwise */
|
||||
bool CheckHeadersAreContinuous(const std::vector<CBlockHeader>& headers) const;
|
||||
/** Try to continue a low-work headers sync that has already begun.
|
||||
|
|
@ -1722,7 +1709,6 @@ void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler& scheduler)
|
|||
void PeerManagerImpl::FinalizeNode(const CNode& node)
|
||||
{
|
||||
NodeId nodeid = node.GetId();
|
||||
int misbehavior{0};
|
||||
{
|
||||
LOCK(cs_main);
|
||||
{
|
||||
|
|
@ -1733,7 +1719,6 @@ void PeerManagerImpl::FinalizeNode(const CNode& node)
|
|||
// destructed.
|
||||
PeerRef peer = RemovePeer(nodeid);
|
||||
assert(peer != nullptr);
|
||||
misbehavior = WITH_LOCK(peer->m_misbehavior_mutex, return peer->m_misbehavior_score);
|
||||
m_wtxid_relay_peers -= peer->m_wtxid_relay;
|
||||
assert(m_wtxid_relay_peers >= 0);
|
||||
}
|
||||
|
|
@ -1776,7 +1761,7 @@ void PeerManagerImpl::FinalizeNode(const CNode& node)
|
|||
assert(m_orphanage.Size() == 0);
|
||||
}
|
||||
} // cs_main
|
||||
if (node.fSuccessfullyConnected && misbehavior == 0 &&
|
||||
if (node.fSuccessfullyConnected &&
|
||||
!node.IsBlockOnlyConn() && !node.IsInboundConn()) {
|
||||
// Only change visible addrman state for full outbound peers. We don't
|
||||
// call Connected() for feeler connections since they don't have
|
||||
|
|
@ -1897,28 +1882,16 @@ void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef& tx)
|
|||
vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % m_opts.max_extra_txs;
|
||||
}
|
||||
|
||||
void PeerManagerImpl::Misbehaving(Peer& peer, int howmuch, const std::string& message)
|
||||
void PeerManagerImpl::Misbehaving(Peer& peer, const std::string& message)
|
||||
{
|
||||
assert(howmuch > 0);
|
||||
|
||||
LOCK(peer.m_misbehavior_mutex);
|
||||
const int score_before{peer.m_misbehavior_score};
|
||||
peer.m_misbehavior_score += howmuch;
|
||||
const int score_now{peer.m_misbehavior_score};
|
||||
|
||||
const std::string message_prefixed = message.empty() ? "" : (": " + message);
|
||||
std::string warning;
|
||||
|
||||
if (score_now >= DISCOURAGEMENT_THRESHOLD && score_before < DISCOURAGEMENT_THRESHOLD) {
|
||||
warning = " DISCOURAGE THRESHOLD EXCEEDED";
|
||||
peer.m_should_discourage = true;
|
||||
}
|
||||
|
||||
LogPrint(BCLog::NET, "Misbehaving: peer=%d (%d -> %d)%s%s\n",
|
||||
peer.m_id, score_before, score_now, warning, message_prefixed);
|
||||
peer.m_should_discourage = true;
|
||||
LogPrint(BCLog::NET, "Misbehaving: peer=%d%s\n", peer.m_id, message_prefixed);
|
||||
}
|
||||
|
||||
bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
void PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState& state,
|
||||
bool via_compact_block, const std::string& message)
|
||||
{
|
||||
PeerRef peer{GetPeerRef(nodeid)};
|
||||
|
|
@ -1933,8 +1906,8 @@ bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidati
|
|||
case BlockValidationResult::BLOCK_CONSENSUS:
|
||||
case BlockValidationResult::BLOCK_MUTATED:
|
||||
if (!via_compact_block) {
|
||||
if (peer) Misbehaving(*peer, 100, message);
|
||||
return true;
|
||||
if (peer) Misbehaving(*peer, message);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case BlockValidationResult::BLOCK_CACHED_INVALID:
|
||||
|
|
@ -1948,21 +1921,20 @@ bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidati
|
|||
// Discourage outbound (but not inbound) peers if on an invalid chain.
|
||||
// Exempt HB compact block peers. Manual connections are always protected from discouragement.
|
||||
if (!via_compact_block && !node_state->m_is_inbound) {
|
||||
if (peer) Misbehaving(*peer, 100, message);
|
||||
return true;
|
||||
if (peer) Misbehaving(*peer, message);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case BlockValidationResult::BLOCK_INVALID_HEADER:
|
||||
case BlockValidationResult::BLOCK_CHECKPOINT:
|
||||
case BlockValidationResult::BLOCK_INVALID_PREV:
|
||||
if (peer) Misbehaving(*peer, 100, message);
|
||||
return true;
|
||||
if (peer) Misbehaving(*peer, message);
|
||||
return;
|
||||
// Conflicting (but not necessarily invalid) data or different policy:
|
||||
case BlockValidationResult::BLOCK_MISSING_PREV:
|
||||
// TODO: Handle this much more gracefully (10 DoS points is super arbitrary)
|
||||
if (peer) Misbehaving(*peer, 10, message);
|
||||
return true;
|
||||
if (peer) Misbehaving(*peer, message);
|
||||
return;
|
||||
case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
|
||||
case BlockValidationResult::BLOCK_TIME_FUTURE:
|
||||
break;
|
||||
|
|
@ -1970,10 +1942,9 @@ bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidati
|
|||
if (message != "") {
|
||||
LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state)
|
||||
void PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationState& state)
|
||||
{
|
||||
PeerRef peer{GetPeerRef(nodeid)};
|
||||
switch (state.GetResult()) {
|
||||
|
|
@ -1981,8 +1952,8 @@ bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationStat
|
|||
break;
|
||||
// The node is providing invalid data:
|
||||
case TxValidationResult::TX_CONSENSUS:
|
||||
if (peer) Misbehaving(*peer, 100, "");
|
||||
return true;
|
||||
if (peer) Misbehaving(*peer, "");
|
||||
return;
|
||||
// Conflicting (but not necessarily invalid) data or different policy:
|
||||
case TxValidationResult::TX_RECENT_CONSENSUS_CHANGE:
|
||||
case TxValidationResult::TX_INPUTS_NOT_STANDARD:
|
||||
|
|
@ -1998,7 +1969,6 @@ bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationStat
|
|||
case TxValidationResult::TX_UNKNOWN:
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool PeerManagerImpl::BlockRequestAllowed(const CBlockIndex* pindex)
|
||||
|
|
@ -2683,7 +2653,7 @@ void PeerManagerImpl::SendBlockTransactions(CNode& pfrom, Peer& peer, const CBlo
|
|||
BlockTransactions resp(req);
|
||||
for (size_t i = 0; i < req.indexes.size(); i++) {
|
||||
if (req.indexes[i] >= block.vtx.size()) {
|
||||
Misbehaving(peer, 100, "getblocktxn with out-of-bounds tx indices");
|
||||
Misbehaving(peer, "getblocktxn with out-of-bounds tx indices");
|
||||
return;
|
||||
}
|
||||
resp.txn[i] = block.vtx[req.indexes[i]];
|
||||
|
|
@ -2696,7 +2666,7 @@ bool PeerManagerImpl::CheckHeadersPoW(const std::vector<CBlockHeader>& headers,
|
|||
{
|
||||
// Do these headers have proof-of-work matching what's claimed?
|
||||
if (!HasValidProofOfWork(headers, consensusParams)) {
|
||||
Misbehaving(peer, 100, "header with invalid proof of work");
|
||||
Misbehaving(peer, "header with invalid proof of work");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
|
@ -2720,37 +2690,24 @@ arith_uint256 PeerManagerImpl::GetAntiDoSWorkThreshold()
|
|||
* announcement.
|
||||
*
|
||||
* We'll send a getheaders message in response to try to connect the chain.
|
||||
*
|
||||
* The peer can send up to MAX_NUM_UNCONNECTING_HEADERS_MSGS in a row that
|
||||
* don't connect before given DoS points.
|
||||
*
|
||||
* Once a headers message is received that is valid and does connect,
|
||||
* m_num_unconnecting_headers_msgs gets reset back to 0.
|
||||
*/
|
||||
void PeerManagerImpl::HandleFewUnconnectingHeaders(CNode& pfrom, Peer& peer,
|
||||
void PeerManagerImpl::HandleUnconnectingHeaders(CNode& pfrom, Peer& peer,
|
||||
const std::vector<CBlockHeader>& headers)
|
||||
{
|
||||
peer.m_num_unconnecting_headers_msgs++;
|
||||
// Try to fill in the missing headers.
|
||||
const CBlockIndex* best_header{WITH_LOCK(cs_main, return m_chainman.m_best_header)};
|
||||
if (MaybeSendGetHeaders(pfrom, GetLocator(best_header), peer)) {
|
||||
LogPrint(BCLog::NET, "received header %s: missing prev block %s, sending getheaders (%d) to end (peer=%d, m_num_unconnecting_headers_msgs=%d)\n",
|
||||
LogPrint(BCLog::NET, "received header %s: missing prev block %s, sending getheaders (%d) to end (peer=%d)\n",
|
||||
headers[0].GetHash().ToString(),
|
||||
headers[0].hashPrevBlock.ToString(),
|
||||
best_header->nHeight,
|
||||
pfrom.GetId(), peer.m_num_unconnecting_headers_msgs);
|
||||
pfrom.GetId());
|
||||
}
|
||||
|
||||
// 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.
|
||||
WITH_LOCK(cs_main, UpdateBlockAvailability(pfrom.GetId(), headers.back().GetHash()));
|
||||
|
||||
// The peer may just be broken, so periodically assign DoS points if this
|
||||
// condition persists.
|
||||
if (peer.m_num_unconnecting_headers_msgs % MAX_NUM_UNCONNECTING_HEADERS_MSGS == 0) {
|
||||
Misbehaving(peer, 20, strprintf("%d non-connecting headers", peer.m_num_unconnecting_headers_msgs));
|
||||
}
|
||||
}
|
||||
|
||||
bool PeerManagerImpl::CheckHeadersAreContinuous(const std::vector<CBlockHeader>& headers) const
|
||||
|
|
@ -2769,25 +2726,21 @@ bool PeerManagerImpl::IsContinuationOfLowWorkHeadersSync(Peer& peer, CNode& pfro
|
|||
{
|
||||
if (peer.m_headers_sync) {
|
||||
auto result = peer.m_headers_sync->ProcessNextHeaders(headers, headers.size() == MAX_HEADERS_RESULTS);
|
||||
// If it is a valid continuation, we should treat the existing getheaders request as responded to.
|
||||
if (result.success) peer.m_last_getheaders_timestamp = {};
|
||||
if (result.request_more) {
|
||||
auto locator = peer.m_headers_sync->NextHeadersRequestLocator();
|
||||
// If we were instructed to ask for a locator, it should not be empty.
|
||||
Assume(!locator.vHave.empty());
|
||||
// We can only be instructed to request more if processing was successful.
|
||||
Assume(result.success);
|
||||
if (!locator.vHave.empty()) {
|
||||
// It should be impossible for the getheaders request to fail,
|
||||
// because we should have cleared the last getheaders timestamp
|
||||
// when processing the headers that triggered this call. But
|
||||
// it may be possible to bypass this via compactblock
|
||||
// processing, so check the result before logging just to be
|
||||
// safe.
|
||||
// because we just cleared the last getheaders timestamp.
|
||||
bool sent_getheaders = MaybeSendGetHeaders(pfrom, locator, peer);
|
||||
if (sent_getheaders) {
|
||||
LogPrint(BCLog::NET, "more getheaders (from %s) to peer=%d\n",
|
||||
locator.vHave.front().ToString(), pfrom.GetId());
|
||||
} else {
|
||||
LogPrint(BCLog::NET, "error sending next getheaders (from %s) to continue sync with peer=%d\n",
|
||||
locator.vHave.front().ToString(), pfrom.GetId());
|
||||
}
|
||||
Assume(sent_getheaders);
|
||||
LogPrint(BCLog::NET, "more getheaders (from %s) to peer=%d\n",
|
||||
locator.vHave.front().ToString(), pfrom.GetId());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2996,11 +2949,6 @@ void PeerManagerImpl::HeadersDirectFetchBlocks(CNode& pfrom, const Peer& peer, c
|
|||
void PeerManagerImpl::UpdatePeerStateForReceivedHeaders(CNode& pfrom, Peer& peer,
|
||||
const CBlockIndex& last_header, bool received_new_header, bool may_have_more_headers)
|
||||
{
|
||||
if (peer.m_num_unconnecting_headers_msgs > 0) {
|
||||
LogPrint(BCLog::NET, "peer=%d: resetting m_num_unconnecting_headers_msgs (%d -> 0)\n", pfrom.GetId(), peer.m_num_unconnecting_headers_msgs);
|
||||
}
|
||||
peer.m_num_unconnecting_headers_msgs = 0;
|
||||
|
||||
LOCK(cs_main);
|
||||
CNodeState *nodestate = State(pfrom.GetId());
|
||||
|
||||
|
|
@ -3066,6 +3014,9 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, Peer& peer,
|
|||
LOCK(m_headers_presync_mutex);
|
||||
m_headers_presync_stats.erase(pfrom.GetId());
|
||||
}
|
||||
// A headers message with no headers cannot be an announcement, so assume
|
||||
// it is a response to our last getheaders request, if there is one.
|
||||
peer.m_last_getheaders_timestamp = {};
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -3082,7 +3033,7 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, Peer& peer,
|
|||
}
|
||||
// Check that headers are connected to each other in a continuous sequence
|
||||
if(!CheckHeadersAreContinuous(headers)) {
|
||||
Misbehaving(peer, 20, "non-continuous headers sequence");
|
||||
Misbehaving(peer, "non-continuous headers sequence");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -3153,17 +3104,18 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, Peer& peer,
|
|||
bool headers_connect_blockindex{chain_start_header != nullptr};
|
||||
|
||||
if (!headers_connect_blockindex) {
|
||||
if (nCount <= MAX_BLOCKS_TO_ANNOUNCE) {
|
||||
// If this looks like it could be a BIP 130 block announcement, use
|
||||
// special logic for handling headers that don't connect, as this
|
||||
// could be benign.
|
||||
HandleFewUnconnectingHeaders(pfrom, peer, headers);
|
||||
} else {
|
||||
Misbehaving(peer, 10, "invalid header received");
|
||||
}
|
||||
// This could be a BIP 130 block announcement, use
|
||||
// special logic for handling headers that don't connect, as this
|
||||
// could be benign.
|
||||
HandleUnconnectingHeaders(pfrom, peer, headers);
|
||||
return;
|
||||
}
|
||||
|
||||
// If headers connect, assume that this is in response to any outstanding getheaders
|
||||
// request we may have sent, and clear out the time of our last request. Non-connecting
|
||||
// headers cannot be a response to a getheaders request.
|
||||
peer.m_last_getheaders_timestamp = {};
|
||||
|
||||
// If the headers we received are already in memory and an ancestor of
|
||||
// m_best_header or our tip, skip anti-DoS checks. These headers will not
|
||||
// use any more memory (and we are not leaking information that could be
|
||||
|
|
@ -3700,7 +3652,7 @@ void PeerManagerImpl::ProcessCompactBlockTxns(CNode& pfrom, Peer& peer, const Bl
|
|||
ReadStatus status = partialBlock.FillBlock(*pblock, block_transactions.txn);
|
||||
if (status == READ_STATUS_INVALID) {
|
||||
RemoveBlockRequest(block_transactions.blockhash, pfrom.GetId()); // Reset in-flight state in case Misbehaving does not result in a disconnect
|
||||
Misbehaving(peer, 100, "invalid compact block/non-matching block transactions");
|
||||
Misbehaving(peer, "invalid compact block/non-matching block transactions");
|
||||
return;
|
||||
} else if (status == READ_STATUS_FAILED) {
|
||||
if (first_in_flight) {
|
||||
|
|
@ -4184,7 +4136,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
|
||||
if (vAddr.size() > MAX_ADDR_TO_SEND)
|
||||
{
|
||||
Misbehaving(*peer, 20, strprintf("%s message size = %u", msg_type, vAddr.size()));
|
||||
Misbehaving(*peer, strprintf("%s message size = %u", msg_type, vAddr.size()));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -4266,7 +4218,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
vRecv >> vInv;
|
||||
if (vInv.size() > MAX_INV_SZ)
|
||||
{
|
||||
Misbehaving(*peer, 20, strprintf("inv message size = %u", vInv.size()));
|
||||
Misbehaving(*peer, strprintf("inv message size = %u", vInv.size()));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -4358,7 +4310,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
vRecv >> vInv;
|
||||
if (vInv.size() > MAX_INV_SZ)
|
||||
{
|
||||
Misbehaving(*peer, 20, strprintf("getdata message size = %u", vInv.size()));
|
||||
Misbehaving(*peer, strprintf("getdata message size = %u", vInv.size()));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -4913,7 +4865,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
ReadStatus status = partialBlock.InitData(cmpctblock, vExtraTxnForCompact);
|
||||
if (status == READ_STATUS_INVALID) {
|
||||
RemoveBlockRequest(pindex->GetBlockHash(), pfrom.GetId()); // Reset in-flight state in case Misbehaving does not result in a disconnect
|
||||
Misbehaving(*peer, 100, "invalid compact block");
|
||||
Misbehaving(*peer, "invalid compact block");
|
||||
return;
|
||||
} else if (status == READ_STATUS_FAILED) {
|
||||
if (first_in_flight) {
|
||||
|
|
@ -5053,16 +5005,12 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
return;
|
||||
}
|
||||
|
||||
// Assume that this is in response to any outstanding getheaders
|
||||
// request we may have sent, and clear out the time of our last request
|
||||
peer->m_last_getheaders_timestamp = {};
|
||||
|
||||
std::vector<CBlockHeader> headers;
|
||||
|
||||
// Bypass the normal CBlock deserialization, as we don't want to risk deserializing 2000 full blocks.
|
||||
unsigned int nCount = ReadCompactSize(vRecv);
|
||||
if (nCount > MAX_HEADERS_RESULTS) {
|
||||
Misbehaving(*peer, 20, strprintf("headers message size = %u", nCount));
|
||||
Misbehaving(*peer, strprintf("headers message size = %u", nCount));
|
||||
return;
|
||||
}
|
||||
headers.resize(nCount);
|
||||
|
|
@ -5109,7 +5057,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
if (prev_block && IsBlockMutated(/*block=*/*pblock,
|
||||
/*check_witness_root=*/DeploymentActiveAfter(prev_block, m_chainman, Consensus::DEPLOYMENT_SEGWIT))) {
|
||||
LogDebug(BCLog::NET, "Received mutated block from peer=%d\n", peer->m_id);
|
||||
Misbehaving(*peer, 100, "mutated block");
|
||||
Misbehaving(*peer, "mutated block");
|
||||
WITH_LOCK(cs_main, RemoveBlockRequest(pblock->GetHash(), peer->m_id));
|
||||
return;
|
||||
}
|
||||
|
|
@ -5290,7 +5238,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
if (!filter.IsWithinSizeConstraints())
|
||||
{
|
||||
// There is no excuse for sending a too-large filter
|
||||
Misbehaving(*peer, 100, "too-large bloom filter");
|
||||
Misbehaving(*peer, "too-large bloom filter");
|
||||
} else if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
|
||||
{
|
||||
LOCK(tx_relay->m_bloom_filter_mutex);
|
||||
|
|
@ -5326,7 +5274,7 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
|
|||
}
|
||||
}
|
||||
if (bad) {
|
||||
Misbehaving(*peer, 100, "bad filteradd message");
|
||||
Misbehaving(*peer, "bad filteradd message");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue