refactor/p2p: Decouple CNode from PeerManagerImpl::MaybeDiscourageAndDisconnect

Refactor MaybeDiscourageAndDisconnect to accept individual parameters (has_no_ban, is_manual, is_local_addr, is_inbound_onion, peer_addr)
instead of taking a CNode& reference directly.
This decouples the function from CNode while preserving all original logic paths and behavior.

Author: kevkevinpal

src/net_processing.cpp

@@ -585,11 +585,17 @@ class PeerManagerImpl final : public PeerManager
 
     /** Maybe disconnect a peer and discourage future connections from its address.
      *
-     * @param[in]   pnode     The node to check.
-     * @param[in]   peer      The peer object to check.
-     * @return                True if the peer was marked for disconnection in this function
+     * @param[in]   peer                The peer object to check.
+     * @param[in]   peer_addr           The peer's address.
+     * @param[in]   has_no_ban          Whether the peer has NoBan permission.
+     * @param[in]   is_manual           Whether the peer is manually connected.
+     * @param[in]   is_local_addr       Whether the peer's address is local.
+     * @param[in]   is_inbound_onion    Whether the peer is an inbound onion connection.
+     * @return                          True if the peer was marked for disconnection in this function
      */
-    bool MaybeDiscourageAndDisconnect(CNode& pnode, Peer& peer);
+    bool MaybeDiscourageAndDisconnect(Peer& peer, const CNetAddr& peer_addr,
+                                       bool has_no_ban, bool is_manual,
+                                       bool is_local_addr, bool is_inbound_onion);
 
     /** Handle a transaction whose result was not MempoolAcceptResult::ResultType::VALID.
      * @param[in]   first_time_failure            Whether we should consider inserting into vExtraTxnForCompact, adding
@@ -4936,7 +4942,9 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
     return;
 }
 
-bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode& pnode, Peer& peer)
+bool PeerManagerImpl::MaybeDiscourageAndDisconnect(Peer& peer, const CNetAddr& peer_addr,
+                                                    bool has_no_ban, bool is_manual,
+                                                    bool is_local_addr, bool is_inbound_onion)
 {
     {
         LOCK(peer.m_misbehavior_mutex);
@@ -4947,31 +4955,30 @@ bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode& pnode, Peer& peer)
         peer.m_should_discourage = false;
     } // peer.m_misbehavior_mutex
 
-    if (pnode.HasPermission(NetPermissionFlags::NoBan)) {
+    if (has_no_ban) {
         // We never disconnect or discourage peers for bad behavior if they have NetPermissionFlags::NoBan permission
         LogPrintf("Warning: not punishing noban peer %d!\n", peer.m_id);
         return false;
     }
 
-    if (pnode.IsManualConn()) {
+    if (is_manual) {
         // We never disconnect or discourage manual peers for bad behavior
         LogPrintf("Warning: not punishing manually connected peer %d!\n", peer.m_id);
         return false;
     }
 
-    if (pnode.addr.IsLocal()) {
+    if (is_local_addr) {
         // We disconnect local peers for bad behavior but don't discourage (since that would discourage
         // all peers on the same local address)
         LogDebug(BCLog::NET, "Warning: disconnecting but not discouraging %s peer %d!\n",
-                 pnode.m_inbound_onion ? "inbound onion" : "local", peer.m_id);
-        pnode.fDisconnect = true;
+                 is_inbound_onion ? "inbound onion" : "local", peer.m_id);
         return true;
     }
 
     // Normal case: Disconnect the peer and discourage all nodes sharing the address
     LogDebug(BCLog::NET, "Disconnecting and discouraging peer %d!\n", peer.m_id);
-    if (m_banman) m_banman->Discourage(pnode.addr);
-    m_connman.DisconnectNode(pnode.addr);
+    if (m_banman) m_banman->Discourage(peer_addr);
+    m_connman.DisconnectNode(peer_addr);
     return true;
 }
 
@@ -5473,7 +5480,11 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
 
     // We must call MaybeDiscourageAndDisconnect first, to ensure that we'll
     // disconnect misbehaving peers even before the version handshake is complete.
-    if (MaybeDiscourageAndDisconnect(*pto, *peer)) return true;
+    if (MaybeDiscourageAndDisconnect(*peer, pto->addr,
+                                      pto->HasPermission(NetPermissionFlags::NoBan),
+                                      pto->IsManualConn(),
+                                      pto->addr.IsLocal(),
+                                      pto->m_inbound_onion)) return true;
 
     // Initiate version handshake for outbound connections
     if (!pto->IsInboundConn() && !peer->m_outbound_version_message_sent) {