![]() |
Bitcoin Core
21.99.0
P2P Digital Currency
|
#include <net.h>
Classes | |
struct | CachedAddrResponse |
Cache responses to addr requests to minimize privacy leak. More... | |
struct | ListenSocket |
struct | Options |
Public Types | |
enum | NumConnections { CONNECTIONS_NONE = 0, CONNECTIONS_IN = (1U << 0), CONNECTIONS_OUT = (1U << 1), CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT) } |
using | NodeFn = std::function< void(CNode *)> |
Public Member Functions | |
void | Init (const Options &connOptions) |
CConnman (uint64_t seed0, uint64_t seed1, bool network_active=true) | |
~CConnman () | |
bool | Start (CScheduler &scheduler, const Options &options) |
void | StopThreads () |
void | StopNodes () |
void | Stop () |
void | Interrupt () |
bool | GetNetworkActive () const |
bool | GetUseAddrmanOutgoing () const |
void | SetNetworkActive (bool active) |
void | OpenNetworkConnection (const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *strDest, ConnectionType conn_type) |
bool | CheckIncomingNonce (uint64_t nonce) |
bool | ForNode (NodeId id, std::function< bool(CNode *pnode)> func) |
void | PushMessage (CNode *pnode, CSerializedNetMsg &&msg) |
void | ForEachNode (const NodeFn &func) |
void | ForEachNode (const NodeFn &func) const |
template<typename Callable , typename CallableAfter > | |
void | ForEachNodeThen (Callable &&pre, CallableAfter &&post) |
template<typename Callable , typename CallableAfter > | |
void | ForEachNodeThen (Callable &&pre, CallableAfter &&post) const |
void | SetServices (const CService &addr, ServiceFlags nServices) |
void | MarkAddressGood (const CAddress &addr) |
bool | AddNewAddresses (const std::vector< CAddress > &vAddr, const CAddress &addrFrom, int64_t nTimePenalty=0) |
std::vector< CAddress > | GetAddresses (size_t max_addresses, size_t max_pct) |
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 () |
void | StartExtraBlockRelayPeers () |
int | GetExtraFullOutboundCount () |
int | GetExtraBlockRelayCount () |
bool | AddNode (const std::string &node) |
bool | RemoveAddedNode (const std::string &node) |
std::vector< AddedNodeInfo > | GetAddedNodeInfo () |
bool | AddConnection (const std::string &address, ConnectionType conn_type) |
Attempts to open a connection. More... | |
size_t | GetNodeCount (NumConnections num) |
void | GetNodeStats (std::vector< CNodeStats > &vstats) |
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... | |
uint64_t | GetMaxOutboundTarget () |
std::chrono::seconds | GetMaxOutboundTimeframe () |
bool | OutboundTargetReached (bool historicalBlockServingLimit) |
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 () |
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 () |
returns the time left in the current max outbound cycle in case of no limit, it will always return 0 More... | |
uint64_t | GetTotalBytesRecv () |
uint64_t | GetTotalBytesSent () |
CSipHasher | GetDeterministicRandomizer (uint64_t id) const |
Get a unique deterministic randomizer. More... | |
unsigned int | GetReceiveFloodSize () const |
void | WakeMessageHandler () |
int64_t | PoissonNextSendInbound (int64_t now, int average_interval_seconds) |
Attempts to obfuscate tx time through exponentially distributed emitting. More... | |
void | SetAsmap (std::vector< bool > asmap) |
Private Member Functions | |
bool | BindListenPort (const CService &bindAddr, bilingual_str &strError, NetPermissionFlags permissions) |
bool | Bind (const CService &addr, unsigned int flags, NetPermissionFlags permissions) |
bool | InitBinds (const std::vector< CService > &binds, const std::vector< NetWhitebindPermissions > &whiteBinds, const std::vector< CService > &onion_binds) |
void | ThreadOpenAddedConnections () |
void | AddAddrFetch (const std::string &strDest) |
void | ProcessAddrFetch () |
void | ThreadOpenConnections (std::vector< std::string > connect) |
void | ThreadMessageHandler () |
void | AcceptConnection (const ListenSocket &hListenSocket) |
void | DisconnectNodes () |
void | NotifyNumConnectionsChanged () |
void | InactivityCheck (CNode *pnode) const |
bool | GenerateSelectSet (std::set< SOCKET > &recv_set, std::set< SOCKET > &send_set, std::set< SOCKET > &error_set) |
void | SocketEvents (std::set< SOCKET > &recv_set, std::set< SOCKET > &send_set, std::set< SOCKET > &error_set) |
void | SocketHandler () |
void | ThreadSocketHandler () |
void | ThreadDNSAddressSeed () |
uint64_t | CalculateKeyedNetGroup (const CAddress &ad) const |
CNode * | FindNode (const CNetAddr &ip) |
CNode * | FindNode (const CSubNet &subNet) |
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) |
void | AddWhitelistPermissionFlags (NetPermissionFlags &flags, const CNetAddr &addr) const |
void | DeleteNode (CNode *pnode) |
NodeId | GetNewNodeId () |
size_t | SocketSendData (CNode &node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend) |
void | DumpAddresses () |
void | RecordBytesRecv (uint64_t bytes) |
void | RecordBytesSent (uint64_t bytes) |
std::vector< CAddress > | GetCurrentBlockRelayOnlyConns () const |
Return vector of current BLOCK_RELAY peers. More... | |
uint64_t nTotalBytesRecv | GUARDED_BY (cs_totalBytesRecv) |
uint64_t nTotalBytesSent | GUARDED_BY (cs_totalBytesSent) |
uint64_t nMaxOutboundTotalBytesSentInCycle | GUARDED_BY (cs_totalBytesSent) |
std::chrono::seconds nMaxOutboundCycleStartTime | GUARDED_BY (cs_totalBytesSent) |
uint64_t nMaxOutboundLimit | GUARDED_BY (cs_totalBytesSent) |
std::deque< std::string > m_addr_fetches | GUARDED_BY (m_addr_fetches_mutex) |
std::vector< std::string > vAddedNodes | GUARDED_BY (cs_vAddedNodes) |
std::vector< CNode * > vNodes | GUARDED_BY (cs_vNodes) |
bool fMsgProcWake | GUARDED_BY (mutexMsgProc) |
flag for waking the message processor. More... | |
Static Private Member Functions | |
static bool | NodeFullyConnected (const CNode *pnode) |
Private Attributes | |
RecursiveMutex | cs_totalBytesRecv |
RecursiveMutex | cs_totalBytesSent |
int64_t | m_peer_connect_timeout |
std::vector< NetWhitelistPermissions > | vWhitelistedRange |
unsigned int | nSendBufferMaxSize {0} |
unsigned int | nReceiveFloodSize {0} |
std::vector< ListenSocket > | vhListenSocket |
std::atomic< bool > | fNetworkActive {true} |
bool | fAddressesInitialized {false} |
CAddrMan | addrman |
RecursiveMutex | m_addr_fetches_mutex |
RecursiveMutex | cs_vAddedNodes |
std::list< CNode * > | vNodesDisconnected |
RecursiveMutex | cs_vNodes |
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... | |
ServiceFlags | nLocalServices |
Services this instance offers. More... | |
std::unique_ptr< CSemaphore > | semOutbound |
std::unique_ptr< CSemaphore > | semAddnode |
int | nMaxConnections |
int | m_max_outbound_full_relay |
int | m_max_outbound_block_relay |
int | nMaxAddnode |
int | nMaxFeeler |
int | m_max_outbound |
bool | m_use_addrman_outgoing |
CClientUIInterface * | clientInterface |
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 |
std::thread | threadDNSAddressSeed |
std::thread | threadSocketHandler |
std::thread | threadOpenAddedConnections |
std::thread | threadOpenConnections |
std::thread | threadMessageHandler |
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::atomic< int64_t > | m_next_send_inv_to_incoming {0} |
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... | |
Friends | |
struct | CConnmanTest |
struct | ConnmanTestMsg |
using CConnman::NodeFn = std::function<void(CNode*)> |
CConnman::CConnman | ( | uint64_t | seed0, |
uint64_t | seed1, | ||
bool | network_active = true |
||
) |
CConnman::~CConnman | ( | ) |
|
private |
|
private |
bool CConnman::AddConnection | ( | const std::string & | address, |
ConnectionType | conn_type | ||
) |
Attempts to open a connection.
Currently only used from tests.
[in] | address | Address of node to try connecting to |
[in] | conn_type | ConnectionType::OUTBOUND or ConnectionType::BLOCK_RELAY |
Definition at line 1125 of file net.cpp.
|
private |
|
private |
|
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 971 of file net.cpp.
|
private |
|
private |
|
private |
|
private |
|
private |
bool CConnman::DisconnectNode | ( | const std::string & | node | ) |
bool CConnman::DisconnectNode | ( | const CSubNet & | subnet | ) |
bool CConnman::DisconnectNode | ( | const CNetAddr & | addr | ) |
|
private |
|
private |
|
private |
|
inline |
|
inline |
|
inline |
|
inline |
std::vector< AddedNodeInfo > CConnman::GetAddedNodeInfo | ( | ) |
std::vector< CAddress > CConnman::GetAddresses | ( | size_t | max_addresses, |
size_t | max_pct | ||
) |
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 2588 of file net.cpp.
|
private |
CSipHasher CConnman::GetDeterministicRandomizer | ( | uint64_t | id | ) | 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()
.
std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle | ( | ) |
|
private |
size_t CConnman::GetNodeCount | ( | NumConnections | num | ) |
void CConnman::GetNodeStats | ( | std::vector< CNodeStats > & | vstats | ) |
uint64_t CConnman::GetOutboundTargetBytesLeft | ( | ) |
bool CConnman::GetTryNewOutboundPeer | ( | ) |
|
inlineprivate |
|
inlineprivate |
|
inlineprivate |
|
inlineprivate |
|
private |
|
private |
|
private |
|
private |
flag for waking the message processor.
|
private |
|
inline |
|
private |
void CConnman::Interrupt | ( | ) |
void CConnman::MarkAddressGood | ( | const CAddress & | addr | ) |
|
staticprivate |
|
private |
void CConnman::OpenNetworkConnection | ( | const CAddress & | addrConnect, |
bool | fCountFailure, | ||
CSemaphoreGrant * | grantOutbound, | ||
const char * | strDest, | ||
ConnectionType | conn_type | ||
) |
bool CConnman::OutboundTargetReached | ( | bool | historicalBlockServingLimit | ) |
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 2769 of file net.cpp.
int64_t CConnman::PoissonNextSendInbound | ( | int64_t | now, |
int | average_interval_seconds | ||
) |
|
private |
void CConnman::PushMessage | ( | CNode * | pnode, |
CSerializedNetMsg && | msg | ||
) |
|
private |
|
private |
void CConnman::SetNetworkActive | ( | bool | active | ) |
void CConnman::SetServices | ( | const CService & | addr, |
ServiceFlags | nServices | ||
) |
void CConnman::SetTryNewOutboundPeer | ( | bool | flag | ) |
|
private |
|
private |
bool CConnman::Start | ( | CScheduler & | scheduler, |
const Options & | options | ||
) |
|
inline |
void CConnman::StopNodes | ( | ) |
|
private |
|
private |
|
private |
|
private |
|
private |
void CConnman::WakeMessageHandler | ( | ) |
|
private |
|
private |
|
private |
|
private |
|
mutableprivate |
|
private |
|
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 |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
Services this instance offers.
This data is replicated in each CNode instance we create during peer connection (in ConnectNode()) under a member also called nLocalServices.
This data is not marked const, but after being set it should not change. See the note in CNode::nLocalServices documentation.
|
private |
|
private |
|
private |
|
private |
|
private |