 |
Bitcoin Core
21.99.0
P2P Digital Currency
|
|
Bitcoin Core
21.99.0
P2P Digital Currency
|
Information about a peer. More...
#include <net.h>
Classes | |
| struct | TxRelay |
Public Member Functions | |
| SOCKET hSocket | GUARDED_BY (cs_hSocket) |
| size_t nSendSize | GUARDED_BY (cs_vSend) |
| Total size of all vSendMsg entries. More... | |
| size_t nSendOffset | GUARDED_BY (cs_vSend) |
| Offset inside the first vSendMsg already sent. More... | |
| uint64_t nSendBytes | GUARDED_BY (cs_vSend) |
| std::deque< std::vector< unsigned char > > vSendMsg | GUARDED_BY (cs_vSend) |
| std::list< CNetMessage > vProcessMsg | GUARDED_BY (cs_vProcessMsg) |
| uint64_t nRecvBytes | GUARDED_BY (cs_vRecv) |
| std::string cleanSubVer | GUARDED_BY (cs_SubVer) |
| cleanSubVer is a sanitized string of the user agent byte array we read from the wire. More... | |
| bool | HasPermission (NetPermissionFlags permission) const |
| bool | IsOutboundOrBlockRelayConn () const |
| bool | IsFullOutboundConn () const |
| bool | IsManualConn () const |
| bool | IsBlockOnlyConn () const |
| bool | IsFeelerConn () const |
| bool | IsAddrFetchConn () const |
| bool | IsInboundConn () const |
| bool | RelayAddrsWithConn () const |
| bool | ExpectServicesFromConn () const |
| Network | ConnectedThroughNetwork () const |
| Get network the peer connected through. More... | |
| std::chrono::microseconds m_next_addr_send | GUARDED_BY (m_addr_send_times_mutex) |
| std::chrono::microseconds m_next_local_addr_send | GUARDED_BY (m_addr_send_times_mutex) |
| CNode (NodeId id, ServiceFlags nLocalServicesIn, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, const CAddress &addrBindIn, const std::string &addrNameIn, ConnectionType conn_type_in, bool inbound_onion) | |
| ~CNode () | |
| CNode (const CNode &)=delete | |
| CNode & | operator= (const CNode &)=delete |
| NodeId | GetId () const |
| uint64_t | GetLocalNonce () const |
| int | GetRefCount () const |
| bool | ReceiveMsgBytes (Span< const uint8_t > msg_bytes, bool &complete) |
| Receive bytes from the buffer and deserialize them into messages. More... | |
| void | SetCommonVersion (int greatest_common_version) |
| int | GetCommonVersion () const |
| CService | GetAddrLocal () const |
| void | SetAddrLocal (const CService &addrLocalIn) |
| May not be called more than once. More... | |
| CNode * | AddRef () |
| void | Release () |
| void | AddAddressKnown (const CAddress &_addr) |
| bool | IsAddrCompatible (const CAddress &addr) const |
| Whether the peer supports the address. More... | |
| void | PushAddress (const CAddress &_addr, FastRandomContext &insecure_rand) |
| void | AddKnownTx (const uint256 &hash) |
| void | PushTxInventory (const uint256 &hash) |
| void | CloseSocketDisconnect () |
| void | copyStats (CNodeStats &stats, const std::vector< bool > &m_asmap) |
| ServiceFlags | GetLocalServices () const |
| std::string | GetAddrName () const |
| void | MaybeSetAddrName (const std::string &addrNameIn) |
| Sets the addrName only if it was not previously set. More... | |
| std::string | ConnectionTypeAsString () const |
| void | PongReceived (std::chrono::microseconds ping_time) |
| A ping-pong round trip has completed successfully. More... | |
Public Attributes | |
| std::unique_ptr< TransportDeserializer > | m_deserializer |
| std::unique_ptr< TransportSerializer > | m_serializer |
| NetPermissionFlags | m_permissionFlags {PF_NONE} |
| std::atomic< ServiceFlags > | nServices {NODE_NONE} |
| Mutex | cs_vSend |
| Mutex | cs_hSocket |
| Mutex | cs_vRecv |
| RecursiveMutex | cs_vProcessMsg |
| size_t | nProcessQueueSize {0} |
| RecursiveMutex | cs_sendProcessing |
| std::atomic< int64_t > | nLastSend {0} |
| std::atomic< int64_t > | nLastRecv {0} |
| const int64_t | nTimeConnected |
| Unix epoch time at peer connection, in seconds. More... | |
| std::atomic< int64_t > | nTimeOffset {0} |
| const CAddress | addr |
| const CAddress | addrBind |
| const bool | m_inbound_onion |
| Whether this peer is an inbound onion, i.e. connected via our Tor onion service. More... | |
| std::atomic< int > | nVersion {0} |
| RecursiveMutex | cs_SubVer |
| bool | m_prefer_evict {false} |
| bool | fClient {false} |
| bool | m_limited_node {false} |
| std::atomic_bool | m_wants_addrv2 {false} |
| Whether the peer has signaled support for receiving ADDRv2 (BIP155) messages, implying a preference to receive ADDRv2 instead of ADDR ones. More... | |
| std::atomic_bool | fSuccessfullyConnected {false} |
| fSuccessfullyConnected is set to true on receiving VERACK from the peer. More... | |
| std::atomic_bool | fDisconnect {false} |
| bool | fSentAddr {false} |
| CSemaphoreGrant | grantOutbound |
| std::atomic< int > | nRefCount {0} |
| const uint64_t | nKeyedNetGroup |
| std::atomic_bool | fPauseRecv {false} |
| std::atomic_bool | fPauseSend {false} |
| std::atomic< bool > | m_bip152_highbandwidth_to {false} |
| std::atomic< bool > | m_bip152_highbandwidth_from {false} |
| std::vector< CAddress > | vAddrToSend |
| std::unique_ptr< CRollingBloomFilter > | m_addr_known {nullptr} |
| bool | fGetAddr {false} |
| Mutex | m_addr_send_times_mutex |
| std::unique_ptr< TxRelay > | m_tx_relay |
| std::atomic< int64_t > | nLastBlockTime {0} |
| UNIX epoch time of the last block received from this peer that we had not yet seen (e.g. More... | |
| std::atomic< int64_t > | nLastTXTime {0} |
| UNIX epoch time of the last transaction received from this peer that we had not yet seen (e.g. More... | |
| std::atomic< std::chrono::microseconds > | m_last_ping_time {0us} |
| Last measured round-trip time. More... | |
| std::atomic< std::chrono::microseconds > | m_min_ping_time {std::chrono::microseconds::max()} |
| Lowest measured round-trip time. More... | |
Private Member Functions | |
| std::string addrName | GUARDED_BY (cs_addrName) |
| CService addrLocal | GUARDED_BY (cs_addrLocal) |
| mapMsgCmdSize mapSendBytesPerMsgCmd | GUARDED_BY (cs_vSend) |
| mapMsgCmdSize mapRecvBytesPerMsgCmd | GUARDED_BY (cs_vRecv) |
Private Attributes | |
| const NodeId | id |
| const uint64_t | nLocalHostNonce |
| const ConnectionType | m_conn_type |
| std::atomic< int > | m_greatest_common_version {INIT_PROTO_VERSION} |
| const ServiceFlags | nLocalServices |
| Services offered to this peer. More... | |
| std::list< CNetMessage > | vRecvMsg |
| RecursiveMutex | cs_addrName |
| RecursiveMutex | cs_addrLocal |
Friends | |
| class | CConnman |
| struct | ConnmanTestMsg |
| CNode::CNode | ( | NodeId | id, |
| ServiceFlags | nLocalServicesIn, | ||
| SOCKET | hSocketIn, | ||
| const CAddress & | addrIn, | ||
| uint64_t | nKeyedNetGroupIn, | ||
| uint64_t | nLocalHostNonceIn, | ||
| const CAddress & | addrBindIn, | ||
| const std::string & | addrNameIn, | ||
| ConnectionType | conn_type_in, | ||
| bool | inbound_onion | ||
| ) |
| CNode::~CNode | ( | ) |
|
delete |
|
inline |
|
inline |
| void CNode::CloseSocketDisconnect | ( | ) |
| Network CNode::ConnectedThroughNetwork | ( | ) | const |
Get network the peer connected through.
Returns Network::NET_ONION for inbound onion connections, and CNetAddr::GetNetClass() otherwise. The latter cannot be used directly because it doesn't detect the former, and it's not the responsibility of the CNetAddr class to know the actual network a peer is connected through.
Definition at line 558 of file net.cpp.
|
inline |
| void CNode::copyStats | ( | CNodeStats & | stats, |
| const std::vector< bool > & | m_asmap | ||
| ) |
|
inline |
| CService CNode::GetAddrLocal | ( | ) | const |
| std::string CNode::GetAddrName | ( | ) | const |
|
inline |
|
inline |
|
inline |
|
private |
|
private |
| SOCKET hSocket CNode::GUARDED_BY | ( | cs_hSocket | ) |
|
inline |
| std::list<CNetMessage> vProcessMsg CNode::GUARDED_BY | ( | cs_vProcessMsg | ) |
|
private |
|
inline |
|
inline |
| std::deque<std::vector<unsigned char> > vSendMsg CNode::GUARDED_BY | ( | cs_vSend | ) |
|
private |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
| void CNode::MaybeSetAddrName | ( | const std::string & | addrNameIn | ) |
|
inline |
|
inline |
| bool CNode::ReceiveMsgBytes | ( | Span< const uint8_t > | msg_bytes, |
| bool & | complete | ||
| ) |
Receive bytes from the buffer and deserialize them into messages.
| [in] | msg_bytes | The raw data |
| [out] | complete | Set True if at least one message has been deserialized and is ready to be processed |
Definition at line 622 of file net.cpp.
|
inline |
| void CNode::SetAddrLocal | ( | const CService & | addrLocalIn | ) |
|
inline |
|
mutableprivate |
|
mutableprivate |
| RecursiveMutex CNode::cs_sendProcessing |
| RecursiveMutex CNode::cs_SubVer |
| RecursiveMutex CNode::cs_vProcessMsg |
| std::atomic_bool CNode::fSuccessfullyConnected {false} |
| CSemaphoreGrant CNode::grantOutbound |
| std::unique_ptr<CRollingBloomFilter> CNode::m_addr_known {nullptr} |
|
private |
| std::unique_ptr<TransportDeserializer> CNode::m_deserializer |
|
private |
| const bool CNode::m_inbound_onion |
| std::atomic<std::chrono::microseconds> CNode::m_last_ping_time {0us} |
| std::atomic<std::chrono::microseconds> CNode::m_min_ping_time {std::chrono::microseconds::max()} |
Lowest measured round-trip time.
Used as an inbound peer eviction criterium in CConnman::AttemptToEvictConnection.
| NetPermissionFlags CNode::m_permissionFlags {PF_NONE} |
| std::unique_ptr<TransportSerializer> CNode::m_serializer |
| std::atomic_bool CNode::m_wants_addrv2 {false} |
| std::atomic<int64_t> CNode::nLastBlockTime {0} |
UNIX epoch time of the last block received from this peer that we had not yet seen (e.g.
not already received from another peer), that passed preliminary validity checks and was saved to disk, even if we don't connect the block or it eventually fails connection. Used as an inbound peer eviction criterium in CConnman::AttemptToEvictConnection.
| std::atomic<int64_t> CNode::nLastTXTime {0} |
UNIX epoch time of the last transaction received from this peer that we had not yet seen (e.g.
not already received from another peer) and that was accepted into our mempool. Used as an inbound peer eviction criterium in CConnman::AttemptToEvictConnection.
|
private |
Services offered to this peer.
This is supplied by the parent CConnman during peer connection (CConnman::ConnectNode()) from its attribute of the same name.
This is const because there is no protocol defined for renegotiating services initially offered to a peer. The set of local services we offer should not change after initialization.
An interesting example of this is NODE_NETWORK and initial block download: a node which starts up from scratch doesn't have any blocks to serve, but still advertises NODE_NETWORK because it will eventually fulfill this role after IBD completes. P2P code is written in such a way that it can gracefully handle peers who don't make good on their service advertisements.
| std::atomic<ServiceFlags> CNode::nServices {NODE_NONE} |
| const int64_t CNode::nTimeConnected |
|
private |
1.8.17