Bitcoin Core 28.99.0
P2P Digital Currency
|
#include <net.h>
Classes | |
struct | CachedAddrResponse |
Cache responses to addr requests to minimize privacy leak. More... | |
struct | ListenSocket |
class | NodesSnapshot |
RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes. More... | |
struct | Options |
struct | ReconnectionInfo |
Struct for entries in m_reconnections. More... | |
Public Types | |
using | NodeFn = std::function< void(CNode *)> |
Public Member Functions | |
void | Init (const Options &connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex |
const bool | use_v2transport (GetLocalServices() &NODE_P2P_V2) |
for (const std::string &added_node :connOptions.m_added_nodes) | |
CConnman (uint64_t seed0, uint64_t seed1, AddrMan &addrman, const NetGroupManager &netgroupman, const CChainParams ¶ms, bool network_active=true) | |
~CConnman () | |
bool | Start (CScheduler &scheduler, const Options &options) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex |
void | StopThreads () |
void | StopNodes () |
void | Stop () |
void | Interrupt () EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc) |
bool | GetNetworkActive () const |
bool | GetUseAddrmanOutgoing () const |
void | SetNetworkActive (bool active) |
void | OpenNetworkConnection (const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant &&grant_outbound, const char *strDest, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex) |
bool | CheckIncomingNonce (uint64_t nonce) |
void | ASMapHealthCheck () |
RecursiveMutex & | GetNodesMutex () const LOCK_RETURNED(m_nodes_mutex) |
bool | ForNode (NodeId id, std::function< bool(CNode *pnode)> func) |
void | PushMessage (CNode *pnode, CSerializedNetMsg &&msg) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
void | ForEachNode (const NodeFn &func) |
void | ForEachNode (const NodeFn &func) const |
std::vector< CAddress > | GetAddresses (size_t max_addresses, size_t max_pct, std::optional< Network > network, const bool filtered=true) const |
Return all or many randomly selected addresses, optionally by network. More... | |
std::vector< CAddress > | GetAddresses (CNode &requestor, size_t max_addresses, size_t max_pct) |
Cache is used to minimize topology leaks, so it should be used for all non-trusted calls, for example, p2p. More... | |
void | SetTryNewOutboundPeer (bool flag) |
bool | GetTryNewOutboundPeer () const |
void | StartExtraBlockRelayPeers () |
int | GetFullOutboundConnCount () const |
int | GetExtraFullOutboundCount () const |
int | GetExtraBlockRelayCount () const |
bool | AddNode (const AddedNodeParams &add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex) |
bool | RemoveAddedNode (const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex) |
bool | AddedNodesContain (const CAddress &addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex) |
std::vector< AddedNodeInfo > | GetAddedNodeInfo (bool include_connected) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex) |
bool | AddConnection (const std::string &address, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex) |
Attempts to open a connection. More... | |
size_t | GetNodeCount (ConnectionDirection) const |
std::map< CNetAddr, LocalServiceInfo > | getNetLocalAddresses () const |
uint32_t | GetMappedAS (const CNetAddr &addr) const |
void | GetNodeStats (std::vector< CNodeStats > &vstats) const |
bool | DisconnectNode (const std::string &node) |
bool | DisconnectNode (const CSubNet &subnet) |
bool | DisconnectNode (const CNetAddr &addr) |
bool | DisconnectNode (NodeId id) |
ServiceFlags | GetLocalServices () const |
Used to convey which local services we are offering peers during node connection. More... | |
void | AddLocalServices (ServiceFlags services) |
Updates the local services that this node advertises to other peers during connection handshake. More... | |
void | RemoveLocalServices (ServiceFlags services) |
uint64_t | GetMaxOutboundTarget () const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
std::chrono::seconds | GetMaxOutboundTimeframe () const |
bool | OutboundTargetReached (bool historicalBlockServingLimit) const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
check if the outbound target is reached if param historicalBlockServingLimit is set true, the function will response true if the limit for serving historical blocks has been reached More... | |
uint64_t | GetOutboundTargetBytesLeft () const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
response the bytes left in the current max outbound cycle in case of no limit, it will always response 0 More... | |
std::chrono::seconds | GetMaxOutboundTimeLeftInCycle () const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
uint64_t | GetTotalBytesRecv () const |
uint64_t | GetTotalBytesSent () const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
CSipHasher | GetDeterministicRandomizer (uint64_t id) const |
Get a unique deterministic randomizer. More... | |
void | WakeMessageHandler () EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc) |
bool | ShouldRunInactivityChecks (const CNode &node, std::chrono::seconds now) const |
Return true if we should disconnect the peer for failing an inactivity check. More... | |
bool | MultipleManualOrFullOutboundConns (Network net) const EXCLUSIVE_LOCKS_REQUIRED(m_nodes_mutex) |
Private Member Functions | |
std::chrono::seconds | GetMaxOutboundTimeLeftInCycle_ () const EXCLUSIVE_LOCKS_REQUIRED(m_total_bytes_sent_mutex) |
returns the time left in the current max outbound cycle in case of no limit, it will always return 0 More... | |
bool | BindListenPort (const CService &bindAddr, bilingual_str &strError, NetPermissionFlags permissions) |
bool | Bind (const CService &addr, unsigned int flags, NetPermissionFlags permissions) |
bool | InitBinds (const Options &options) |
void | ThreadOpenAddedConnections () EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex |
void | AddAddrFetch (const std::string &strDest) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex) |
void | ProcessAddrFetch () EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex |
void | ThreadOpenConnections (std::vector< std::string > connect, Span< const std::string > seed_nodes) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex |
void | ThreadMessageHandler () EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc) |
void | ThreadI2PAcceptIncoming () |
void | AcceptConnection (const ListenSocket &hListenSocket) |
void | CreateNodeFromAcceptedSocket (std::unique_ptr< Sock > &&sock, NetPermissionFlags permission_flags, const CAddress &addr_bind, const CAddress &addr) |
Create a CNode object from a socket that has just been accepted and add the node to the m_nodes member. More... | |
void | DisconnectNodes () EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex |
void | NotifyNumConnectionsChanged () |
bool | InactivityCheck (const CNode &node) const |
Return true if the peer is inactive and should be disconnected. More... | |
Sock::EventsPerSock | GenerateWaitSockets (Span< CNode *const > nodes) |
Generate a collection of sockets to check for IO readiness. More... | |
void | SocketHandler () EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex |
Check connected and listening sockets for IO readiness and process them accordingly. More... | |
void | SocketHandlerConnected (const std::vector< CNode * > &nodes, const Sock::EventsPerSock &events_per_sock) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex |
Do the read/write for connected sockets that are ready for IO. More... | |
void | SocketHandlerListening (const Sock::EventsPerSock &events_per_sock) |
Accept incoming connections, one from each read-ready listening socket. More... | |
void | ThreadSocketHandler () EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex |
void | ThreadDNSAddressSeed () EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex |
uint64_t | CalculateKeyedNetGroup (const CAddress &ad) const |
CNode * | FindNode (const CNetAddr &ip) |
CNode * | FindNode (const std::string &addrName) |
CNode * | FindNode (const CService &addr) |
bool | AlreadyConnectedToAddress (const CAddress &addr) |
Determine whether we're already connected to a given address, in order to avoid initiating duplicate connections. More... | |
bool | AttemptToEvictConnection () |
Try to find a connection to evict when the node is full. More... | |
CNode * | ConnectNode (CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex) |
void | AddWhitelistPermissionFlags (NetPermissionFlags &flags, const CNetAddr &addr, const std::vector< NetWhitelistPermissions > &ranges) const |
void | DeleteNode (CNode *pnode) |
NodeId | GetNewNodeId () |
std::pair< size_t, bool > | SocketSendData (CNode &node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend) |
(Try to) send data from node's vSendMsg. More... | |
void | DumpAddresses () |
void | RecordBytesRecv (uint64_t bytes) |
void | RecordBytesSent (uint64_t bytes) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex) |
std::unordered_set< Network > | GetReachableEmptyNetworks () const |
Return reachable networks for which we have no addresses in addrman and therefore may require loading fixed seeds. More... | |
std::vector< CAddress > | GetCurrentBlockRelayOnlyConns () const |
Return vector of current BLOCK_RELAY peers. More... | |
bool | MaybePickPreferredNetwork (std::optional< Network > &network) |
Search for a "preferred" network, a reachable network to which we currently don't have any OUTBOUND_FULL_RELAY or MANUAL connections. More... | |
uint16_t | GetDefaultPort (Network net) const |
uint16_t | GetDefaultPort (const std::string &addr) const |
uint64_t nTotalBytesSent | GUARDED_BY (m_total_bytes_sent_mutex) |
uint64_t nMaxOutboundTotalBytesSentInCycle | GUARDED_BY (m_total_bytes_sent_mutex) |
std::chrono::seconds nMaxOutboundCycleStartTime | GUARDED_BY (m_total_bytes_sent_mutex) |
uint64_t nMaxOutboundLimit | GUARDED_BY (m_total_bytes_sent_mutex) |
std::deque< std::string > m_addr_fetches | GUARDED_BY (m_addr_fetches_mutex) |
std::vector< AddedNodeParams > m_added_node_params | GUARDED_BY (m_added_nodes_mutex) |
std::vector< CNode * > m_nodes | GUARDED_BY (m_nodes_mutex) |
std::array< unsigned int, Network::NET_MAX > m_network_conn_counts | GUARDED_BY (m_nodes_mutex) |
bool fMsgProcWake | GUARDED_BY (mutexMsgProc) |
flag for waking the message processor. More... | |
std::queue< std::unique_ptr< i2p::sam::Session > > m_unused_i2p_sessions | GUARDED_BY (m_unused_i2p_sessions_mutex) |
A pool of created I2P SAM transient sessions that should be used instead of creating new ones in order to reduce the load on the I2P network. More... | |
std::list< ReconnectionInfo > m_reconnections | GUARDED_BY (m_reconnections_mutex) |
List of reconnections we have to make. More... | |
void | PerformReconnections () EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex |
Attempt reconnections, if m_reconnections non-empty. More... | |
Static Private Member Functions | |
static bool | NodeFullyConnected (const CNode *pnode) |
Private Attributes | |
void | !m_unused_i2p_sessions_mutex |
void | !m_reconnections_mutex |
void | !m_added_nodes_mutex |
void | !m_nodes_mutex |
void | !mutexMsgProc |
Mutex | m_total_bytes_sent_mutex |
std::atomic< uint64_t > | nTotalBytesRecv {0} |
std::chrono::seconds | m_peer_connect_timeout |
std::vector< NetWhitelistPermissions > | vWhitelistedRangeIncoming |
std::vector< NetWhitelistPermissions > | vWhitelistedRangeOutgoing |
unsigned int | nSendBufferMaxSize {0} |
unsigned int | nReceiveFloodSize {0} |
std::vector< ListenSocket > | vhListenSocket |
std::atomic< bool > | fNetworkActive {true} |
bool | fAddressesInitialized {false} |
AddrMan & | addrman |
const NetGroupManager & | m_netgroupman |
Mutex | m_addr_fetches_mutex |
Mutex | m_added_nodes_mutex |
std::list< CNode * > | m_nodes_disconnected |
RecursiveMutex | m_nodes_mutex |
std::atomic< NodeId > | nLastNodeId {0} |
unsigned int | nPrevNodeCount {0} |
std::map< uint64_t, CachedAddrResponse > | m_addr_response_caches |
Addr responses stored in different caches per (network, local socket) prevent cross-network node identification. More... | |
std::atomic< ServiceFlags > | m_local_services |
Services this node offers. More... | |
std::unique_ptr< CSemaphore > | semOutbound |
std::unique_ptr< CSemaphore > | semAddnode |
int | m_max_automatic_connections |
Maximum number of automatic connections permitted, excluding manual connections but including inbounds. More... | |
int | m_max_outbound_full_relay |
int | m_max_outbound_block_relay |
int | m_max_addnode {MAX_ADDNODE_CONNECTIONS} |
int | m_max_feeler {MAX_FEELER_CONNECTIONS} |
int | m_max_automatic_outbound |
int | m_max_inbound |
bool | m_use_addrman_outgoing |
CClientUIInterface * | m_client_interface |
NetEventsInterface * | m_msgproc |
BanMan * | m_banman |
Pointer to this node's banman. More... | |
std::vector< CAddress > | m_anchors |
Addresses that were saved during the previous clean shutdown. More... | |
const uint64_t | nSeed0 |
SipHasher seeds for deterministic randomness. More... | |
const uint64_t | nSeed1 |
std::condition_variable | condMsgProc |
Mutex | mutexMsgProc |
std::atomic< bool > | flagInterruptMsgProc {false} |
CThreadInterrupt | interruptNet |
This is signaled when network activity should cease. More... | |
std::unique_ptr< i2p::sam::Session > | m_i2p_sam_session |
I2P SAM session. More... | |
std::thread | threadDNSAddressSeed |
std::thread | threadSocketHandler |
std::thread | threadOpenAddedConnections |
std::thread | threadOpenConnections |
std::thread | threadMessageHandler |
std::thread | threadI2PAcceptIncoming |
std::atomic_bool | m_try_another_outbound_peer |
flag for deciding to connect to an extra outbound peer, in excess of m_max_outbound_full_relay This takes the place of a feeler connection More... | |
std::atomic_bool | m_start_extra_block_relay_peers {false} |
flag for initiating extra block-relay-only peer connections. More... | |
std::vector< CService > | m_onion_binds |
A vector of -bind=<address>:<port>=onion arguments each of which is an address and port that are designated for incoming Tor connections. More... | |
bool | whitelist_forcerelay |
flag for adding 'forcerelay' permission to whitelisted inbound and manual peers with default permissions. More... | |
bool | whitelist_relay |
flag for adding 'relay' permission to whitelisted inbound and manual peers with default permissions. More... | |
Mutex | m_unused_i2p_sessions_mutex |
Mutex protecting m_i2p_sam_sessions. More... | |
Mutex | m_reconnections_mutex |
Mutex protecting m_reconnections. More... | |
const CChainParams & | m_params |
Static Private Attributes | |
static constexpr size_t | MAX_UNUSED_I2P_SESSIONS_SIZE {10} |
Cap on the size of m_unused_i2p_sessions , to ensure it does not unexpectedly use too much memory. More... | |
Friends | |
struct | ConnmanTestMsg |
using CConnman::NodeFn = std::function<void(CNode*)> |
CConnman::CConnman | ( | uint64_t | seed0, |
uint64_t | seed1, | ||
AddrMan & | addrman, | ||
const NetGroupManager & | netgroupman, | ||
const CChainParams & | params, | ||
bool | network_active = true |
||
) |
CConnman::~CConnman | ( | ) |
|
private |
|
private |
bool CConnman::AddConnection | ( | const std::string & | address, |
ConnectionType | conn_type, | ||
bool | use_v2transport = false |
||
) |
Attempts to open a connection.
Currently only used from tests.
[in] | address | Address of node to try connecting to |
[in] | conn_type | ConnectionType::OUTBOUND, ConnectionType::BLOCK_RELAY, ConnectionType::ADDR_FETCH or ConnectionType::FEELER |
[in] | use_v2transport | Set to true if node attempts to connect using BIP 324 v2 transport protocol. |
Definition at line 1829 of file net.cpp.
bool CConnman::AddedNodesContain | ( | const CAddress & | addr | ) | const |
|
inline |
bool CConnman::AddNode | ( | const AddedNodeParams & | add | ) |
|
private |
|
private |
void CConnman::ASMapHealthCheck | ( | ) |
|
private |
Try to find a connection to evict when the node is full.
Extreme care must be taken to avoid opening the node to attacker triggered network partitioning. The strategy used here is to protect a small number of peers for each of several distinct characteristics which are difficult to forge. In order to partition a node the attacker must be simultaneously better at all of them than honest peers.
Definition at line 1663 of file net.cpp.
|
private |
|
private |
|
private |
|
private |
|
private |
Create a CNode
object from a socket that has just been accepted and add the node to the m_nodes
member.
[in] | sock | Connected socket to communicate with the peer. |
[in] | permission_flags | The peer's permissions. |
[in] | addr_bind | The address and port at our side of the connection. |
[in] | addr | The address and port at the peer's side of the connection. |
Definition at line 1734 of file net.cpp.
|
private |
bool CConnman::DisconnectNode | ( | const CNetAddr & | addr | ) |
bool CConnman::DisconnectNode | ( | const CSubNet & | subnet | ) |
bool CConnman::DisconnectNode | ( | const std::string & | node | ) |
|
private |
|
private |
|
private |
|
inline |
|
inline |
|
private |
std::vector< AddedNodeInfo > CConnman::GetAddedNodeInfo | ( | bool | include_connected | ) | const |
std::vector< CAddress > CConnman::GetAddresses | ( | CNode & | requestor, |
size_t | max_addresses, | ||
size_t | max_pct | ||
) |
Cache is used to minimize topology leaks, so it should be used for all non-trusted calls, for example, p2p.
A non-malicious call (from RPC or a peer with addr permission) should call the function without a parameter to avoid using the cache.
Definition at line 3451 of file net.cpp.
std::vector< CAddress > CConnman::GetAddresses | ( | size_t | max_addresses, |
size_t | max_pct, | ||
std::optional< Network > | network, | ||
const bool | filtered = true |
||
) | const |
Return all or many randomly selected addresses, optionally by network.
[in] | max_addresses | Maximum number of addresses to return (0 = all). |
[in] | max_pct | Maximum percentage of addresses to return (0 = all). Value must be from 0 to 100. |
[in] | network | Select only addresses of this network (nullopt = all). |
[in] | filtered | Select only addresses that are considered high quality (false = all). |
Definition at line 3440 of file net.cpp.
|
private |
|
private |
|
private |
CSipHasher CConnman::GetDeterministicRandomizer | ( | uint64_t | id | ) | const |
int CConnman::GetFullOutboundConnCount | ( | ) | const |
ServiceFlags CConnman::GetLocalServices | ( | ) | const |
Used to convey which local services we are offering peers during node connection.
The data returned by this is used in CNode construction, which is used to advertise which services we are offering that peer during net_processing.cpp:PushNodeVersion()
.
Definition at line 3716 of file net.cpp.
uint32_t CConnman::GetMappedAS | ( | const CNetAddr & | addr | ) | const |
uint64_t CConnman::GetMaxOutboundTarget | ( | ) | const |
std::chrono::seconds CConnman::GetMaxOutboundTimeframe | ( | ) | const |
std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle | ( | ) | const |
|
private |
std::map< CNetAddr, LocalServiceInfo > CConnman::getNetLocalAddresses | ( | ) | const |
|
inline |
|
private |
size_t CConnman::GetNodeCount | ( | ConnectionDirection | flags | ) | const |
RecursiveMutex & CConnman::GetNodesMutex | ( | ) | const |
void CConnman::GetNodeStats | ( | std::vector< CNodeStats > & | vstats | ) | const |
uint64_t CConnman::GetOutboundTargetBytesLeft | ( | ) | const |
|
private |
uint64_t CConnman::GetTotalBytesRecv | ( | ) | const |
uint64_t CConnman::GetTotalBytesSent | ( | ) | const |
bool CConnman::GetTryNewOutboundPeer | ( | ) | const |
|
private |
|
private |
|
private |
|
private |
|
private |
List of reconnections we have to make.
|
inlineprivate |
|
inlineprivate |
|
inlineprivate |
|
private |
|
private |
A pool of created I2P SAM transient sessions that should be used instead of creating new ones in order to reduce the load on the I2P network.
Creating a session in I2P is not cheap, thus if this is not empty, then pick an entry from it instead of creating a new session. If connecting to a host fails, then the created session is put to this pool for reuse.
|
private |
flag for waking the message processor.
|
private |
void CConnman::Init | ( | const Options & | connOptions | ) |
|
private |
void CConnman::Interrupt | ( | ) |
|
private |
Search for a "preferred" network, a reachable network to which we currently don't have any OUTBOUND_FULL_RELAY or MANUAL connections.
There needs to be at least one address in AddrMan for a preferred network to be picked.
[out] | network | Preferred network, if found. |
Definition at line 2442 of file net.cpp.
bool CConnman::MultipleManualOrFullOutboundConns | ( | Network | net | ) | const |
|
staticprivate |
|
private |
void CConnman::OpenNetworkConnection | ( | const CAddress & | addrConnect, |
bool | fCountFailure, | ||
CSemaphoreGrant && | grant_outbound, | ||
const char * | strDest, | ||
ConnectionType | conn_type, | ||
bool | use_v2transport | ||
) |
bool CConnman::OutboundTargetReached | ( | bool | historicalBlockServingLimit | ) | const |
check if the outbound target is reached if param historicalBlockServingLimit is set true, the function will response true if the limit for serving historical blocks has been reached
Definition at line 3673 of file net.cpp.
|
private |
|
private |
void CConnman::PushMessage | ( | CNode * | pnode, |
CSerializedNetMsg && | msg | ||
) |
|
private |
|
private |
bool CConnman::RemoveAddedNode | ( | const std::string & | node | ) |
|
inline |
void CConnman::SetNetworkActive | ( | bool | active | ) |
void CConnman::SetTryNewOutboundPeer | ( | bool | flag | ) |
bool CConnman::ShouldRunInactivityChecks | ( | const CNode & | node, |
std::chrono::seconds | now | ||
) | const |
|
private |
|
private |
Do the read/write for connected sockets that are ready for IO.
[in] | nodes | Nodes to process. The socket of each node is checked against what . |
[in] | events_per_sock | Sockets that are ready for IO. |
Definition at line 2060 of file net.cpp.
|
private |
|
private |
bool CConnman::Start | ( | CScheduler & | scheduler, |
const Options & | options | ||
) |
|
inline |
void CConnman::StopNodes | ( | ) |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
const bool CConnman::use_v2transport | ( | GetLocalServices() & | NODE_P2P_V2 | ) |
void CConnman::WakeMessageHandler | ( | ) |
|
friend |
void CConnman::!m_total_bytes_sent_mutex |
|
private |
|
private |
|
private |
Addr responses stored in different caches per (network, local socket) prevent cross-network node identification.
If a node for example is multi-homed under Tor and IPv6, a single cache (or no cache at all) would let an attacker to easily detect that it is the same node by comparing responses. Indexing by local socket prevents leakage when a node has multiple listening addresses on the same network.
The used memory equals to 1000 CAddress records (or around 40 bytes) per distinct Network (up to 5) we have/had an inbound peer from, resulting in at most ~196 KB. Every separate local socket may add up to ~196 KB extra.
|
private |
|
private |
CConnman::m_client_interface = connOptions.uiInterface |
|
private |
|
private |
|
private |
Services this node offers.
This data is replicated in each Peer instance we create.
This data is not marked const, but after being set it should not change. Unless AssumeUTXO is started, in which case, the peer will be limited until the background chain sync finishes.
|
private |
CConnman::m_max_automatic_connections = connOptions.m_max_automatic_connections |
|
private |
CConnman::m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler |
|
private |
CConnman::m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound) |
CConnman::m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay) |
CConnman::m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections) |
|
private |
|
private |
|
mutableprivate |
|
private |
|
private |
CConnman::m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout} |
|
private |
|
private |
|
private |
|
private |
|
private |
CConnman::m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing |
|
staticconstexprprivate |
|
private |
CConnman::nSendBufferMaxSize = connOptions.nSendBufferMaxSize |
|
private |
|
private |
|
private |
CConnman::vWhitelistedRangeIncoming = connOptions.vWhitelistedRangeIncoming |
|
private |
CConnman::vWhitelistedRangeOutgoing = connOptions.vWhitelistedRangeOutgoing |
|
private |
CConnman::whitelist_forcerelay = connOptions.whitelist_forcerelay |
|
private |
|
private |