Bitcoin ABC 0.26.3
P2P Digital Currency
|
#include <avalanche/proofid.h>
#include <avalanche/proofradixtreeadapter.h>
#include <chainparams.h>
#include <common/bloom.h>
#include <compat.h>
#include <consensus/amount.h>
#include <crypto/siphash.h>
#include <hash.h>
#include <i2p.h>
#include <kernel/cs_main.h>
#include <logging.h>
#include <net_permissions.h>
#include <netaddress.h>
#include <netbase.h>
#include <nodeid.h>
#include <protocol.h>
#include <pubkey.h>
#include <radix.h>
#include <random.h>
#include <span.h>
#include <streams.h>
#include <sync.h>
#include <threadinterrupt.h>
#include <uint256.h>
#include <util/check.h>
#include <util/sock.h>
#include <util/time.h>
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <deque>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <thread>
#include <vector>
Go to the source code of this file.
Classes | |
struct | AddedNodeInfo |
struct | CSerializedNetMsg |
struct | LocalServiceInfo |
struct | CNodeStats |
POD that contains various stats about a node. More... | |
class | CNetMessage |
Transport protocol agnostic message container. More... | |
class | TransportDeserializer |
The TransportDeserializer takes care of holding and deserializing the network receive buffer. More... | |
class | V1TransportDeserializer |
class | TransportSerializer |
The TransportSerializer prepares messages for the network transport. More... | |
class | V1TransportSerializer |
struct | CNodeOptions |
class | CNode |
Information about a peer. More... | |
class | NetEventsInterface |
Interface for message handling. More... | |
class | CConnman |
struct | CConnman::Options |
struct | CConnman::ListenSocket |
struct | CConnman::CachedAddrResponse |
Cache responses to addr requests to minimize privacy leak. More... | |
class | CConnman::NodesSnapshot |
RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes. More... | |
struct | NodeEvictionCandidate |
Typedefs | |
typedef std::map< std::string, uint64_t > | mapMsgCmdSize |
Enumerations | |
enum class | ConnectionType { INBOUND , OUTBOUND_FULL_RELAY , MANUAL , FEELER , BLOCK_RELAY , ADDR_FETCH , AVALANCHE_OUTBOUND } |
Different types of connections to a peer. More... | |
enum | { LOCAL_NONE , LOCAL_IF , LOCAL_BIND , LOCAL_MAPPED , LOCAL_MANUAL , LOCAL_MAX } |
Functions | |
std::string | ConnectionTypeAsString (ConnectionType conn_type) |
Convert ConnectionType enum to a string value. | |
void | Discover () |
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses to self-advertise. | |
uint16_t | GetListenPort () |
bool | IsPeerAddrLocalGood (CNode *pnode) |
std::optional< CService > | GetLocalAddrForPeer (CNode &node) |
Returns a local address that we should advertise to this peer. | |
void | SetReachable (enum Network net, bool reachable) |
Mark a network as reachable or unreachable (no automatic connects to it) | |
bool | IsReachable (enum Network net) |
bool | IsReachable (const CNetAddr &addr) |
bool | AddLocal (const CService &addr, int nScore=LOCAL_NONE) |
bool | AddLocal (const CNetAddr &addr, int nScore=LOCAL_NONE) |
void | RemoveLocal (const CService &addr) |
bool | SeenLocal (const CService &addr) |
vote for a local address | |
bool | IsLocal (const CService &addr) |
check whether a given address is potentially local | |
bool | GetLocal (CService &addr, const CNetAddr *paddrPeer=nullptr) |
CService | GetLocalAddress (const CNetAddr &addrPeer) |
std::map< CNetAddr, LocalServiceInfo > mapLocalHost | GUARDED_BY (g_maplocalhost_mutex) |
std::string | getSubVersionEB (uint64_t MaxBlockSize) |
This function convert MaxBlockSize from byte to MB with a decimal precision one digit rounded down E.g. | |
std::string | userAgent (const Config &config) |
void | CaptureMessageToFile (const CAddress &addr, const std::string &msg_type, Span< const uint8_t > data, bool is_incoming) |
Dump binary message to file, with timestamp. | |
std::optional< NodeId > | SelectNodeToEvict (std::vector< NodeEvictionCandidate > &&vEvictionCandidates) |
Select an inbound peer to evict after filtering out (protecting) peers having distinct, difficult-to-forge characteristics. | |
void | ProtectEvictionCandidatesByRatio (std::vector< NodeEvictionCandidate > &vEvictionCandidates) |
Protect desirable or disadvantaged inbound peers from eviction by ratio. | |
Variables | |
static constexpr std::chrono::minutes | TIMEOUT_INTERVAL {20} |
Time after which to disconnect, after waiting for a ping response (or inactivity). | |
static constexpr auto | FEELER_INTERVAL = 2min |
Run the feeler connection loop once every 2 minutes. | |
static constexpr auto | EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min |
Run the extra block-relay-only connection loop once every 5 minutes. | |
static const unsigned int | MAX_SUBVERSION_LENGTH = 256 |
Maximum length of the user agent string in version message. | |
static const int | MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 16 |
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks, tx, addrs, etc) | |
static const int | MAX_ADDNODE_CONNECTIONS = 8 |
Maximum number of addnode outgoing nodes. | |
static const int | MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2 |
Maximum number of block-relay-only outgoing connections. | |
static const int | DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS = 300 |
Maximum number of avalanche enabled outgoing connections by default. | |
static const int | MAX_FEELER_CONNECTIONS = 1 |
Maximum number of feeler connections. | |
static const bool | DEFAULT_LISTEN = true |
-listen default | |
static const unsigned int | DEFAULT_MAX_PEER_CONNECTIONS = 4096 |
The maximum number of peer connections to maintain. | |
static constexpr uint64_t | DEFAULT_MAX_UPLOAD_TARGET = 0 |
The default for -maxuploadtarget. | |
static const bool | DEFAULT_BLOCKSONLY = false |
Default for blocks only. | |
static const int64_t | DEFAULT_PEER_CONNECT_TIMEOUT = 60 |
-peertimeout default | |
static const int | NUM_FDS_MESSAGE_CAPTURE = 1 |
Number of file descriptors required for message capture. | |
static const bool | DEFAULT_FORCEDNSSEED = false |
static const bool | DEFAULT_DNSSEED = true |
static const bool | DEFAULT_FIXEDSEEDS = true |
static const size_t | DEFAULT_MAXRECEIVEBUFFER = 5 * 1000 |
static const size_t | DEFAULT_MAXSENDBUFFER = 1 * 1000 |
const std::vector< std::string > | CONNECTION_TYPE_DOC |
bool | fDiscover |
bool | fListen |
GlobalMutex | g_maplocalhost_mutex |
const std::string | NET_MESSAGE_COMMAND_OTHER |
std::function< void(const CAddress &addr, const std::string &msg_type, Span< const uint8_t > data, bool is_incoming)> | CaptureMessage |
Defaults to CaptureMessageToFile() , but can be overridden by unit tests. | |
|
strong |
Different types of connections to a peer.
This enum encapsulates the information we have available at the time of opening or accepting the connection. Aside from INBOUND, all types are initiated by us.
Enumerator | |
---|---|
INBOUND | Inbound connections are those initiated by a peer. This is the only property we know at the time of connection, until P2P messages are exchanged. |
OUTBOUND_FULL_RELAY | These are the default connections that we use to connect with the network. There is no restriction on what is relayed- by default we relay blocks, addresses & transactions. We automatically attempt to open MAX_OUTBOUND_FULL_RELAY_CONNECTIONS using addresses from our AddrMan. |
MANUAL | We open manual connections to addresses that users explicitly inputted via the addnode RPC, or the -connect command line argument. Even if a manual connection is misbehaving, we do not automatically disconnect or add it to our discouragement filter. |
FEELER | Feeler connections are short-lived connections made to check that a node is alive. They can be useful for:
|
BLOCK_RELAY | We use block-relay-only connections to help prevent against partition attacks. By not relaying transactions or addresses, these connections are harder to detect by a third party, thus helping obfuscate the network topology. We automatically attempt to open MAX_BLOCK_RELAY_ONLY_ANCHORS using addresses from our anchors.dat. Then addresses from our AddrMan if MAX_BLOCK_RELAY_ONLY_CONNECTIONS isn't reached yet. |
ADDR_FETCH | AddrFetch connections are short lived connections used to solicit addresses from peers. These are initiated to addresses submitted via the -seednode command line argument, or under certain conditions when the AddrMan is empty. |
AVALANCHE_OUTBOUND | Special case of connection to a full relay outbound with avalanche service enabled. |
bool AddLocal | ( | const CNetAddr & | addr, |
int | nScore = LOCAL_NONE |
||
) |
bool AddLocal | ( | const CService & | addr, |
int | nScore = LOCAL_NONE |
||
) |
std::string ConnectionTypeAsString | ( | ConnectionType | conn_type | ) |
void Discover | ( | ) |
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses to self-advertise.
The loopback interface is skipped and only the first address from each interface is used.
Definition at line 2634 of file net.cpp.
uint16_t GetListenPort | ( | ) |
std::optional< CService > GetLocalAddrForPeer | ( | CNode & | node | ) |
std::string getSubVersionEB | ( | uint64_t | MaxBlockSize | ) |
This function convert MaxBlockSize from byte to MB with a decimal precision one digit rounded down E.g.
1660000 -> 1.6 2010000 -> 2.0 1000000 -> 1.0 230000 -> 0.2 50000 -> 0.0
NB behavior for EB<1MB not standardized yet still the function applies the same algo used for EB greater or equal to 1MB
Definition at line 3409 of file net.cpp.
|
extern |
void ProtectEvictionCandidatesByRatio | ( | std::vector< NodeEvictionCandidate > & | vEvictionCandidates | ) |
Protect desirable or disadvantaged inbound peers from eviction by ratio.
This function protects half of the peers which have been connected the longest, to replicate the non-eviction implicit behavior and preclude attacks that start later.
Half of these protected spots (1/4 of the total) are reserved for the following categories of peers, sorted by longest uptime, even if they're not longest uptime overall:
-bind=addr[:port]=onion
will not be detected as inbound onion connectionsThis helps protect these privacy network peers, which tend to be otherwise disadvantaged under our eviction criteria for their higher min ping times relative to IPv4/IPv6 peers, and favorise the diversity of peer connections.
Definition at line 1040 of file net.cpp.
std::optional< NodeId > SelectNodeToEvict | ( | std::vector< NodeEvictionCandidate > && | vEvictionCandidates | ) |
Select an inbound peer to evict after filtering out (protecting) peers having distinct, difficult-to-forge characteristics.
The protection logic picks out fixed numbers of desirable peers per various criteria, followed by (mostly) ratios of desirable or disadvantaged peers. If any eviction candidates remain, the selection logic chooses a peer to evict.
Definition at line 1135 of file net.cpp.
std::string userAgent | ( | const Config & | config | ) |
|
extern |
Defaults to CaptureMessageToFile()
, but can be overridden by unit tests.
const std::vector<std::string> CONNECTION_TYPE_DOC |
|
static |
|
static |
|
extern |
|
static |
|
static |
|
static |
|
static |
|
static |
|
staticconstexpr |