diff --git a/doc/tracing.md b/doc/tracing.md index 718f5f752..c3736e3a3 100644 --- a/doc/tracing.md +++ b/doc/tracing.md @@ -1,266 +1,266 @@ # User-space, Statically Defined Tracing (USDT) for Bitcoin ABC Bitcoin ABC includes statically defined tracepoints to allow for more observability during development, debugging, code review, and production usage. These tracepoints make it possible to keep track of custom statistics and enable detailed monitoring of otherwise hidden internals. They have little to no performance impact when unused. ``` eBPF and USDT Overview ====================== ┌──────────────────┐ ┌──────────────┐ │ tracing script │ │ bitcoind │ │==================│ 2. │==============│ │ eBPF │ tracing │ hooks │ │ │ code │ logic │ into┌─┤►tracepoint 1─┼───┐ 3. └────┬───┴──▲──────┘ ├─┤►tracepoint 2 │ │ pass args 1. │ │ 4. │ │ ... │ │ to eBPF User compiles │ │ pass data to │ └──────────────┘ │ program Space & loads │ │ tracing script │ │ ─────────────────┼──────┼─────────────────┼────────────────────┼─── Kernel │ │ │ │ Space ┌──┬─▼──────┴─────────────────┴────────────┐ │ │ │ eBPF program │◄──────┘ │ └───────────────────────────────────────┤ │ eBPF kernel Virtual Machine (sandboxed) │ └──────────────────────────────────────────┘ 1. The tracing script compiles the eBPF code and loads the eBPF program into a kernel VM 2. The eBPF program hooks into one or more tracepoints 3. When the tracepoint is called, the arguments are passed to the eBPF program 4. The eBPF program processes the arguments and returns data to the tracing script ``` The Linux kernel can hook into the tracepoints during runtime and pass data to sandboxed [eBPF] programs running in the kernel. These eBPF programs can, for example, collect statistics or pass data back to user-space scripts for further processing. [eBPF]: https://ebpf.io/ The two main eBPF front-ends with support for USDT are [bpftrace] and [BPF Compiler Collection (BCC)]. BCC is used for complex tools and daemons and `bpftrace` is preferred for one-liners and shorter scripts. Examples for both can be found in [contrib/tracing]. [bpftrace]: https://github.com/iovisor/bpftrace [BPF Compiler Collection (BCC)]: https://github.com/iovisor/bcc [contrib/tracing]: ../contrib/tracing/ ## Tracepoint documentation The currently available tracepoints are listed here. ### Context `net` #### Tracepoint `net:inbound_message` Is called when a message is received from a peer over the P2P network. Passes information about our peer, the connection and the message as arguments. Arguments passed: 1. Peer ID as `int64` 2. Peer Address and Port (IPv4, IPv6, Tor v3, I2P, ...) as `pointer to C-style String` (max. length 68 characters) 3. Connection Type (inbound, feeler, outbound-full-relay, ...) as `pointer to C-style String` (max. length 20 characters) 4. Message Type (inv, ping, getdata, addrv2, ...) as `pointer to C-style String` (max. length 20 characters) 5. Message Size in bytes as `uint64` 6. Message Bytes as `pointer to unsigned chars` (i.e. bytes) Note: The message is passed to the tracepoint in full, however, due to space limitations in the eBPF kernel VM it might not be possible to pass the message to user-space in full. Messages longer than a 32kb might be cut off. This can be detected in tracing scripts by comparing the message size to the length of the passed message. #### Tracepoint `net:outbound_message` Is called when a message is send to a peer over the P2P network. Passes information about our peer, the connection and the message as arguments. Arguments passed: 1. Peer ID as `int64` 2. Peer Address and Port (IPv4, IPv6, Tor v3, I2P, ...) as `pointer to C-style String` (max. length 68 characters) 3. Connection Type (inbound, feeler, outbound-full-relay, ...) as `pointer to C-style String` (max. length 20 characters) 4. Message Type (inv, ping, getdata, addrv2, ...) as `pointer to C-style String` (max. length 20 characters) 5. Message Size in bytes as `uint64` 6. Message Bytes as `pointer to unsigned chars` (i.e. bytes) Note: The message is passed to the tracepoint in full, however, due to space limitations in the eBPF kernel VM it might not be possible to pass the message to user-space in full. Messages longer than a 32kb might be cut off. This can be detected in tracing scripts by comparing the message size to the length of the passed message. ### Context `validation` #### Tracepoint `validation:block_connected` Is called *after* a block is connected to the chain. Can, for example, be used to benchmark block connections together with `-reindex`. Arguments passed: 1. Block Header Hash as `pointer to C-style String` (64 characters) 2. Block Height as `int32` 3. Transactions in the Block as `uint64` 4. Inputs spend in the Block as `int32` 5. SigChecks in the Block (excluding coinbase) as `uint64` 6. Time it took to connect the Block in microseconds (µs) as `uint64` 7. Block Header Hash as `pointer to unsigned chars` (i.e. 32 bytes in little-endian) Note: The 7th argument can't be accessed by bpftrace and is purposefully chosen to be the block header hash as bytes. See [bpftrace argument limit] for more details. [bpftrace argument limit]: #bpftrace-argument-limit ## Adding tracepoints to Bitcoin ABC To add a new tracepoint, `#include ` in the compilation unit where the tracepoint is inserted. Use one of the `TRACEx` macros listed below depending on the number of arguments passed to the tracepoint. Up to 12 arguments can be provided. The `context` and `event` specify the names by which the tracepoint is referred to. Please use `snake_case` and try to make sure that the tracepoint names make sense even without detailed knowledge of the implementation details. Do not forget to update the tracepoint list in this document. ```c #define TRACE(context, event) #define TRACE1(context, event, a) #define TRACE2(context, event, a, b) #define TRACE3(context, event, a, b, c) #define TRACE4(context, event, a, b, c, d) #define TRACE5(context, event, a, b, c, d, e) #define TRACE6(context, event, a, b, c, d, e, f) #define TRACE7(context, event, a, b, c, d, e, f, g) #define TRACE8(context, event, a, b, c, d, e, f, g, h) #define TRACE9(context, event, a, b, c, d, e, f, g, h, i) #define TRACE10(context, event, a, b, c, d, e, f, g, h, i, j) #define TRACE11(context, event, a, b, c, d, e, f, g, h, i, j, k) #define TRACE12(context, event, a, b, c, d, e, f, g, h, i, j, k, l) ``` For example: ```C++ TRACE6(net, inbound_message, pnode->GetId(), - pnode->GetAddrName().c_str(), + pnode->m_addr_name.c_str(), pnode->ConnectionTypeAsString().c_str(), sanitizedType.c_str(), msg.data.size(), msg.data.data() ); ``` ### Guidelines and best practices #### Clear motivation and use-case Tracepoints need a clear motivation and use-case. The motivation should outweigh the impact on, for example, code readability. There is no point in adding tracepoints that don't end up being used. #### Provide an example When adding a new tracepoint, provide an example. Examples can show the use case and help reviewers testing that the tracepoint works as intended. The examples can be kept simple but should give others a starting point when working with the tracepoint. See existing examples in [contrib/tracing/]. [contrib/tracing/]: ../contrib/tracing/ #### No expensive computations for tracepoints Data passed to the tracepoint should be inexpensive to compute. Although the tracepoint itself only has overhead when enabled, the code to compute arguments is always run - even if the tracepoint is not used. For example, avoid serialization and parsing. #### Semi-stable API Tracepoints should have a semi-stable API. Users should be able to rely on the tracepoints for scripting. This means tracepoints need to be documented, and the argument order ideally should not change. If there is an important reason to change argument order, make sure to document the change and update the examples using the tracepoint. #### eBPF Virtual Machine limits Keep the eBPF Virtual Machine limits in mind. eBPF programs receiving data from the tracepoints run in a sandboxed Linux kernel VM. This VM has a limited stack size of 512 bytes. Check if it makes sense to pass larger amounts of data, for example, with a tracing script that can handle the passed data. #### `bpftrace` argument limit While tracepoints can have up to 12 arguments, bpftrace scripts currently only support reading from the first six arguments (`arg0` till `arg5`) on `x86_64`. bpftrace currently lacks real support for handling and printing binary data, like block header hashes and txids. When a tracepoint passes more than six arguments, then string and integer arguments should preferably be placed in the first six argument fields. Binary data can be placed in later arguments. The BCC supports reading from all 12 arguments. #### Strings as C-style String Generally, strings should be passed into the `TRACEx` macros as pointers to C-style strings (a null-terminated sequence of characters). For C++ `std::strings`, [`c_str()`] can be used. It's recommended to document the maximum expected string size if known. [`c_str()`]: https://www.cplusplus.com/reference/string/string/c_str/ ## Listing available tracepoints Multiple tools can list the available tracepoints in a `bitcoind` binary with USDT support. ### GDB - GNU Project Debugger To list probes in Bitcoin ABC, use `info probes` in `gdb`: ``` $ gdb ./src/bitcoind … (gdb) info probes Type Provider Name Where Semaphore Object stap net inbound_message 0x000000000014419e /src/bitcoind stap net outbound_message 0x0000000000107c05 /src/bitcoind stap validation block_connected 0x00000000002fb10c /src/bitcoind … ``` ### With `readelf` The `readelf` tool can be used to display the USDT tracepoints in Bitcoin ABC. Look for the notes with the description `NT_STAPSDT`. ``` $ readelf -n ./src/bitcoind | grep NT_STAPSDT -A 4 -B 2 Displaying notes found in: .note.stapsdt Owner Data size Description stapsdt 0x0000005d NT_STAPSDT (SystemTap probe descriptors) Provider: net Name: outbound_message Location: 0x0000000000107c05, Base: 0x0000000000579c90, Semaphore: 0x0000000000000000 Arguments: -8@%r12 8@%rbx 8@%rdi 8@192(%rsp) 8@%rax 8@%rdx … ``` ### With `tplist` The `tplist` tool is provided by BCC (see [Installing BCC]). It displays kernel tracepoints or USDT probes and their formats (for more information, see the [`tplist` usage demonstration]). There are slight binary naming differences between distributions. For example, on [Ubuntu the binary is called `tplist-bpfcc`][ubuntu binary]. [Installing BCC]: https://github.com/iovisor/bcc/blob/master/INSTALL.md [`tplist` usage demonstration]: https://github.com/iovisor/bcc/blob/master/tools/tplist_example.txt [ubuntu binary]: https://github.com/iovisor/bcc/blob/master/INSTALL.md#ubuntu---binary ``` $ tplist -l ./src/bitcoind -v b'net':b'outbound_message' [sema 0x0] 1 location(s) 6 argument(s) … ``` diff --git a/src/net.cpp b/src/net.cpp index 47a4937fe..f763238a0 100644 --- a/src/net.cpp +++ b/src/net.cpp @@ -1,3669 +1,3656 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2019 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #if defined(HAVE_CONFIG_H) #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef WIN32 #include #else #include #endif #ifdef USE_POLL #include #endif #include #include #include #include #include #include #include #include /** Maximum number of block-relay-only anchor connections */ static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2; static_assert(MAX_BLOCK_RELAY_ONLY_ANCHORS <= static_cast(MAX_BLOCK_RELAY_ONLY_CONNECTIONS), "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed " "MAX_BLOCK_RELAY_ONLY_CONNECTIONS."); /** Anchor IP address database file name */ const char *const ANCHORS_DATABASE_FILENAME = "anchors.dat"; // How often to dump addresses to peers.dat static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15}; /** * Number of DNS seeds to query when the number of connections is low. */ static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3; /** * How long to delay before querying DNS seeds * * If we have more than THRESHOLD entries in addrman, then it's likely * that we got those addresses from having previously connected to the P2P * network, and that we'll be able to successfully reconnect to the P2P * network via contacting one of them. So if that's the case, spend a * little longer trying to connect to known peers before querying the * DNS seeds. */ static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11}; static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5}; // "many" vs "few" peers static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000; /** The default timeframe for -maxuploadtarget. 1 day. */ static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24}; // We add a random period time (0 to 1 seconds) to feeler connections to prevent // synchronization. #define FEELER_SLEEP_WINDOW 1 /** Used to pass flags to the Bind() function */ enum BindFlags { BF_NONE = 0, BF_EXPLICIT = (1U << 0), BF_REPORT_ERROR = (1U << 1), /** * Do not call AddLocal() for our special addresses, e.g., for incoming * Tor connections, to prevent gossiping them over the network. */ BF_DONT_ADVERTISE = (1U << 2), }; // The set of sockets cannot be modified while waiting // The sleep time needs to be small to avoid new sockets stalling static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50; const std::string NET_MESSAGE_COMMAND_OTHER = "*other*"; // SHA256("netgroup")[0:8] static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("localhostnonce")[0:8] static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[8:16] static const uint64_t RANDOMIZER_ID_EXTRAENTROPY = 0x94b05d41679a4ff7ULL; // SHA256("addrcache")[0:8] static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL; // // Global state variables // bool fDiscover = true; bool fListen = true; RecursiveMutex cs_mapLocalHost; std::map mapLocalHost GUARDED_BY(cs_mapLocalHost); static bool vfLimited[NET_MAX] GUARDED_BY(cs_mapLocalHost) = {}; void CConnman::AddAddrFetch(const std::string &strDest) { LOCK(m_addr_fetches_mutex); m_addr_fetches.push_back(strDest); } uint16_t GetListenPort() { return static_cast( gArgs.GetIntArg("-port", Params().GetDefaultPort())); } // find 'best' local address for a particular peer bool GetLocal(CService &addr, const CNetAddr *paddrPeer) { if (!fListen) { return false; } int nBestScore = -1; int nBestReachability = -1; { LOCK(cs_mapLocalHost); for (const auto &entry : mapLocalHost) { int nScore = entry.second.nScore; int nReachability = entry.first.GetReachabilityFrom(paddrPeer); if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) { addr = CService(entry.first, entry.second.nPort); nBestReachability = nReachability; nBestScore = nScore; } } } return nBestScore >= 0; } //! Convert the pnSeed6 array into usable address objects. static std::vector convertSeed6(const std::vector &vSeedsIn) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. Seed nodes are given // a random 'last seen time' of between one and two weeks ago. const int64_t nOneWeek = 7 * 24 * 60 * 60; std::vector vSeedsOut; vSeedsOut.reserve(vSeedsIn.size()); FastRandomContext rng; for (const auto &seed_in : vSeedsIn) { struct in6_addr ip; memcpy(&ip, seed_in.addr, sizeof(ip)); CAddress addr(CService(ip, seed_in.port), GetDesirableServiceFlags(NODE_NONE)); addr.nTime = GetTime() - rng.randrange(nOneWeek) - nOneWeek; vSeedsOut.push_back(addr); } return vSeedsOut; } // Get best local address for a particular peer as a CAddress. Otherwise, return // the unroutable 0.0.0.0 but filled in with the normal parameters, since the IP // may be changed to a useful one by discovery. CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices) { CAddress ret(CService(CNetAddr(), GetListenPort()), nLocalServices); CService addr; if (GetLocal(addr, paddrPeer)) { ret = CAddress(addr, nLocalServices); } ret.nTime = GetAdjustedTime(); return ret; } static int GetnScore(const CService &addr) { LOCK(cs_mapLocalHost); if (mapLocalHost.count(addr) == 0) { return 0; } return mapLocalHost[addr].nScore; } // Is our peer's addrLocal potentially useful as an external IP source? bool IsPeerAddrLocalGood(CNode *pnode) { CService addrLocal = pnode->GetAddrLocal(); return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() && IsReachable(addrLocal.GetNetwork()); } std::optional GetLocalAddrForPeer(CNode *pnode) { CAddress addrLocal = GetLocalAddress(&pnode->addr, pnode->GetLocalServices()); if (gArgs.GetBoolArg("-addrmantest", false)) { // use IPv4 loopback during addrmantest addrLocal = CAddress(CService(LookupNumeric("127.0.0.1", GetListenPort())), pnode->GetLocalServices()); } // If discovery is enabled, sometimes give our peer the address it // tells us that it sees us as in case it has a better idea of our // address than we do. FastRandomContext rng; if (IsPeerAddrLocalGood(pnode) && (!addrLocal.IsRoutable() || rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0)) { addrLocal.SetIP(pnode->GetAddrLocal()); } if (addrLocal.IsRoutable() || gArgs.GetBoolArg("-addrmantest", false)) { LogPrint(BCLog::NET, "Advertising address %s to peer=%d\n", addrLocal.ToString(), pnode->GetId()); return addrLocal; } // Address is unroutable. Don't advertise. return std::nullopt; } // Learn a new local address. bool AddLocal(const CService &addr, int nScore) { if (!addr.IsRoutable()) { return false; } if (!fDiscover && nScore < LOCAL_MANUAL) { return false; } if (!IsReachable(addr)) { return false; } LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore); { LOCK(cs_mapLocalHost); bool fAlready = mapLocalHost.count(addr) > 0; LocalServiceInfo &info = mapLocalHost[addr]; if (!fAlready || nScore >= info.nScore) { info.nScore = nScore + (fAlready ? 1 : 0); info.nPort = addr.GetPort(); } } return true; } bool AddLocal(const CNetAddr &addr, int nScore) { return AddLocal(CService(addr, GetListenPort()), nScore); } void RemoveLocal(const CService &addr) { LOCK(cs_mapLocalHost); LogPrintf("RemoveLocal(%s)\n", addr.ToString()); mapLocalHost.erase(addr); } void SetReachable(enum Network net, bool reachable) { if (net == NET_UNROUTABLE || net == NET_INTERNAL) { return; } LOCK(cs_mapLocalHost); vfLimited[net] = !reachable; } bool IsReachable(enum Network net) { LOCK(cs_mapLocalHost); return !vfLimited[net]; } bool IsReachable(const CNetAddr &addr) { return IsReachable(addr.GetNetwork()); } /** vote for a local address */ bool SeenLocal(const CService &addr) { LOCK(cs_mapLocalHost); if (mapLocalHost.count(addr) == 0) { return false; } mapLocalHost[addr].nScore++; return true; } /** check whether a given address is potentially local */ bool IsLocal(const CService &addr) { LOCK(cs_mapLocalHost); return mapLocalHost.count(addr) > 0; } CNode *CConnman::FindNode(const CNetAddr &ip) { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (static_cast(pnode->addr) == ip) { return pnode; } } return nullptr; } CNode *CConnman::FindNode(const CSubNet &subNet) { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (subNet.Match(static_cast(pnode->addr))) { return pnode; } } return nullptr; } CNode *CConnman::FindNode(const std::string &addrName) { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { - if (pnode->GetAddrName() == addrName) { + if (pnode->m_addr_name == addrName) { return pnode; } } return nullptr; } CNode *CConnman::FindNode(const CService &addr) { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (static_cast(pnode->addr) == addr) { return pnode; } } return nullptr; } bool CConnman::AlreadyConnectedToAddress(const CAddress &addr) { return FindNode(static_cast(addr)) || FindNode(addr.ToStringIPPort()); } bool CConnman::CheckIncomingNonce(uint64_t nonce) { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() == nonce) { return false; } } return true; } /** Get the bind address for a socket as CAddress */ static CAddress GetBindAddress(SOCKET sock) { CAddress addr_bind; struct sockaddr_storage sockaddr_bind; socklen_t sockaddr_bind_len = sizeof(sockaddr_bind); if (sock != INVALID_SOCKET) { if (!getsockname(sock, (struct sockaddr *)&sockaddr_bind, &sockaddr_bind_len)) { addr_bind.SetSockAddr((const struct sockaddr *)&sockaddr_bind); } else { LogPrint(BCLog::NET, "Warning: getsockname failed\n"); } } return addr_bind; } CNode *CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type) { assert(conn_type != ConnectionType::INBOUND); if (pszDest == nullptr) { if (IsLocal(addrConnect)) { return nullptr; } // Look for an existing connection CNode *pnode = FindNode(static_cast(addrConnect)); if (pnode) { LogPrintf("Failed to open new connection, already connected\n"); return nullptr; } } /// debug print LogPrint(BCLog::NET, "trying connection %s lastseen=%.1fhrs\n", pszDest ? pszDest : addrConnect.ToString(), pszDest ? 0.0 : (double)(GetAdjustedTime() - addrConnect.nTime) / 3600.0); // Resolve const uint16_t default_port{pszDest != nullptr ? Params().GetDefaultPort(pszDest) : Params().GetDefaultPort()}; if (pszDest) { std::vector resolved; if (Lookup(pszDest, resolved, default_port, fNameLookup && !HaveNameProxy(), 256) && !resolved.empty()) { addrConnect = CAddress(resolved[GetRand(resolved.size())], NODE_NONE); if (!addrConnect.IsValid()) { LogPrint(BCLog::NET, "Resolver returned invalid address %s for %s\n", addrConnect.ToString(), pszDest); return nullptr; } // It is possible that we already have a connection to the IP/port // pszDest resolved to. In that case, drop the connection that was - // just created, and return the existing CNode instead. Also store - // the name we used to connect in that CNode, so that future - // FindNode() calls to that name catch this early. + // just created. LOCK(cs_vNodes); CNode *pnode = FindNode(static_cast(addrConnect)); if (pnode) { - pnode->MaybeSetAddrName(std::string(pszDest)); LogPrintf("Failed to open new connection, already connected\n"); return nullptr; } } } // Connect bool connected = false; std::unique_ptr sock; proxyType proxy; CAddress addr_bind; assert(!addr_bind.IsValid()); if (addrConnect.IsValid()) { bool proxyConnectionFailed = false; if (addrConnect.GetNetwork() == NET_I2P && m_i2p_sam_session.get() != nullptr) { i2p::Connection conn; if (m_i2p_sam_session->Connect(addrConnect, conn, proxyConnectionFailed)) { connected = true; sock = std::move(conn.sock); addr_bind = CAddress{conn.me, NODE_NONE}; } } else if (GetProxy(addrConnect.GetNetwork(), proxy)) { sock = CreateSock(proxy.proxy); if (!sock) { return nullptr; } connected = ConnectThroughProxy( proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), *sock, nConnectTimeout, proxyConnectionFailed); } else { // no proxy needed (none set for target network) sock = CreateSock(addrConnect); if (!sock) { return nullptr; } connected = ConnectSocketDirectly(addrConnect, *sock, nConnectTimeout, conn_type == ConnectionType::MANUAL); } if (!proxyConnectionFailed) { // If a connection to the node was attempted, and failure (if any) // is not caused by a problem connecting to the proxy, mark this as // an attempt. addrman.Attempt(addrConnect, fCountFailure); } } else if (pszDest && GetNameProxy(proxy)) { sock = CreateSock(proxy.proxy); if (!sock) { return nullptr; } std::string host; uint16_t port{default_port}; SplitHostPort(std::string(pszDest), port, host); bool proxyConnectionFailed; connected = ConnectThroughProxy(proxy, host, port, *sock, nConnectTimeout, proxyConnectionFailed); } if (!connected) { return nullptr; } // Add node NodeId id = GetNewNodeId(); uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE) .Write(id) .Finalize(); uint64_t extra_entropy = GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY) .Write(id) .Finalize(); if (!addr_bind.IsValid()) { addr_bind = GetBindAddress(sock->Get()); } CNode *pnode = new CNode(id, nLocalServices, sock->Release(), addrConnect, CalculateKeyedNetGroup(addrConnect), nonce, extra_entropy, addr_bind, pszDest ? pszDest : "", conn_type, /* inbound_onion */ false); pnode->AddRef(); // We're making a new connection, harvest entropy from the time (and our // peer count) RandAddEvent(uint32_t(id)); return pnode; } void CNode::CloseSocketDisconnect() { fDisconnect = true; LOCK(cs_hSocket); if (hSocket != INVALID_SOCKET) { LogPrint(BCLog::NET, "disconnecting peer=%d\n", id); CloseSocket(hSocket); } } void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags &flags, const CNetAddr &addr) const { for (const auto &subnet : vWhitelistedRange) { if (subnet.m_subnet.Match(addr)) { NetPermissions::AddFlag(flags, subnet.m_flags); } } } std::string CNode::ConnectionTypeAsString() const { switch (m_conn_type) { case ConnectionType::INBOUND: return "inbound"; case ConnectionType::MANUAL: return "manual"; case ConnectionType::FEELER: return "feeler"; case ConnectionType::OUTBOUND_FULL_RELAY: return "outbound-full-relay"; case ConnectionType::BLOCK_RELAY: return "block-relay-only"; case ConnectionType::ADDR_FETCH: return "addr-fetch"; case ConnectionType::AVALANCHE_OUTBOUND: return "avalanche"; } // no default case, so the compiler can warn about missing cases assert(false); } -std::string CNode::GetAddrName() const { - LOCK(cs_addrName); - return addrName; -} - -void CNode::MaybeSetAddrName(const std::string &addrNameIn) { - LOCK(cs_addrName); - if (addrName.empty()) { - addrName = addrNameIn; - } -} - CService CNode::GetAddrLocal() const { LOCK(cs_addrLocal); return addrLocal; } void CNode::SetAddrLocal(const CService &addrLocalIn) { LOCK(cs_addrLocal); if (addrLocal.IsValid()) { error("Addr local already set for node: %i. Refusing to change from %s " "to %s", id, addrLocal.ToString(), addrLocalIn.ToString()); } else { addrLocal = addrLocalIn; } } Network CNode::ConnectedThroughNetwork() const { return m_inbound_onion ? NET_ONION : addr.GetNetClass(); } void CNode::copyStats(CNodeStats &stats) { stats.nodeid = this->GetId(); stats.nServices = nServices; stats.addr = addr; stats.addrBind = addrBind; stats.m_network = ConnectedThroughNetwork(); if (m_tx_relay != nullptr) { LOCK(m_tx_relay->cs_filter); stats.fRelayTxes = m_tx_relay->fRelayTxes; } else { stats.fRelayTxes = false; } stats.m_last_send = m_last_send; stats.m_last_recv = m_last_recv; stats.m_last_tx_time = m_last_tx_time; stats.m_last_proof_time = m_last_proof_time; stats.m_last_block_time = m_last_block_time; stats.m_connected = m_connected; stats.nTimeOffset = nTimeOffset; - stats.addrName = GetAddrName(); + stats.m_addr_name = m_addr_name; stats.nVersion = nVersion; { LOCK(cs_SubVer); stats.cleanSubVer = cleanSubVer; } stats.fInbound = IsInboundConn(); stats.m_manual_connection = IsManualConn(); stats.m_bip152_highbandwidth_to = m_bip152_highbandwidth_to; stats.m_bip152_highbandwidth_from = m_bip152_highbandwidth_from; { LOCK(cs_vSend); stats.mapSendBytesPerMsgCmd = mapSendBytesPerMsgCmd; stats.nSendBytes = nSendBytes; } { LOCK(cs_vRecv); stats.mapRecvBytesPerMsgCmd = mapRecvBytesPerMsgCmd; stats.nRecvBytes = nRecvBytes; } stats.m_legacyWhitelisted = m_legacyWhitelisted; stats.m_permissionFlags = m_permissionFlags; if (m_tx_relay != nullptr) { LOCK(m_tx_relay->cs_feeFilter); stats.minFeeFilter = m_tx_relay->minFeeFilter; } else { stats.minFeeFilter = Amount::zero(); } stats.m_last_ping_time = m_last_ping_time; stats.m_min_ping_time = m_min_ping_time; // Leave string empty if addrLocal invalid (not filled in yet) CService addrLocalUnlocked = GetAddrLocal(); stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : ""; stats.m_conn_type_string = ConnectionTypeAsString(); stats.m_availabilityScore = m_avalanche_enabled ? std::make_optional(getAvailabilityScore()) : std::nullopt; } bool CNode::ReceiveMsgBytes(const Config &config, Span msg_bytes, bool &complete) { complete = false; const auto time = GetTime(); LOCK(cs_vRecv); m_last_recv = std::chrono::duration_cast(time); nRecvBytes += msg_bytes.size(); while (msg_bytes.size() > 0) { // Absorb network data. int handled = m_deserializer->Read(config, msg_bytes); if (handled < 0) { return false; } if (m_deserializer->Complete()) { // decompose a transport agnostic CNetMessage from the deserializer CNetMessage msg = m_deserializer->GetMessage(config, time); // Store received bytes per message command to prevent a memory DOS, // only allow valid commands. mapMsgCmdSize::iterator i = mapRecvBytesPerMsgCmd.find(msg.m_command); if (i == mapRecvBytesPerMsgCmd.end()) { i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER); } assert(i != mapRecvBytesPerMsgCmd.end()); i->second += msg.m_raw_message_size; // push the message to the process queue, vRecvMsg.push_back(std::move(msg)); complete = true; } } return true; } int V1TransportDeserializer::readHeader(const Config &config, Span msg_bytes) { // copy data to temporary parsing buffer uint32_t nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos; uint32_t nCopy = std::min(nRemaining, msg_bytes.size()); memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy); nHdrPos += nCopy; // if header incomplete, exit if (nHdrPos < CMessageHeader::HEADER_SIZE) { return nCopy; } // deserialize to CMessageHeader try { hdrbuf >> hdr; } catch (const std::exception &) { return -1; } // Reject oversized messages if (hdr.IsOversized(config)) { LogPrint(BCLog::NET, "Oversized header detected\n"); return -1; } // switch state to reading message data in_data = true; return nCopy; } int V1TransportDeserializer::readData(Span msg_bytes) { unsigned int nRemaining = hdr.nMessageSize - nDataPos; unsigned int nCopy = std::min(nRemaining, msg_bytes.size()); if (vRecv.size() < nDataPos + nCopy) { // Allocate up to 256 KiB ahead, but never more than the total message // size. vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024)); } hasher.Write(msg_bytes.first(nCopy)); memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy); nDataPos += nCopy; return nCopy; } const uint256 &V1TransportDeserializer::GetMessageHash() const { assert(Complete()); if (data_hash.IsNull()) { hasher.Finalize(data_hash); } return data_hash; } CNetMessage V1TransportDeserializer::GetMessage(const Config &config, const std::chrono::microseconds time) { // decompose a single CNetMessage from the TransportDeserializer CNetMessage msg(std::move(vRecv)); // store state about valid header, netmagic and checksum msg.m_valid_header = hdr.IsValid(config); // FIXME Split CheckHeaderMagicAndCommand() into CheckHeaderMagic() and // CheckCommand() to prevent the net magic check code duplication. msg.m_valid_netmagic = (memcmp(std::begin(hdr.pchMessageStart), std::begin(config.GetChainParams().NetMagic()), CMessageHeader::MESSAGE_START_SIZE) == 0); uint256 hash = GetMessageHash(); // store command string, payload size msg.m_command = hdr.GetCommand(); msg.m_message_size = hdr.nMessageSize; msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE; // We just received a message off the wire, harvest entropy from the time // (and the message checksum) RandAddEvent(ReadLE32(hash.begin())); msg.m_valid_checksum = (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) == 0); if (!msg.m_valid_checksum) { LogPrint( BCLog::NET, "CHECKSUM ERROR (%s, %u bytes), expected %s was %s\n", SanitizeString(msg.m_command), msg.m_message_size, HexStr(Span(hash.begin(), hash.begin() + CMessageHeader::CHECKSUM_SIZE)), HexStr(hdr.pchChecksum)); } // store receive time msg.m_time = time; // reset the network deserializer (prepare for the next message) Reset(); return msg; } void V1TransportSerializer::prepareForTransport(const Config &config, CSerializedNetMsg &msg, std::vector &header) { // create dbl-sha256 checksum uint256 hash = Hash(msg.data); // create header CMessageHeader hdr(config.GetChainParams().NetMagic(), msg.m_type.c_str(), msg.data.size()); memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE); // serialize header header.reserve(CMessageHeader::HEADER_SIZE); CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, header, 0, hdr}; } size_t CConnman::SocketSendData(CNode &node) const { size_t nSentSize = 0; size_t nMsgCount = 0; for (const auto &data : node.vSendMsg) { assert(data.size() > node.nSendOffset); int nBytes = 0; { LOCK(node.cs_hSocket); if (node.hSocket == INVALID_SOCKET) { break; } nBytes = send( node.hSocket, reinterpret_cast(data.data()) + node.nSendOffset, data.size() - node.nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT); } if (nBytes == 0) { // couldn't send anything at all break; } if (nBytes < 0) { // error int nErr = WSAGetLastError(); if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) { LogPrint(BCLog::NET, "socket send error for peer=%d: %s\n", node.GetId(), NetworkErrorString(nErr)); node.CloseSocketDisconnect(); } break; } assert(nBytes > 0); node.m_last_send = GetTime(); node.nSendBytes += nBytes; node.nSendOffset += nBytes; nSentSize += nBytes; if (node.nSendOffset != data.size()) { // could not send full message; stop sending more break; } node.nSendOffset = 0; node.nSendSize -= data.size(); node.fPauseSend = node.nSendSize > nSendBufferMaxSize; nMsgCount++; } node.vSendMsg.erase(node.vSendMsg.begin(), node.vSendMsg.begin() + nMsgCount); if (node.vSendMsg.empty()) { assert(node.nSendOffset == 0); assert(node.nSendSize == 0); } return nSentSize; } static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { return a.m_min_ping_time > b.m_min_ping_time; } static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { return a.m_connected > b.m_connected; } static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { return a.nKeyedNetGroup < b.nKeyedNetGroup; } static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { // There is a fall-through here because it is common for a node to have many // peers which have not yet relayed a block. if (a.m_last_block_time != b.m_last_block_time) { return a.m_last_block_time < b.m_last_block_time; } if (a.fRelevantServices != b.fRelevantServices) { return b.fRelevantServices; } return a.m_connected > b.m_connected; } static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { // There is a fall-through here because it is common for a node to have more // than a few peers that have not yet relayed txn. if (a.m_last_tx_time != b.m_last_tx_time) { return a.m_last_tx_time < b.m_last_tx_time; } if (a.fRelayTxes != b.fRelayTxes) { return b.fRelayTxes; } if (a.fBloomFilter != b.fBloomFilter) { return a.fBloomFilter; } return a.m_connected > b.m_connected; } static bool CompareNodeProofTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { // There is a fall-through here because it is common for a node to have more // than a few peers that have not yet relayed proofs. This fallback is also // used in the case avalanche is not enabled. if (a.m_last_proof_time != b.m_last_proof_time) { return a.m_last_proof_time < b.m_last_proof_time; } return a.m_connected > b.m_connected; } // Pick out the potential block-relay only peers, and sort them by last block // time. static bool CompareNodeBlockRelayOnlyTime(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { if (a.fRelayTxes != b.fRelayTxes) { return a.fRelayTxes; } if (a.m_last_block_time != b.m_last_block_time) { return a.m_last_block_time < b.m_last_block_time; } if (a.fRelevantServices != b.fRelevantServices) { return b.fRelevantServices; } return a.m_connected > b.m_connected; } static bool CompareNodeAvailabilityScore(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) { // Equality can happen if the nodes have no score or it has not been // computed yet. if (a.availabilityScore != b.availabilityScore) { return a.availabilityScore < b.availabilityScore; } return a.m_connected > b.m_connected; } /** * Sort eviction candidates by network/localhost and connection uptime. * Candidates near the beginning are more likely to be evicted, and those * near the end are more likely to be protected, e.g. less likely to be evicted. * - First, nodes that are not `is_local` and that do not belong to `network`, * sorted by increasing uptime (from most recently connected to connected * longer). * - Then, nodes that are `is_local` or belong to `network`, sorted by * increasing uptime. */ struct CompareNodeNetworkTime { const bool m_is_local; const Network m_network; CompareNodeNetworkTime(bool is_local, Network network) : m_is_local(is_local), m_network(network) {} bool operator()(const NodeEvictionCandidate &a, const NodeEvictionCandidate &b) const { if (m_is_local && a.m_is_local != b.m_is_local) { return b.m_is_local; } if ((a.m_network == m_network) != (b.m_network == m_network)) { return b.m_network == m_network; } return a.m_connected > b.m_connected; }; }; //! Sort an array by the specified comparator, then erase the last K elements //! where predicate is true. template static void EraseLastKElements( std::vector &elements, Comparator comparator, size_t k, std::function predicate = [](const NodeEvictionCandidate &n) { return true; }) { std::sort(elements.begin(), elements.end(), comparator); size_t eraseSize = std::min(k, elements.size()); elements.erase( std::remove_if(elements.end() - eraseSize, elements.end(), predicate), elements.end()); } void ProtectEvictionCandidatesByRatio( std::vector &eviction_candidates) { // Protect the half of the remaining nodes which have been connected the // longest. This replicates the non-eviction implicit behavior, and // precludes attacks that start later. // To promote the diversity of our peer connections, reserve up to half of // these protected spots for Tor/onion, localhost and I2P peers, even if // they're not the longest uptime overall. This helps protect these // higher-latency peers that tend to be otherwise disadvantaged under our // eviction criteria. const size_t initial_size = eviction_candidates.size(); const size_t total_protect_size{initial_size / 2}; // Disadvantaged networks to protect: I2P, localhost and Tor/onion. In case // of equal counts, earlier array members have first opportunity to recover // unused slots from the previous iteration. struct Net { bool is_local; Network id; size_t count; }; std::array networks{{{false, NET_I2P, 0}, {/* localhost */ true, NET_MAX, 0}, {false, NET_ONION, 0}}}; // Count and store the number of eviction candidates per network. for (Net &n : networks) { n.count = std::count_if( eviction_candidates.cbegin(), eviction_candidates.cend(), [&n](const NodeEvictionCandidate &c) { return n.is_local ? c.m_is_local : c.m_network == n.id; }); } // Sort `networks` by ascending candidate count, to give networks having // fewer candidates the first opportunity to recover unused protected slots // from the previous iteration. std::stable_sort(networks.begin(), networks.end(), [](Net a, Net b) { return a.count < b.count; }); // Protect up to 25% of the eviction candidates by disadvantaged network. const size_t max_protect_by_network{total_protect_size / 2}; size_t num_protected{0}; while (num_protected < max_protect_by_network) { // Count the number of disadvantaged networks from which we have peers // to protect. auto num_networks = std::count_if(networks.begin(), networks.end(), [](const Net &n) { return n.count; }); if (num_networks == 0) { break; } const size_t disadvantaged_to_protect{max_protect_by_network - num_protected}; const size_t protect_per_network{std::max( disadvantaged_to_protect / num_networks, static_cast(1))}; // Early exit flag if there are no remaining candidates by disadvantaged // network. bool protected_at_least_one{false}; for (Net &n : networks) { if (n.count == 0) { continue; } const size_t before = eviction_candidates.size(); EraseLastKElements( eviction_candidates, CompareNodeNetworkTime(n.is_local, n.id), protect_per_network, [&n](const NodeEvictionCandidate &c) { return n.is_local ? c.m_is_local : c.m_network == n.id; }); const size_t after = eviction_candidates.size(); if (before > after) { protected_at_least_one = true; const size_t delta{before - after}; num_protected += delta; if (num_protected >= max_protect_by_network) { break; } n.count -= delta; } } if (!protected_at_least_one) { break; } } // Calculate how many we removed, and update our total number of peers that // we want to protect based on uptime accordingly. assert(num_protected == initial_size - eviction_candidates.size()); const size_t remaining_to_protect{total_protect_size - num_protected}; EraseLastKElements(eviction_candidates, ReverseCompareNodeTimeConnected, remaining_to_protect); } [[nodiscard]] std::optional SelectNodeToEvict(std::vector &&vEvictionCandidates) { // Protect connections with certain characteristics // Deterministically select 4 peers to protect by netgroup. // An attacker cannot predict which netgroups will be protected EraseLastKElements(vEvictionCandidates, CompareNetGroupKeyed, 4); // Protect the 8 nodes with the lowest minimum ping time. // An attacker cannot manipulate this metric without physically moving nodes // closer to the target. EraseLastKElements(vEvictionCandidates, ReverseCompareNodeMinPingTime, 8); // Protect 4 nodes that most recently sent us novel transactions accepted // into our mempool. An attacker cannot manipulate this metric without // performing useful work. EraseLastKElements(vEvictionCandidates, CompareNodeTXTime, 4); // Protect 4 nodes that most recently sent us novel proofs accepted // into our proof pool. An attacker cannot manipulate this metric without // performing useful work. // TODO this filter must happen before the last tx time once avalanche is // enabled for pre-consensus. EraseLastKElements(vEvictionCandidates, CompareNodeProofTime, 4); // Protect up to 8 non-tx-relay peers that have sent us novel blocks. EraseLastKElements(vEvictionCandidates, CompareNodeBlockRelayOnlyTime, 8, [](const NodeEvictionCandidate &n) { return !n.fRelayTxes && n.fRelevantServices; }); // Protect 4 nodes that most recently sent us novel blocks. // An attacker cannot manipulate this metric without performing useful work. EraseLastKElements(vEvictionCandidates, CompareNodeBlockTime, 4); // Protect up to 128 nodes that have the highest avalanche availability // score. EraseLastKElements(vEvictionCandidates, CompareNodeAvailabilityScore, 128, [](NodeEvictionCandidate const &n) { return n.availabilityScore > 0.; }); // Protect some of the remaining eviction candidates by ratios of desirable // or disadvantaged characteristics. ProtectEvictionCandidatesByRatio(vEvictionCandidates); if (vEvictionCandidates.empty()) { return std::nullopt; } // If any remaining peers are preferred for eviction consider only them. // This happens after the other preferences since if a peer is really the // best by other criteria (esp relaying blocks) // then we probably don't want to evict it no matter what. if (std::any_of( vEvictionCandidates.begin(), vEvictionCandidates.end(), [](NodeEvictionCandidate const &n) { return n.prefer_evict; })) { vEvictionCandidates.erase( std::remove_if( vEvictionCandidates.begin(), vEvictionCandidates.end(), [](NodeEvictionCandidate const &n) { return !n.prefer_evict; }), vEvictionCandidates.end()); } // Identify the network group with the most connections and youngest member. // (vEvictionCandidates is already sorted by reverse connect time) uint64_t naMostConnections; unsigned int nMostConnections = 0; std::chrono::seconds nMostConnectionsTime{0}; std::map> mapNetGroupNodes; for (const NodeEvictionCandidate &node : vEvictionCandidates) { std::vector &group = mapNetGroupNodes[node.nKeyedNetGroup]; group.push_back(node); const auto grouptime{group[0].m_connected}; size_t group_size = group.size(); if (group_size > nMostConnections || (group_size == nMostConnections && grouptime > nMostConnectionsTime)) { nMostConnections = group_size; nMostConnectionsTime = grouptime; naMostConnections = node.nKeyedNetGroup; } } // Reduce to the network group with the most connections vEvictionCandidates = std::move(mapNetGroupNodes[naMostConnections]); // Disconnect from the network group with the most connections return vEvictionCandidates.front().id; } /** 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. */ bool CConnman::AttemptToEvictConnection() { std::vector vEvictionCandidates; { LOCK(cs_vNodes); for (const CNode *node : vNodes) { if (node->HasPermission(PF_NOBAN)) { continue; } if (!node->IsInboundConn()) { continue; } if (node->fDisconnect) { continue; } bool peer_relay_txes = false; bool peer_filter_not_null = false; if (node->m_tx_relay != nullptr) { LOCK(node->m_tx_relay->cs_filter); peer_relay_txes = node->m_tx_relay->fRelayTxes; peer_filter_not_null = node->m_tx_relay->pfilter != nullptr; } NodeEvictionCandidate candidate = { node->GetId(), node->m_connected, node->m_min_ping_time, node->m_last_block_time, node->m_last_proof_time, node->m_last_tx_time, HasAllDesirableServiceFlags(node->nServices), peer_relay_txes, peer_filter_not_null, node->nKeyedNetGroup, node->m_prefer_evict, node->addr.IsLocal(), node->ConnectedThroughNetwork(), node->m_avalanche_enabled ? node->getAvailabilityScore() : -std::numeric_limits::infinity()}; vEvictionCandidates.push_back(candidate); } } const std::optional node_id_to_evict = SelectNodeToEvict(std::move(vEvictionCandidates)); if (!node_id_to_evict) { return false; } LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (pnode->GetId() == *node_id_to_evict) { LogPrint( BCLog::NET, "selected %s connection for eviction peer=%d; disconnecting\n", pnode->ConnectionTypeAsString(), pnode->GetId()); pnode->fDisconnect = true; return true; } } return false; } void CConnman::AcceptConnection(const ListenSocket &hListenSocket) { struct sockaddr_storage sockaddr; socklen_t len = sizeof(sockaddr); SOCKET hSocket = accept(hListenSocket.socket, (struct sockaddr *)&sockaddr, &len); CAddress addr; if (hSocket == INVALID_SOCKET) { const int nErr = WSAGetLastError(); if (nErr != WSAEWOULDBLOCK) { LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr)); } return; } if (!addr.SetSockAddr((const struct sockaddr *)&sockaddr)) { LogPrintf("Warning: Unknown socket family\n"); } const CAddress addr_bind = GetBindAddress(hSocket); NetPermissionFlags permissionFlags = NetPermissionFlags::PF_NONE; hListenSocket.AddSocketPermissionFlags(permissionFlags); CreateNodeFromAcceptedSocket(hSocket, permissionFlags, addr_bind, addr); } void CConnman::CreateNodeFromAcceptedSocket(SOCKET hSocket, NetPermissionFlags permissionFlags, const CAddress &addr_bind, const CAddress &addr) { int nInbound = 0; int nMaxInbound = nMaxConnections - m_max_outbound; AddWhitelistPermissionFlags(permissionFlags, addr); bool legacyWhitelisted = false; if (NetPermissions::HasFlag(permissionFlags, NetPermissionFlags::PF_ISIMPLICIT)) { NetPermissions::ClearFlag(permissionFlags, PF_ISIMPLICIT); if (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) { NetPermissions::AddFlag(permissionFlags, PF_FORCERELAY); } if (gArgs.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY)) { NetPermissions::AddFlag(permissionFlags, PF_RELAY); } NetPermissions::AddFlag(permissionFlags, PF_MEMPOOL); NetPermissions::AddFlag(permissionFlags, PF_NOBAN); legacyWhitelisted = true; } { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->IsInboundConn()) { nInbound++; } } } if (!fNetworkActive) { LogPrint(BCLog::NET, "connection from %s dropped: not accepting new connections\n", addr.ToString()); CloseSocket(hSocket); return; } if (!IsSelectableSocket(hSocket)) { LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToString()); CloseSocket(hSocket); return; } // According to the internet TCP_NODELAY is not carried into accepted // sockets on all platforms. Set it again here just to be sure. SetSocketNoDelay(hSocket); // Don't accept connections from banned peers. bool banned = m_banman && m_banman->IsBanned(addr); if (!NetPermissions::HasFlag(permissionFlags, NetPermissionFlags::PF_NOBAN) && banned) { LogPrint(BCLog::NET, "connection from %s dropped (banned)\n", addr.ToString()); CloseSocket(hSocket); return; } // Only accept connections from discouraged peers if our inbound slots // aren't (almost) full. bool discouraged = m_banman && m_banman->IsDiscouraged(addr); if (!NetPermissions::HasFlag(permissionFlags, NetPermissionFlags::PF_NOBAN) && nInbound + 1 >= nMaxInbound && discouraged) { LogPrint(BCLog::NET, "connection from %s dropped (discouraged)\n", addr.ToString()); CloseSocket(hSocket); return; } if (nInbound >= nMaxInbound) { if (!AttemptToEvictConnection()) { // No connection to evict, disconnect the new connection LogPrint(BCLog::NET, "failed to find an eviction candidate - " "connection dropped (full)\n"); CloseSocket(hSocket); return; } } NodeId id = GetNewNodeId(); uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE) .Write(id) .Finalize(); uint64_t extra_entropy = GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY) .Write(id) .Finalize(); ServiceFlags nodeServices = nLocalServices; if (NetPermissions::HasFlag(permissionFlags, PF_BLOOMFILTER)) { nodeServices = static_cast(nodeServices | NODE_BLOOM); } const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end(); CNode *pnode = new CNode( id, nodeServices, hSocket, addr, CalculateKeyedNetGroup(addr), nonce, extra_entropy, addr_bind, "", ConnectionType::INBOUND, inbound_onion); pnode->AddRef(); pnode->m_permissionFlags = permissionFlags; // If this flag is present, the user probably expect that RPC and QT report // it as whitelisted (backward compatibility) pnode->m_legacyWhitelisted = legacyWhitelisted; pnode->m_prefer_evict = discouraged; for (auto interface : m_msgproc) { interface->InitializeNode(*config, pnode); } LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToString()); { LOCK(cs_vNodes); vNodes.push_back(pnode); } // We received a new connection, harvest entropy from the time (and our peer // count) RandAddEvent(uint32_t(id)); } bool CConnman::AddConnection(const std::string &address, ConnectionType conn_type) { std::optional max_connections; switch (conn_type) { case ConnectionType::INBOUND: case ConnectionType::MANUAL: return false; case ConnectionType::OUTBOUND_FULL_RELAY: max_connections = m_max_outbound_full_relay; break; case ConnectionType::BLOCK_RELAY: max_connections = m_max_outbound_block_relay; break; // no limit for ADDR_FETCH because -seednode has no limit either case ConnectionType::ADDR_FETCH: break; // no limit for FEELER connections since they're short-lived case ConnectionType::FEELER: break; case ConnectionType::AVALANCHE_OUTBOUND: max_connections = m_max_avalanche_outbound; break; } // no default case, so the compiler can warn about missing cases // Count existing connections int existing_connections = WITH_LOCK( cs_vNodes, return std::count_if( vNodes.begin(), vNodes.end(), [conn_type](CNode *node) { return node->m_conn_type == conn_type; });); // Max connections of specified type already exist if (max_connections != std::nullopt && existing_connections >= max_connections) { return false; } // Max total outbound connections already exist CSemaphoreGrant grant(*semOutbound, true); if (!grant) { return false; } OpenNetworkConnection(CAddress(), false, &grant, address.c_str(), conn_type); return true; } void CConnman::DisconnectNodes() { { LOCK(cs_vNodes); if (!fNetworkActive) { // Disconnect any connected nodes for (CNode *pnode : vNodes) { if (!pnode->fDisconnect) { LogPrint(BCLog::NET, "Network not active, dropping peer=%d\n", pnode->GetId()); pnode->fDisconnect = true; } } } // Disconnect unused nodes std::vector vNodesCopy = vNodes; for (CNode *pnode : vNodesCopy) { if (pnode->fDisconnect) { // remove from vNodes vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end()); // release outbound grant (if any) pnode->grantOutbound.Release(); // close socket and cleanup pnode->CloseSocketDisconnect(); // hold in disconnected pool until all refs are released pnode->Release(); vNodesDisconnected.push_back(pnode); } } } { // Delete disconnected nodes std::list vNodesDisconnectedCopy = vNodesDisconnected; for (CNode *pnode : vNodesDisconnectedCopy) { // wait until threads are done using it if (pnode->GetRefCount() <= 0) { bool fDelete = false; { TRY_LOCK(pnode->cs_vSend, lockSend); if (lockSend) { fDelete = true; } } if (fDelete) { vNodesDisconnected.remove(pnode); DeleteNode(pnode); } } } } } void CConnman::NotifyNumConnectionsChanged() { size_t vNodesSize; { LOCK(cs_vNodes); vNodesSize = vNodes.size(); } if (vNodesSize != nPrevNodeCount) { nPrevNodeCount = vNodesSize; if (clientInterface) { clientInterface->NotifyNumConnectionsChanged(vNodesSize); } } } bool CConnman::ShouldRunInactivityChecks(const CNode &node, std::chrono::seconds now) const { return node.m_connected + m_peer_connect_timeout < now; } bool CConnman::InactivityCheck(const CNode &node) const { // Tests that see disconnects after using mocktime can start nodes with a // large timeout. For example, -peertimeout=999999999. const auto now{GetTime()}; const auto last_send{node.m_last_send.load()}; const auto last_recv{node.m_last_recv.load()}; if (!ShouldRunInactivityChecks(node, now)) { return false; } if (last_recv.count() == 0 || last_send.count() == 0) { LogPrint(BCLog::NET, "socket no message in first %i seconds, %d %d peer=%d\n", count_seconds(m_peer_connect_timeout), last_recv.count() != 0, last_send.count() != 0, node.GetId()); return true; } if (now > last_send + TIMEOUT_INTERVAL) { LogPrint(BCLog::NET, "socket sending timeout: %is peer=%d\n", count_seconds(now - last_send), node.GetId()); return true; } if (now > last_recv + TIMEOUT_INTERVAL) { LogPrint(BCLog::NET, "socket receive timeout: %is peer=%d\n", count_seconds(now - last_recv), node.GetId()); return true; } if (!node.fSuccessfullyConnected) { LogPrint(BCLog::NET, "version handshake timeout peer=%d\n", node.GetId()); return true; } return false; } bool CConnman::GenerateSelectSet(std::set &recv_set, std::set &send_set, std::set &error_set) { for (const ListenSocket &hListenSocket : vhListenSocket) { recv_set.insert(hListenSocket.socket); } { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { // Implement the following logic: // * If there is data to send, select() for sending data. As this // only happens when optimistic write failed, we choose to first // drain the write buffer in this case before receiving more. This // avoids needlessly queueing received data, if the remote peer is // not themselves receiving data. This means properly utilizing // TCP flow control signalling. // * Otherwise, if there is space left in the receive buffer, // select() for receiving data. // * Hand off all complete messages to the processor, to be handled // without blocking here. bool select_recv = !pnode->fPauseRecv; bool select_send; { LOCK(pnode->cs_vSend); select_send = !pnode->vSendMsg.empty(); } LOCK(pnode->cs_hSocket); if (pnode->hSocket == INVALID_SOCKET) { continue; } error_set.insert(pnode->hSocket); if (select_send) { send_set.insert(pnode->hSocket); continue; } if (select_recv) { recv_set.insert(pnode->hSocket); } } } return !recv_set.empty() || !send_set.empty() || !error_set.empty(); } #ifdef USE_POLL void CConnman::SocketEvents(std::set &recv_set, std::set &send_set, std::set &error_set) { std::set recv_select_set, send_select_set, error_select_set; if (!GenerateSelectSet(recv_select_set, send_select_set, error_select_set)) { interruptNet.sleep_for( std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS)); return; } std::unordered_map pollfds; for (SOCKET socket_id : recv_select_set) { pollfds[socket_id].fd = socket_id; pollfds[socket_id].events |= POLLIN; } for (SOCKET socket_id : send_select_set) { pollfds[socket_id].fd = socket_id; pollfds[socket_id].events |= POLLOUT; } for (SOCKET socket_id : error_select_set) { pollfds[socket_id].fd = socket_id; // These flags are ignored, but we set them for clarity pollfds[socket_id].events |= POLLERR | POLLHUP; } std::vector vpollfds; vpollfds.reserve(pollfds.size()); for (auto it : pollfds) { vpollfds.push_back(std::move(it.second)); } if (poll(vpollfds.data(), vpollfds.size(), SELECT_TIMEOUT_MILLISECONDS) < 0) { return; } if (interruptNet) { return; } for (struct pollfd pollfd_entry : vpollfds) { if (pollfd_entry.revents & POLLIN) { recv_set.insert(pollfd_entry.fd); } if (pollfd_entry.revents & POLLOUT) { send_set.insert(pollfd_entry.fd); } if (pollfd_entry.revents & (POLLERR | POLLHUP)) { error_set.insert(pollfd_entry.fd); } } } #else void CConnman::SocketEvents(std::set &recv_set, std::set &send_set, std::set &error_set) { std::set recv_select_set, send_select_set, error_select_set; if (!GenerateSelectSet(recv_select_set, send_select_set, error_select_set)) { interruptNet.sleep_for( std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS)); return; } // // Find which sockets have data to receive // struct timeval timeout; timeout.tv_sec = 0; // frequency to poll pnode->vSend timeout.tv_usec = SELECT_TIMEOUT_MILLISECONDS * 1000; fd_set fdsetRecv; fd_set fdsetSend; fd_set fdsetError; FD_ZERO(&fdsetRecv); FD_ZERO(&fdsetSend); FD_ZERO(&fdsetError); SOCKET hSocketMax = 0; for (SOCKET hSocket : recv_select_set) { FD_SET(hSocket, &fdsetRecv); hSocketMax = std::max(hSocketMax, hSocket); } for (SOCKET hSocket : send_select_set) { FD_SET(hSocket, &fdsetSend); hSocketMax = std::max(hSocketMax, hSocket); } for (SOCKET hSocket : error_select_set) { FD_SET(hSocket, &fdsetError); hSocketMax = std::max(hSocketMax, hSocket); } int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout); if (interruptNet) { return; } if (nSelect == SOCKET_ERROR) { int nErr = WSAGetLastError(); LogPrintf("socket select error %s\n", NetworkErrorString(nErr)); for (unsigned int i = 0; i <= hSocketMax; i++) { FD_SET(i, &fdsetRecv); } FD_ZERO(&fdsetSend); FD_ZERO(&fdsetError); if (!interruptNet.sleep_for( std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS))) { return; } } for (SOCKET hSocket : recv_select_set) { if (FD_ISSET(hSocket, &fdsetRecv)) { recv_set.insert(hSocket); } } for (SOCKET hSocket : send_select_set) { if (FD_ISSET(hSocket, &fdsetSend)) { send_set.insert(hSocket); } } for (SOCKET hSocket : error_select_set) { if (FD_ISSET(hSocket, &fdsetError)) { error_set.insert(hSocket); } } } #endif void CConnman::SocketHandler() { std::set recv_set, send_set, error_set; SocketEvents(recv_set, send_set, error_set); if (interruptNet) { return; } // // Accept new connections // for (const ListenSocket &hListenSocket : vhListenSocket) { if (hListenSocket.socket != INVALID_SOCKET && recv_set.count(hListenSocket.socket) > 0) { AcceptConnection(hListenSocket); } } // // Service each socket // std::vector vNodesCopy; { LOCK(cs_vNodes); vNodesCopy = vNodes; for (CNode *pnode : vNodesCopy) { pnode->AddRef(); } } for (CNode *pnode : vNodesCopy) { if (interruptNet) { return; } // // Receive // bool recvSet = false; bool sendSet = false; bool errorSet = false; { LOCK(pnode->cs_hSocket); if (pnode->hSocket == INVALID_SOCKET) { continue; } recvSet = recv_set.count(pnode->hSocket) > 0; sendSet = send_set.count(pnode->hSocket) > 0; errorSet = error_set.count(pnode->hSocket) > 0; } if (recvSet || errorSet) { // typical socket buffer is 8K-64K uint8_t pchBuf[0x10000]; int32_t nBytes = 0; { LOCK(pnode->cs_hSocket); if (pnode->hSocket == INVALID_SOCKET) { continue; } nBytes = recv(pnode->hSocket, (char *)pchBuf, sizeof(pchBuf), MSG_DONTWAIT); } if (nBytes > 0) { bool notify = false; if (!pnode->ReceiveMsgBytes( *config, Span(pchBuf, nBytes), notify)) { pnode->CloseSocketDisconnect(); } RecordBytesRecv(nBytes); if (notify) { size_t nSizeAdded = 0; auto it(pnode->vRecvMsg.begin()); for (; it != pnode->vRecvMsg.end(); ++it) { // vRecvMsg contains only completed CNetMessage // the single possible partially deserialized message // are held by TransportDeserializer nSizeAdded += it->m_raw_message_size; } { LOCK(pnode->cs_vProcessMsg); pnode->vProcessMsg.splice(pnode->vProcessMsg.end(), pnode->vRecvMsg, pnode->vRecvMsg.begin(), it); pnode->nProcessQueueSize += nSizeAdded; pnode->fPauseRecv = pnode->nProcessQueueSize > nReceiveFloodSize; } WakeMessageHandler(); } } else if (nBytes == 0) { // socket closed gracefully if (!pnode->fDisconnect) { LogPrint(BCLog::NET, "socket closed for peer=%d\n", pnode->GetId()); } pnode->CloseSocketDisconnect(); } else if (nBytes < 0) { // error int nErr = WSAGetLastError(); if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) { if (!pnode->fDisconnect) { LogPrint(BCLog::NET, "socket recv error for peer=%d: %s\n", pnode->GetId(), NetworkErrorString(nErr)); } pnode->CloseSocketDisconnect(); } } } // // Send // if (sendSet) { LOCK(pnode->cs_vSend); size_t nBytes = SocketSendData(*pnode); if (nBytes) { RecordBytesSent(nBytes); } } if (InactivityCheck(*pnode)) { pnode->fDisconnect = true; } } { LOCK(cs_vNodes); for (CNode *pnode : vNodesCopy) { pnode->Release(); } } } void CConnman::ThreadSocketHandler() { while (!interruptNet) { DisconnectNodes(); NotifyNumConnectionsChanged(); SocketHandler(); } } void CConnman::WakeMessageHandler() { { LOCK(mutexMsgProc); fMsgProcWake = true; } condMsgProc.notify_one(); } void CConnman::ThreadDNSAddressSeed() { FastRandomContext rng; std::vector seeds = GetRandomizedDNSSeeds(config->GetChainParams()); // Number of seeds left before testing if we have enough connections int seeds_right_now = 0; int found = 0; if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) { // When -forcednsseed is provided, query all. seeds_right_now = seeds.size(); } else if (addrman.size() == 0) { // If we have no known peers, query all. // This will occur on the first run, or if peers.dat has been // deleted. seeds_right_now = seeds.size(); } // goal: only query DNS seed if address need is acute // * If we have a reasonable number of peers in addrman, spend // some time trying them first. This improves user privacy by // creating fewer identifying DNS requests, reduces trust by // giving seeds less influence on the network topology, and // reduces traffic to the seeds. // * When querying DNS seeds query a few at once, this ensures // that we don't give DNS seeds the ability to eclipse nodes // that query them. // * If we continue having problems, eventually query all the // DNS seeds, and if that fails too, also try the fixed seeds. // (done in ThreadOpenConnections) const std::chrono::seconds seeds_wait_time = (addrman.size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS); for (const std::string &seed : seeds) { if (seeds_right_now == 0) { seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE; if (addrman.size() > 0) { LogPrintf("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count()); std::chrono::seconds to_wait = seeds_wait_time; while (to_wait.count() > 0) { // if sleeping for the MANY_PEERS interval, wake up // early to see if we have enough peers and can stop // this thread entirely freeing up its resources std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait); if (!interruptNet.sleep_for(w)) { return; } to_wait -= w; int nRelevant = 0; { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) { ++nRelevant; } } } if (nRelevant >= 2) { if (found > 0) { LogPrintf("%d addresses found from DNS seeds\n", found); LogPrintf( "P2P peers available. Finished DNS seeding.\n"); } else { LogPrintf( "P2P peers available. Skipped DNS seeding.\n"); } return; } } } } if (interruptNet) { return; } // hold off on querying seeds if P2P network deactivated if (!fNetworkActive) { LogPrintf("Waiting for network to be reactivated before querying " "DNS seeds.\n"); do { if (!interruptNet.sleep_for(std::chrono::seconds{1})) { return; } } while (!fNetworkActive); } LogPrintf("Loading addresses from DNS seed %s\n", seed); if (HaveNameProxy()) { AddAddrFetch(seed); } else { std::vector vIPs; std::vector vAdd; ServiceFlags requiredServiceBits = GetDesirableServiceFlags(NODE_NONE); std::string host = strprintf("x%x.%s", requiredServiceBits, seed); CNetAddr resolveSource; if (!resolveSource.SetInternal(host)) { continue; } // Limits number of IPs learned from a DNS seed unsigned int nMaxIPs = 256; if (LookupHost(host, vIPs, nMaxIPs, true)) { for (const CNetAddr &ip : vIPs) { int nOneDay = 24 * 3600; CAddress addr = CAddress( CService(ip, config->GetChainParams().GetDefaultPort()), requiredServiceBits); // Use a random age between 3 and 7 days old. addr.nTime = GetTime() - 3 * nOneDay - rng.randrange(4 * nOneDay); vAdd.push_back(addr); found++; } addrman.Add(vAdd, resolveSource); } else { // We now avoid directly using results from DNS Seeds which do // not support service bit filtering, instead using them as a // addrfetch to get nodes with our desired service bits. AddAddrFetch(seed); } } --seeds_right_now; } LogPrintf("%d addresses found from DNS seeds\n", found); } void CConnman::DumpAddresses() { int64_t nStart = GetTimeMillis(); DumpPeerAddresses(config->GetChainParams(), ::gArgs, addrman); LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat %dms\n", addrman.size(), GetTimeMillis() - nStart); } void CConnman::ProcessAddrFetch() { std::string strDest; { LOCK(m_addr_fetches_mutex); if (m_addr_fetches.empty()) { return; } strDest = m_addr_fetches.front(); m_addr_fetches.pop_front(); } CAddress addr; CSemaphoreGrant grant(*semOutbound, true); if (grant) { OpenNetworkConnection(addr, false, &grant, strDest.c_str(), ConnectionType::ADDR_FETCH); } } bool CConnman::GetTryNewOutboundPeer() { return m_try_another_outbound_peer; } void CConnman::SetTryNewOutboundPeer(bool flag) { m_try_another_outbound_peer = flag; LogPrint(BCLog::NET, "net: setting try another outbound peer=%s\n", flag ? "true" : "false"); } // Return the number of peers we have over our outbound connection limit. // Exclude peers that are marked for disconnect, or are going to be disconnected // soon (eg ADDR_FETCH and FEELER). // Also exclude peers that haven't finished initial connection handshake yet (so // that we don't decide we're over our desired connection limit, and then evict // some peer that has finished the handshake). int CConnman::GetExtraFullOutboundCount() { int full_outbound_peers = 0; { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) { ++full_outbound_peers; } } } return std::max(full_outbound_peers - m_max_outbound_full_relay - m_max_avalanche_outbound, 0); } int CConnman::GetExtraBlockRelayCount() { int block_relay_peers = 0; { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsBlockOnlyConn()) { ++block_relay_peers; } } } return std::max(block_relay_peers - m_max_outbound_block_relay, 0); } void CConnman::ThreadOpenConnections( const std::vector connect, std::function mockOpenConnection) { // Connect to specific addresses if (!connect.empty()) { for (int64_t nLoop = 0;; nLoop++) { ProcessAddrFetch(); for (const std::string &strAddr : connect) { CAddress addr(CService(), NODE_NONE); OpenNetworkConnection(addr, false, nullptr, strAddr.c_str(), ConnectionType::MANUAL); for (int i = 0; i < 10 && i < nLoop; i++) { if (!interruptNet.sleep_for( std::chrono::milliseconds(500))) { return; } } } if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) { return; } } } // Initiate network connections auto start = GetTime(); // Minimum time before next feeler connection (in microseconds). auto next_feeler = PoissonNextSend(start, FEELER_INTERVAL); auto next_extra_block_relay = PoissonNextSend(start, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL); const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED); bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS); if (!add_fixed_seeds) { LogPrintf("Fixed seeds are disabled\n"); } while (!interruptNet) { ProcessAddrFetch(); // No need to sleep the thread if we are mocking the network connection if (!mockOpenConnection && !interruptNet.sleep_for(std::chrono::milliseconds(500))) { return; } CSemaphoreGrant grant(*semOutbound); if (interruptNet) { return; } if (add_fixed_seeds && addrman.size() == 0) { // When the node starts with an empty peers.dat, there are a few // other sources of peers before we fallback on to fixed seeds: // -dnsseed, -seednode, -addnode If none of those are available, we // fallback on to fixed seeds immediately, else we allow 60 seconds // for any of those sources to populate addrman. bool add_fixed_seeds_now = false; // It is cheapest to check if enough time has passed first. if (GetTime() > start + std::chrono::minutes{1}) { add_fixed_seeds_now = true; LogPrintf("Adding fixed seeds as 60 seconds have passed and " "addrman is empty\n"); } // Checking !dnsseed is cheaper before locking 2 mutexes. if (!add_fixed_seeds_now && !dnsseed) { LOCK2(m_addr_fetches_mutex, cs_vAddedNodes); if (m_addr_fetches.empty() && vAddedNodes.empty()) { add_fixed_seeds_now = true; LogPrintf( "Adding fixed seeds as -dnsseed=0, -addnode is not " "provided and all -seednode(s) attempted\n"); } } if (add_fixed_seeds_now) { CNetAddr local; local.SetInternal("fixedseeds"); addrman.Add(convertSeed6(config->GetChainParams().FixedSeeds()), local); add_fixed_seeds = false; } } // // Choose an address to connect to based on most recently seen // CAddress addrConnect; // Only connect out to one peer per network group (/16 for IPv4). int nOutboundFullRelay = 0; int nOutboundBlockRelay = 0; int nOutboundAvalanche = 0; std::set> setConnected; { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->IsAvalancheOutboundConnection()) { nOutboundAvalanche++; } else if (pnode->IsFullOutboundConn()) { nOutboundFullRelay++; } else if (pnode->IsBlockOnlyConn()) { nOutboundBlockRelay++; } // Netgroups for inbound and manual peers are not excluded // because our goal here is to not use multiple of our // limited outbound slots on a single netgroup but inbound // and manual peers do not use our outbound slots. Inbound // peers also have the added issue that they could be attacker // controlled and could be used to prevent us from connecting // to particular hosts if we used them here. switch (pnode->m_conn_type) { case ConnectionType::INBOUND: case ConnectionType::MANUAL: break; case ConnectionType::AVALANCHE_OUTBOUND: case ConnectionType::OUTBOUND_FULL_RELAY: case ConnectionType::BLOCK_RELAY: case ConnectionType::ADDR_FETCH: case ConnectionType::FEELER: setConnected.insert( pnode->addr.GetGroup(addrman.GetAsmap())); } // no default case, so the compiler can warn about missing // cases } } ConnectionType conn_type = ConnectionType::OUTBOUND_FULL_RELAY; auto now = GetTime(); bool anchor = false; bool fFeeler = false; // Determine what type of connection to open. Opening // BLOCK_RELAY connections to addresses from anchors.dat gets the // highest priority. Then we open AVALANCHE_OUTBOUND connection until we // hit our avalanche outbound peer limit, which is 0 if avalanche is not // enabled. We fallback after 50 retries to OUTBOUND_FULL_RELAY if the // peer is not avalanche capable until we meet our full-relay capacity. // Then we open BLOCK_RELAY connection until we hit our block-relay-only // peer limit. // GetTryNewOutboundPeer() gets set when a stale tip is detected, so we // try opening an additional OUTBOUND_FULL_RELAY connection. If none of // these conditions are met, check to see if it's time to try an extra // block-relay-only peer (to confirm our tip is current, see below) or // the next_feeler timer to decide if we should open a FEELER. if (!m_anchors.empty() && (nOutboundBlockRelay < m_max_outbound_block_relay)) { conn_type = ConnectionType::BLOCK_RELAY; anchor = true; } else if (g_avalanche && (nOutboundAvalanche < m_max_avalanche_outbound)) { conn_type = ConnectionType::AVALANCHE_OUTBOUND; } else if (nOutboundFullRelay < m_max_outbound_full_relay) { // OUTBOUND_FULL_RELAY } else if (nOutboundBlockRelay < m_max_outbound_block_relay) { conn_type = ConnectionType::BLOCK_RELAY; } else if (GetTryNewOutboundPeer()) { // OUTBOUND_FULL_RELAY } else if (now > next_extra_block_relay && m_start_extra_block_relay_peers) { // Periodically connect to a peer (using regular outbound selection // methodology from addrman) and stay connected long enough to sync // headers, but not much else. // // Then disconnect the peer, if we haven't learned anything new. // // The idea is to make eclipse attacks very difficult to pull off, // because every few minutes we're finding a new peer to learn // headers from. // // This is similar to the logic for trying extra outbound // (full-relay) peers, except: // - we do this all the time on a poisson timer, rather than just // when our tip is stale // - we potentially disconnect our next-youngest block-relay-only // peer, if our newest block-relay-only peer delivers a block more // recently. // See the eviction logic in net_processing.cpp. // // Because we can promote these connections to block-relay-only // connections, they do not get their own ConnectionType enum // (similar to how we deal with extra outbound peers). next_extra_block_relay = PoissonNextSend(now, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL); conn_type = ConnectionType::BLOCK_RELAY; } else if (now > next_feeler) { next_feeler = PoissonNextSend(now, FEELER_INTERVAL); conn_type = ConnectionType::FEELER; fFeeler = true; } else { // skip to next iteration of while loop continue; } addrman.ResolveCollisions(); int64_t nANow = GetAdjustedTime(); int nTries = 0; while (!interruptNet) { if (anchor && !m_anchors.empty()) { const CAddress addr = m_anchors.back(); m_anchors.pop_back(); if (!addr.IsValid() || IsLocal(addr) || !IsReachable(addr) || !HasAllDesirableServiceFlags(addr.nServices) || setConnected.count(addr.GetGroup(addrman.GetAsmap()))) { continue; } addrConnect = addr; LogPrint(BCLog::NET, "Trying to make an anchor connection to %s\n", addrConnect.ToString()); break; } // If we didn't find an appropriate destination after trying 100 // addresses fetched from addrman, stop this loop, and let the outer // loop run again (which sleeps, adds seed nodes, recalculates // already-connected network ranges, ...) before trying new addrman // addresses. nTries++; if (nTries > 100) { break; } CAddress addr; int64_t addr_last_try{0}; if (fFeeler) { // First, try to get a tried table collision address. This // returns an empty (invalid) address if there are no collisions // to try. std::tie(addr, addr_last_try) = addrman.SelectTriedCollision(); if (!addr.IsValid()) { // No tried table collisions. Select a new table address // for our feeler. std::tie(addr, addr_last_try) = addrman.Select(true); } else if (AlreadyConnectedToAddress(addr)) { // If test-before-evict logic would have us connect to a // peer that we're already connected to, just mark that // address as Good(). We won't be able to initiate the // connection anyway, so this avoids inadvertently evicting // a currently-connected peer. addrman.Good(addr); // Select a new table address for our feeler instead. std::tie(addr, addr_last_try) = addrman.Select(true); } } else { // Not a feeler std::tie(addr, addr_last_try) = addrman.Select(); } // Require outbound connections, other than feelers and avalanche, // to be to distinct network groups if (!fFeeler && conn_type != ConnectionType::AVALANCHE_OUTBOUND && setConnected.count(addr.GetGroup(addrman.GetAsmap()))) { break; } // if we selected an invalid or local address, restart if (!addr.IsValid() || IsLocal(addr)) { break; } if (!IsReachable(addr)) { continue; } // only consider very recently tried nodes after 30 failed attempts if (nANow - addr_last_try < 600 && nTries < 30) { continue; } // for non-feelers, require all the services we'll want, // for feelers, only require they be a full node (only because most // SPV clients don't have a good address DB available) if (!fFeeler && !HasAllDesirableServiceFlags(addr.nServices)) { continue; } if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) { continue; } // Do not connect to bad ports, unless 50 invalid addresses have // been selected already. if (nTries < 50 && (addr.IsIPv4() || addr.IsIPv6()) && IsBadPort(addr.GetPort())) { continue; } // For avalanche peers, check they have the avalanche service bit // set. if (conn_type == ConnectionType::AVALANCHE_OUTBOUND && !(addr.nServices & NODE_AVALANCHE)) { // If this peer is not suitable as an avalanche one and we tried // over 50 addresses already, see if we can fallback to a non // avalanche full outbound. if (nTries < 50 || nOutboundFullRelay >= m_max_outbound_full_relay || setConnected.count(addr.GetGroup(addrman.GetAsmap()))) { // Fallback is not desirable or possible, try another one continue; } // Fallback is possible, update the connection type accordingly conn_type = ConnectionType::OUTBOUND_FULL_RELAY; } addrConnect = addr; break; } if (addrConnect.IsValid()) { if (fFeeler) { // Add small amount of random noise before connection to avoid // synchronization. int randsleep = GetRandInt(FEELER_SLEEP_WINDOW * 1000); if (!interruptNet.sleep_for( std::chrono::milliseconds(randsleep))) { return; } LogPrint(BCLog::NET, "Making feeler connection to %s\n", addrConnect.ToString()); } // This mock is for testing purpose only. It prevents the thread // from attempting the connection which is useful for testing. if (mockOpenConnection) { mockOpenConnection(addrConnect, conn_type); } else { OpenNetworkConnection(addrConnect, int(setConnected.size()) >= std::min(nMaxConnections - 1, 2), &grant, nullptr, conn_type); } } } } std::vector CConnman::GetCurrentBlockRelayOnlyConns() const { std::vector ret; LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->IsBlockOnlyConn()) { ret.push_back(pnode->addr); } } return ret; } std::vector CConnman::GetAddedNodeInfo() { std::vector ret; std::list lAddresses(0); { LOCK(cs_vAddedNodes); ret.reserve(vAddedNodes.size()); std::copy(vAddedNodes.cbegin(), vAddedNodes.cend(), std::back_inserter(lAddresses)); } // Build a map of all already connected addresses (by IP:port and by name) // to inbound/outbound and resolved CService std::map mapConnected; std::map> mapConnectedByName; { LOCK(cs_vNodes); for (const CNode *pnode : vNodes) { if (pnode->addr.IsValid()) { mapConnected[pnode->addr] = pnode->IsInboundConn(); } - std::string addrName = pnode->GetAddrName(); + std::string addrName{pnode->m_addr_name}; if (!addrName.empty()) { mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(), static_cast(pnode->addr)); } } } for (const std::string &strAddNode : lAddresses) { CService service( LookupNumeric(strAddNode, Params().GetDefaultPort(strAddNode))); AddedNodeInfo addedNode{strAddNode, CService(), false, false}; if (service.IsValid()) { // strAddNode is an IP:port auto it = mapConnected.find(service); if (it != mapConnected.end()) { addedNode.resolvedAddress = service; addedNode.fConnected = true; addedNode.fInbound = it->second; } } else { // strAddNode is a name auto it = mapConnectedByName.find(strAddNode); if (it != mapConnectedByName.end()) { addedNode.resolvedAddress = it->second.second; addedNode.fConnected = true; addedNode.fInbound = it->second.first; } } ret.emplace_back(std::move(addedNode)); } return ret; } void CConnman::ThreadOpenAddedConnections() { while (true) { CSemaphoreGrant grant(*semAddnode); std::vector vInfo = GetAddedNodeInfo(); bool tried = false; for (const AddedNodeInfo &info : vInfo) { if (!info.fConnected) { if (!grant.TryAcquire()) { // If we've used up our semaphore and need a new one, let's // not wait here since while we are waiting the // addednodeinfo state might change. break; } tried = true; CAddress addr(CService(), NODE_NONE); OpenNetworkConnection(addr, false, &grant, info.strAddedNode.c_str(), ConnectionType::MANUAL); if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) { return; } } } // Retry every 60 seconds if a connection was attempted, otherwise two // seconds. if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2))) { return; } } } // If successful, this moves the passed grant to the constructed node. void CConnman::OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound, const char *pszDest, ConnectionType conn_type) { assert(conn_type != ConnectionType::INBOUND); // // Initiate outbound network connection // if (interruptNet) { return; } if (!fNetworkActive) { return; } if (!pszDest) { bool banned_or_discouraged = m_banman && (m_banman->IsDiscouraged(addrConnect) || m_banman->IsBanned(addrConnect)); if (IsLocal(addrConnect) || banned_or_discouraged || AlreadyConnectedToAddress(addrConnect)) { return; } } else if (FindNode(std::string(pszDest))) { return; } CNode *pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type); if (!pnode) { return; } if (grantOutbound) { grantOutbound->MoveTo(pnode->grantOutbound); } for (auto interface : m_msgproc) { interface->InitializeNode(*config, pnode); } { LOCK(cs_vNodes); vNodes.push_back(pnode); } } void CConnman::ThreadMessageHandler() { while (!flagInterruptMsgProc) { std::vector vNodesCopy; { LOCK(cs_vNodes); vNodesCopy = vNodes; for (CNode *pnode : vNodesCopy) { pnode->AddRef(); } } bool fMoreWork = false; for (CNode *pnode : vNodesCopy) { if (pnode->fDisconnect) { continue; } bool fMoreNodeWork = false; // Receive messages for (auto interface : m_msgproc) { fMoreNodeWork |= interface->ProcessMessages( *config, pnode, flagInterruptMsgProc); } fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend); if (flagInterruptMsgProc) { return; } // Send messages { LOCK(pnode->cs_sendProcessing); for (auto interface : m_msgproc) { interface->SendMessages(*config, pnode); } } if (flagInterruptMsgProc) { return; } } { LOCK(cs_vNodes); for (CNode *pnode : vNodesCopy) { pnode->Release(); } } WAIT_LOCK(mutexMsgProc, lock); if (!fMoreWork) { condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this]() EXCLUSIVE_LOCKS_REQUIRED( mutexMsgProc) { return fMsgProcWake; }); } fMsgProcWake = false; } } void CConnman::ThreadI2PAcceptIncoming() { static constexpr auto err_wait_begin = 1s; static constexpr auto err_wait_cap = 5min; auto err_wait = err_wait_begin; bool advertising_listen_addr = false; i2p::Connection conn; while (!interruptNet) { if (!m_i2p_sam_session->Listen(conn)) { if (advertising_listen_addr && conn.me.IsValid()) { RemoveLocal(conn.me); advertising_listen_addr = false; } interruptNet.sleep_for(err_wait); if (err_wait < err_wait_cap) { err_wait *= 2; } continue; } if (!advertising_listen_addr) { AddLocal(conn.me, LOCAL_MANUAL); advertising_listen_addr = true; } if (!m_i2p_sam_session->Accept(conn)) { continue; } CreateNodeFromAcceptedSocket( conn.sock->Release(), NetPermissionFlags::PF_NONE, CAddress{conn.me, NODE_NONE}, CAddress{conn.peer, NODE_NONE}); } } bool CConnman::BindListenPort(const CService &addrBind, bilingual_str &strError, NetPermissionFlags permissions) { int nOne = 1; // Create socket for listening for incoming connections struct sockaddr_storage sockaddr; socklen_t len = sizeof(sockaddr); if (!addrBind.GetSockAddr((struct sockaddr *)&sockaddr, &len)) { strError = strprintf( Untranslated("Error: Bind address family for %s not supported"), addrBind.ToString()); LogPrintf("%s\n", strError.original); return false; } std::unique_ptr sock = CreateSock(addrBind); if (!sock) { strError = strprintf(Untranslated("Error: Couldn't open socket for incoming " "connections (socket returned error %s)"), NetworkErrorString(WSAGetLastError())); LogPrintf("%s\n", strError.original); return false; } // Allow binding if the port is still in TIME_WAIT state after // the program was closed and restarted. setsockopt(sock->Get(), SOL_SOCKET, SO_REUSEADDR, (sockopt_arg_type)&nOne, sizeof(int)); // Some systems don't have IPV6_V6ONLY but are always v6only; others do have // the option and enable it by default or not. Try to enable it, if // possible. if (addrBind.IsIPv6()) { #ifdef IPV6_V6ONLY setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_V6ONLY, (sockopt_arg_type)&nOne, sizeof(int)); #endif #ifdef WIN32 int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED; setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, (sockopt_arg_type)&nProtLevel, sizeof(int)); #endif } if (::bind(sock->Get(), (struct sockaddr *)&sockaddr, len) == SOCKET_ERROR) { int nErr = WSAGetLastError(); if (nErr == WSAEADDRINUSE) { strError = strprintf(_("Unable to bind to %s on this computer. %s " "is probably already running."), addrBind.ToString(), PACKAGE_NAME); } else { strError = strprintf(_("Unable to bind to %s on this computer " "(bind returned error %s)"), addrBind.ToString(), NetworkErrorString(nErr)); } LogPrintf("%s\n", strError.original); return false; } LogPrintf("Bound to %s\n", addrBind.ToString()); // Listen for incoming connections if (listen(sock->Get(), SOMAXCONN) == SOCKET_ERROR) { strError = strprintf(_("Error: Listening for incoming connections " "failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError())); LogPrintf("%s\n", strError.original); return false; } vhListenSocket.push_back(ListenSocket(sock->Release(), permissions)); return true; } void Discover() { if (!fDiscover) { return; } #ifdef WIN32 // Get local host IP char pszHostName[256] = ""; if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR) { std::vector vaddr; if (LookupHost(pszHostName, vaddr, 0, true)) { for (const CNetAddr &addr : vaddr) { if (AddLocal(addr, LOCAL_IF)) { LogPrintf("%s: %s - %s\n", __func__, pszHostName, addr.ToString()); } } } } #elif (HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS) // Get local host ip struct ifaddrs *myaddrs; if (getifaddrs(&myaddrs) == 0) { for (struct ifaddrs *ifa = myaddrs; ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr || (ifa->ifa_flags & IFF_UP) == 0 || strcmp(ifa->ifa_name, "lo") == 0 || strcmp(ifa->ifa_name, "lo0") == 0) { continue; } if (ifa->ifa_addr->sa_family == AF_INET) { struct sockaddr_in *s4 = reinterpret_cast(ifa->ifa_addr); CNetAddr addr(s4->sin_addr); if (AddLocal(addr, LOCAL_IF)) { LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name, addr.ToString()); } } else if (ifa->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6 *s6 = reinterpret_cast(ifa->ifa_addr); CNetAddr addr(s6->sin6_addr); if (AddLocal(addr, LOCAL_IF)) { LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name, addr.ToString()); } } } freeifaddrs(myaddrs); } #endif } void CConnman::SetNetworkActive(bool active) { LogPrintf("%s: %s\n", __func__, active); if (fNetworkActive == active) { return; } fNetworkActive = active; uiInterface.NotifyNetworkActiveChanged(fNetworkActive); } CConnman::CConnman(const Config &configIn, uint64_t nSeed0In, uint64_t nSeed1In, AddrMan &addrmanIn, bool network_active) : config(&configIn), addrman(addrmanIn), nSeed0(nSeed0In), nSeed1(nSeed1In) { SetTryNewOutboundPeer(false); Options connOptions; Init(connOptions); SetNetworkActive(network_active); } NodeId CConnman::GetNewNodeId() { return nLastNodeId.fetch_add(1); } bool CConnman::Bind(const CService &addr, unsigned int flags, NetPermissionFlags permissions) { if (!(flags & BF_EXPLICIT) && !IsReachable(addr)) { return false; } bilingual_str strError; if (!BindListenPort(addr, strError, permissions)) { if ((flags & BF_REPORT_ERROR) && clientInterface) { clientInterface->ThreadSafeMessageBox( strError, "", CClientUIInterface::MSG_ERROR); } return false; } if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) && !(permissions & PF_NOBAN)) { AddLocal(addr, LOCAL_BIND); } return true; } bool CConnman::InitBinds(const Options &options) { bool fBound = false; for (const auto &addrBind : options.vBinds) { fBound |= Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR), NetPermissionFlags::PF_NONE); } for (const auto &addrBind : options.vWhiteBinds) { fBound |= Bind(addrBind.m_service, (BF_EXPLICIT | BF_REPORT_ERROR), addrBind.m_flags); } for (const auto &addr_bind : options.onion_binds) { fBound |= Bind(addr_bind, BF_EXPLICIT | BF_DONT_ADVERTISE, NetPermissionFlags::PF_NONE); } if (options.bind_on_any) { struct in_addr inaddr_any; inaddr_any.s_addr = htonl(INADDR_ANY); struct in6_addr inaddr6_any = IN6ADDR_ANY_INIT; fBound |= Bind(CService(inaddr6_any, GetListenPort()), BF_NONE, NetPermissionFlags::PF_NONE); fBound |= Bind(CService(inaddr_any, GetListenPort()), !fBound ? BF_REPORT_ERROR : BF_NONE, NetPermissionFlags::PF_NONE); } return fBound; } bool CConnman::Start(CScheduler &scheduler, const Options &connOptions) { Init(connOptions); if (fListen && !InitBinds(connOptions)) { if (clientInterface) { clientInterface->ThreadSafeMessageBox( _("Failed to listen on any port. Use -listen=0 if you want " "this."), "", CClientUIInterface::MSG_ERROR); } return false; } proxyType i2p_sam; if (GetProxy(NET_I2P, i2p_sam)) { m_i2p_sam_session = std::make_unique( gArgs.GetDataDirNet() / "i2p_private_key", i2p_sam.proxy, &interruptNet); } for (const auto &strDest : connOptions.vSeedNodes) { AddAddrFetch(strDest); } if (m_use_addrman_outgoing) { // Load addresses from anchors.dat m_anchors = ReadAnchors(config->GetChainParams(), gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME); if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) { m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS); } LogPrintf( "%i block-relay-only anchors will be tried for connections.\n", m_anchors.size()); } uiInterface.InitMessage(_("Starting network threads...").translated); fAddressesInitialized = true; if (semOutbound == nullptr) { // initialize semaphore semOutbound = std::make_unique( std::min(m_max_outbound, nMaxConnections)); } if (semAddnode == nullptr) { // initialize semaphore semAddnode = std::make_unique(nMaxAddnode); } // // Start threads // assert(m_msgproc.size() > 0); InterruptSocks5(false); interruptNet.reset(); flagInterruptMsgProc = false; { LOCK(mutexMsgProc); fMsgProcWake = false; } // Send and receive from sockets, accept connections threadSocketHandler = std::thread(&util::TraceThread, "net", [this] { ThreadSocketHandler(); }); if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)) { LogPrintf("DNS seeding disabled\n"); } else { threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed", [this] { ThreadDNSAddressSeed(); }); } // Initiate manual connections threadOpenAddedConnections = std::thread( &util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); }); if (connOptions.m_use_addrman_outgoing && !connOptions.m_specified_outgoing.empty()) { if (clientInterface) { clientInterface->ThreadSafeMessageBox( _("Cannot provide specific connections and have addrman find " "outgoing connections at the same."), "", CClientUIInterface::MSG_ERROR); } return false; } if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty()) { threadOpenConnections = std::thread(&util::TraceThread, "opencon", [this, connect = connOptions.m_specified_outgoing] { ThreadOpenConnections(connect, nullptr); }); } // Process messages threadMessageHandler = std::thread(&util::TraceThread, "msghand", [this] { ThreadMessageHandler(); }); if (connOptions.m_i2p_accept_incoming && m_i2p_sam_session.get() != nullptr) { threadI2PAcceptIncoming = std::thread(&util::TraceThread, "i2paccept", [this] { ThreadI2PAcceptIncoming(); }); } // Dump network addresses scheduler.scheduleEvery( [this]() { this->DumpAddresses(); return true; }, DUMP_PEERS_INTERVAL); return true; } class CNetCleanup { public: CNetCleanup() {} ~CNetCleanup() { #ifdef WIN32 // Shutdown Windows Sockets WSACleanup(); #endif } }; static CNetCleanup instance_of_cnetcleanup; void CConnman::Interrupt() { { LOCK(mutexMsgProc); flagInterruptMsgProc = true; } condMsgProc.notify_all(); interruptNet(); InterruptSocks5(true); if (semOutbound) { for (int i = 0; i < m_max_outbound; i++) { semOutbound->post(); } } if (semAddnode) { for (int i = 0; i < nMaxAddnode; i++) { semAddnode->post(); } } } void CConnman::StopThreads() { if (threadI2PAcceptIncoming.joinable()) { threadI2PAcceptIncoming.join(); } if (threadMessageHandler.joinable()) { threadMessageHandler.join(); } if (threadOpenConnections.joinable()) { threadOpenConnections.join(); } if (threadOpenAddedConnections.joinable()) { threadOpenAddedConnections.join(); } if (threadDNSAddressSeed.joinable()) { threadDNSAddressSeed.join(); } if (threadSocketHandler.joinable()) { threadSocketHandler.join(); } } void CConnman::StopNodes() { if (fAddressesInitialized) { DumpAddresses(); fAddressesInitialized = false; if (m_use_addrman_outgoing) { // Anchor connections are only dumped during clean shutdown. std::vector anchors_to_dump = GetCurrentBlockRelayOnlyConns(); if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) { anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS); } DumpAnchors(config->GetChainParams(), gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump); } } // Delete peer connections. std::vector nodes; WITH_LOCK(cs_vNodes, nodes.swap(vNodes)); for (CNode *pnode : nodes) { pnode->CloseSocketDisconnect(); DeleteNode(pnode); } // Close listening sockets. for (ListenSocket &hListenSocket : vhListenSocket) { if (hListenSocket.socket != INVALID_SOCKET) { if (!CloseSocket(hListenSocket.socket)) { LogPrintf("CloseSocket(hListenSocket) failed with error %s\n", NetworkErrorString(WSAGetLastError())); } } } for (CNode *pnode : vNodesDisconnected) { DeleteNode(pnode); } vNodesDisconnected.clear(); vhListenSocket.clear(); semOutbound.reset(); semAddnode.reset(); } void CConnman::DeleteNode(CNode *pnode) { assert(pnode); for (auto interface : m_msgproc) { interface->FinalizeNode(*config, *pnode); } delete pnode; } CConnman::~CConnman() { Interrupt(); Stop(); } std::vector CConnman::GetAddresses(size_t max_addresses, size_t max_pct, std::optional network) { std::vector addresses = addrman.GetAddr(max_addresses, max_pct, network); if (m_banman) { addresses.erase(std::remove_if(addresses.begin(), addresses.end(), [this](const CAddress &addr) { return m_banman->IsDiscouraged( addr) || m_banman->IsBanned(addr); }), addresses.end()); } return addresses; } std::vector CConnman::GetAddresses(CNode &requestor, size_t max_addresses, size_t max_pct) { auto local_socket_bytes = requestor.addrBind.GetAddrBytes(); uint64_t cache_id = GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE) .Write(requestor.addr.GetNetwork()) .Write(local_socket_bytes.data(), local_socket_bytes.size()) .Finalize(); const auto current_time = GetTime(); auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{}); CachedAddrResponse &cache_entry = r.first->second; // New CachedAddrResponse have expiration 0. if (cache_entry.m_cache_entry_expiration < current_time) { cache_entry.m_addrs_response_cache = GetAddresses(max_addresses, max_pct, /* network */ std::nullopt); // Choosing a proper cache lifetime is a trade-off between the privacy // leak minimization and the usefulness of ADDR responses to honest // users. // // Longer cache lifetime makes it more difficult for an attacker to // scrape enough AddrMan data to maliciously infer something useful. By // the time an attacker scraped enough AddrMan records, most of the // records should be old enough to not leak topology info by e.g. // analyzing real-time changes in timestamps. // // It takes only several hundred requests to scrape everything from an // AddrMan containing 100,000 nodes, so ~24 hours of cache lifetime // indeed makes the data less inferable by the time most of it could be // scraped (considering that timestamps are updated via ADDR // self-announcements and when nodes communicate). We also should be // robust to those attacks which may not require scraping *full* // victim's AddrMan (because even several timestamps of the same handful // of nodes may leak privacy). // // On the other hand, longer cache lifetime makes ADDR responses // outdated and less useful for an honest requestor, e.g. if most nodes // in the ADDR response are no longer active. // // However, the churn in the network is known to be rather low. Since we // consider nodes to be "terrible" (see IsTerrible()) if the timestamps // are older than 30 days, max. 24 hours of "penalty" due to cache // shouldn't make any meaningful difference in terms of the freshness of // the response. cache_entry.m_cache_entry_expiration = current_time + std::chrono::hours(21) + GetRandMillis(std::chrono::hours(6)); } return cache_entry.m_addrs_response_cache; } bool CConnman::AddNode(const std::string &strNode) { LOCK(cs_vAddedNodes); for (const std::string &it : vAddedNodes) { if (strNode == it) { return false; } } vAddedNodes.push_back(strNode); return true; } bool CConnman::RemoveAddedNode(const std::string &strNode) { LOCK(cs_vAddedNodes); for (std::vector::iterator it = vAddedNodes.begin(); it != vAddedNodes.end(); ++it) { if (strNode == *it) { vAddedNodes.erase(it); return true; } } return false; } size_t CConnman::GetNodeCount(NumConnections flags) { LOCK(cs_vNodes); // Shortcut if we want total if (flags == CConnman::CONNECTIONS_ALL) { return vNodes.size(); } int nNum = 0; for (const auto &pnode : vNodes) { if (flags & (pnode->IsInboundConn() ? CONNECTIONS_IN : CONNECTIONS_OUT)) { nNum++; } } return nNum; } void CConnman::GetNodeStats(std::vector &vstats) { vstats.clear(); LOCK(cs_vNodes); vstats.reserve(vNodes.size()); for (CNode *pnode : vNodes) { vstats.emplace_back(); pnode->copyStats(vstats.back()); vstats.back().m_mapped_as = pnode->addr.GetMappedAS(addrman.GetAsmap()); } } bool CConnman::DisconnectNode(const std::string &strNode) { LOCK(cs_vNodes); if (CNode *pnode = FindNode(strNode)) { LogPrint(BCLog::NET, "disconnect by address%s matched peer=%d; disconnecting\n", (fLogIPs ? strprintf("=%s", strNode) : ""), pnode->GetId()); pnode->fDisconnect = true; return true; } return false; } bool CConnman::DisconnectNode(const CSubNet &subnet) { bool disconnected = false; LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (subnet.Match(pnode->addr)) { LogPrint(BCLog::NET, "disconnect by subnet%s matched peer=%d; disconnecting\n", (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""), pnode->GetId()); pnode->fDisconnect = true; disconnected = true; } } return disconnected; } bool CConnman::DisconnectNode(const CNetAddr &addr) { return DisconnectNode(CSubNet(addr)); } bool CConnman::DisconnectNode(NodeId id) { LOCK(cs_vNodes); for (CNode *pnode : vNodes) { if (id == pnode->GetId()) { LogPrint(BCLog::NET, "disconnect by id peer=%d; disconnecting\n", pnode->GetId()); pnode->fDisconnect = true; return true; } } return false; } void CConnman::RecordBytesRecv(uint64_t bytes) { LOCK(cs_totalBytesRecv); nTotalBytesRecv += bytes; } void CConnman::RecordBytesSent(uint64_t bytes) { LOCK(cs_totalBytesSent); nTotalBytesSent += bytes; const auto now = GetTime(); if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now) { // timeframe expired, reset cycle nMaxOutboundCycleStartTime = now; nMaxOutboundTotalBytesSentInCycle = 0; } // TODO, exclude peers with download permission nMaxOutboundTotalBytesSentInCycle += bytes; } uint64_t CConnman::GetMaxOutboundTarget() { LOCK(cs_totalBytesSent); return nMaxOutboundLimit; } std::chrono::seconds CConnman::GetMaxOutboundTimeframe() { return MAX_UPLOAD_TIMEFRAME; } std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle() { LOCK(cs_totalBytesSent); if (nMaxOutboundLimit == 0) { return 0s; } if (nMaxOutboundCycleStartTime.count() == 0) { return MAX_UPLOAD_TIMEFRAME; } const std::chrono::seconds cycleEndTime = nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME; const auto now = GetTime(); return (cycleEndTime < now) ? 0s : cycleEndTime - now; } bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) { LOCK(cs_totalBytesSent); if (nMaxOutboundLimit == 0) { return false; } if (historicalBlockServingLimit) { // keep a large enough buffer to at least relay each block once. const std::chrono::seconds timeLeftInCycle = GetMaxOutboundTimeLeftInCycle(); const uint64_t buffer = timeLeftInCycle / std::chrono::minutes{10} * ONE_MEGABYTE; if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer) { return true; } } else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) { return true; } return false; } uint64_t CConnman::GetOutboundTargetBytesLeft() { LOCK(cs_totalBytesSent); if (nMaxOutboundLimit == 0) { return 0; } return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle; } uint64_t CConnman::GetTotalBytesRecv() { LOCK(cs_totalBytesRecv); return nTotalBytesRecv; } uint64_t CConnman::GetTotalBytesSent() { LOCK(cs_totalBytesSent); return nTotalBytesSent; } ServiceFlags CConnman::GetLocalServices() const { return nLocalServices; } unsigned int CConnman::GetReceiveFloodSize() const { return nReceiveFloodSize; } void CNode::invsPolled(uint32_t count) { invCounters += count; } void CNode::invsVoted(uint32_t count) { invCounters += uint64_t(count) << 32; } void CNode::updateAvailabilityScore() { if (!m_avalanche_enabled) { return; } uint64_t windowInvCounters = invCounters.exchange(0); double previousScore = availabilityScore; int64_t polls = windowInvCounters & std::numeric_limits::max(); int64_t votes = windowInvCounters >> 32; availabilityScore = AVALANCHE_STATISTICS_DECAY_FACTOR * (2 * votes - polls) + (1. - AVALANCHE_STATISTICS_DECAY_FACTOR) * previousScore; } double CNode::getAvailabilityScore() const { // The score is set atomically so there is no need to lock the statistics // when reading. return availabilityScore; } CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, uint64_t nLocalExtraEntropyIn, const CAddress &addrBindIn, const std::string &addrNameIn, ConnectionType conn_type_in, bool inbound_onion) : m_connected(GetTime()), addr(addrIn), - addrBind(addrBindIn), m_inbound_onion(inbound_onion), - nKeyedNetGroup(nKeyedNetGroupIn), + addrBind(addrBindIn), m_addr_name{addrNameIn.empty() + ? addr.ToStringIPPort() + : addrNameIn}, + m_inbound_onion(inbound_onion), nKeyedNetGroup(nKeyedNetGroupIn), m_tx_relay(conn_type_in != ConnectionType::BLOCK_RELAY ? std::make_unique() : nullptr), m_proof_relay(isAvalancheEnabled(gArgs) ? std::make_unique() : nullptr), // Don't relay addr messages to peers that we connect to as // block-relay-only peers (to prevent adversaries from inferring these // links from addr traffic). id(idIn), nLocalHostNonce(nLocalHostNonceIn), nLocalExtraEntropy(nLocalExtraEntropyIn), m_conn_type(conn_type_in), nLocalServices(nLocalServicesIn) { if (inbound_onion) { assert(conn_type_in == ConnectionType::INBOUND); } hSocket = hSocketIn; - addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn; for (const std::string &msg : getAllNetMessageTypes()) { mapRecvBytesPerMsgCmd[msg] = 0; } mapRecvBytesPerMsgCmd[NET_MESSAGE_COMMAND_OTHER] = 0; if (fLogIPs) { - LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", addrName, id); + LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", m_addr_name, + id); } else { LogPrint(BCLog::NET, "Added connection peer=%d\n", id); } m_deserializer = std::make_unique( V1TransportDeserializer(GetConfig().GetChainParams().NetMagic(), SER_NETWORK, INIT_PROTO_VERSION)); m_serializer = std::make_unique(V1TransportSerializer()); } CNode::~CNode() { CloseSocket(hSocket); } bool CConnman::NodeFullyConnected(const CNode *pnode) { return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect; } void CConnman::PushMessage(CNode *pnode, CSerializedNetMsg &&msg) { size_t nMessageSize = msg.data.size(); LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n", msg.m_type, nMessageSize, pnode->GetId()); if (gArgs.GetBoolArg("-capturemessages", false)) { CaptureMessage(pnode->addr, msg.m_type, msg.data, /*incoming=*/false); } - TRACE6(net, outbound_message, pnode->GetId(), pnode->GetAddrName().c_str(), + TRACE6(net, outbound_message, pnode->GetId(), pnode->m_addr_name.c_str(), pnode->ConnectionTypeAsString().c_str(), msg.m_type.c_str(), msg.data.size(), msg.data.data()); // make sure we use the appropriate network transport format std::vector serializedHeader; pnode->m_serializer->prepareForTransport(*config, msg, serializedHeader); size_t nTotalSize = nMessageSize + serializedHeader.size(); size_t nBytesSent = 0; { LOCK(pnode->cs_vSend); bool optimisticSend(pnode->vSendMsg.empty()); // log total amount of bytes per message type pnode->mapSendBytesPerMsgCmd[msg.m_type] += nTotalSize; pnode->nSendSize += nTotalSize; if (pnode->nSendSize > nSendBufferMaxSize) { pnode->fPauseSend = true; } pnode->vSendMsg.push_back(std::move(serializedHeader)); if (nMessageSize) { pnode->vSendMsg.push_back(std::move(msg.data)); } // If write queue empty, attempt "optimistic write" if (optimisticSend == true) { nBytesSent = SocketSendData(*pnode); } } if (nBytesSent) { RecordBytesSent(nBytesSent); } } bool CConnman::ForNode(NodeId id, std::function func) { CNode *found = nullptr; LOCK(cs_vNodes); for (auto &&pnode : vNodes) { if (pnode->GetId() == id) { found = pnode; break; } } return found != nullptr && NodeFullyConnected(found) && func(found); } std::chrono::microseconds CConnman::PoissonNextSendInbound(std::chrono::microseconds now, std::chrono::seconds average_interval) { if (m_next_send_inv_to_incoming.load() < now) { // If this function were called from multiple threads simultaneously // it would be possible that both update the next send variable, and // return a different result to their caller. This is not possible in // practice as only the net processing thread invokes this function. m_next_send_inv_to_incoming = PoissonNextSend(now, average_interval); } return m_next_send_inv_to_incoming; } std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval) { double unscaled = -log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */); return now + std::chrono::duration_cast( unscaled * average_interval + 0.5us); } CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const { return CSipHasher(nSeed0, nSeed1).Write(id); } uint64_t CConnman::CalculateKeyedNetGroup(const CAddress &ad) const { std::vector vchNetGroup(ad.GetGroup(addrman.GetAsmap())); return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP) .Write(vchNetGroup.data(), vchNetGroup.size()) .Finalize(); } /** * 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 */ std::string getSubVersionEB(uint64_t MaxBlockSize) { // Prepare EB string we are going to add to SubVer: // 1) translate from byte to MB and convert to string // 2) limit the EB string to the first decimal digit (floored) std::stringstream ebMBs; ebMBs << (MaxBlockSize / (ONE_MEGABYTE / 10)); std::string eb = ebMBs.str(); eb.insert(eb.size() - 1, ".", 1); if (eb.substr(0, 1) == ".") { eb = "0" + eb; } return eb; } std::string userAgent(const Config &config) { // format excessive blocksize value std::string eb = getSubVersionEB(config.GetMaxBlockSize()); std::vector uacomments; uacomments.push_back("EB" + eb); // Comments are checked for char compliance at startup, it is safe to add // them to the user agent string for (const std::string &cmt : gArgs.GetArgs("-uacomment")) { uacomments.push_back(cmt); } const std::string client_name = gArgs.GetArg("-uaclientname", CLIENT_NAME); const std::string client_version = gArgs.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION)); // Size compliance is checked at startup, it is safe to not check it again return FormatUserAgent(client_name, client_version, uacomments); } void CaptureMessage(const CAddress &addr, const std::string &msg_type, const Span &data, bool is_incoming) { // Note: This function captures the message at the time of processing, // not at socket receive/send time. // This ensures that the messages are always in order from an application // layer (processing) perspective. auto now = GetTime(); // Windows folder names can not include a colon std::string clean_addr = addr.ToString(); std::replace(clean_addr.begin(), clean_addr.end(), ':', '_'); fs::path base_path = gArgs.GetDataDirNet() / "message_capture" / clean_addr; fs::create_directories(base_path); fs::path path = base_path / (is_incoming ? "msgs_recv.dat" : "msgs_sent.dat"); CAutoFile f(fsbridge::fopen(path, "ab"), SER_DISK, CLIENT_VERSION); ser_writedata64(f, now.count()); f.write(msg_type.data(), msg_type.length()); for (auto i = msg_type.length(); i < CMessageHeader::COMMAND_SIZE; ++i) { f << '\0'; } uint32_t size = data.size(); ser_writedata32(f, size); f.write((const char *)data.data(), data.size()); } diff --git a/src/net.h b/src/net.h index adc5cd8ff..e011ccfa0 100644 --- a/src/net.h +++ b/src/net.h @@ -1,1500 +1,1494 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2019 The Bitcoin Core developers // Copyright (c) 2017-2019 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #ifndef BITCOIN_NET_H #define BITCOIN_NET_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // For cs_main #include #include #include #include #include #include #include #include #include class AddrMan; class BanMan; class Config; class CNode; class CScheduler; struct bilingual_str; /** Default for -whitelistrelay. */ static const bool DEFAULT_WHITELISTRELAY = true; /** Default for -whitelistforcerelay. */ static const bool DEFAULT_WHITELISTFORCERELAY = false; /** * Time after which to disconnect, after waiting for a ping response (or * inactivity). */ static constexpr std::chrono::minutes TIMEOUT_INTERVAL{20}; /** Run the feeler connection loop once every 2 minutes. **/ static constexpr auto FEELER_INTERVAL = 2min; /** Run the extra block-relay-only connection loop once every 5 minutes. **/ static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min; /** Maximum length of the user agent string in `version` message */ static const unsigned int MAX_SUBVERSION_LENGTH = 256; /** * Maximum number of automatic outgoing nodes over which we'll relay everything * (blocks, tx, addrs, etc) */ static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 16; /** Maximum number of addnode outgoing nodes */ static const int MAX_ADDNODE_CONNECTIONS = 8; /** Maximum number of block-relay-only outgoing connections */ static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS = 2; /** * Maximum number of avalanche enabled outgoing connections by default. * Can be overridden with the -maxavalancheoutbound option. */ static const int DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS = 300; /** Maximum number of feeler connections */ static const int MAX_FEELER_CONNECTIONS = 1; /** -listen default */ static const bool DEFAULT_LISTEN = true; /** * The maximum number of peer connections to maintain. * This quantity might not be reachable on some systems, especially on platforms * that do not provide a working poll() interface. */ static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 4096; /** The default for -maxuploadtarget. 0 = Unlimited */ static constexpr uint64_t DEFAULT_MAX_UPLOAD_TARGET = 0; /** Default for blocks only*/ static const bool DEFAULT_BLOCKSONLY = false; /** -peertimeout default */ static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60; /** Number of file descriptors required for message capture **/ static const int NUM_FDS_MESSAGE_CAPTURE = 1; 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; /** Refresh period for the avalanche statistics computation */ static constexpr std::chrono::minutes AVALANCHE_STATISTICS_REFRESH_PERIOD{10}; /** Time constant for the avalanche statistics computation */ static constexpr std::chrono::minutes AVALANCHE_STATISTICS_TIME_CONSTANT{10}; /** * Pre-computed decay factor for the avalanche statistics computation. * There is currently no constexpr variant of std::exp, so use a const. */ static const double AVALANCHE_STATISTICS_DECAY_FACTOR = 1. - std::exp(-1. * AVALANCHE_STATISTICS_REFRESH_PERIOD.count() / AVALANCHE_STATISTICS_TIME_CONSTANT.count()); struct AddedNodeInfo { std::string strAddedNode; CService resolvedAddress; bool fConnected; bool fInbound; }; struct CNodeStats; class CClientUIInterface; struct CSerializedNetMsg { CSerializedNetMsg() = default; CSerializedNetMsg(CSerializedNetMsg &&) = default; CSerializedNetMsg &operator=(CSerializedNetMsg &&) = default; // No copying, only moves. CSerializedNetMsg(const CSerializedNetMsg &msg) = delete; CSerializedNetMsg &operator=(const CSerializedNetMsg &) = delete; std::vector data; std::string m_type; }; const std::vector CONNECTION_TYPE_DOC{ "outbound-full-relay (default automatic connections)", "block-relay-only (does not relay transactions or addresses)", "inbound (initiated by the peer)", "manual (added via addnode RPC or -addnode/-connect configuration options)", "addr-fetch (short-lived automatic connection for soliciting addresses)", "feeler (short-lived automatic connection for testing addresses)"}; /** * 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. */ enum class ConnectionType { /** * 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. */ INBOUND, /** * 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. */ OUTBOUND_FULL_RELAY, /** * 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. */ MANUAL, /** * Feeler connections are short-lived connections made to check that a node * is alive. They can be useful for: * - test-before-evict: if one of the peers is considered for eviction from * our AddrMan because another peer is mapped to the same slot in the * tried table, evict only if this longer-known peer is offline. * - move node addresses from New to Tried table, so that we have more * connectable addresses in our AddrMan. * Note that in the literature ("Eclipse Attacks on Bitcoin’s Peer-to-Peer * Network") only the latter feature is referred to as "feeler connections", * although in our codebase feeler connections encompass test-before-evict * as well. * We make these connections approximately every FEELER_INTERVAL: * first we resolve previously found collisions if they exist * (test-before-evict), otherwise connect to a node from the new table. */ FEELER, /** * 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. */ BLOCK_RELAY, /** * 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. */ ADDR_FETCH, /** * Special case of connection to a full relay outbound with avalanche * service enabled. */ AVALANCHE_OUTBOUND, }; void Discover(); uint16_t GetListenPort(); enum { // unknown LOCAL_NONE, // address a local interface listens on LOCAL_IF, // address explicit bound to LOCAL_BIND, // address reported by UPnP or NAT-PMP LOCAL_MAPPED, // address explicitly specified (-externalip=) LOCAL_MANUAL, LOCAL_MAX }; bool IsPeerAddrLocalGood(CNode *pnode); /** Returns a local address that we should advertise to this peer */ std::optional GetLocalAddrForPeer(CNode *pnode); /** * Mark a network as reachable or unreachable (no automatic connects to it) * @note Networks are reachable by default */ void SetReachable(enum Network net, bool reachable); /** @returns true if the network is reachable, false otherwise */ bool IsReachable(enum Network net); /** @returns true if the address is in a reachable network, false otherwise */ 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); bool IsLocal(const CService &addr); bool GetLocal(CService &addr, const CNetAddr *paddrPeer = nullptr); CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices); extern bool fDiscover; extern bool fListen; struct LocalServiceInfo { int nScore; uint16_t nPort; }; extern RecursiveMutex cs_mapLocalHost; extern std::map mapLocalHost GUARDED_BY(cs_mapLocalHost); extern const std::string NET_MESSAGE_COMMAND_OTHER; // Command, total bytes typedef std::map mapMsgCmdSize; /** * POD that contains various stats about a node. * Usually constructed from CConman::GetNodeStats. Stats are filled from the * node using CNode::copyStats. */ struct CNodeStats { NodeId nodeid; ServiceFlags nServices; bool fRelayTxes; std::chrono::seconds m_last_send; std::chrono::seconds m_last_recv; std::chrono::seconds m_last_tx_time; std::chrono::seconds m_last_proof_time; std::chrono::seconds m_last_block_time; std::chrono::seconds m_connected; int64_t nTimeOffset; - std::string addrName; + std::string m_addr_name; int nVersion; std::string cleanSubVer; bool fInbound; bool m_manual_connection; bool m_bip152_highbandwidth_to; bool m_bip152_highbandwidth_from; int m_starting_height; uint64_t nSendBytes; mapMsgCmdSize mapSendBytesPerMsgCmd; uint64_t nRecvBytes; mapMsgCmdSize mapRecvBytesPerMsgCmd; NetPermissionFlags m_permissionFlags; bool m_legacyWhitelisted; std::chrono::microseconds m_last_ping_time; std::chrono::microseconds m_min_ping_time; Amount minFeeFilter; // Our address, as reported by the peer std::string addrLocal; // Address of this peer CAddress addr; // Bind address of our side of the connection CAddress addrBind; // Network the peer connected through Network m_network; uint32_t m_mapped_as; std::string m_conn_type_string; std::optional m_availabilityScore; }; /** * Transport protocol agnostic message container. * Ideally it should only contain receive time, payload, * command and size. */ class CNetMessage { public: //! received message data CDataStream m_recv; //! time of message receipt std::chrono::microseconds m_time{0}; bool m_valid_netmagic = false; bool m_valid_header = false; bool m_valid_checksum = false; //! size of the payload uint32_t m_message_size{0}; //! used wire size of the message (including header/checksum) uint32_t m_raw_message_size{0}; std::string m_command; CNetMessage(CDataStream &&recv_in) : m_recv(std::move(recv_in)) {} void SetVersion(int nVersionIn) { m_recv.SetVersion(nVersionIn); } }; /** * The TransportDeserializer takes care of holding and deserializing the * network receive buffer. It can deserialize the network buffer into a * transport protocol agnostic CNetMessage (command & payload) */ class TransportDeserializer { public: // returns true if the current deserialization is complete virtual bool Complete() const = 0; // set the serialization context version virtual void SetVersion(int version) = 0; /** read and deserialize data, advances msg_bytes data pointer */ virtual int Read(const Config &config, Span &msg_bytes) = 0; // decomposes a message from the context virtual CNetMessage GetMessage(const Config &config, std::chrono::microseconds time) = 0; virtual ~TransportDeserializer() {} }; class V1TransportDeserializer final : public TransportDeserializer { private: mutable CHash256 hasher; mutable uint256 data_hash; // Parsing header (false) or data (true) bool in_data; // Partially received header. CDataStream hdrbuf; // Complete header. CMessageHeader hdr; // Received message data. CDataStream vRecv; uint32_t nHdrPos; uint32_t nDataPos; const uint256 &GetMessageHash() const; int readHeader(const Config &config, Span msg_bytes); int readData(Span msg_bytes); void Reset() { vRecv.clear(); hdrbuf.clear(); hdrbuf.resize(24); in_data = false; nHdrPos = 0; nDataPos = 0; data_hash.SetNull(); hasher.Reset(); } public: V1TransportDeserializer( const CMessageHeader::MessageMagic &pchMessageStartIn, int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn), vRecv(nTypeIn, nVersionIn) { Reset(); } bool Complete() const override { if (!in_data) { return false; } return (hdr.nMessageSize == nDataPos); } void SetVersion(int nVersionIn) override { hdrbuf.SetVersion(nVersionIn); vRecv.SetVersion(nVersionIn); } int Read(const Config &config, Span &msg_bytes) override { int ret = in_data ? readData(msg_bytes) : readHeader(config, msg_bytes); if (ret < 0) { Reset(); } else { msg_bytes = msg_bytes.subspan(ret); } return ret; } CNetMessage GetMessage(const Config &config, std::chrono::microseconds time) override; }; /** * The TransportSerializer prepares messages for the network transport */ class TransportSerializer { public: // prepare message for transport (header construction, error-correction // computation, payload encryption, etc.) virtual void prepareForTransport(const Config &config, CSerializedNetMsg &msg, std::vector &header) = 0; virtual ~TransportSerializer() {} }; class V1TransportSerializer : public TransportSerializer { public: void prepareForTransport(const Config &config, CSerializedNetMsg &msg, std::vector &header) override; }; /** Information about a peer */ class CNode { friend class CConnman; friend struct ConnmanTestMsg; public: std::unique_ptr m_deserializer; std::unique_ptr m_serializer; // socket std::atomic nServices{NODE_NONE}; SOCKET hSocket GUARDED_BY(cs_hSocket); // Total size of all vSendMsg entries. size_t nSendSize{0}; // Offset inside the first vSendMsg already sent. size_t nSendOffset{0}; uint64_t nSendBytes GUARDED_BY(cs_vSend){0}; std::deque> vSendMsg GUARDED_BY(cs_vSend); Mutex cs_vSend; Mutex cs_hSocket; Mutex cs_vRecv; RecursiveMutex cs_vProcessMsg; std::list vProcessMsg GUARDED_BY(cs_vProcessMsg); size_t nProcessQueueSize{0}; RecursiveMutex cs_sendProcessing; uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0}; std::atomic m_last_send{0s}; std::atomic m_last_recv{0s}; //! Unix epoch time at peer connection const std::chrono::seconds m_connected; std::atomic nTimeOffset{0}; // Address of this peer const CAddress addr; // Bind address of our side of the connection const CAddress addrBind; + const std::string m_addr_name; //! Whether this peer is an inbound onion, i.e. connected via our Tor onion //! service. const bool m_inbound_onion; std::atomic nVersion{0}; // The nonce provided by the remote host. uint64_t nRemoteHostNonce{0}; // The extra entropy provided by the remote host. uint64_t nRemoteExtraEntropy{0}; /** * cleanSubVer is a sanitized string of the user agent byte array we read * from the wire. This cleaned string can safely be logged or displayed. */ RecursiveMutex cs_SubVer; std::string cleanSubVer GUARDED_BY(cs_SubVer){}; // This peer is preferred for eviction. bool m_prefer_evict{false}; bool HasPermission(NetPermissionFlags permission) const { return NetPermissions::HasFlag(m_permissionFlags, permission); } // This boolean is unusued in actual processing, only present for backward // compatibility at RPC/QT level bool m_legacyWhitelisted{false}; // set by version message bool fClient{false}; // after BIP159, set by version message bool m_limited_node{false}; std::atomic_bool fSuccessfullyConnected{false}; // Setting fDisconnect to true will cause the node to be disconnected the // next time DisconnectNodes() runs std::atomic_bool fDisconnect{false}; CSemaphoreGrant grantOutbound; std::atomic nRefCount{0}; const uint64_t nKeyedNetGroup; std::atomic_bool fPauseRecv{false}; std::atomic_bool fPauseSend{false}; bool IsOutboundOrBlockRelayConn() const { switch (m_conn_type) { case ConnectionType::OUTBOUND_FULL_RELAY: case ConnectionType::BLOCK_RELAY: case ConnectionType::AVALANCHE_OUTBOUND: return true; case ConnectionType::INBOUND: case ConnectionType::MANUAL: case ConnectionType::ADDR_FETCH: case ConnectionType::FEELER: return false; } // no default case, so the compiler can warn about missing cases assert(false); } bool IsFullOutboundConn() const { return m_conn_type == ConnectionType::OUTBOUND_FULL_RELAY || m_conn_type == ConnectionType::AVALANCHE_OUTBOUND; } bool IsManualConn() const { return m_conn_type == ConnectionType::MANUAL; } bool IsBlockOnlyConn() const { return m_conn_type == ConnectionType::BLOCK_RELAY; } bool IsFeelerConn() const { return m_conn_type == ConnectionType::FEELER; } bool IsAddrFetchConn() const { return m_conn_type == ConnectionType::ADDR_FETCH; } bool IsInboundConn() const { return m_conn_type == ConnectionType::INBOUND; } bool IsAvalancheOutboundConnection() const { return m_conn_type == ConnectionType::AVALANCHE_OUTBOUND; } bool ExpectServicesFromConn() const { switch (m_conn_type) { case ConnectionType::INBOUND: case ConnectionType::MANUAL: case ConnectionType::FEELER: return false; case ConnectionType::OUTBOUND_FULL_RELAY: case ConnectionType::BLOCK_RELAY: case ConnectionType::ADDR_FETCH: case ConnectionType::AVALANCHE_OUTBOUND: return true; } // no default case, so the compiler can warn about missing cases assert(false); } /** * 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. * * @return network the peer connected through. */ Network ConnectedThroughNetwork() const; protected: mapMsgCmdSize mapSendBytesPerMsgCmd; mapMsgCmdSize mapRecvBytesPerMsgCmd GUARDED_BY(cs_vRecv); public: // We selected peer as (compact blocks) high-bandwidth peer (BIP152) std::atomic m_bip152_highbandwidth_to{false}; // Peer selected us as (compact blocks) high-bandwidth peer (BIP152) std::atomic m_bip152_highbandwidth_from{false}; struct TxRelay { mutable RecursiveMutex cs_filter; // We use fRelayTxes for two purposes - // a) it allows us to not relay tx invs before receiving the peer's // version message. // b) the peer may tell us in its version message that we should not // relay tx invs unless it loads a bloom filter. bool fRelayTxes GUARDED_BY(cs_filter){false}; std::unique_ptr pfilter PT_GUARDED_BY(cs_filter) GUARDED_BY(cs_filter){nullptr}; mutable RecursiveMutex cs_tx_inventory; CRollingBloomFilter filterInventoryKnown GUARDED_BY(cs_tx_inventory){ 50000, 0.000001}; // Set of transaction ids we still have to announce. // They are sorted by the mempool before relay, so the order is not // important. std::set setInventoryTxToSend GUARDED_BY(cs_tx_inventory); // Used for BIP35 mempool sending bool fSendMempool GUARDED_BY(cs_tx_inventory){false}; // Last time a "MEMPOOL" request was serviced. std::atomic m_last_mempool_req{0s}; std::chrono::microseconds nNextInvSend{0}; RecursiveMutex cs_feeFilter; // Minimum fee rate with which to filter inv's to this node Amount minFeeFilter GUARDED_BY(cs_feeFilter){Amount::zero()}; Amount lastSentFeeFilter{Amount::zero()}; std::chrono::microseconds m_next_send_feefilter{0}; }; // m_tx_relay == nullptr if we're not relaying transactions with this peer const std::unique_ptr m_tx_relay; struct ProofRelay { mutable RecursiveMutex cs_proof_inventory; std::set setInventoryProofToSend GUARDED_BY(cs_proof_inventory); // Prevent sending proof invs if the peer already knows about them CRollingBloomFilter filterProofKnown GUARDED_BY(cs_proof_inventory){ 10000, 0.000001}; std::chrono::microseconds nextInvSend{0}; RadixTree sharedProofs; std::atomic lastSharedProofsUpdate{0s}; std::atomic compactproofs_requested{false}; }; // m_proof_relay == nullptr if we're not relaying proofs with this peer const std::unique_ptr m_proof_relay; // True if we know this peer is using Avalanche (at least polling) std::atomic m_avalanche_enabled{false}; // Pubkey used to verify signatures on Avalanche messages from this peer std::optional m_avalanche_pubkey; /** The node was polled for count invs */ void invsPolled(uint32_t count); /** The node voted for count invs */ void invsVoted(uint32_t count); /** * The availability score is calculated using an exponentially weighted * average. * This has several interesting properties: * - The most recent polls/responses have more weight than the previous * ones. A node that recently stopped answering will see its ratio * decrease quickly. * - This is a low-pass filter, so it causes delay. This means that a * node needs to have a track record for the ratio to be high. A node * that has been little requested will have a lower ratio than a node * that failed to answer a few polls but answered a lot of them. * - It is cheap to compute. * * This is expected to be called at a fixed interval of * AVALANCHE_STATISTICS_REFRESH_PERIOD. */ void updateAvailabilityScore(); double getAvailabilityScore() const; // Store the next time we will consider a getavaaddr message from this peer std::chrono::seconds m_nextGetAvaAddr{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 m_last_block_time{0s}; /** * 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. */ std::atomic m_last_tx_time{0s}; /** * UNIX epoch time of the last proof received from this peer that we * had not yet seen (e.g. not already received from another peer) and that * was accepted into our proof pool. Used as an inbound peer eviction * criterium in CConnman::AttemptToEvictConnection. */ std::atomic m_last_proof_time{0s}; /** Last measured round-trip time. Used only for RPC/GUI stats/debugging.*/ std::atomic m_last_ping_time{0us}; /** * Lowest measured round-trip time. Used as an inbound peer eviction * criterium in CConnman::AttemptToEvictConnection. */ std::atomic m_min_ping_time{ std::chrono::microseconds::max()}; CNode(NodeId id, ServiceFlags nLocalServicesIn, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, uint64_t nLocalExtraEntropyIn, const CAddress &addrBindIn, const std::string &addrNameIn, ConnectionType conn_type_in, bool inbound_onion); ~CNode(); CNode(const CNode &) = delete; CNode &operator=(const CNode &) = delete; /** * A ping-pong round trip has completed successfully. Update latest and * minimum ping times. */ void PongReceived(std::chrono::microseconds ping_time) { m_last_ping_time = ping_time; m_min_ping_time = std::min(m_min_ping_time.load(), ping_time); } private: const NodeId id; const uint64_t nLocalHostNonce; const uint64_t nLocalExtraEntropy; const ConnectionType m_conn_type; std::atomic m_greatest_common_version{INIT_PROTO_VERSION}; //! 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. const ServiceFlags nLocalServices; NetPermissionFlags m_permissionFlags{PF_NONE}; // Used only by SocketHandler thread std::list vRecvMsg; - mutable RecursiveMutex cs_addrName; - std::string addrName GUARDED_BY(cs_addrName); - // Our address, as reported by the peer CService addrLocal GUARDED_BY(cs_addrLocal); mutable RecursiveMutex cs_addrLocal; /** * The inventories polled and voted counters since last score * computation, stored as a pair of uint32_t with the poll counter * being the 32 lowest bits and the vote counter the 32 highest bits. */ std::atomic invCounters{0}; /** The last computed score */ std::atomic availabilityScore{0.}; public: NodeId GetId() const { return id; } uint64_t GetLocalNonce() const { return nLocalHostNonce; } uint64_t GetLocalExtraEntropy() const { return nLocalExtraEntropy; } int GetRefCount() const { assert(nRefCount >= 0); return nRefCount; } /** * Receive bytes from the buffer and deserialize them into messages. * * @param[in] msg_bytes The raw data * @param[out] complete Set True if at least one message has been * deserialized and is ready to be processed * @return True if the peer should stay connected, * False if the peer should be disconnected from. */ bool ReceiveMsgBytes(const Config &config, Span msg_bytes, bool &complete); void SetCommonVersion(int greatest_common_version) { Assume(m_greatest_common_version == INIT_PROTO_VERSION); m_greatest_common_version = greatest_common_version; } int GetCommonVersion() const { return m_greatest_common_version; } CService GetAddrLocal() const; //! May not be called more than once void SetAddrLocal(const CService &addrLocalIn); CNode *AddRef() { nRefCount++; return this; } void Release() { nRefCount--; } void AddKnownTx(const TxId &txid) { if (m_tx_relay != nullptr) { LOCK(m_tx_relay->cs_tx_inventory); m_tx_relay->filterInventoryKnown.insert(txid); } } void PushTxInventory(const TxId &txid) { if (m_tx_relay == nullptr) { return; } LOCK(m_tx_relay->cs_tx_inventory); if (!m_tx_relay->filterInventoryKnown.contains(txid)) { m_tx_relay->setInventoryTxToSend.insert(txid); } } void AddKnownProof(const avalanche::ProofId &proofid) { if (m_proof_relay != nullptr) { LOCK(m_proof_relay->cs_proof_inventory); m_proof_relay->filterProofKnown.insert(proofid); } } void PushProofInventory(const avalanche::ProofId &proofid) { if (m_proof_relay == nullptr) { return; } LOCK(m_proof_relay->cs_proof_inventory); if (!m_proof_relay->filterProofKnown.contains(proofid)) { m_proof_relay->setInventoryProofToSend.insert(proofid); } } void CloseSocketDisconnect(); void copyStats(CNodeStats &stats); ServiceFlags GetLocalServices() const { return nLocalServices; } - std::string GetAddrName() const; - //! Sets the addrName only if it was not previously set - void MaybeSetAddrName(const std::string &addrNameIn); - std::string ConnectionTypeAsString() const; }; /** * Interface for message handling */ class NetEventsInterface { public: /** Initialize a peer (setup state, queue any initial messages) */ virtual void InitializeNode(const Config &config, CNode *pnode) = 0; /** Handle removal of a peer (clear state) */ virtual void FinalizeNode(const Config &config, const CNode &node) = 0; /** * Process protocol messages received from a given node * * @param[in] config The applicable configuration object. * @param[in] pnode The node which we have received messages * from. * @param[in] interrupt Interrupt condition for processing threads * @return True if there is more work to be done */ virtual bool ProcessMessages(const Config &config, CNode *pnode, std::atomic &interrupt) = 0; /** * Send queued protocol messages to a given node. * * @param[in] config The applicable configuration object. * @param[in] pnode The node which we are sending messages to. * @return True if there is more work to be done */ virtual bool SendMessages(const Config &config, CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(pnode->cs_sendProcessing) = 0; protected: /** * Protected destructor so that instances can only be deleted by derived * classes. If that restriction is no longer desired, this should be made * public and virtual. */ ~NetEventsInterface() = default; }; namespace { struct CConnmanTest; } class NetEventsInterface; class CConnman { public: enum NumConnections { CONNECTIONS_NONE = 0, CONNECTIONS_IN = (1U << 0), CONNECTIONS_OUT = (1U << 1), CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT), }; struct Options { ServiceFlags nLocalServices = NODE_NONE; int nMaxConnections = 0; int m_max_outbound_full_relay = 0; int m_max_outbound_block_relay = 0; int m_max_avalanche_outbound = 0; int nMaxAddnode = 0; int nMaxFeeler = 0; CClientUIInterface *uiInterface = nullptr; std::vector m_msgproc; BanMan *m_banman = nullptr; unsigned int nSendBufferMaxSize = 0; unsigned int nReceiveFloodSize = 0; uint64_t nMaxOutboundLimit = 0; int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT; std::vector vSeedNodes; std::vector vWhitelistedRange; std::vector vWhiteBinds; std::vector vBinds; std::vector onion_binds; /// True if the user did not specify -bind= or -whitebind= and thus /// we should bind on `0.0.0.0` (IPv4) and `::` (IPv6). bool bind_on_any; bool m_use_addrman_outgoing = true; std::vector m_specified_outgoing; std::vector m_added_nodes; bool m_i2p_accept_incoming = true; }; void Init(const Options &connOptions) { nLocalServices = connOptions.nLocalServices; nMaxConnections = connOptions.nMaxConnections; m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing; nMaxAddnode = connOptions.nMaxAddnode; nMaxFeeler = connOptions.nMaxFeeler; { // Lock cs_main to prevent a potential race with the peer validation // logic thread. LOCK(::cs_main); m_max_outbound_full_relay = std::min(connOptions.m_max_outbound_full_relay, connOptions.nMaxConnections); m_max_avalanche_outbound = connOptions.m_max_avalanche_outbound; m_max_outbound_block_relay = connOptions.m_max_outbound_block_relay; m_max_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + nMaxFeeler + m_max_avalanche_outbound; } clientInterface = connOptions.uiInterface; m_banman = connOptions.m_banman; m_msgproc = connOptions.m_msgproc; nSendBufferMaxSize = connOptions.nSendBufferMaxSize; nReceiveFloodSize = connOptions.nReceiveFloodSize; m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout}; { LOCK(cs_totalBytesSent); nMaxOutboundLimit = connOptions.nMaxOutboundLimit; } vWhitelistedRange = connOptions.vWhitelistedRange; { LOCK(cs_vAddedNodes); vAddedNodes = connOptions.m_added_nodes; } m_onion_binds = connOptions.onion_binds; } CConnman(const Config &configIn, uint64_t seed0, uint64_t seed1, AddrMan &addrmanIn, bool network_active = true); ~CConnman(); bool Start(CScheduler &scheduler, const Options &options); void StopThreads(); void StopNodes(); void Stop() { StopThreads(); StopNodes(); }; void Interrupt(); bool GetNetworkActive() const { return fNetworkActive; }; bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; }; 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 func); void PushMessage(CNode *pnode, CSerializedNetMsg &&msg); using NodeFn = std::function; void ForEachNode(const NodeFn &func) { LOCK(cs_vNodes); for (auto &&node : vNodes) { if (NodeFullyConnected(node)) { func(node); } } }; void ForEachNode(const NodeFn &func) const { LOCK(cs_vNodes); for (auto &&node : vNodes) { if (NodeFullyConnected(node)) { func(node); } } }; // Addrman functions /** * Return all or many randomly selected addresses, optionally by network. * * @param[in] max_addresses Maximum number of addresses to return * (0 = all). * @param[in] max_pct Maximum percentage of addresses to return * (0 = all). * @param[in] network Select only addresses of this network * (nullopt = all). */ std::vector GetAddresses(size_t max_addresses, size_t max_pct, std::optional network); /** * 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. */ std::vector GetAddresses(CNode &requestor, size_t max_addresses, size_t max_pct); // This allows temporarily exceeding m_max_outbound_full_relay, with the // goal of finding a peer that is better than all our current peers. void SetTryNewOutboundPeer(bool flag); bool GetTryNewOutboundPeer(); void StartExtraBlockRelayPeers() { LogPrint(BCLog::NET, "net: enabling extra block-relay-only peers\n"); m_start_extra_block_relay_peers = true; } // Return the number of outbound peers we have in excess of our target (eg, // if we previously called SetTryNewOutboundPeer(true), and have since set // to false, we may have extra peers that we wish to disconnect). This may // return a value less than (num_outbound_connections - num_outbound_slots) // in cases where some outbound connections are not yet fully connected, or // not yet fully disconnected. int GetExtraFullOutboundCount(); // Count the number of block-relay-only peers we have over our limit. int GetExtraBlockRelayCount(); bool AddNode(const std::string &node); bool RemoveAddedNode(const std::string &node); std::vector GetAddedNodeInfo(); /** * Attempts to open a connection. Currently only used from tests. * * @param[in] address Address of node to try connecting to * @param[in] conn_type ConnectionType::OUTBOUND, * ConnectionType::BLOCK_RELAY, * ConnectionType::ADDR_FETCH, or * ConnectionType::FEELER * @return bool Returns false if there are no available * slots for this connection: * - conn_type not a supported ConnectionType * - Max total outbound connection capacity filled * - Max connection capacity for type is filled */ bool AddConnection(const std::string &address, ConnectionType conn_type); size_t GetNodeCount(NumConnections num); void GetNodeStats(std::vector &vstats); bool DisconnectNode(const std::string &node); bool DisconnectNode(const CSubNet &subnet); bool DisconnectNode(const CNetAddr &addr); bool DisconnectNode(NodeId id); //! 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()`. ServiceFlags GetLocalServices() const; uint64_t GetMaxOutboundTarget(); std::chrono::seconds GetMaxOutboundTimeframe(); //! 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. bool OutboundTargetReached(bool historicalBlockServingLimit); //! response the bytes left in the current max outbound cycle in case of no //! limit, it will always response 0 uint64_t GetOutboundTargetBytesLeft(); //! returns the time in second left in the current max outbound cycle in //! case of no limit, it will always return 0 std::chrono::seconds GetMaxOutboundTimeLeftInCycle(); uint64_t GetTotalBytesRecv(); uint64_t GetTotalBytesSent(); /** Get a unique deterministic randomizer. */ CSipHasher GetDeterministicRandomizer(uint64_t id) const; unsigned int GetReceiveFloodSize() const; void WakeMessageHandler(); /** * Attempts to obfuscate tx time through exponentially distributed emitting. * Works assuming that a single interval is used. * Variable intervals will result in privacy decrease. */ std::chrono::microseconds PoissonNextSendInbound(std::chrono::microseconds now, std::chrono::seconds average_interval); /** * Return true if we should disconnect the peer for failing an inactivity * check. */ bool ShouldRunInactivityChecks(const CNode &node, std::chrono::seconds now) const; private: struct ListenSocket { public: SOCKET socket; inline void AddSocketPermissionFlags(NetPermissionFlags &flags) const { NetPermissions::AddFlag(flags, m_permissions); } ListenSocket(SOCKET socket_, NetPermissionFlags permissions_) : socket(socket_), m_permissions(permissions_) {} private: NetPermissionFlags m_permissions; }; 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(); void AddAddrFetch(const std::string &strDest); void ProcessAddrFetch(); void ThreadOpenConnections(std::vector connect, std::function mockOpenConnection); void ThreadMessageHandler(); void ThreadI2PAcceptIncoming(); void AcceptConnection(const ListenSocket &hListenSocket); /** * Create a `CNode` object from a socket that has just been accepted and add * the node to the `vNodes` member. * @param[in] hSocket Connected socket to communicate with the peer. * @param[in] permissionFlags The peer's permissions. * @param[in] addr_bind The address and port at our side of the connection. * @param[in] addr The address and port at the peer's side of the connection */ void CreateNodeFromAcceptedSocket(SOCKET hSocket, NetPermissionFlags permissionFlags, const CAddress &addr_bind, const CAddress &addr); void DisconnectNodes(); void NotifyNumConnectionsChanged(); /** Return true if the peer is inactive and should be disconnected. */ bool InactivityCheck(const CNode &node) const; bool GenerateSelectSet(std::set &recv_set, std::set &send_set, std::set &error_set); void SocketEvents(std::set &recv_set, std::set &send_set, std::set &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); /** * Determine whether we're already connected to a given address, in order to * avoid initiating duplicate connections. */ bool AlreadyConnectedToAddress(const CAddress &addr); bool AttemptToEvictConnection(); 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(); // Network stats void RecordBytesRecv(uint64_t bytes); void RecordBytesSent(uint64_t bytes); /** * Return vector of current BLOCK_RELAY peers. */ std::vector GetCurrentBlockRelayOnlyConns() const; // Whether the node should be passed out in ForEach* callbacks static bool NodeFullyConnected(const CNode *pnode); const Config *config; // Network usage totals RecursiveMutex cs_totalBytesRecv; RecursiveMutex cs_totalBytesSent; uint64_t nTotalBytesRecv GUARDED_BY(cs_totalBytesRecv){0}; uint64_t nTotalBytesSent GUARDED_BY(cs_totalBytesSent){0}; // outbound limit & stats uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(cs_totalBytesSent){0}; std::chrono::seconds nMaxOutboundCycleStartTime GUARDED_BY(cs_totalBytesSent){0}; uint64_t nMaxOutboundLimit GUARDED_BY(cs_totalBytesSent); // P2P timeout in seconds std::chrono::seconds m_peer_connect_timeout; // Whitelisted ranges. Any node connecting from these is automatically // whitelisted (as well as those connecting to whitelisted binds). std::vector vWhitelistedRange; unsigned int nSendBufferMaxSize{0}; unsigned int nReceiveFloodSize{0}; std::vector vhListenSocket; std::atomic fNetworkActive{true}; bool fAddressesInitialized{false}; AddrMan &addrman; std::deque m_addr_fetches GUARDED_BY(m_addr_fetches_mutex); RecursiveMutex m_addr_fetches_mutex; std::vector vAddedNodes GUARDED_BY(cs_vAddedNodes); RecursiveMutex cs_vAddedNodes; std::vector vNodes GUARDED_BY(cs_vNodes); std::list vNodesDisconnected; mutable RecursiveMutex cs_vNodes; std::atomic nLastNodeId{0}; unsigned int nPrevNodeCount{0}; /** * Cache responses to addr requests to minimize privacy leak. * Attack example: scraping addrs in real-time may allow an attacker * to infer new connections of the victim by detecting new records * with fresh timestamps (per self-announcement). */ struct CachedAddrResponse { std::vector m_addrs_response_cache; std::chrono::microseconds m_cache_entry_expiration{0}; }; /** * 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. */ std::map m_addr_response_caches; /** * 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. * * \sa CNode::nLocalServices */ ServiceFlags nLocalServices; std::unique_ptr semOutbound; std::unique_ptr semAddnode; int nMaxConnections; // How many full-relay (tx, block, addr) outbound peers we want int m_max_outbound_full_relay; // How many block-relay only outbound peers we want // We do not relay tx or addr messages with these peers int m_max_outbound_block_relay; // How many avalanche enabled outbound peers we want int m_max_avalanche_outbound; int nMaxAddnode; int nMaxFeeler; int m_max_outbound; bool m_use_addrman_outgoing; CClientUIInterface *clientInterface; // FIXME m_msgproc is a terrible name std::vector m_msgproc; /** * Pointer to this node's banman. May be nullptr - check existence before * dereferencing. */ BanMan *m_banman; /** * Addresses that were saved during the previous clean shutdown. We'll * attempt to make block-relay-only connections to them. */ std::vector m_anchors; /** SipHasher seeds for deterministic randomness */ const uint64_t nSeed0, nSeed1; /** flag for waking the message processor. */ bool fMsgProcWake GUARDED_BY(mutexMsgProc); std::condition_variable condMsgProc; Mutex mutexMsgProc; std::atomic flagInterruptMsgProc{false}; /** * This is signaled when network activity should cease. * A pointer to it is saved in `m_i2p_sam_session`, so make sure that * the lifetime of `interruptNet` is not shorter than * the lifetime of `m_i2p_sam_session`. */ CThreadInterrupt interruptNet; /** * I2P SAM session. * Used to accept incoming and make outgoing I2P connections. */ std::unique_ptr m_i2p_sam_session; std::thread threadDNSAddressSeed; std::thread threadSocketHandler; std::thread threadOpenAddedConnections; std::thread threadOpenConnections; std::thread threadMessageHandler; std::thread threadI2PAcceptIncoming; /** * 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. */ std::atomic_bool m_try_another_outbound_peer; /** * flag for initiating extra block-relay-only peer connections. * this should only be enabled after initial chain sync has occurred, * as these connections are intended to be short-lived and low-bandwidth. */ std::atomic_bool m_start_extra_block_relay_peers{false}; std::atomic m_next_send_inv_to_incoming{0us}; /** * A vector of -bind=
:=onion arguments each of which is * an address and port that are designated for incoming Tor connections. */ std::vector m_onion_binds; friend struct ::CConnmanTest; friend struct ConnmanTestMsg; }; /** * Return a timestamp in the future (in microseconds) for exponentially * distributed events. */ std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval); std::string getSubVersionEB(uint64_t MaxBlockSize); std::string userAgent(const Config &config); /** Dump binary message to file, with timestamp */ void CaptureMessage(const CAddress &addr, const std::string &msg_type, const Span &data, bool is_incoming); struct NodeEvictionCandidate { NodeId id; std::chrono::seconds m_connected; std::chrono::microseconds m_min_ping_time; std::chrono::seconds m_last_block_time; std::chrono::seconds m_last_proof_time; std::chrono::seconds m_last_tx_time; bool fRelevantServices; bool fRelayTxes; bool fBloomFilter; uint64_t nKeyedNetGroup; bool prefer_evict; bool m_is_local; Network m_network; double availabilityScore; }; /** * 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. */ [[nodiscard]] std::optional SelectNodeToEvict(std::vector &&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: * * - onion peers connected via our tor control service * * - localhost peers, as manually configured hidden services not using * `-bind=addr[:port]=onion` will not be detected as inbound onion connections * * - I2P peers * * This 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. */ void ProtectEvictionCandidatesByRatio( std::vector &vEvictionCandidates); #endif // BITCOIN_NET_H diff --git a/src/net_processing.cpp b/src/net_processing.cpp index fa60f052c..17b093422 100644 --- a/src/net_processing.cpp +++ b/src/net_processing.cpp @@ -1,7180 +1,7179 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // For NDEBUG compile time check #include #include #include #include #include #include #include #include /** How long to cache transactions in mapRelay for normal relay */ static constexpr auto RELAY_TX_CACHE_TIME = 15min; /** * How long a transaction has to be in the mempool before it can * unconditionally be relayed (even when not in mapRelay). */ static constexpr auto UNCONDITIONAL_RELAY_DELAY = 2min; /** * Headers download timeout. * Timeout = base + per_header * (expected number of headers) */ static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_BASE = 15min; static constexpr auto HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER = 1ms; /** * Protect at least this many outbound peers from disconnection due to * slow/behind headers chain. */ static constexpr int32_t MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT = 4; /** * Timeout for (unprotected) outbound peers to sync to our chainwork, in * seconds. */ // 20 minutes static constexpr int64_t CHAIN_SYNC_TIMEOUT = 20 * 60; /** How frequently to check for stale tips, in seconds */ // 10 minutes static constexpr int64_t STALE_CHECK_INTERVAL = 10 * 60; /** * How frequently to check for extra outbound peers and disconnect, in seconds. */ static constexpr int64_t EXTRA_PEER_CHECK_INTERVAL = 45; /** * Minimum time an outbound-peer-eviction candidate must be connected for, in * order to evict, in seconds. */ static constexpr std::chrono::seconds MINIMUM_CONNECT_TIME{30}; /** SHA256("main address relay")[0:8] */ static constexpr uint64_t RANDOMIZER_ID_ADDRESS_RELAY = 0x3cac0035b5866b90ULL; /// Age after which a stale block will no longer be served if requested as /// protection against fingerprinting. Set to one month, denominated in seconds. static constexpr int STALE_RELAY_AGE_LIMIT = 30 * 24 * 60 * 60; /// Age after which a block is considered historical for purposes of rate /// limiting block relay. Set to one week, denominated in seconds. static constexpr int HISTORICAL_BLOCK_AGE = 7 * 24 * 60 * 60; /** * Time between pings automatically sent out for latency probing and keepalive. */ static constexpr std::chrono::minutes PING_INTERVAL{2}; /** The maximum number of entries in a locator */ static const unsigned int MAX_LOCATOR_SZ = 101; /** The maximum number of entries in an 'inv' protocol message */ static const unsigned int MAX_INV_SZ = 50000; static_assert(MAX_PROTOCOL_MESSAGE_LENGTH > MAX_INV_SZ * sizeof(CInv), "Max protocol message length must be greater than largest " "possible INV message"); /** Minimum time between 2 successives getavaaddr messages from the same peer */ static constexpr std::chrono::minutes GETAVAADDR_INTERVAL{2}; /** * If no proof was requested from a compact proof message after this timeout * expired, the proof radix tree can be cleaned up. */ static constexpr std::chrono::minutes AVALANCHE_AVAPROOFS_TIMEOUT{2}; struct DataRequestParameters { /** * Maximum number of in-flight data requests from a peer. It is not a hard * limit, but the threshold at which point the overloaded_peer_delay kicks * in. */ const size_t max_peer_request_in_flight; /** * Maximum number of inventories to consider for requesting, per peer. It * provides a reasonable DoS limit to per-peer memory usage spent on * announcements, while covering peers continuously sending INVs at the * maximum rate (by our own policy, see INVENTORY_BROADCAST_PER_SECOND) for * several minutes, while not receiving the actual data (from any peer) in * response to requests for them. */ const size_t max_peer_announcements; /** How long to delay requesting data from non-preferred peers */ const std::chrono::seconds nonpref_peer_delay; /** * How long to delay requesting data from overloaded peers (see * max_peer_request_in_flight). */ const std::chrono::seconds overloaded_peer_delay; /** * How long to wait (in microseconds) before a data request from an * additional peer. */ const std::chrono::microseconds getdata_interval; /** * Permission flags a peer requires to bypass the request limits tracking * limits and delay penalty. */ const NetPermissionFlags bypass_request_limits_permissions; }; static constexpr DataRequestParameters TX_REQUEST_PARAMS{ 100, // max_peer_request_in_flight 5000, // max_peer_announcements std::chrono::seconds(2), // nonpref_peer_delay std::chrono::seconds(2), // overloaded_peer_delay std::chrono::seconds(60), // getdata_interval PF_RELAY, // bypass_request_limits_permissions }; static constexpr DataRequestParameters PROOF_REQUEST_PARAMS{ 100, // max_peer_request_in_flight 5000, // max_peer_announcements std::chrono::seconds(2), // nonpref_peer_delay std::chrono::seconds(2), // overloaded_peer_delay std::chrono::seconds(60), // getdata_interval PF_BYPASS_PROOF_REQUEST_LIMITS, // bypass_request_limits_permissions }; /** * Limit to avoid sending big packets. Not used in processing incoming GETDATA * for compatibility. */ static const unsigned int MAX_GETDATA_SZ = 1000; /** * Number of blocks that can be requested at any given time from a single peer. */ static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16; /** * Time during which a peer must stall block download progress before being * disconnected. */ static constexpr auto BLOCK_STALLING_TIMEOUT = 2s; /** * Number of headers sent in one getheaders result. We rely on the assumption * that if a peer sends * less than this number, we reached its tip. Changing this value is a protocol * upgrade. */ static const unsigned int MAX_HEADERS_RESULTS = 2000; /** * Maximum depth of blocks we're willing to serve as compact blocks to peers * when requested. For older blocks, a regular BLOCK response will be sent. */ static const int MAX_CMPCTBLOCK_DEPTH = 5; /** * Maximum depth of blocks we're willing to respond to GETBLOCKTXN requests * for. */ static const int MAX_BLOCKTXN_DEPTH = 10; /** * Size of the "block download window": how far ahead of our current height do * we fetch? Larger windows tolerate larger download speed differences between * peer, but increase the potential degree of disordering of blocks on disk * (which make reindexing and pruning harder). We'll probably * want to make this a per-peer adaptive value at some point. */ static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024; /** * Block download timeout base, expressed in multiples of the block interval * (i.e. 10 min) */ static constexpr double BLOCK_DOWNLOAD_TIMEOUT_BASE = 1; /** * Additional block download timeout per parallel downloading peer (i.e. 5 min) */ static constexpr double BLOCK_DOWNLOAD_TIMEOUT_PER_PEER = 0.5; /** * Maximum number of headers to announce when relaying blocks with headers * message. */ static const unsigned int MAX_BLOCKS_TO_ANNOUNCE = 8; /** Maximum number of unconnecting headers announcements before DoS score */ static const int MAX_UNCONNECTING_HEADERS = 10; /** Minimum blocks required to signal NODE_NETWORK_LIMITED */ static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288; /** * Average delay between local address broadcasts. */ static constexpr auto AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL = 24h; /** * Average delay between peer address broadcasts. */ static constexpr auto AVG_ADDRESS_BROADCAST_INTERVAL = 30s; /** * Average delay between trickled inventory transmissions for inbound peers. * Blocks and peers with noban permission bypass this. */ static constexpr auto INBOUND_INVENTORY_BROADCAST_INTERVAL = 5s; /** * Maximum rate of inventory items to send per second. * Limits the impact of low-fee transaction floods. */ static constexpr unsigned int INVENTORY_BROADCAST_PER_SECOND = 7; /** Maximum number of inventory items to send per transmission. */ static constexpr unsigned int INVENTORY_BROADCAST_MAX_PER_MB = INVENTORY_BROADCAST_PER_SECOND * count_seconds(INBOUND_INVENTORY_BROADCAST_INTERVAL); /** The number of most recently announced transactions a peer can request. */ static constexpr unsigned int INVENTORY_MAX_RECENT_RELAY = 3500; /** * Verify that INVENTORY_MAX_RECENT_RELAY is enough to cache everything * typically relayed before unconditional relay from the mempool kicks in. This * is only a lower bound, and it should be larger to account for higher inv rate * to outbound peers, and random variations in the broadcast mechanism. */ static_assert(INVENTORY_MAX_RECENT_RELAY >= INVENTORY_BROADCAST_PER_SECOND * UNCONDITIONAL_RELAY_DELAY / std::chrono::seconds{1}, "INVENTORY_RELAY_MAX too low"); /** * Average delay between feefilter broadcasts in seconds. */ static constexpr auto AVG_FEEFILTER_BROADCAST_INTERVAL = 10min; /** * Maximum feefilter broadcast delay after significant change. */ static constexpr auto MAX_FEEFILTER_CHANGE_DELAY = 5min; /** * Maximum number of compact filters that may be requested with one * getcfilters. See BIP 157. */ static constexpr uint32_t MAX_GETCFILTERS_SIZE = 1000; /** * Maximum number of cf hashes that may be requested with one getcfheaders. See * BIP 157. */ static constexpr uint32_t MAX_GETCFHEADERS_SIZE = 2000; /** * the maximum percentage of addresses from our addrman to return in response * to a getaddr message. */ static constexpr size_t MAX_PCT_ADDR_TO_SEND = 23; /** The maximum number of address records permitted in an ADDR message. */ static constexpr size_t MAX_ADDR_TO_SEND{1000}; /** * The maximum rate of address records we're willing to process on average. Can * be bypassed using the NetPermissionFlags::Addr permission. */ static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1}; /** * The soft limit of the address processing token bucket (the regular * MAX_ADDR_RATE_PER_SECOND based increments won't go above this, but the * MAX_ADDR_TO_SEND increment following GETADDR is exempt from this limit). */ static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND}; inline size_t GetMaxAddrToSend() { return gArgs.GetIntArg("-maxaddrtosend", MAX_ADDR_TO_SEND); } // Internal stuff namespace { /** * Blocks that are in flight, and that are in the queue to be downloaded. */ struct QueuedBlock { BlockHash hash; //! Optional. const CBlockIndex *pindex; //! Whether this block has validated headers at the time of request. bool fValidatedHeaders; //! Optional, used for CMPCTBLOCK downloads std::unique_ptr partialBlock; }; /** * Data structure for an individual peer. This struct is not protected by * cs_main since it does not contain validation-critical data. * * Memory is owned by shared pointers and this object is destructed when * the refcount drops to zero. * * Mutexes inside this struct must not be held when locking m_peer_mutex. * * TODO: move most members from CNodeState to this structure. * TODO: move remaining application-layer data members from CNode to this * structure. */ struct Peer { /** Same id as the CNode object for this peer */ const NodeId m_id{0}; /** Protects misbehavior data members */ Mutex m_misbehavior_mutex; /** Accumulated misbehavior score for this peer */ int m_misbehavior_score GUARDED_BY(m_misbehavior_mutex){0}; /** Whether this peer should be disconnected and marked as discouraged * (unless it has the noban permission). */ bool m_should_discourage GUARDED_BY(m_misbehavior_mutex){false}; /** Protects block inventory data members */ Mutex m_block_inv_mutex; /** * List of blocks that we'll anounce via an `inv` message. * There is no final sorting before sending, as they are always sent * immediately and in the order requested. */ std::vector m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex); /** * Unfiltered list of blocks that we'd like to announce via a `headers` * message. If we can't announce via a `headers` message, we'll fall back to * announcing via `inv`. */ std::vector m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex); /** * The final block hash that we sent in an `inv` message to this peer. * When the peer requests this block, we send an `inv` message to trigger * the peer to request the next sequence of block hashes. * Most peers use headers-first syncing, which doesn't use this mechanism */ BlockHash m_continuation_block GUARDED_BY(m_block_inv_mutex){}; /** This peer's reported block height when we connected */ std::atomic m_starting_height{-1}; /** The pong reply we're expecting, or 0 if no pong expected. */ std::atomic m_ping_nonce_sent{0}; /** When the last ping was sent, or 0 if no ping was ever sent */ std::atomic m_ping_start{0us}; /** Whether a ping has been requested by the user */ std::atomic m_ping_queued{false}; /** * A vector of addresses to send to the peer, limited to MAX_ADDR_TO_SEND. */ std::vector m_addrs_to_send; /** * Probabilistic filter to track recent addr messages relayed with this * peer. Used to avoid relaying redundant addresses to this peer. * * We initialize this filter for outbound peers (other than * block-relay-only connections) or when an inbound peer sends us an * address related message (ADDR, ADDRV2, GETADDR). * * Presence of this filter must correlate with m_addr_relay_enabled. **/ std::unique_ptr m_addr_known; /** * Whether we are participating in address relay with this connection. * * We set this bool to true for outbound peers (other than * block-relay-only connections), or when an inbound peer sends us an * address related message (ADDR, ADDRV2, GETADDR). * * We use this bool to decide whether a peer is eligible for gossiping * addr messages. This avoids relaying to peers that are unlikely to * forward them, effectively blackholing self announcements. Reasons * peers might support addr relay on the link include that they connected * to us as a block-relay-only peer or they are a light client. * * This field must correlate with whether m_addr_known has been * initialized. */ std::atomic_bool m_addr_relay_enabled{false}; /** Whether a getaddr request to this peer is outstanding. */ bool m_getaddr_sent{false}; /** Guards address sending timers. */ mutable Mutex m_addr_send_times_mutex; /** Time point to send the next ADDR message to this peer. */ std::chrono::microseconds m_next_addr_send GUARDED_BY(m_addr_send_times_mutex){0}; /** Time point to possibly re-announce our local address to this peer. */ std::chrono::microseconds m_next_local_addr_send GUARDED_BY(m_addr_send_times_mutex){0}; /** * Whether the peer has signaled support for receiving ADDRv2 (BIP155) * messages, indicating a preference to receive ADDRv2 instead of ADDR ones. */ std::atomic_bool m_wants_addrv2{false}; /** Whether this peer has already sent us a getaddr message. */ bool m_getaddr_recvd{false}; /** Guards m_addr_token_bucket */ mutable Mutex m_addr_token_bucket_mutex; /** * Number of addresses that can be processed from this peer. Start at 1 * to permit self-announcement. */ double m_addr_token_bucket GUARDED_BY(m_addr_token_bucket_mutex){1.0}; /** When m_addr_token_bucket was last updated */ std::chrono::microseconds m_addr_token_timestamp{ GetTime()}; /** Total number of addresses that were dropped due to rate limiting. */ std::atomic m_addr_rate_limited{0}; /** * Total number of addresses that were processed (excludes rate-limited * ones). */ std::atomic m_addr_processed{0}; /** * Set of txids to reconsider once their parent transactions have been * accepted */ std::set m_orphan_work_set GUARDED_BY(g_cs_orphans); /** Protects m_getdata_requests **/ Mutex m_getdata_requests_mutex; /** Work queue of items requested by this peer **/ std::deque m_getdata_requests GUARDED_BY(m_getdata_requests_mutex); explicit Peer(NodeId id) : m_id(id) {} }; using PeerRef = std::shared_ptr; class PeerManagerImpl final : public PeerManager { public: PeerManagerImpl(const CChainParams &chainparams, CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, bool ignore_incoming_txs); /** Overridden from CValidationInterface. */ void BlockConnected(const std::shared_ptr &pblock, const CBlockIndex *pindexConnected) override; void BlockDisconnected(const std::shared_ptr &block, const CBlockIndex *pindex) override; void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override; void BlockChecked(const CBlock &block, const BlockValidationState &state) override; void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr &pblock) override; /** Implement NetEventsInterface */ void InitializeNode(const Config &config, CNode *pnode) override; void FinalizeNode(const Config &config, const CNode &node) override; bool ProcessMessages(const Config &config, CNode *pfrom, std::atomic &interrupt) override; bool SendMessages(const Config &config, CNode *pto) override EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing); /** Implement PeerManager */ void StartScheduledTasks(CScheduler &scheduler) override; void CheckForStaleTipAndEvictPeers() override; bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) override; bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; } void SendPings() override; void RelayTransaction(const TxId &txid) override; void RelayProof(const avalanche::ProofId &proofid) override; void SetBestHeight(int height) override { m_best_height = height; }; void Misbehaving(const NodeId pnode, const int howmuch, const std::string &message) override; void ProcessMessage(const Config &config, CNode &pfrom, const std::string &msg_type, CDataStream &vRecv, const std::chrono::microseconds time_received, const std::atomic &interruptMsgProc) override; private: /** * Consider evicting an outbound peer based on the amount of time they've * been behind our tip. */ void ConsiderEviction(CNode &pto, int64_t time_in_seconds) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * If we have extra outbound peers, try to disconnect the one with the * oldest block announcement. */ void EvictExtraOutboundPeers(std::chrono::seconds now) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Retrieve unbroadcast transactions from the mempool and reattempt * sending to peers */ void ReattemptInitialBroadcast(CScheduler &scheduler); /** * Update the avalanche statistics for all the nodes */ void UpdateAvalancheStatistics() const; /** * Process periodic avalanche network messaging and cleanups. */ void AvalanchePeriodicNetworking(CScheduler &scheduler) const; /** * Get a shared pointer to the Peer object. * May return an empty shared_ptr if the Peer object can't be found. */ PeerRef GetPeerRef(NodeId id) const; /** * Get a shared pointer to the Peer object and remove it from m_peer_map. * May return an empty shared_ptr if the Peer object can't be found. */ PeerRef RemovePeer(NodeId id); // overloaded variant of above to operate on CNode*s void Misbehaving(const CNode &node, int howmuch, const std::string &message) { Misbehaving(node.GetId(), howmuch, message); } /** * Potentially mark a node discouraged based on the contents of a * BlockValidationState object * * @param[in] via_compact_block this bool is passed in because * net_processing should punish peers differently depending on whether the * data was provided in a compact block message or not. If the compact block * had a valid header, but contained invalid txs, the peer should not be * punished. See BIP 152. * * @return Returns true if the peer was punished (probably disconnected) */ bool MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState &state, bool via_compact_block, const std::string &message = ""); /** * Potentially disconnect and discourage a node based on the contents of a * TxValidationState object * * @return Returns true if the peer was punished (probably disconnected) */ bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState &state, const std::string &message = ""); /** * 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 */ bool MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer); void ProcessOrphanTx(const Config &config, std::set &orphan_work_set) EXCLUSIVE_LOCKS_REQUIRED(cs_main, g_cs_orphans); /** Process a single headers message from a peer. */ void ProcessHeadersMessage(const Config &config, CNode &pfrom, const Peer &peer, const std::vector &headers, bool via_compact_block); void SendBlockTransactions(CNode &pfrom, const CBlock &block, const BlockTransactionsRequest &req); /** * Register with InvRequestTracker that a TX INV has been received from a * peer. The announcement parameters are decided in PeerManager and then * passed to InvRequestTracker. */ void AddTxAnnouncement(const CNode &node, const TxId &txid, std::chrono::microseconds current_time) EXCLUSIVE_LOCKS_REQUIRED(::cs_main); /** * Register with InvRequestTracker that a PROOF INV has been received from a * peer. The announcement parameters are decided in PeerManager and then * passed to InvRequestTracker. */ void AddProofAnnouncement(const CNode &node, const avalanche::ProofId &proofid, std::chrono::microseconds current_time, bool preferred) EXCLUSIVE_LOCKS_REQUIRED(cs_proofrequest); /** Send a version message to a peer */ void PushNodeVersion(const Config &config, CNode &pnode, int64_t nTime); /** * Send a ping message every PING_INTERVAL or if requested via RPC. May mark * the peer to be disconnected if a ping has timed out. * We use mockable time for ping timeouts, so setmocktime may cause pings * to time out. */ void MaybeSendPing(CNode &node_to, Peer &peer, std::chrono::microseconds now); /** Send `addr` messages on a regular schedule. */ void MaybeSendAddr(CNode &node, Peer &peer, std::chrono::microseconds current_time); /** Send `feefilter` message. */ void MaybeSendFeefilter(CNode &node, std::chrono::microseconds current_time); /** * Relay (gossip) an address to a few randomly chosen nodes. * * @param[in] originator The id of the peer that sent us the address. We * don't want to relay it back. * @param[in] addr Address to relay. * @param[in] fReachable Whether the address' network is reachable. We * relay unreachable addresses less. */ void RelayAddress(NodeId originator, const CAddress &addr, bool fReachable); const CChainParams &m_chainparams; CConnman &m_connman; AddrMan &m_addrman; /** * Pointer to this node's banman. May be nullptr - check existence before * dereferencing. */ BanMan *const m_banman; ChainstateManager &m_chainman; CTxMemPool &m_mempool; InvRequestTracker m_txrequest GUARDED_BY(::cs_main); Mutex cs_proofrequest; InvRequestTracker m_proofrequest GUARDED_BY(cs_proofrequest); /** The height of the best chain */ std::atomic m_best_height{-1}; //! Next time to check for stale tip int64_t m_stale_tip_check_time; /** Whether this node is running in blocks only mode */ const bool m_ignore_incoming_txs; /** * Whether we've completed initial sync yet, for determining when to turn * on extra block-relay-only peers. */ bool m_initial_sync_finished{false}; /** * Protects m_peer_map. This mutex must not be locked while holding a lock * on any of the mutexes inside a Peer object. */ mutable Mutex m_peer_mutex; /** * Map of all Peer objects, keyed by peer id. This map is protected * by the m_peer_mutex. Once a shared pointer reference is * taken, the lock may be released. Individual fields are protected by * their own locks. */ std::map m_peer_map GUARDED_BY(m_peer_mutex); /** Number of nodes with fSyncStarted. */ int nSyncStarted GUARDED_BY(cs_main) = 0; /** * Sources of received blocks, saved to be able to punish them when * processing happens afterwards. * Set mapBlockSource[hash].second to false if the node should not be * punished if the block is invalid. */ std::map> mapBlockSource GUARDED_BY(cs_main); /** Number of outbound peers with m_chain_sync.m_protect. */ int m_outbound_peers_with_protect_from_disconnect GUARDED_BY(cs_main) = 0; bool AlreadyHaveTx(const TxId &txid) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Filter for transactions that were recently rejected by the mempool. * These are not rerequested until the chain tip changes, at which point * the entire filter is reset. * * Without this filter we'd be re-requesting txs from each of our peers, * increasing bandwidth consumption considerably. For instance, with 100 * peers, half of which relay a tx we don't accept, that might be a 50x * bandwidth increase. A flooding attacker attempting to roll-over the * filter using minimum-sized, 60byte, transactions might manage to send * 1000/sec if we have fast peers, so we pick 120,000 to give our peers a * two minute window to send invs to us. * * Decreasing the false positive rate is fairly cheap, so we pick one in a * million to make it highly unlikely for users to have issues with this * filter. * * Memory used: 1.3 MB */ std::unique_ptr recentRejects GUARDED_BY(cs_main); uint256 hashRecentRejectsChainTip GUARDED_BY(cs_main); /** * Filter for transactions that have been recently confirmed. * We use this to avoid requesting transactions that have already been * confirmed. */ Mutex m_recent_confirmed_transactions_mutex; std::unique_ptr m_recent_confirmed_transactions GUARDED_BY(m_recent_confirmed_transactions_mutex); /** * Returns a bool indicating whether we requested this block. * Also used if a block was /not/ received and timed out or started with * another peer */ bool MarkBlockAsReceived(const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Mark a block as in flight * Returns false, still setting pit, if the block was already in flight from * the same peer pit will only be valid as long as the same cs_main lock is * being held */ bool MarkBlockAsInFlight(const Config &config, NodeId nodeid, const BlockHash &hash, const CBlockIndex *pindex = nullptr, std::list::iterator **pit = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main); bool TipMayBeStale() EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Update pindexLastCommonBlock and add not-in-flight missing successors to * vBlocks, until it has at most count entries. */ void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector &vBlocks, NodeId &nodeStaller) EXCLUSIVE_LOCKS_REQUIRED(cs_main); std::map::iterator>> mapBlocksInFlight GUARDED_BY(cs_main); /** When our tip was last updated. */ std::atomic m_last_tip_update{0}; /** * Determine whether or not a peer can request a transaction, and return it * (or nullptr if not found or not allowed). */ CTransactionRef FindTxForGetData(const CNode &peer, const TxId &txid, const std::chrono::seconds mempool_req, const std::chrono::seconds now) LOCKS_EXCLUDED(cs_main); void ProcessGetData(const Config &config, CNode &pfrom, Peer &peer, const std::atomic &interruptMsgProc) EXCLUSIVE_LOCKS_REQUIRED(peer.m_getdata_requests_mutex) LOCKS_EXCLUDED(cs_main); /** Process a new block. Perform any post-processing housekeeping */ void ProcessBlock(const Config &config, CNode &node, const std::shared_ptr &block, bool force_processing); /** Relay map. */ typedef std::map MapRelay; MapRelay mapRelay GUARDED_BY(cs_main); /** * Expiration-time ordered list of (expire time, relay map entry) pairs, * protected by cs_main). */ std::deque> g_relay_expiration GUARDED_BY(cs_main); /** * When a peer sends us a valid block, instruct it to announce blocks to us * using CMPCTBLOCK if possible by adding its nodeid to the end of * lNodesAnnouncingHeaderAndIDs, and keeping that list under a certain size * by removing the first element if necessary. */ void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** Stack of nodes which we have set to announce using compact blocks */ std::list lNodesAnnouncingHeaderAndIDs GUARDED_BY(cs_main); /** Number of peers from which we're downloading blocks. */ int nPeersWithValidatedDownloads GUARDED_BY(cs_main) = 0; /** Storage for orphan information */ TxOrphanage m_orphanage; void AddToCompactExtraTransactions(const CTransactionRef &tx) EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans); /** * Orphan/conflicted/etc transactions that are kept for compact block * reconstruction. * The last * -blockreconstructionextratxn/DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN of * these are kept in a ring buffer */ std::vector> vExtraTxnForCompact GUARDED_BY(g_cs_orphans); /** Offset into vExtraTxnForCompact to insert the next tx */ size_t vExtraTxnForCompactIt GUARDED_BY(g_cs_orphans) = 0; /** * Check whether the last unknown block a peer advertised is not yet known. */ void ProcessBlockAvailability(NodeId nodeid) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Update tracking information about which blocks a peer is assumed to have. */ void UpdateBlockAvailability(NodeId nodeid, const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main); bool CanDirectFetch(const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * To prevent fingerprinting attacks, only send blocks/headers outside of * the active chain if they are no more than a month older (both in time, * and in best equivalent proof of work) than the best header chain we know * about and we fully-validated them at some point. */ bool BlockRequestAllowed(const CBlockIndex *pindex, const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main); bool AlreadyHaveBlock(const BlockHash &block_hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main); bool AlreadyHaveProof(const avalanche::ProofId &proofid); void ProcessGetBlockData(const Config &config, CNode &pfrom, Peer &peer, const CInv &inv, CConnman &connman); /** * Validation logic for compact filters request handling. * * May disconnect from the peer in the case of a bad request. * * @param[in] peer The peer that we received the request from * @param[in] chain_params Chain parameters * @param[in] filter_type The filter type the request is for. Must be * basic filters. * @param[in] start_height The start height for the request * @param[in] stop_hash The stop_hash for the request * @param[in] max_height_diff The maximum number of items permitted to * request, as specified in BIP 157 * @param[out] stop_index The CBlockIndex for the stop_hash block, if * the request can be serviced. * @param[out] filter_index The filter index, if the request can be * serviced. * @return True if the request can be serviced. */ bool PrepareBlockFilterRequest( CNode &peer, const CChainParams &chain_params, BlockFilterType filter_type, uint32_t start_height, const BlockHash &stop_hash, uint32_t max_height_diff, const CBlockIndex *&stop_index, BlockFilterIndex *&filter_index); /** * Handle a cfilters request. * * May disconnect from the peer in the case of a bad request. * * @param[in] peer The peer that we received the request from * @param[in] vRecv The raw message received * @param[in] chain_params Chain parameters * @param[in] connman Pointer to the connection manager */ void ProcessGetCFilters(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman); /** * Handle a cfheaders request. * * May disconnect from the peer in the case of a bad request. * * @param[in] peer The peer that we received the request from * @param[in] vRecv The raw message received * @param[in] chain_params Chain parameters * @param[in] connman Pointer to the connection manager */ void ProcessGetCFHeaders(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman); /** * Handle a getcfcheckpt request. * * May disconnect from the peer in the case of a bad request. * * @param[in] peer The peer that we received the request from * @param[in] vRecv The raw message received * @param[in] chain_params Chain parameters * @param[in] connman Pointer to the connection manager */ void ProcessGetCFCheckPt(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman); /** * Decide a response for an Avalanche poll about the given block. * * @param[in] hash The hash of the block being polled for * @return Our current vote for the block */ uint32_t GetAvalancheVoteForBlock(const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main); /** * Checks if address relay is permitted with peer. If needed, initializes * the m_addr_known bloom filter and sets m_addr_relay_enabled to true. * * @return True if address relay is enabled with peer * False if address relay is disallowed */ bool SetupAddressRelay(CNode &node, Peer &peer); /** * Manage reception of an avalanche proof. * * @return False if the peer is misbehaving, true otherwise */ bool ReceivedAvalancheProof(CNode &peer, const avalanche::ProofRef &proof); }; } // namespace namespace { /** * Filter for proofs that are consensus-invalid or were recently invalidated * by avalanche (finalized rejection). These are not rerequested until they are * rolled out of the filter. * * Without this filter we'd be re-requesting proofs from each of our peers, * increasing bandwidth consumption considerably. * * Decreasing the false positive rate is fairly cheap, so we pick one in a * million to make it highly unlikely for users to have issues with this filter. */ Mutex cs_invalidProofs; std::unique_ptr invalidProofs GUARDED_BY(cs_invalidProofs); /** Number of preferable block download peers. */ int nPreferredDownload GUARDED_BY(cs_main) = 0; } // namespace namespace { /** * Maintain validation-specific state about nodes, protected by cs_main, instead * by CNode's own locks. This simplifies asynchronous operation, where * processing of incoming data is done after the ProcessMessage call returns, * and we're no longer holding the node's locks. */ struct CNodeState { //! The peer's address const CService address; //! The best known block we know this peer has announced. const CBlockIndex *pindexBestKnownBlock; //! The hash of the last unknown block this peer has announced. BlockHash hashLastUnknownBlock; //! The last full block we both have. const CBlockIndex *pindexLastCommonBlock; //! The best header we have sent our peer. const CBlockIndex *pindexBestHeaderSent; //! Length of current-streak of unconnecting headers announcements int nUnconnectingHeaders; //! Whether we've started headers synchronization with this peer. bool fSyncStarted; //! When to potentially disconnect peer for stalling headers download std::chrono::microseconds m_headers_sync_timeout{0us}; //! Since when we're stalling block download progress (in microseconds), or //! 0. std::chrono::microseconds m_stalling_since{0us}; std::list vBlocksInFlight; //! When the first entry in vBlocksInFlight started downloading. Don't care //! when vBlocksInFlight is empty. std::chrono::microseconds m_downloading_since{0us}; int nBlocksInFlight; int nBlocksInFlightValidHeaders; //! Whether we consider this a preferred download peer. bool fPreferredDownload; //! Whether this peer wants invs or headers (when possible) for block //! announcements. bool fPreferHeaders; //! Whether this peer wants invs or cmpctblocks (when possible) for block //! announcements. bool fPreferHeaderAndIDs; /** * Whether this peer will send us cmpctblocks if we request them. * This is not used to gate request logic, as we really only care about * fSupportsDesiredCmpctVersion, but is used as a flag to "lock in" the * version of compact blocks we send. */ bool fProvidesHeaderAndIDs; /** * If we've announced NODE_WITNESS to this peer: whether the peer sends * witnesses in cmpctblocks/blocktxns, otherwise: whether this peer sends * non-witnesses in cmpctblocks/blocktxns. */ bool fSupportsDesiredCmpctVersion; /** * State used to enforce CHAIN_SYNC_TIMEOUT and EXTRA_PEER_CHECK_INTERVAL * logic. * * Both are only in effect for outbound, non-manual, non-protected * connections. Any peer protected (m_protect = true) is not chosen for * eviction. A peer is marked as protected if all of these are true: * - its connection type is IsBlockOnlyConn() == false * - it gave us a valid connecting header * - we haven't reached MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT yet * - it has a better chain than we have * * CHAIN_SYNC_TIMEOUT: if a peer's best known block has less work than our * tip, set a timeout CHAIN_SYNC_TIMEOUT seconds in the future: * - If at timeout their best known block now has more work than our tip * when the timeout was set, then either reset the timeout or clear it * (after comparing against our current tip's work) * - If at timeout their best known block still has less work than our tip * did when the timeout was set, then send a getheaders message, and set a * shorter timeout, HEADERS_RESPONSE_TIME seconds in future. If their best * known block is still behind when that new timeout is reached, disconnect. * * EXTRA_PEER_CHECK_INTERVAL: after each interval, if we have too many * outbound peers, drop the outbound one that least recently announced us a * new block. */ struct ChainSyncTimeoutState { //! A timeout used for checking whether our peer has sufficiently //! synced. int64_t m_timeout; //! A header with the work we require on our peer's chain. const CBlockIndex *m_work_header; //! After timeout is reached, set to true after sending getheaders. bool m_sent_getheaders; //! Whether this peer is protected from disconnection due to a bad/slow //! chain. bool m_protect; }; ChainSyncTimeoutState m_chain_sync; //! Time of last new block announcement int64_t m_last_block_announcement; struct AvalancheState { std::chrono::time_point last_poll; }; AvalancheState m_avalanche_state; //! Whether this peer is an inbound connection bool m_is_inbound; //! A rolling bloom filter of all announced tx CInvs to this peer. CRollingBloomFilter m_recently_announced_invs = CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001}; //! A rolling bloom filter of all announced Proofs CInvs to this peer. CRollingBloomFilter m_recently_announced_proofs = CRollingBloomFilter{INVENTORY_MAX_RECENT_RELAY, 0.000001}; CNodeState(CAddress addrIn, bool is_inbound) : address(addrIn), m_is_inbound(is_inbound) { pindexBestKnownBlock = nullptr; hashLastUnknownBlock = BlockHash(); pindexLastCommonBlock = nullptr; pindexBestHeaderSent = nullptr; nUnconnectingHeaders = 0; fSyncStarted = false; nBlocksInFlight = 0; nBlocksInFlightValidHeaders = 0; fPreferredDownload = false; fPreferHeaders = false; fPreferHeaderAndIDs = false; fProvidesHeaderAndIDs = false; fSupportsDesiredCmpctVersion = false; m_chain_sync = {0, nullptr, false, false}; m_last_block_announcement = 0; m_recently_announced_invs.reset(); m_recently_announced_proofs.reset(); } }; /** Map maintaining per-node state. */ static std::map mapNodeState GUARDED_BY(cs_main); static CNodeState *State(NodeId pnode) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { std::map::iterator it = mapNodeState.find(pnode); if (it == mapNodeState.end()) { return nullptr; } return &it->second; } /** * Whether the peer supports the address. For example, a peer that does not * implement BIP155 cannot receive Tor v3 addresses because it requires * ADDRv2 (BIP155) encoding. */ static bool IsAddrCompatible(const Peer &peer, const CAddress &addr) { return peer.m_wants_addrv2 || addr.IsAddrV1Compatible(); } static void AddAddressKnown(Peer &peer, const CAddress &addr) { assert(peer.m_addr_known); peer.m_addr_known->insert(addr.GetKey()); } static void PushAddress(Peer &peer, const CAddress &addr, FastRandomContext &insecure_rand) { // Known checking here is only to save space from duplicates. // Before sending, we'll filter it again for known addresses that were // added after addresses were pushed. assert(peer.m_addr_known); if (addr.IsValid() && !peer.m_addr_known->contains(addr.GetKey()) && IsAddrCompatible(peer, addr)) { if (peer.m_addrs_to_send.size() >= GetMaxAddrToSend()) { peer.m_addrs_to_send[insecure_rand.randrange( peer.m_addrs_to_send.size())] = addr; } else { peer.m_addrs_to_send.push_back(addr); } } } static bool isPreferredDownloadPeer(const CNode &pfrom) { LOCK(cs_main); const CNodeState *state = State(pfrom.GetId()); return state && state->fPreferredDownload; } static void UpdatePreferredDownload(const CNode &node, CNodeState *state) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { nPreferredDownload -= state->fPreferredDownload; // Whether this node should be marked as a preferred download node. state->fPreferredDownload = (!node.IsInboundConn() || node.HasPermission(PF_NOBAN)) && !node.IsAddrFetchConn() && !node.fClient; nPreferredDownload += state->fPreferredDownload; } bool PeerManagerImpl::MarkBlockAsReceived(const BlockHash &hash) { std::map::iterator>>::iterator itInFlight = mapBlocksInFlight.find(hash); if (itInFlight != mapBlocksInFlight.end()) { CNodeState *state = State(itInFlight->second.first); assert(state != nullptr); state->nBlocksInFlightValidHeaders -= itInFlight->second.second->fValidatedHeaders; if (state->nBlocksInFlightValidHeaders == 0 && itInFlight->second.second->fValidatedHeaders) { // Last validated block on the queue was received. nPeersWithValidatedDownloads--; } if (state->vBlocksInFlight.begin() == itInFlight->second.second) { // First block on the queue was received, update the start download // time for the next one state->m_downloading_since = std::max(state->m_downloading_since, GetTime()); } state->vBlocksInFlight.erase(itInFlight->second.second); state->nBlocksInFlight--; state->m_stalling_since = 0us; mapBlocksInFlight.erase(itInFlight); return true; } return false; } bool PeerManagerImpl::MarkBlockAsInFlight( const Config &config, NodeId nodeid, const BlockHash &hash, const CBlockIndex *pindex, std::list::iterator **pit) { CNodeState *state = State(nodeid); assert(state != nullptr); // Short-circuit most stuff in case it is from the same node. std::map::iterator>>::iterator itInFlight = mapBlocksInFlight.find(hash); if (itInFlight != mapBlocksInFlight.end() && itInFlight->second.first == nodeid) { if (pit) { *pit = &itInFlight->second.second; } return false; } // Make sure it's not listed somewhere already. MarkBlockAsReceived(hash); std::list::iterator it = state->vBlocksInFlight.insert( state->vBlocksInFlight.end(), {hash, pindex, pindex != nullptr, std::unique_ptr( pit ? new PartiallyDownloadedBlock(config, &m_mempool) : nullptr)}); state->nBlocksInFlight++; state->nBlocksInFlightValidHeaders += it->fValidatedHeaders; if (state->nBlocksInFlight == 1) { // We're starting a block download (batch) from this peer. state->m_downloading_since = GetTime(); } if (state->nBlocksInFlightValidHeaders == 1 && pindex != nullptr) { nPeersWithValidatedDownloads++; } itInFlight = mapBlocksInFlight .insert(std::make_pair(hash, std::make_pair(nodeid, it))) .first; if (pit) { *pit = &itInFlight->second.second; } return true; } void PeerManagerImpl::MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid) { AssertLockHeld(cs_main); CNodeState *nodestate = State(nodeid); if (!nodestate) { LogPrint(BCLog::NET, "node state unavailable: peer=%d\n", nodeid); return; } if (!nodestate->fProvidesHeaderAndIDs) { return; } for (std::list::iterator it = lNodesAnnouncingHeaderAndIDs.begin(); it != lNodesAnnouncingHeaderAndIDs.end(); it++) { if (*it == nodeid) { lNodesAnnouncingHeaderAndIDs.erase(it); lNodesAnnouncingHeaderAndIDs.push_back(nodeid); return; } } m_connman.ForNode(nodeid, [this](CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED( ::cs_main) { AssertLockHeld(::cs_main); uint64_t nCMPCTBLOCKVersion = 1; if (lNodesAnnouncingHeaderAndIDs.size() >= 3) { // As per BIP152, we only get 3 of our peers to announce // blocks using compact encodings. m_connman.ForNode( lNodesAnnouncingHeaderAndIDs.front(), [this, nCMPCTBLOCKVersion](CNode *pnodeStop) { m_connman.PushMessage( pnodeStop, CNetMsgMaker(pnodeStop->GetCommonVersion()) .Make(NetMsgType::SENDCMPCT, /*fAnnounceUsingCMPCTBLOCK=*/false, nCMPCTBLOCKVersion)); // save BIP152 bandwidth state: we select peer to be // low-bandwidth pnodeStop->m_bip152_highbandwidth_to = false; return true; }); lNodesAnnouncingHeaderAndIDs.pop_front(); } m_connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetCommonVersion()) .Make(NetMsgType::SENDCMPCT, /*fAnnounceUsingCMPCTBLOCK=*/true, nCMPCTBLOCKVersion)); // save BIP152 bandwidth state: we select peer to be high-bandwidth pfrom->m_bip152_highbandwidth_to = true; lNodesAnnouncingHeaderAndIDs.push_back(pfrom->GetId()); return true; }); } bool PeerManagerImpl::TipMayBeStale() { AssertLockHeld(cs_main); const Consensus::Params &consensusParams = m_chainparams.GetConsensus(); if (m_last_tip_update == 0) { m_last_tip_update = GetTime(); } return m_last_tip_update < GetTime() - consensusParams.nPowTargetSpacing * 3 && mapBlocksInFlight.empty(); } bool PeerManagerImpl::CanDirectFetch(const Consensus::Params &consensusParams) { return m_chainman.ActiveChain().Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20; } static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { if (state->pindexBestKnownBlock && pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight)) { return true; } if (state->pindexBestHeaderSent && pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight)) { return true; } return false; } void PeerManagerImpl::ProcessBlockAvailability(NodeId nodeid) { CNodeState *state = State(nodeid); assert(state != nullptr); if (!state->hashLastUnknownBlock.IsNull()) { const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(state->hashLastUnknownBlock); if (pindex && pindex->nChainWork > 0) { if (state->pindexBestKnownBlock == nullptr || pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) { state->pindexBestKnownBlock = pindex; } state->hashLastUnknownBlock.SetNull(); } } } void PeerManagerImpl::UpdateBlockAvailability(NodeId nodeid, const BlockHash &hash) { CNodeState *state = State(nodeid); assert(state != nullptr); ProcessBlockAvailability(nodeid); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash); if (pindex && pindex->nChainWork > 0) { // An actually better block was announced. if (state->pindexBestKnownBlock == nullptr || pindex->nChainWork >= state->pindexBestKnownBlock->nChainWork) { state->pindexBestKnownBlock = pindex; } } else { // An unknown block was announced; just assume that the latest one is // the best one. state->hashLastUnknownBlock = hash; } } void PeerManagerImpl::FindNextBlocksToDownload( NodeId nodeid, unsigned int count, std::vector &vBlocks, NodeId &nodeStaller) { if (count == 0) { return; } vBlocks.reserve(vBlocks.size() + count); CNodeState *state = State(nodeid); assert(state != nullptr); // Make sure pindexBestKnownBlock is up to date, we'll need it. ProcessBlockAvailability(nodeid); if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->nChainWork < m_chainman.ActiveChain().Tip()->nChainWork || state->pindexBestKnownBlock->nChainWork < nMinimumChainWork) { // This peer has nothing interesting. return; } if (state->pindexLastCommonBlock == nullptr) { // Bootstrap quickly by guessing a parent of our best tip is the forking // point. Guessing wrong in either direction is not a problem. state->pindexLastCommonBlock = m_chainman .ActiveChain()[std::min(state->pindexBestKnownBlock->nHeight, m_chainman.ActiveChain().Height())]; } // If the peer reorganized, our previous pindexLastCommonBlock may not be an // ancestor of its current tip anymore. Go back enough to fix that. state->pindexLastCommonBlock = LastCommonAncestor( state->pindexLastCommonBlock, state->pindexBestKnownBlock); if (state->pindexLastCommonBlock == state->pindexBestKnownBlock) { return; } std::vector vToFetch; const CBlockIndex *pindexWalk = state->pindexLastCommonBlock; // Never fetch further than the best block we know the peer has, or more // than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last linked block we have in // common with this peer. The +1 is so we can detect stalling, namely if we // would be able to download that next block if the window were 1 larger. int nWindowEnd = state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW; int nMaxHeight = std::min(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1); NodeId waitingfor = -1; while (pindexWalk->nHeight < nMaxHeight) { // Read up to 128 (or more, if more blocks than that are needed) // successors of pindexWalk (towards pindexBestKnownBlock) into // vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as // expensive as iterating over ~100 CBlockIndex* entries anyway. int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight, std::max(count - vBlocks.size(), 128)); vToFetch.resize(nToFetch); pindexWalk = state->pindexBestKnownBlock->GetAncestor( pindexWalk->nHeight + nToFetch); vToFetch[nToFetch - 1] = pindexWalk; for (unsigned int i = nToFetch - 1; i > 0; i--) { vToFetch[i - 1] = vToFetch[i]->pprev; } // Iterate over those blocks in vToFetch (in forward direction), adding // the ones that are not yet downloaded and not in flight to vBlocks. In // the meantime, update pindexLastCommonBlock as long as all ancestors // are already downloaded, or if it's already part of our chain (and // therefore don't need it even if pruned). for (const CBlockIndex *pindex : vToFetch) { if (!pindex->IsValid(BlockValidity::TREE)) { // We consider the chain that this peer is on invalid. return; } if (pindex->nStatus.hasData() || m_chainman.ActiveChain().Contains(pindex)) { if (pindex->HaveTxsDownloaded()) { state->pindexLastCommonBlock = pindex; } } else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) { // The block is not already downloaded, and not yet in flight. if (pindex->nHeight > nWindowEnd) { // We reached the end of the window. if (vBlocks.size() == 0 && waitingfor != nodeid) { // We aren't able to fetch anything, but we would be if // the download window was one larger. nodeStaller = waitingfor; } return; } vBlocks.push_back(pindex); if (vBlocks.size() == count) { return; } } else if (waitingfor == -1) { // This is the first already-in-flight block. waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first; } } } } } // namespace template static bool TooManyAnnouncements(const CNode &node, const InvRequestTracker &requestTracker, const DataRequestParameters &requestParams) { return !node.HasPermission( requestParams.bypass_request_limits_permissions) && requestTracker.Count(node.GetId()) >= requestParams.max_peer_announcements; } /** * Compute the request time for this announcement, current time plus delays for: * - nonpref_peer_delay for announcements from non-preferred connections * - overloaded_peer_delay for announcements from peers which have at least * max_peer_request_in_flight requests in flight (and don't have PF_RELAY). */ template static std::chrono::microseconds ComputeRequestTime(const CNode &node, const InvRequestTracker &requestTracker, const DataRequestParameters &requestParams, std::chrono::microseconds current_time, bool preferred) { auto delay = std::chrono::microseconds{0}; if (!preferred) { delay += requestParams.nonpref_peer_delay; } if (!node.HasPermission(requestParams.bypass_request_limits_permissions) && requestTracker.CountInFlight(node.GetId()) >= requestParams.max_peer_request_in_flight) { delay += requestParams.overloaded_peer_delay; } return current_time + delay; } void PeerManagerImpl::PushNodeVersion(const Config &config, CNode &pnode, int64_t nTime) { // Note that pnode.GetLocalServices() is a reflection of the local // services we were offering when the CNode object was created for this // peer. ServiceFlags nLocalNodeServices = pnode.GetLocalServices(); uint64_t nonce = pnode.GetLocalNonce(); const int nNodeStartingHeight{m_best_height}; NodeId nodeid = pnode.GetId(); CAddress addr = pnode.addr; uint64_t extraEntropy = pnode.GetLocalExtraEntropy(); CAddress addrYou = addr.IsRoutable() && !IsProxy(addr) && addr.IsAddrV1Compatible() ? addr : CAddress(CService(), addr.nServices); CAddress addrMe = CAddress(CService(), nLocalNodeServices); const bool tx_relay = !m_ignore_incoming_txs && pnode.m_tx_relay != nullptr && !pnode.IsFeelerConn(); m_connman.PushMessage( &pnode, CNetMsgMaker(INIT_PROTO_VERSION) .Make(NetMsgType::VERSION, PROTOCOL_VERSION, uint64_t(nLocalNodeServices), nTime, addrYou, addrMe, nonce, userAgent(config), nNodeStartingHeight, tx_relay, extraEntropy)); if (fLogIPs) { LogPrint(BCLog::NET, "send version message: version %d, blocks=%d, us=%s, them=%s, " "txrelay=%d, peer=%d\n", PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), addrYou.ToString(), tx_relay, nodeid); } else { LogPrint(BCLog::NET, "send version message: version %d, blocks=%d, us=%s, " "txrelay=%d, peer=%d\n", PROTOCOL_VERSION, nNodeStartingHeight, addrMe.ToString(), tx_relay, nodeid); } } void PeerManagerImpl::AddTxAnnouncement( const CNode &node, const TxId &txid, std::chrono::microseconds current_time) { // For m_txrequest and state AssertLockHeld(::cs_main); if (TooManyAnnouncements(node, m_txrequest, TX_REQUEST_PARAMS)) { return; } const bool preferred = isPreferredDownloadPeer(node); auto reqtime = ComputeRequestTime(node, m_txrequest, TX_REQUEST_PARAMS, current_time, preferred); m_txrequest.ReceivedInv(node.GetId(), txid, preferred, reqtime); } void PeerManagerImpl::AddProofAnnouncement( const CNode &node, const avalanche::ProofId &proofid, std::chrono::microseconds current_time, bool preferred) { // For m_proofrequest AssertLockHeld(cs_proofrequest); if (TooManyAnnouncements(node, m_proofrequest, PROOF_REQUEST_PARAMS)) { return; } auto reqtime = ComputeRequestTime( node, m_proofrequest, PROOF_REQUEST_PARAMS, current_time, preferred); m_proofrequest.ReceivedInv(node.GetId(), proofid, preferred, reqtime); } // This function is used for testing the stale tip eviction logic, see // denialofservice_tests.cpp void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds) { LOCK(cs_main); CNodeState *state = State(node); if (state) { state->m_last_block_announcement = time_in_seconds; } } void PeerManagerImpl::InitializeNode(const Config &config, CNode *pnode) { CAddress addr = pnode->addr; - std::string addrName = pnode->GetAddrName(); NodeId nodeid = pnode->GetId(); { LOCK(cs_main); mapNodeState.emplace_hint( mapNodeState.end(), std::piecewise_construct, std::forward_as_tuple(nodeid), std::forward_as_tuple(addr, pnode->IsInboundConn())); assert(m_txrequest.Count(nodeid) == 0); } { PeerRef peer = std::make_shared(nodeid); LOCK(m_peer_mutex); m_peer_map.emplace_hint(m_peer_map.end(), nodeid, std::move(peer)); } if (!pnode->IsInboundConn()) { PushNodeVersion(config, *pnode, GetTime()); } } void PeerManagerImpl::ReattemptInitialBroadcast(CScheduler &scheduler) { std::set unbroadcast_txids = m_mempool.GetUnbroadcastTxs(); for (const TxId &txid : unbroadcast_txids) { // Sanity check: all unbroadcast txns should exist in the mempool if (m_mempool.exists(txid)) { RelayTransaction(txid); } else { m_mempool.RemoveUnbroadcastTx(txid, true); } } if (g_avalanche && isAvalancheEnabled(gArgs)) { // Get and sanitize the list of proofids to broadcast. The RelayProof // call is done in a second loop to avoid locking cs_vNodes while // cs_peerManager is locked which would cause a potential deadlock due // to reversed lock order. auto unbroadcasted_proofids = g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) { auto unbroadcasted_proofids = pm.getUnbroadcastProofs(); auto it = unbroadcasted_proofids.begin(); while (it != unbroadcasted_proofids.end()) { // Sanity check: all unbroadcast proofs should be bound to a // peer in the peermanager if (!pm.isBoundToPeer(*it)) { pm.removeUnbroadcastProof(*it); it = unbroadcasted_proofids.erase(it); continue; } ++it; } return unbroadcasted_proofids; }); // Remaining proofids are the ones to broadcast for (const auto &proofid : unbroadcasted_proofids) { RelayProof(proofid); } } // Schedule next run for 10-15 minutes in the future. // We add randomness on every cycle to avoid the possibility of P2P // fingerprinting. const auto reattemptBroadcastInterval = 10min + GetRandMillis(5min); scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); }, reattemptBroadcastInterval); } void PeerManagerImpl::UpdateAvalancheStatistics() const { m_connman.ForEachNode( [](CNode *pnode) { pnode->updateAvailabilityScore(); }); } void PeerManagerImpl::AvalanchePeriodicNetworking(CScheduler &scheduler) const { const auto now = GetTime(); std::vector avanode_ids; bool fQuorumEstablished; bool fShouldRequestMoreNodes; if (!g_avalanche) { // Not enabled or not ready yet, retry later goto scheduleLater; } fQuorumEstablished = g_avalanche->isQuorumEstablished(); fShouldRequestMoreNodes = g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) { return pm.shouldRequestMoreNodes(); }); m_connman.ForEachNode([&](CNode *pnode) { // Build a list of the avalanche peers nodeids if (pnode->m_avalanche_enabled && (!fQuorumEstablished || !pnode->IsInboundConn())) { avanode_ids.push_back(pnode->GetId()); } // If a proof radix tree timed out, cleanup if (pnode->m_proof_relay && now > (pnode->m_proof_relay->lastSharedProofsUpdate.load() + AVALANCHE_AVAPROOFS_TIMEOUT)) { pnode->m_proof_relay->sharedProofs = {}; } }); if (avanode_ids.empty()) { // No node is available for messaging, retry later goto scheduleLater; } Shuffle(avanode_ids.begin(), avanode_ids.end(), FastRandomContext()); // Request avalanche addresses from our peers for (NodeId avanodeId : avanode_ids) { m_connman.ForNode(avanodeId, [&](CNode *pavanode) { LogPrint(BCLog::AVALANCHE, "Requesting more avalanche addresses from peer %d\n", avanodeId); m_connman.PushMessage(pavanode, CNetMsgMaker(pavanode->GetCommonVersion()) .Make(NetMsgType::GETAVAADDR)); PeerRef peer = GetPeerRef(avanodeId); WITH_LOCK(peer->m_addr_token_bucket_mutex, peer->m_addr_token_bucket += GetMaxAddrToSend()); return true; }); // If we have no reason to believe that we need more nodes, only request // addresses from one of our peers. if (fQuorumEstablished && !fShouldRequestMoreNodes) { break; } } if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) { // Don't request proofs while in IBD. We're likely to orphan them // because we don't have the UTXOs. goto scheduleLater; } // If we never had an avaproofs message yet, be kind and only request to a // subset of our peers as we expect a ton of avaproofs message in the // process. if (g_avalanche->getAvaproofsNodeCounter() == 0) { avanode_ids.resize(std::min(avanode_ids.size(), 3)); } for (NodeId nodeid : avanode_ids) { // Send a getavaproofs to one of our peers m_connman.ForNode(nodeid, [&](CNode *pavanode) { LogPrint(BCLog::AVALANCHE, "Requesting compact proofs from peer %d\n", pavanode->GetId()); if (pavanode->m_proof_relay) { m_connman.PushMessage(pavanode, CNetMsgMaker(pavanode->GetCommonVersion()) .Make(NetMsgType::GETAVAPROOFS)); pavanode->m_proof_relay->compactproofs_requested = true; } return true; }); } scheduleLater: // Schedule next run for 2-5 minutes in the future. // We add randomness on every cycle to avoid the possibility of P2P // fingerprinting. const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min); scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); }, avalanchePeriodicNetworkingInterval); } void PeerManagerImpl::FinalizeNode(const Config &config, const CNode &node) { NodeId nodeid = node.GetId(); int misbehavior{0}; { LOCK(cs_main); { // We remove the PeerRef from g_peer_map here, but we don't always // destruct the Peer. Sometimes another thread is still holding a // PeerRef, so the refcount is >= 1. Be careful not to do any // processing here that assumes Peer won't be changed before it's // destructed. PeerRef peer = RemovePeer(nodeid); assert(peer != nullptr); misbehavior = WITH_LOCK(peer->m_misbehavior_mutex, return peer->m_misbehavior_score); LOCK(m_peer_mutex); m_peer_map.erase(nodeid); } CNodeState *state = State(nodeid); assert(state != nullptr); if (state->fSyncStarted) { nSyncStarted--; } for (const QueuedBlock &entry : state->vBlocksInFlight) { mapBlocksInFlight.erase(entry.hash); } WITH_LOCK(g_cs_orphans, m_orphanage.EraseForPeer(nodeid)); m_txrequest.DisconnectedPeer(nodeid); nPreferredDownload -= state->fPreferredDownload; nPeersWithValidatedDownloads -= (state->nBlocksInFlightValidHeaders != 0); assert(nPeersWithValidatedDownloads >= 0); m_outbound_peers_with_protect_from_disconnect -= state->m_chain_sync.m_protect; assert(m_outbound_peers_with_protect_from_disconnect >= 0); mapNodeState.erase(nodeid); if (mapNodeState.empty()) { // Do a consistency check after the last peer is removed. assert(mapBlocksInFlight.empty()); assert(nPreferredDownload == 0); assert(nPeersWithValidatedDownloads == 0); assert(m_outbound_peers_with_protect_from_disconnect == 0); assert(m_txrequest.Size() == 0); } } if (node.fSuccessfullyConnected && misbehavior == 0 && !node.IsBlockOnlyConn() && !node.IsInboundConn()) { // Only change visible addrman state for full outbound peers. We don't // call Connected() for feeler connections since they don't have // fSuccessfullyConnected set. m_addrman.Connected(node.addr); } WITH_LOCK(cs_proofrequest, m_proofrequest.DisconnectedPeer(nodeid)); LogPrint(BCLog::NET, "Cleared nodestate for peer=%d\n", nodeid); } PeerRef PeerManagerImpl::GetPeerRef(NodeId id) const { LOCK(m_peer_mutex); auto it = m_peer_map.find(id); return it != m_peer_map.end() ? it->second : nullptr; } PeerRef PeerManagerImpl::RemovePeer(NodeId id) { PeerRef ret; LOCK(m_peer_mutex); auto it = m_peer_map.find(id); if (it != m_peer_map.end()) { ret = std::move(it->second); m_peer_map.erase(it); } return ret; } bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) { { LOCK(cs_main); CNodeState *state = State(nodeid); if (state == nullptr) { return false; } stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->nHeight : -1; stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->nHeight : -1; for (const QueuedBlock &queue : state->vBlocksInFlight) { if (queue.pindex) { stats.vHeightInFlight.push_back(queue.pindex->nHeight); } } } PeerRef peer = GetPeerRef(nodeid); if (peer == nullptr) { return false; } stats.m_starting_height = peer->m_starting_height; // It is common for nodes with good ping times to suddenly become lagged, // due to a new block arriving or other large transfer. // Merely reporting pingtime might fool the caller into thinking the node // was still responsive, since pingtime does not update until the ping is // complete, which might take a while. So, if a ping is taking an unusually // long time in flight, the caller can immediately detect that this is // happening. std::chrono::microseconds ping_wait{0}; if ((0 != peer->m_ping_nonce_sent) && (0 != peer->m_ping_start.load().count())) { ping_wait = GetTime() - peer->m_ping_start.load(); } stats.m_ping_wait = ping_wait; stats.m_addr_processed = peer->m_addr_processed.load(); stats.m_addr_rate_limited = peer->m_addr_rate_limited.load(); stats.m_addr_relay_enabled = peer->m_addr_relay_enabled.load(); return true; } void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef &tx) { size_t max_extra_txn = gArgs.GetIntArg( "-blockreconstructionextratxn", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN); if (max_extra_txn <= 0) { return; } if (!vExtraTxnForCompact.size()) { vExtraTxnForCompact.resize(max_extra_txn); } vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetHash(), tx); vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn; } void PeerManagerImpl::Misbehaving(const NodeId pnode, const int howmuch, const std::string &message) { assert(howmuch > 0); PeerRef peer = GetPeerRef(pnode); if (peer == nullptr) { return; } LOCK(peer->m_misbehavior_mutex); peer->m_misbehavior_score += howmuch; const std::string message_prefixed = message.empty() ? "" : (": " + message); if (peer->m_misbehavior_score >= DISCOURAGEMENT_THRESHOLD && peer->m_misbehavior_score - howmuch < DISCOURAGEMENT_THRESHOLD) { LogPrint(BCLog::NET, "Misbehaving: peer=%d (%d -> %d) BAN THRESHOLD EXCEEDED%s\n", pnode, peer->m_misbehavior_score - howmuch, peer->m_misbehavior_score, message_prefixed); peer->m_should_discourage = true; } else { LogPrint(BCLog::NET, "Misbehaving: peer=%d (%d -> %d)%s\n", pnode, peer->m_misbehavior_score - howmuch, peer->m_misbehavior_score, message_prefixed); } } bool PeerManagerImpl::MaybePunishNodeForBlock(NodeId nodeid, const BlockValidationState &state, bool via_compact_block, const std::string &message) { switch (state.GetResult()) { case BlockValidationResult::BLOCK_RESULT_UNSET: break; // The node is providing invalid data: case BlockValidationResult::BLOCK_CONSENSUS: case BlockValidationResult::BLOCK_MUTATED: if (!via_compact_block) { Misbehaving(nodeid, 100, message); return true; } break; case BlockValidationResult::BLOCK_CACHED_INVALID: { LOCK(cs_main); CNodeState *node_state = State(nodeid); if (node_state == nullptr) { break; } // Ban outbound (but not inbound) peers if on an invalid chain. // Exempt HB compact block peers. Manual connections are always // protected from discouragement. if (!via_compact_block && !node_state->m_is_inbound) { Misbehaving(nodeid, 100, message); return true; } break; } case BlockValidationResult::BLOCK_INVALID_HEADER: case BlockValidationResult::BLOCK_CHECKPOINT: case BlockValidationResult::BLOCK_INVALID_PREV: Misbehaving(nodeid, 100, message); return true; case BlockValidationResult::BLOCK_FINALIZATION: // TODO: Use the state object to report this is probably not the // best idea. This is effectively unreachable, unless there is a bug // somewhere. Misbehaving(nodeid, 20, message); return true; // Conflicting (but not necessarily invalid) data or different policy: case BlockValidationResult::BLOCK_MISSING_PREV: // TODO: Handle this much more gracefully (10 DoS points is super // arbitrary) Misbehaving(nodeid, 10, message); return true; case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE: case BlockValidationResult::BLOCK_TIME_FUTURE: break; } if (message != "") { LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message); } return false; } bool PeerManagerImpl::MaybePunishNodeForTx(NodeId nodeid, const TxValidationState &state, const std::string &message) { switch (state.GetResult()) { case TxValidationResult::TX_RESULT_UNSET: break; // The node is providing invalid data: case TxValidationResult::TX_CONSENSUS: Misbehaving(nodeid, 100, message); return true; // Conflicting (but not necessarily invalid) data or different policy: case TxValidationResult::TX_RECENT_CONSENSUS_CHANGE: case TxValidationResult::TX_INPUTS_NOT_STANDARD: case TxValidationResult::TX_NOT_STANDARD: case TxValidationResult::TX_MISSING_INPUTS: case TxValidationResult::TX_PREMATURE_SPEND: case TxValidationResult::TX_CONFLICT: case TxValidationResult::TX_MEMPOOL_POLICY: case TxValidationResult::TX_NO_MEMPOOL: break; } if (message != "") { LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message); } return false; } bool PeerManagerImpl::BlockRequestAllowed( const CBlockIndex *pindex, const Consensus::Params &consensusParams) { AssertLockHeld(cs_main); if (m_chainman.ActiveChain().Contains(pindex)) { return true; } return pindex->IsValid(BlockValidity::SCRIPTS) && (pindexBestHeader != nullptr) && (pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() < STALE_RELAY_AGE_LIMIT) && (GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, consensusParams) < STALE_RELAY_AGE_LIMIT); } std::unique_ptr PeerManager::make(const CChainParams &chainparams, CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, bool ignore_incoming_txs) { return std::make_unique(chainparams, connman, addrman, banman, chainman, pool, ignore_incoming_txs); } PeerManagerImpl::PeerManagerImpl(const CChainParams &chainparams, CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, bool ignore_incoming_txs) : m_chainparams(chainparams), m_connman(connman), m_addrman(addrman), m_banman(banman), m_chainman(chainman), m_mempool(pool), m_stale_tip_check_time(0), m_ignore_incoming_txs(ignore_incoming_txs) { // Initialize global variables that cannot be constructed at startup. recentRejects.reset(new CRollingBloomFilter(120000, 0.000001)); { LOCK(cs_invalidProofs); invalidProofs = std::make_unique(100000, 0.000001); } // Blocks don't typically have more than 4000 transactions, so this should // be at least six blocks (~1 hr) worth of transactions that we can store. // If the number of transactions appearing in a block goes up, or if we are // seeing getdata requests more than an hour after initial announcement, we // can increase this number. // The false positive rate of 1/1M should come out to less than 1 // transaction per day that would be inadvertently ignored (which is the // same probability that we have in the reject filter). m_recent_confirmed_transactions.reset( new CRollingBloomFilter(24000, 0.000001)); } void PeerManagerImpl::StartScheduledTasks(CScheduler &scheduler) { // Stale tip checking and peer eviction are on two different timers, but we // don't want them to get out of sync due to drift in the scheduler, so we // combine them in one function and schedule at the quicker (peer-eviction) // timer. static_assert( EXTRA_PEER_CHECK_INTERVAL < STALE_CHECK_INTERVAL, "peer eviction timer should be less than stale tip check timer"); scheduler.scheduleEvery( [this]() { this->CheckForStaleTipAndEvictPeers(); return true; }, std::chrono::seconds{EXTRA_PEER_CHECK_INTERVAL}); // schedule next run for 10-15 minutes in the future const auto reattemptBroadcastInterval = 10min + GetRandMillis(5min); scheduler.scheduleFromNow([&] { ReattemptInitialBroadcast(scheduler); }, reattemptBroadcastInterval); // Update the avalanche statistics on a schedule scheduler.scheduleEvery( [this]() { UpdateAvalancheStatistics(); return true; }, AVALANCHE_STATISTICS_REFRESH_PERIOD); // schedule next run for 2-5 minutes in the future const auto avalanchePeriodicNetworkingInterval = 2min + GetRandMillis(3min); scheduler.scheduleFromNow([&] { AvalanchePeriodicNetworking(scheduler); }, avalanchePeriodicNetworkingInterval); } /** * Evict orphan txn pool entries based on a newly connected * block, remember the recently confirmed transactions, and delete tracked * announcements for them. Also save the time of the last tip update. */ void PeerManagerImpl::BlockConnected( const std::shared_ptr &pblock, const CBlockIndex *pindex) { m_orphanage.EraseForBlock(*pblock); m_last_tip_update = GetTime(); { LOCK(m_recent_confirmed_transactions_mutex); for (const CTransactionRef &ptx : pblock->vtx) { m_recent_confirmed_transactions->insert(ptx->GetId()); } } { LOCK(cs_main); for (const auto &ptx : pblock->vtx) { m_txrequest.ForgetInvId(ptx->GetId()); } } } void PeerManagerImpl::BlockDisconnected( const std::shared_ptr &block, const CBlockIndex *pindex) { // To avoid relay problems with transactions that were previously // confirmed, clear our filter of recently confirmed transactions whenever // there's a reorg. // This means that in a 1-block reorg (where 1 block is disconnected and // then another block reconnected), our filter will drop to having only one // block's worth of transactions in it, but that should be fine, since // presumably the most common case of relaying a confirmed transaction // should be just after a new block containing it is found. LOCK(m_recent_confirmed_transactions_mutex); m_recent_confirmed_transactions->reset(); } // All of the following cache a recent block, and are protected by // cs_most_recent_block static RecursiveMutex cs_most_recent_block; static std::shared_ptr most_recent_block GUARDED_BY(cs_most_recent_block); static std::shared_ptr most_recent_compact_block GUARDED_BY(cs_most_recent_block); static uint256 most_recent_block_hash GUARDED_BY(cs_most_recent_block); /** * Maintain state about the best-seen block and fast-announce a compact block * to compatible peers. */ void PeerManagerImpl::NewPoWValidBlock( const CBlockIndex *pindex, const std::shared_ptr &pblock) { std::shared_ptr pcmpctblock = std::make_shared(*pblock); const CNetMsgMaker msgMaker(PROTOCOL_VERSION); LOCK(cs_main); static int nHighestFastAnnounce = 0; if (pindex->nHeight <= nHighestFastAnnounce) { return; } nHighestFastAnnounce = pindex->nHeight; uint256 hashBlock(pblock->GetHash()); { LOCK(cs_most_recent_block); most_recent_block_hash = hashBlock; most_recent_block = pblock; most_recent_compact_block = pcmpctblock; } m_connman.ForEachNode( [this, &pcmpctblock, pindex, &msgMaker, &hashBlock](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { AssertLockHeld(::cs_main); // TODO: Avoid the repeated-serialization here if (pnode->GetCommonVersion() < INVALID_CB_NO_BAN_VERSION || pnode->fDisconnect) { return; } ProcessBlockAvailability(pnode->GetId()); CNodeState &state = *State(pnode->GetId()); // If the peer has, or we announced to them the previous block // already, but we don't think they have this one, go ahead and // announce it. if (state.fPreferHeaderAndIDs && !PeerHasHeader(&state, pindex) && PeerHasHeader(&state, pindex->pprev)) { LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", "PeerManager::NewPoWValidBlock", hashBlock.ToString(), pnode->GetId()); m_connman.PushMessage( pnode, msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock)); state.pindexBestHeaderSent = pindex; } }); } /** * Update our best height and announce any block hashes which weren't previously * in m_chainman.ActiveChain() to our peers. */ void PeerManagerImpl::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) { SetBestHeight(pindexNew->nHeight); SetServiceFlagsIBDCache(!fInitialDownload); // Don't relay inventory during initial block download. if (fInitialDownload) { return; } // Find the hashes of all blocks that weren't previously in the best chain. std::vector vHashes; const CBlockIndex *pindexToAnnounce = pindexNew; while (pindexToAnnounce != pindexFork) { vHashes.push_back(pindexToAnnounce->GetBlockHash()); pindexToAnnounce = pindexToAnnounce->pprev; if (vHashes.size() == MAX_BLOCKS_TO_ANNOUNCE) { // Limit announcements in case of a huge reorganization. Rely on the // peer's synchronization mechanism in that case. break; } } { LOCK(m_peer_mutex); for (auto &it : m_peer_map) { Peer &peer = *it.second; LOCK(peer.m_block_inv_mutex); for (const BlockHash &hash : reverse_iterate(vHashes)) { peer.m_blocks_for_headers_relay.push_back(hash); } } } m_connman.WakeMessageHandler(); } /** * Handle invalid block rejection and consequent peer banning, maintain which * peers announce compact blocks. */ void PeerManagerImpl::BlockChecked(const CBlock &block, const BlockValidationState &state) { LOCK(cs_main); const BlockHash hash = block.GetHash(); std::map>::iterator it = mapBlockSource.find(hash); // If the block failed validation, we know where it came from and we're // still connected to that peer, maybe punish. if (state.IsInvalid() && it != mapBlockSource.end() && State(it->second.first)) { MaybePunishNodeForBlock(/*nodeid=*/it->second.first, state, /*via_compact_block=*/!it->second.second); } // Check that: // 1. The block is valid // 2. We're not in initial block download // 3. This is currently the best block we're aware of. We haven't updated // the tip yet so we have no way to check this directly here. Instead we // just check that there are currently no other blocks in flight. else if (state.IsValid() && !m_chainman.ActiveChainstate().IsInitialBlockDownload() && mapBlocksInFlight.count(hash) == mapBlocksInFlight.size()) { if (it != mapBlockSource.end()) { MaybeSetPeerAsAnnouncingHeaderAndIDs(it->second.first); } } if (it != mapBlockSource.end()) { mapBlockSource.erase(it); } } ////////////////////////////////////////////////////////////////////////////// // // Messages // bool PeerManagerImpl::AlreadyHaveTx(const TxId &txid) { assert(recentRejects); if (m_chainman.ActiveChain().Tip()->GetBlockHash() != hashRecentRejectsChainTip) { // If the chain tip has changed previously rejected transactions // might be now valid, e.g. due to a nLockTime'd tx becoming // valid, or a double-spend. Reset the rejects filter and give // those txs a second chance. hashRecentRejectsChainTip = m_chainman.ActiveChain().Tip()->GetBlockHash(); recentRejects->reset(); } if (m_orphanage.HaveTx(txid)) { return true; } { LOCK(m_recent_confirmed_transactions_mutex); if (m_recent_confirmed_transactions->contains(txid)) { return true; } } return recentRejects->contains(txid) || m_mempool.exists(txid); } bool PeerManagerImpl::AlreadyHaveBlock(const BlockHash &block_hash) { return m_chainman.m_blockman.LookupBlockIndex(block_hash) != nullptr; } bool PeerManagerImpl::AlreadyHaveProof(const avalanche::ProofId &proofid) { assert(g_avalanche); auto localProof = g_avalanche->getLocalProof(); if (localProof && localProof->getId() == proofid) { return true; } const bool hasProof = g_avalanche->withPeerManager( [&proofid](avalanche::PeerManager &pm) { return pm.exists(proofid); }); LOCK(cs_invalidProofs); return hasProof || invalidProofs->contains(proofid); } void PeerManagerImpl::SendPings() { LOCK(m_peer_mutex); for (auto &it : m_peer_map) { it.second->m_ping_queued = true; } } void PeerManagerImpl::RelayTransaction(const TxId &txid) { m_connman.ForEachNode( [&txid](CNode *pnode) { pnode->PushTxInventory(txid); }); } void PeerManagerImpl::RelayProof(const avalanche::ProofId &proofid) { m_connman.ForEachNode( [&proofid](CNode *pnode) { pnode->PushProofInventory(proofid); }); } void PeerManagerImpl::RelayAddress(NodeId originator, const CAddress &addr, bool fReachable) { // We choose the same nodes within a given 24h window (if the list of // connected nodes does not change) and we don't relay to nodes that already // know an address. So within 24h we will likely relay a given address once. // This is to prevent a peer from unjustly giving their address better // propagation by sending it to us repeatedly. if (!fReachable && !addr.IsRelayable()) { return; } // Relay to a limited number of other nodes // Use deterministic randomness to send to the same nodes for 24 hours // at a time so the m_addr_knowns of the chosen nodes prevent repeats const uint64_t hash_addr{CServiceHash(0, 0)(addr)}; const CSipHasher hasher{ m_connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY) .Write(hash_addr) .Write((GetTime() + hash_addr) / (24 * 60 * 60))}; FastRandomContext insecure_rand; // Relay reachable addresses to 2 peers. Unreachable addresses are relayed // randomly to 1 or 2 peers. unsigned int nRelayNodes = (fReachable || (hasher.Finalize() & 1)) ? 2 : 1; std::array, 2> best{ {{0, nullptr}, {0, nullptr}}}; assert(nRelayNodes <= best.size()); LOCK(m_peer_mutex); for (auto &[id, peer] : m_peer_map) { if (peer->m_addr_relay_enabled && id != originator && IsAddrCompatible(*peer, addr)) { uint64_t hashKey = CSipHasher(hasher).Write(id).Finalize(); for (unsigned int i = 0; i < nRelayNodes; i++) { if (hashKey > best[i].first) { std::copy(best.begin() + i, best.begin() + nRelayNodes - 1, best.begin() + i + 1); best[i] = std::make_pair(hashKey, peer.get()); break; } } } }; for (unsigned int i = 0; i < nRelayNodes && best[i].first != 0; i++) { PushAddress(*best[i].second, addr, insecure_rand); } } void PeerManagerImpl::ProcessGetBlockData(const Config &config, CNode &pfrom, Peer &peer, const CInv &inv, CConnman &connman) { const Consensus::Params &consensusParams = config.GetChainParams().GetConsensus(); const BlockHash hash(inv.hash); bool send = false; std::shared_ptr a_recent_block; std::shared_ptr a_recent_compact_block; { LOCK(cs_most_recent_block); a_recent_block = most_recent_block; a_recent_compact_block = most_recent_compact_block; } bool need_activate_chain = false; { LOCK(cs_main); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash); if (pindex) { if (pindex->HaveTxsDownloaded() && !pindex->IsValid(BlockValidity::SCRIPTS) && pindex->IsValid(BlockValidity::TREE)) { // If we have the block and all of its parents, but have not yet // validated it, we might be in the middle of connecting it (ie // in the unlock of cs_main before ActivateBestChain but after // AcceptBlock). In this case, we need to run ActivateBestChain // prior to checking the relay conditions below. need_activate_chain = true; } } } // release cs_main before calling ActivateBestChain if (need_activate_chain) { BlockValidationState state; if (!m_chainman.ActiveChainstate().ActivateBestChain(config, state, a_recent_block)) { LogPrint(BCLog::NET, "failed to activate chain (%s)\n", state.ToString()); } } LOCK(cs_main); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash); if (pindex) { send = BlockRequestAllowed(pindex, consensusParams); if (!send) { LogPrint(BCLog::NET, "%s: ignoring request from peer=%i for old " "block that isn't in the main chain\n", __func__, pfrom.GetId()); } } const CNetMsgMaker msgMaker(pfrom.GetCommonVersion()); // Disconnect node in case we have reached the outbound limit for serving // historical blocks. if (send && connman.OutboundTargetReached(true) && (((pindexBestHeader != nullptr) && (pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() > HISTORICAL_BLOCK_AGE)) || inv.IsMsgFilteredBlk()) && // nodes with the download permission may exceed target !pfrom.HasPermission(PF_DOWNLOAD)) { LogPrint(BCLog::NET, "historical block serving limit reached, disconnect peer=%d\n", pfrom.GetId()); // disconnect node pfrom.fDisconnect = true; send = false; } // Avoid leaking prune-height by never sending blocks below the // NODE_NETWORK_LIMITED threshold. // Add two blocks buffer extension for possible races if (send && !pfrom.HasPermission(PF_NOBAN) && ((((pfrom.GetLocalServices() & NODE_NETWORK_LIMITED) == NODE_NETWORK_LIMITED) && ((pfrom.GetLocalServices() & NODE_NETWORK) != NODE_NETWORK) && (m_chainman.ActiveChain().Tip()->nHeight - pindex->nHeight > (int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2)))) { LogPrint(BCLog::NET, "Ignore block request below NODE_NETWORK_LIMITED " "threshold from peer=%d\n", pfrom.GetId()); // disconnect node and prevent it from stalling (would otherwise wait // for the missing block) pfrom.fDisconnect = true; send = false; } // Pruned nodes may have deleted the block, so check whether it's available // before trying to send. if (send && pindex->nStatus.hasData()) { std::shared_ptr pblock; if (a_recent_block && a_recent_block->GetHash() == pindex->GetBlockHash()) { pblock = a_recent_block; } else { // Send block from disk std::shared_ptr pblockRead = std::make_shared(); if (!ReadBlockFromDisk(*pblockRead, pindex, consensusParams)) { assert(!"cannot load block from disk"); } pblock = pblockRead; } if (inv.IsMsgBlk()) { connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, *pblock)); } else if (inv.IsMsgFilteredBlk()) { bool sendMerkleBlock = false; CMerkleBlock merkleBlock; if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_filter); if (pfrom.m_tx_relay->pfilter) { sendMerkleBlock = true; merkleBlock = CMerkleBlock(*pblock, *pfrom.m_tx_relay->pfilter); } } if (sendMerkleBlock) { connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::MERKLEBLOCK, merkleBlock)); // CMerkleBlock just contains hashes, so also push any // transactions in the block the client did not see. This avoids // hurting performance by pointlessly requiring a round-trip. // Note that there is currently no way for a node to request any // single transactions we didn't send here - they must either // disconnect and retry or request the full block. Thus, the // protocol spec specified allows for us to provide duplicate // txn here, however we MUST always provide at least what the // remote peer needs. typedef std::pair PairType; for (PairType &pair : merkleBlock.vMatchedTxn) { connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::TX, *pblock->vtx[pair.first])); } } // else // no response } else if (inv.IsMsgCmpctBlk()) { // If a peer is asking for old blocks, we're almost guaranteed they // won't have a useful mempool to match against a compact block, and // we don't feel like constructing the object for them, so instead // we respond with the full, non-compact block. int nSendFlags = 0; if (CanDirectFetch(consensusParams) && pindex->nHeight >= m_chainman.ActiveChain().Height() - MAX_CMPCTBLOCK_DEPTH) { CBlockHeaderAndShortTxIDs cmpctblock(*pblock); connman.PushMessage( &pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock)); } else { connman.PushMessage( &pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCK, *pblock)); } } { LOCK(peer.m_block_inv_mutex); // Trigger the peer node to send a getblocks request for the next // batch of inventory. if (hash == peer.m_continuation_block) { // Send immediately. This must send even if redundant, and // we want it right after the last block so they don't wait for // other stuff first. std::vector vInv; vInv.push_back(CInv( MSG_BLOCK, m_chainman.ActiveChain().Tip()->GetBlockHash())); connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::INV, vInv)); peer.m_continuation_block = BlockHash(); } } } } CTransactionRef PeerManagerImpl::FindTxForGetData(const CNode &peer, const TxId &txid, const std::chrono::seconds mempool_req, const std::chrono::seconds now) { auto txinfo = m_mempool.info(txid); if (txinfo.tx) { // If a TX could have been INVed in reply to a MEMPOOL request, // or is older than UNCONDITIONAL_RELAY_DELAY, permit the request // unconditionally. if ((mempool_req.count() && txinfo.m_time <= mempool_req) || txinfo.m_time <= now - UNCONDITIONAL_RELAY_DELAY) { return std::move(txinfo.tx); } } { LOCK(cs_main); // Otherwise, the transaction must have been announced recently. if (State(peer.GetId())->m_recently_announced_invs.contains(txid)) { // If it was, it can be relayed from either the mempool... if (txinfo.tx) { return std::move(txinfo.tx); } // ... or the relay pool. auto mi = mapRelay.find(txid); if (mi != mapRelay.end()) { return mi->second; } } } return {}; } //! Determine whether or not a peer can request a proof, and return it (or //! nullptr if not found or not allowed). static avalanche::ProofRef FindProofForGetData(const CNode &peer, const avalanche::ProofId &proofid, const std::chrono::seconds now) { avalanche::ProofRef proof; bool send_unconditionally = g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) { return pm.forPeer(proofid, [&](const avalanche::Peer &peer) { proof = peer.proof; // If we know that proof for long enough, allow for requesting // it. return peer.registration_time <= now - UNCONDITIONAL_RELAY_DELAY; }); }); if (!proof) { // Always send our local proof if it gets requested, assuming it's // valid. This will make it easier to bind with peers upon startup where // the status of our proof is unknown pending for a block. Note that it // still needs to have been announced first (presumably via an avahello // message). proof = g_avalanche->getLocalProof(); } // We don't have this proof if (!proof) { return avalanche::ProofRef(); } if (send_unconditionally) { return proof; } // Otherwise, the proofs must have been announced recently. LOCK(cs_main); if (State(peer.GetId())->m_recently_announced_proofs.contains(proofid)) { return proof; } return avalanche::ProofRef(); } void PeerManagerImpl::ProcessGetData( const Config &config, CNode &pfrom, Peer &peer, const std::atomic &interruptMsgProc) { AssertLockNotHeld(cs_main); std::deque::iterator it = peer.m_getdata_requests.begin(); std::vector vNotFound; const CNetMsgMaker msgMaker(pfrom.GetCommonVersion()); const std::chrono::seconds now = GetTime(); // Get last mempool request time const std::chrono::seconds mempool_req = pfrom.m_tx_relay != nullptr ? pfrom.m_tx_relay->m_last_mempool_req.load() : std::chrono::seconds::min(); // Process as many TX or AVA_PROOF items from the front of the getdata // queue as possible, since they're common and it's efficient to batch // process them. while (it != peer.m_getdata_requests.end()) { if (interruptMsgProc) { return; } // The send buffer provides backpressure. If there's no space in // the buffer, pause processing until the next call. if (pfrom.fPauseSend) { break; } const CInv &inv = *it; if (it->IsMsgProof()) { const avalanche::ProofId proofid(inv.hash); auto proof = FindProofForGetData(pfrom, proofid, now); if (proof) { m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof)); g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) { pm.removeUnbroadcastProof(proofid); }); } else { vNotFound.push_back(inv); } ++it; continue; } if (it->IsMsgTx()) { if (pfrom.m_tx_relay == nullptr) { // Ignore GETDATA requests for transactions from blocks-only // peers. continue; } const TxId txid(inv.hash); CTransactionRef tx = FindTxForGetData(pfrom, txid, mempool_req, now); if (tx) { int nSendFlags = 0; m_connman.PushMessage( &pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *tx)); m_mempool.RemoveUnbroadcastTx(txid); // As we're going to send tx, make sure its unconfirmed parents // are made requestable. std::vector parent_ids_to_add; { LOCK(m_mempool.cs); auto txiter = m_mempool.GetIter(tx->GetId()); if (txiter) { const CTxMemPoolEntry::Parents &parents = (*txiter)->GetMemPoolParentsConst(); parent_ids_to_add.reserve(parents.size()); for (const CTxMemPoolEntry &parent : parents) { if (parent.GetTime() > now - UNCONDITIONAL_RELAY_DELAY) { parent_ids_to_add.push_back( parent.GetTx().GetId()); } } } } for (const TxId &parent_txid : parent_ids_to_add) { // Relaying a transaction with a recent but unconfirmed // parent. if (WITH_LOCK(pfrom.m_tx_relay->cs_tx_inventory, return !pfrom.m_tx_relay->filterInventoryKnown .contains(parent_txid))) { LOCK(cs_main); State(pfrom.GetId()) ->m_recently_announced_invs.insert(parent_txid); } } } else { vNotFound.push_back(inv); } ++it; continue; } // It's neither a proof nor a transaction break; } // Only process one BLOCK item per call, since they're uncommon and can be // expensive to process. if (it != peer.m_getdata_requests.end() && !pfrom.fPauseSend) { const CInv &inv = *it++; if (inv.IsGenBlkMsg()) { ProcessGetBlockData(config, pfrom, peer, inv, m_connman); } // else: If the first item on the queue is an unknown type, we erase it // and continue processing the queue on the next call. } peer.m_getdata_requests.erase(peer.m_getdata_requests.begin(), it); if (!vNotFound.empty()) { // Let the peer know that we didn't find what it asked for, so it // doesn't have to wait around forever. SPV clients care about this // message: it's needed when they are recursively walking the // dependencies of relevant unconfirmed transactions. SPV clients want // to do that because they want to know about (and store and rebroadcast // and risk analyze) the dependencies of transactions relevant to them, // without having to download the entire memory pool. Also, other nodes // can use these messages to automatically request a transaction from // some other peer that annnounced it, and stop waiting for us to // respond. In normal operation, we often send NOTFOUND messages for // parents of transactions that we relay; if a peer is missing a parent, // they may assume we have them and request the parents from us. m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::NOTFOUND, vNotFound)); } } void PeerManagerImpl::SendBlockTransactions( CNode &pfrom, const CBlock &block, const BlockTransactionsRequest &req) { BlockTransactions resp(req); for (size_t i = 0; i < req.indices.size(); i++) { if (req.indices[i] >= block.vtx.size()) { Misbehaving(pfrom, 100, "getblocktxn with out-of-bounds tx indices"); return; } resp.txn[i] = block.vtx[req.indices[i]]; } LOCK(cs_main); const CNetMsgMaker msgMaker(pfrom.GetCommonVersion()); int nSendFlags = 0; m_connman.PushMessage( &pfrom, msgMaker.Make(nSendFlags, NetMsgType::BLOCKTXN, resp)); } void PeerManagerImpl::ProcessHeadersMessage( const Config &config, CNode &pfrom, const Peer &peer, const std::vector &headers, bool via_compact_block) { const CNetMsgMaker msgMaker(pfrom.GetCommonVersion()); size_t nCount = headers.size(); if (nCount == 0) { // Nothing interesting. Stop asking this peers for more headers. return; } bool received_new_header = false; const CBlockIndex *pindexLast = nullptr; { LOCK(cs_main); CNodeState *nodestate = State(pfrom.GetId()); // If this looks like it could be a block announcement (nCount < // MAX_BLOCKS_TO_ANNOUNCE), use special logic for handling headers that // don't connect: // - Send a getheaders message in response to try to connect the chain. // - The peer can send up to MAX_UNCONNECTING_HEADERS in a row that // don't connect before giving DoS points // - Once a headers message is received that is valid and does connect, // nUnconnectingHeaders gets reset back to 0. if (!m_chainman.m_blockman.LookupBlockIndex(headers[0].hashPrevBlock) && nCount < MAX_BLOCKS_TO_ANNOUNCE) { nodestate->nUnconnectingHeaders++; m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator( pindexBestHeader), uint256())); LogPrint( BCLog::NET, "received header %s: missing prev block %s, sending getheaders " "(%d) to end (peer=%d, nUnconnectingHeaders=%d)\n", headers[0].GetHash().ToString(), headers[0].hashPrevBlock.ToString(), pindexBestHeader->nHeight, pfrom.GetId(), nodestate->nUnconnectingHeaders); // Set hashLastUnknownBlock for this peer, so that if we eventually // get the headers - even from a different peer - we can use this // peer to download. UpdateBlockAvailability(pfrom.GetId(), headers.back().GetHash()); if (nodestate->nUnconnectingHeaders % MAX_UNCONNECTING_HEADERS == 0) { // The peer is sending us many headers we can't connect. Misbehaving(pfrom, 20, strprintf("%d non-connecting headers", nodestate->nUnconnectingHeaders)); } return; } BlockHash hashLastBlock; for (const CBlockHeader &header : headers) { if (!hashLastBlock.IsNull() && header.hashPrevBlock != hashLastBlock) { Misbehaving(pfrom, 20, "non-continuous headers sequence"); return; } hashLastBlock = header.GetHash(); } // If we don't have the last header, then they'll have given us // something new (if these headers are valid). if (!m_chainman.m_blockman.LookupBlockIndex(hashLastBlock)) { received_new_header = true; } } BlockValidationState state; if (!m_chainman.ProcessNewBlockHeaders(config, headers, state, &pindexLast)) { if (state.IsInvalid()) { MaybePunishNodeForBlock(pfrom.GetId(), state, via_compact_block, "invalid header received"); return; } } { LOCK(cs_main); CNodeState *nodestate = State(pfrom.GetId()); if (nodestate->nUnconnectingHeaders > 0) { LogPrint(BCLog::NET, "peer=%d: resetting nUnconnectingHeaders (%d -> 0)\n", pfrom.GetId(), nodestate->nUnconnectingHeaders); } nodestate->nUnconnectingHeaders = 0; assert(pindexLast); UpdateBlockAvailability(pfrom.GetId(), pindexLast->GetBlockHash()); // From here, pindexBestKnownBlock should be guaranteed to be non-null, // because it is set in UpdateBlockAvailability. Some nullptr checks are // still present, however, as belt-and-suspenders. if (received_new_header && pindexLast->nChainWork > m_chainman.ActiveChain().Tip()->nChainWork) { nodestate->m_last_block_announcement = GetTime(); } if (nCount == MAX_HEADERS_RESULTS) { // Headers message had its maximum size; the peer may have more // headers. // TODO: optimize: if pindexLast is an ancestor of // m_chainman.ActiveChain().Tip or pindexBestHeader, continue from // there instead. LogPrint( BCLog::NET, "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->nHeight, pfrom.GetId(), peer.m_starting_height); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator(pindexLast), uint256())); } bool fCanDirectFetch = CanDirectFetch(m_chainparams.GetConsensus()); // If this set of headers is valid and ends in a block with at least as // much work as our tip, download as much as possible. if (fCanDirectFetch && pindexLast->IsValid(BlockValidity::TREE) && m_chainman.ActiveChain().Tip()->nChainWork <= pindexLast->nChainWork) { std::vector vToFetch; const CBlockIndex *pindexWalk = pindexLast; // Calculate all the blocks we'd need to switch to pindexLast, up to // a limit. while (pindexWalk && !m_chainman.ActiveChain().Contains(pindexWalk) && vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) { if (!pindexWalk->nStatus.hasData() && !mapBlocksInFlight.count(pindexWalk->GetBlockHash())) { // We don't have this block, and it's not yet in flight. vToFetch.push_back(pindexWalk); } pindexWalk = pindexWalk->pprev; } // If pindexWalk still isn't on our main chain, we're looking at a // very large reorg at a time we think we're close to caught up to // the main chain -- this shouldn't really happen. Bail out on the // direct fetch and rely on parallel download instead. if (!m_chainman.ActiveChain().Contains(pindexWalk)) { LogPrint( BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n", pindexLast->GetBlockHash().ToString(), pindexLast->nHeight); } else { std::vector vGetData; // Download as much as possible, from earliest to latest. for (const CBlockIndex *pindex : reverse_iterate(vToFetch)) { if (nodestate->nBlocksInFlight >= MAX_BLOCKS_IN_TRANSIT_PER_PEER) { // Can't download any more from this peer break; } vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash())); MarkBlockAsInFlight(config, pfrom.GetId(), pindex->GetBlockHash(), pindex); LogPrint(BCLog::NET, "Requesting block %s from peer=%d\n", pindex->GetBlockHash().ToString(), pfrom.GetId()); } if (vGetData.size() > 1) { LogPrint(BCLog::NET, "Downloading blocks toward %s (%d) via headers " "direct fetch\n", pindexLast->GetBlockHash().ToString(), pindexLast->nHeight); } if (vGetData.size() > 0) { if (nodestate->fSupportsDesiredCmpctVersion && vGetData.size() == 1 && mapBlocksInFlight.size() == 1 && pindexLast->pprev->IsValid(BlockValidity::CHAIN)) { // In any case, we want to download using a compact // block, not a regular one. vGetData[0] = CInv(MSG_CMPCT_BLOCK, vGetData[0].hash); } m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETDATA, vGetData)); } } } // If we're in IBD, we want outbound peers that will serve us a useful // chain. Disconnect peers that are on chains with insufficient work. if (m_chainman.ActiveChainstate().IsInitialBlockDownload() && nCount != MAX_HEADERS_RESULTS) { // When nCount < MAX_HEADERS_RESULTS, we know we have no more // headers to fetch from this peer. if (nodestate->pindexBestKnownBlock && nodestate->pindexBestKnownBlock->nChainWork < nMinimumChainWork) { // This peer has too little work on their headers chain to help // us sync -- disconnect if it is an outbound disconnection // candidate. // Note: We compare their tip to nMinimumChainWork (rather than // m_chainman.ActiveChain().Tip()) because we won't start block // download until we have a headers chain that has at least // nMinimumChainWork, even if a peer has a chain past our tip, // as an anti-DoS measure. if (pfrom.IsOutboundOrBlockRelayConn()) { LogPrintf("Disconnecting outbound peer %d -- headers " "chain has insufficient work\n", pfrom.GetId()); pfrom.fDisconnect = true; } } } // If this is an outbound full-relay peer, check to see if we should // protect it from the bad/lagging chain logic. // Note that outbound block-relay peers are excluded from this // protection, and thus always subject to eviction under the bad/lagging // chain logic. // See ChainSyncTimeoutState. if (!pfrom.fDisconnect && pfrom.IsFullOutboundConn() && nodestate->pindexBestKnownBlock != nullptr) { if (m_outbound_peers_with_protect_from_disconnect < MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT && nodestate->pindexBestKnownBlock->nChainWork >= m_chainman.ActiveChain().Tip()->nChainWork && !nodestate->m_chain_sync.m_protect) { LogPrint(BCLog::NET, "Protecting outbound peer=%d from eviction\n", pfrom.GetId()); nodestate->m_chain_sync.m_protect = true; ++m_outbound_peers_with_protect_from_disconnect; } } } } /** * Reconsider orphan transactions after a parent has been accepted to the * mempool. * * @param[in,out] orphan_work_set The set of orphan transactions to * reconsider. Generally only one orphan will be reconsidered on each call of * this function. This set may be added to if accepting an orphan causes its * children to be reconsidered. */ void PeerManagerImpl::ProcessOrphanTx(const Config &config, std::set &orphan_work_set) { AssertLockHeld(cs_main); AssertLockHeld(g_cs_orphans); while (!orphan_work_set.empty()) { const TxId orphanTxId = *orphan_work_set.begin(); orphan_work_set.erase(orphan_work_set.begin()); const auto [porphanTx, from_peer] = m_orphanage.GetTx(orphanTxId); if (porphanTx == nullptr) { continue; } const MempoolAcceptResult result = m_chainman.ProcessTransaction(porphanTx); const TxValidationState &state = result.m_state; if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) { LogPrint(BCLog::MEMPOOL, " accepted orphan tx %s\n", orphanTxId.ToString()); RelayTransaction(orphanTxId); m_orphanage.AddChildrenToWorkSet(*porphanTx, orphan_work_set); m_orphanage.EraseTx(orphanTxId); break; } else if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) { if (state.IsInvalid()) { LogPrint(BCLog::MEMPOOL, " invalid orphan tx %s from peer=%d. %s\n", orphanTxId.ToString(), from_peer, state.ToString()); // Punish peer that gave us an invalid orphan tx MaybePunishNodeForTx(from_peer, state); } // Has inputs but not accepted to mempool // Probably non-standard or insufficient fee LogPrint(BCLog::MEMPOOL, " removed orphan tx %s\n", orphanTxId.ToString()); assert(recentRejects); recentRejects->insert(orphanTxId); m_orphanage.EraseTx(orphanTxId); break; } } } bool PeerManagerImpl::PrepareBlockFilterRequest( CNode &peer, const CChainParams &chain_params, BlockFilterType filter_type, uint32_t start_height, const BlockHash &stop_hash, uint32_t max_height_diff, const CBlockIndex *&stop_index, BlockFilterIndex *&filter_index) { const bool supported_filter_type = (filter_type == BlockFilterType::BASIC && (peer.GetLocalServices() & NODE_COMPACT_FILTERS)); if (!supported_filter_type) { LogPrint(BCLog::NET, "peer %d requested unsupported block filter type: %d\n", peer.GetId(), static_cast(filter_type)); peer.fDisconnect = true; return false; } { LOCK(cs_main); stop_index = m_chainman.m_blockman.LookupBlockIndex(stop_hash); // Check that the stop block exists and the peer would be allowed to // fetch it. if (!stop_index || !BlockRequestAllowed(stop_index, chain_params.GetConsensus())) { LogPrint(BCLog::NET, "peer %d requested invalid block hash: %s\n", peer.GetId(), stop_hash.ToString()); peer.fDisconnect = true; return false; } } uint32_t stop_height = stop_index->nHeight; if (start_height > stop_height) { LogPrint( BCLog::NET, "peer %d sent invalid getcfilters/getcfheaders with " /* Continued */ "start height %d and stop height %d\n", peer.GetId(), start_height, stop_height); peer.fDisconnect = true; return false; } if (stop_height - start_height >= max_height_diff) { LogPrint(BCLog::NET, "peer %d requested too many cfilters/cfheaders: %d / %d\n", peer.GetId(), stop_height - start_height + 1, max_height_diff); peer.fDisconnect = true; return false; } filter_index = GetBlockFilterIndex(filter_type); if (!filter_index) { LogPrint(BCLog::NET, "Filter index for supported type %s not found\n", BlockFilterTypeName(filter_type)); return false; } return true; } void PeerManagerImpl::ProcessGetCFilters(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman) { uint8_t filter_type_ser; uint32_t start_height; BlockHash stop_hash; vRecv >> filter_type_ser >> start_height >> stop_hash; const BlockFilterType filter_type = static_cast(filter_type_ser); const CBlockIndex *stop_index; BlockFilterIndex *filter_index; if (!PrepareBlockFilterRequest( peer, chain_params, filter_type, start_height, stop_hash, MAX_GETCFILTERS_SIZE, stop_index, filter_index)) { return; } std::vector filters; if (!filter_index->LookupFilterRange(start_height, stop_index, filters)) { LogPrint(BCLog::NET, "Failed to find block filter in index: filter_type=%s, " "start_height=%d, stop_hash=%s\n", BlockFilterTypeName(filter_type), start_height, stop_hash.ToString()); return; } for (const auto &filter : filters) { CSerializedNetMsg msg = CNetMsgMaker(peer.GetCommonVersion()) .Make(NetMsgType::CFILTER, filter); connman.PushMessage(&peer, std::move(msg)); } } void PeerManagerImpl::ProcessGetCFHeaders(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman) { uint8_t filter_type_ser; uint32_t start_height; BlockHash stop_hash; vRecv >> filter_type_ser >> start_height >> stop_hash; const BlockFilterType filter_type = static_cast(filter_type_ser); const CBlockIndex *stop_index; BlockFilterIndex *filter_index; if (!PrepareBlockFilterRequest( peer, chain_params, filter_type, start_height, stop_hash, MAX_GETCFHEADERS_SIZE, stop_index, filter_index)) { return; } uint256 prev_header; if (start_height > 0) { const CBlockIndex *const prev_block = stop_index->GetAncestor(static_cast(start_height - 1)); if (!filter_index->LookupFilterHeader(prev_block, prev_header)) { LogPrint(BCLog::NET, "Failed to find block filter header in index: " "filter_type=%s, block_hash=%s\n", BlockFilterTypeName(filter_type), prev_block->GetBlockHash().ToString()); return; } } std::vector filter_hashes; if (!filter_index->LookupFilterHashRange(start_height, stop_index, filter_hashes)) { LogPrint(BCLog::NET, "Failed to find block filter hashes in index: filter_type=%s, " "start_height=%d, stop_hash=%s\n", BlockFilterTypeName(filter_type), start_height, stop_hash.ToString()); return; } CSerializedNetMsg msg = CNetMsgMaker(peer.GetCommonVersion()) .Make(NetMsgType::CFHEADERS, filter_type_ser, stop_index->GetBlockHash(), prev_header, filter_hashes); connman.PushMessage(&peer, std::move(msg)); } void PeerManagerImpl::ProcessGetCFCheckPt(CNode &peer, CDataStream &vRecv, const CChainParams &chain_params, CConnman &connman) { uint8_t filter_type_ser; BlockHash stop_hash; vRecv >> filter_type_ser >> stop_hash; const BlockFilterType filter_type = static_cast(filter_type_ser); const CBlockIndex *stop_index; BlockFilterIndex *filter_index; if (!PrepareBlockFilterRequest( peer, chain_params, filter_type, /*start_height=*/0, stop_hash, /*max_height_diff=*/std::numeric_limits::max(), stop_index, filter_index)) { return; } std::vector headers(stop_index->nHeight / CFCHECKPT_INTERVAL); // Populate headers. const CBlockIndex *block_index = stop_index; for (int i = headers.size() - 1; i >= 0; i--) { int height = (i + 1) * CFCHECKPT_INTERVAL; block_index = block_index->GetAncestor(height); if (!filter_index->LookupFilterHeader(block_index, headers[i])) { LogPrint(BCLog::NET, "Failed to find block filter header in index: " "filter_type=%s, block_hash=%s\n", BlockFilterTypeName(filter_type), block_index->GetBlockHash().ToString()); return; } } CSerializedNetMsg msg = CNetMsgMaker(peer.GetCommonVersion()) .Make(NetMsgType::CFCHECKPT, filter_type_ser, stop_index->GetBlockHash(), headers); connman.PushMessage(&peer, std::move(msg)); } bool IsAvalancheMessageType(const std::string &msg_type) { return msg_type == NetMsgType::AVAHELLO || msg_type == NetMsgType::AVAPOLL || msg_type == NetMsgType::AVARESPONSE || msg_type == NetMsgType::AVAPROOF || msg_type == NetMsgType::GETAVAADDR || msg_type == NetMsgType::GETAVAPROOFS || msg_type == NetMsgType::AVAPROOFS || msg_type == NetMsgType::AVAPROOFSREQ; } uint32_t PeerManagerImpl::GetAvalancheVoteForBlock(const BlockHash &hash) { AssertLockHeld(cs_main); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash); // Unknown block. if (!pindex) { return -1; } // Invalid block if (pindex->nStatus.isInvalid()) { return 1; } // Parked block if (pindex->nStatus.isOnParkedChain()) { return 2; } const CBlockIndex *pindexTip = m_chainman.ActiveChain().Tip(); const CBlockIndex *pindexFork = LastCommonAncestor(pindex, pindexTip); // Active block. if (pindex == pindexFork) { return 0; } // Fork block. if (pindexFork != pindexTip) { return 3; } // Missing block data. if (!pindex->nStatus.hasData()) { return -2; } // This block is built on top of the tip, we have the data, it // is pending connection or rejection. return -3; }; /** * Decide a response for an Avalanche poll about the given transaction. * * FIXME This function should be expanded to return different vote responses * based on inspection of mempool. * * @param[in] mempool The mempool to base our votes on * @param[in] id The id of the transaction being polled for * @return Our current vote for the proof */ static uint32_t getAvalancheVoteForTx(CTxMemPool &mempool, const TxId &id) { return -1; }; /** * Decide a response for an Avalanche poll about the given proof. * * @param[in] id The id of the proof being polled for * @return Our current vote for the proof */ static uint32_t getAvalancheVoteForProof(const avalanche::ProofId &id) { assert(g_avalanche); // Rejected proof if (WITH_LOCK(cs_invalidProofs, return invalidProofs->contains(id))) { return 1; } return g_avalanche->withPeerManager([&id](avalanche::PeerManager &pm) { // The proof is actively bound to a peer if (pm.isBoundToPeer(id)) { return 0; } // Unknown proof if (!pm.exists(id)) { return -1; } // Immature proof if (pm.isImmature(id)) { return 2; } // Not immature, but in conflict with an actively bound proof if (pm.isInConflictingPool(id)) { return 3; } // The proof is known, not rejected, not immature, not a conflict, but // for some reason unbound. This should not happen if the above pools // are managed correctly, but added for robustness. return -2; }); }; void PeerManagerImpl::ProcessBlock(const Config &config, CNode &node, const std::shared_ptr &block, bool force_processing) { bool new_block{false}; m_chainman.ProcessNewBlock(config, block, force_processing, &new_block); if (new_block) { node.m_last_block_time = GetTime(); } else { LOCK(cs_main); mapBlockSource.erase(block->GetHash()); } } void PeerManagerImpl::ProcessMessage( const Config &config, CNode &pfrom, const std::string &msg_type, CDataStream &vRecv, const std::chrono::microseconds time_received, const std::atomic &interruptMsgProc) { LogPrint(BCLog::NET, "received: %s (%u bytes) peer=%d\n", SanitizeString(msg_type), vRecv.size(), pfrom.GetId()); PeerRef peer = GetPeerRef(pfrom.GetId()); if (peer == nullptr) { return; } if (IsAvalancheMessageType(msg_type)) { if (!g_avalanche) { LogPrint(BCLog::AVALANCHE, "Avalanche is not initialized, ignoring %s message\n", msg_type); return; } if (!isAvalancheEnabled(gArgs)) { // If avalanche is not enabled, ignore avalanche messages return; } } if (msg_type == NetMsgType::VERSION) { // Each connection can only send one version message if (pfrom.nVersion != 0) { Misbehaving(pfrom, 1, "redundant version message"); return; } int64_t nTime; CAddress addrMe; CAddress addrFrom; uint64_t nNonce = 1; uint64_t nServiceInt; ServiceFlags nServices; int nVersion; std::string cleanSubVer; int starting_height = -1; bool fRelay = true; uint64_t nExtraEntropy = 1; vRecv >> nVersion >> nServiceInt >> nTime >> addrMe; if (nTime < 0) { nTime = 0; } nServices = ServiceFlags(nServiceInt); if (!pfrom.IsInboundConn()) { m_addrman.SetServices(pfrom.addr, nServices); } if (pfrom.ExpectServicesFromConn() && !HasAllDesirableServiceFlags(nServices)) { LogPrint(BCLog::NET, "peer=%d does not offer the expected services " "(%08x offered, %08x expected); disconnecting\n", pfrom.GetId(), nServices, GetDesirableServiceFlags(nServices)); pfrom.fDisconnect = true; return; } if (pfrom.IsAvalancheOutboundConnection() && !(nServices & NODE_AVALANCHE)) { LogPrint( BCLog::AVALANCHE, "peer=%d does not offer the avalanche service; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; return; } if (nVersion < MIN_PEER_PROTO_VERSION) { // disconnect from peers older than this proto version LogPrint(BCLog::NET, "peer=%d using obsolete version %i; disconnecting\n", pfrom.GetId(), nVersion); pfrom.fDisconnect = true; return; } if (!vRecv.empty()) { vRecv >> addrFrom >> nNonce; } if (!vRecv.empty()) { std::string strSubVer; vRecv >> LIMITED_STRING(strSubVer, MAX_SUBVERSION_LENGTH); cleanSubVer = SanitizeString(strSubVer); } if (!vRecv.empty()) { vRecv >> starting_height; } if (!vRecv.empty()) { vRecv >> fRelay; } if (!vRecv.empty()) { vRecv >> nExtraEntropy; } // Disconnect if we connected to ourself if (pfrom.IsInboundConn() && !m_connman.CheckIncomingNonce(nNonce)) { LogPrintf("connected to self at %s, disconnecting\n", pfrom.addr.ToString()); pfrom.fDisconnect = true; return; } if (pfrom.IsInboundConn() && addrMe.IsRoutable()) { SeenLocal(addrMe); } // Inbound peers send us their version message when they connect. // We send our version message in response. if (pfrom.IsInboundConn()) { PushNodeVersion(config, pfrom, GetAdjustedTime()); } // Change version const int greatest_common_version = std::min(nVersion, PROTOCOL_VERSION); pfrom.SetCommonVersion(greatest_common_version); pfrom.nVersion = nVersion; const CNetMsgMaker msg_maker(greatest_common_version); m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::VERACK)); // Signal ADDRv2 support (BIP155). m_connman.PushMessage(&pfrom, msg_maker.Make(NetMsgType::SENDADDRV2)); pfrom.nServices = nServices; pfrom.SetAddrLocal(addrMe); { LOCK(pfrom.cs_SubVer); pfrom.cleanSubVer = cleanSubVer; } peer->m_starting_height = starting_height; // set nodes not relaying blocks and tx and not serving (parts) of the // historical blockchain as "clients" pfrom.fClient = (!(nServices & NODE_NETWORK) && !(nServices & NODE_NETWORK_LIMITED)); // set nodes not capable of serving the complete blockchain history as // "limited nodes" pfrom.m_limited_node = (!(nServices & NODE_NETWORK) && (nServices & NODE_NETWORK_LIMITED)); if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_filter); // set to true after we get the first filter* message pfrom.m_tx_relay->fRelayTxes = fRelay; } pfrom.nRemoteHostNonce = nNonce; pfrom.nRemoteExtraEntropy = nExtraEntropy; // Potentially mark this peer as a preferred download peer. { LOCK(cs_main); UpdatePreferredDownload(pfrom, State(pfrom.GetId())); } // Self advertisement & GETADDR logic if (!pfrom.IsInboundConn() && SetupAddressRelay(pfrom, *peer)) { // For outbound peers, we try to relay our address (so that other // nodes can try to find us more quickly, as we have no guarantee // that an outbound peer is even aware of how to reach us) and do a // one-time address fetch (to help populate/update our addrman). If // we're starting up for the first time, our addrman may be pretty // empty and no one will know who we are, so these mechanisms are // important to help us connect to the network. // // We skip this for block-relay-only peers. We want to avoid // potentially leaking addr information and we do not want to // indicate to the peer that we will participate in addr relay. if (fListen && !m_chainman.ActiveChainstate().IsInitialBlockDownload()) { CAddress addr = GetLocalAddress(&pfrom.addr, pfrom.GetLocalServices()); FastRandomContext insecure_rand; if (addr.IsRoutable()) { LogPrint(BCLog::NET, "ProcessMessages: advertising address %s\n", addr.ToString()); PushAddress(*peer, addr, insecure_rand); } else if (IsPeerAddrLocalGood(&pfrom)) { addr.SetIP(addrMe); LogPrint(BCLog::NET, "ProcessMessages: advertising address %s\n", addr.ToString()); PushAddress(*peer, addr, insecure_rand); } } // Get recent addresses m_connman.PushMessage(&pfrom, CNetMsgMaker(greatest_common_version) .Make(NetMsgType::GETADDR)); peer->m_getaddr_sent = true; // When requesting a getaddr, accept an additional MAX_ADDR_TO_SEND // addresses in response (bypassing the // MAX_ADDR_PROCESSING_TOKEN_BUCKET limit). WITH_LOCK(peer->m_addr_token_bucket_mutex, peer->m_addr_token_bucket += GetMaxAddrToSend()); } if (!pfrom.IsInboundConn()) { // For non-inbound connections, we update the addrman to record // connection success so that addrman will have an up-to-date // notion of which peers are online and available. // // While we strive to not leak information about block-relay-only // connections via the addrman, not moving an address to the tried // table is also potentially detrimental because new-table entries // are subject to eviction in the event of addrman collisions. We // mitigate the information-leak by never calling // AddrMan::Connected() on block-relay-only peers; see // FinalizeNode(). // // This moves an address from New to Tried table in Addrman, // resolves tried-table collisions, etc. m_addrman.Good(pfrom.addr); } std::string remoteAddr; if (fLogIPs) { remoteAddr = ", peeraddr=" + pfrom.addr.ToString(); } LogPrint(BCLog::NET, "receive version message: [%s] %s: version %d, blocks=%d, " "us=%s, txrelay=%d, peer=%d%s\n", pfrom.addr.ToString(), cleanSubVer, pfrom.nVersion, peer->m_starting_height, addrMe.ToString(), fRelay, pfrom.GetId(), remoteAddr); // Ignore time offsets that are improbable (before the Genesis block) // and may underflow the nTimeOffset calculation. int64_t currentTime = GetTime(); if (nTime >= int64_t(m_chainparams.GenesisBlock().nTime)) { int64_t nTimeOffset = nTime - currentTime; pfrom.nTimeOffset = nTimeOffset; AddTimeData(pfrom.addr, nTimeOffset); } else { Misbehaving(pfrom, 20, "Ignoring invalid timestamp in version message"); } // Feeler connections exist only to verify if address is online. if (pfrom.IsFeelerConn()) { LogPrint(BCLog::NET, "feeler connection completed peer=%d; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; } return; } if (pfrom.nVersion == 0) { // Must have a version message before anything else Misbehaving(pfrom, 10, "non-version message before version handshake"); return; } // At this point, the outgoing message serialization version can't change. const CNetMsgMaker msgMaker(pfrom.GetCommonVersion()); if (msg_type == NetMsgType::VERACK) { if (pfrom.fSuccessfullyConnected) { LogPrint(BCLog::NET, "ignoring redundant verack message from peer=%d\n", pfrom.GetId()); return; } if (!pfrom.IsInboundConn()) { LogPrintf( "New outbound peer connected: version: %d, blocks=%d, " "peer=%d%s (%s)\n", pfrom.nVersion.load(), peer->m_starting_height, pfrom.GetId(), (fLogIPs ? strprintf(", peeraddr=%s", pfrom.addr.ToString()) : ""), pfrom.ConnectionTypeAsString()); } if (pfrom.GetCommonVersion() >= SENDHEADERS_VERSION) { // Tell our peer we prefer to receive headers rather than inv's // We send this to non-NODE NETWORK peers as well, because even // non-NODE NETWORK peers can announce blocks (such as pruning // nodes) m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDHEADERS)); } if (pfrom.GetCommonVersion() >= SHORT_IDS_BLOCKS_VERSION) { // Tell our peer we are willing to provide version 1 or 2 // cmpctblocks. However, we do not request new block announcements // using cmpctblock messages. We send this to non-NODE NETWORK peers // as well, because they may wish to request compact blocks from us. bool fAnnounceUsingCMPCTBLOCK = false; uint64_t nCMPCTBLOCKVersion = 1; m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::SENDCMPCT, fAnnounceUsingCMPCTBLOCK, nCMPCTBLOCKVersion)); } if (g_avalanche && isAvalancheEnabled(gArgs)) { if (g_avalanche->sendHello(&pfrom)) { LogPrint(BCLog::AVALANCHE, "Send avahello to peer %d\n", pfrom.GetId()); auto localProof = g_avalanche->getLocalProof(); if (localProof) { // Add our proof id to the list or the recently announced // proof INVs to this peer. This is used for filtering which // INV can be requested for download. LOCK(cs_main); State(pfrom.GetId()) ->m_recently_announced_proofs.insert( localProof->getId()); } } } pfrom.fSuccessfullyConnected = true; return; } if (!pfrom.fSuccessfullyConnected) { // Must have a verack message before anything else Misbehaving(pfrom, 10, "non-verack message before version handshake"); return; } if (msg_type == NetMsgType::ADDR || msg_type == NetMsgType::ADDRV2) { int stream_version = vRecv.GetVersion(); if (msg_type == NetMsgType::ADDRV2) { // Add ADDRV2_FORMAT to the version so that the CNetAddr and // CAddress unserialize methods know that an address in v2 format is // coming. stream_version |= ADDRV2_FORMAT; } OverrideStream s(&vRecv, vRecv.GetType(), stream_version); std::vector vAddr; s >> vAddr; if (!SetupAddressRelay(pfrom, *peer)) { LogPrint(BCLog::NET, "ignoring %s message from %s peer=%d\n", msg_type, pfrom.ConnectionTypeAsString(), pfrom.GetId()); return; } if (vAddr.size() > GetMaxAddrToSend()) { Misbehaving( pfrom, 20, strprintf("%s message size = %u", msg_type, vAddr.size())); return; } // Store the new addresses std::vector vAddrOk; int64_t nNow = GetAdjustedTime(); int64_t nSince = nNow - 10 * 60; // Update/increment addr rate limiting bucket. const auto current_time = GetTime(); { LOCK(peer->m_addr_token_bucket_mutex); if (peer->m_addr_token_bucket < MAX_ADDR_PROCESSING_TOKEN_BUCKET) { // Don't increment bucket if it's already full const auto time_diff = std::max(current_time - peer->m_addr_token_timestamp, 0us); const double increment = CountSecondsDouble(time_diff) * MAX_ADDR_RATE_PER_SECOND; peer->m_addr_token_bucket = std::min(peer->m_addr_token_bucket + increment, MAX_ADDR_PROCESSING_TOKEN_BUCKET); } } peer->m_addr_token_timestamp = current_time; const bool rate_limited = !pfrom.HasPermission(NetPermissionFlags::PF_ADDR); uint64_t num_proc = 0; uint64_t num_rate_limit = 0; Shuffle(vAddr.begin(), vAddr.end(), FastRandomContext()); for (CAddress &addr : vAddr) { if (interruptMsgProc) { return; } { LOCK(peer->m_addr_token_bucket_mutex); // Apply rate limiting. if (peer->m_addr_token_bucket < 1.0) { if (rate_limited) { ++num_rate_limit; continue; } } else { peer->m_addr_token_bucket -= 1.0; } } // We only bother storing full nodes, though this may include things // which we would not make an outbound connection to, in part // because we may make feeler connections to them. if (!MayHaveUsefulAddressDB(addr.nServices) && !HasAllDesirableServiceFlags(addr.nServices)) { continue; } if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60) { addr.nTime = nNow - 5 * 24 * 60 * 60; } AddAddressKnown(*peer, addr); if (m_banman && (m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr))) { // Do not process banned/discouraged addresses beyond // remembering we received them continue; } ++num_proc; bool fReachable = IsReachable(addr); if (addr.nTime > nSince && !peer->m_getaddr_sent && vAddr.size() <= 10 && addr.IsRoutable()) { // Relay to a limited number of other nodes RelayAddress(pfrom.GetId(), addr, fReachable); } // Do not store addresses outside our network if (fReachable) { vAddrOk.push_back(addr); } } peer->m_addr_processed += num_proc; peer->m_addr_rate_limited += num_rate_limit; LogPrint(BCLog::NET, "Received addr: %u addresses (%u processed, %u rate-limited) " "from peer=%d\n", vAddr.size(), num_proc, num_rate_limit, pfrom.GetId()); m_addrman.Add(vAddrOk, pfrom.addr, 2 * 60 * 60); if (vAddr.size() < 1000) { peer->m_getaddr_sent = false; } // AddrFetch: Require multiple addresses to avoid disconnecting on // self-announcements if (pfrom.IsAddrFetchConn() && vAddr.size() > 1) { LogPrint(BCLog::NET, "addrfetch connection completed peer=%d; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; } return; } if (msg_type == NetMsgType::SENDADDRV2) { peer->m_wants_addrv2 = true; return; } if (msg_type == NetMsgType::SENDHEADERS) { LOCK(cs_main); State(pfrom.GetId())->fPreferHeaders = true; return; } if (msg_type == NetMsgType::SENDCMPCT) { bool fAnnounceUsingCMPCTBLOCK = false; uint64_t nCMPCTBLOCKVersion = 0; vRecv >> fAnnounceUsingCMPCTBLOCK >> nCMPCTBLOCKVersion; if (nCMPCTBLOCKVersion == 1) { LOCK(cs_main); // fProvidesHeaderAndIDs is used to "lock in" version of compact // blocks we send. if (!State(pfrom.GetId())->fProvidesHeaderAndIDs) { State(pfrom.GetId())->fProvidesHeaderAndIDs = true; } State(pfrom.GetId())->fPreferHeaderAndIDs = fAnnounceUsingCMPCTBLOCK; // save whether peer selects us as BIP152 high-bandwidth peer // (receiving sendcmpct(1) signals high-bandwidth, // sendcmpct(0) low-bandwidth) pfrom.m_bip152_highbandwidth_from = fAnnounceUsingCMPCTBLOCK; if (!State(pfrom.GetId())->fSupportsDesiredCmpctVersion) { State(pfrom.GetId())->fSupportsDesiredCmpctVersion = true; } } return; } if (msg_type == NetMsgType::INV) { std::vector vInv; vRecv >> vInv; if (vInv.size() > MAX_INV_SZ) { Misbehaving(pfrom, 20, strprintf("inv message size = %u", vInv.size())); return; } // Reject tx INVs when the -blocksonly setting is enabled, or this is a // block-relay-only peer bool reject_tx_invs{m_ignore_incoming_txs || (pfrom.m_tx_relay == nullptr)}; // Allow peers with relay permission to send data other than blocks // in blocks only mode if (pfrom.HasPermission(PF_RELAY)) { reject_tx_invs = false; } const auto current_time = GetTime(); std::optional best_block; auto logInv = [&](const CInv &inv, bool fAlreadyHave) { LogPrint(BCLog::NET, "got inv: %s %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom.GetId()); }; for (CInv &inv : vInv) { if (interruptMsgProc) { return; } if (inv.IsMsgBlk()) { LOCK(cs_main); const bool fAlreadyHave = AlreadyHaveBlock(BlockHash(inv.hash)); logInv(inv, fAlreadyHave); const BlockHash hash{inv.hash}; UpdateBlockAvailability(pfrom.GetId(), hash); if (!fAlreadyHave && !fImporting && !fReindex && !mapBlocksInFlight.count(hash)) { // Headers-first is the primary method of announcement on // the network. If a node fell back to sending blocks by // inv, it's probably for a re-org. The final block hash // provided should be the highest, so send a getheaders and // then fetch the blocks we need to catch up. best_block = std::move(hash); } continue; } if (inv.IsMsgProof()) { const avalanche::ProofId proofid(inv.hash); const bool fAlreadyHave = AlreadyHaveProof(proofid); logInv(inv, fAlreadyHave); pfrom.AddKnownProof(proofid); if (!fAlreadyHave && g_avalanche && isAvalancheEnabled(gArgs) && !m_chainman.ActiveChainstate().IsInitialBlockDownload()) { const bool preferred = isPreferredDownloadPeer(pfrom); LOCK(cs_proofrequest); AddProofAnnouncement(pfrom, proofid, current_time, preferred); } continue; } if (inv.IsMsgTx()) { LOCK(cs_main); const TxId txid(inv.hash); const bool fAlreadyHave = AlreadyHaveTx(txid); logInv(inv, fAlreadyHave); pfrom.AddKnownTx(txid); if (reject_tx_invs) { LogPrint(BCLog::NET, "transaction (%s) inv sent in violation of " "protocol, disconnecting peer=%d\n", txid.ToString(), pfrom.GetId()); pfrom.fDisconnect = true; return; } else if (!fAlreadyHave && !m_chainman.ActiveChainstate() .IsInitialBlockDownload()) { AddTxAnnouncement(pfrom, txid, current_time); } continue; } LogPrint(BCLog::NET, "Unknown inv type \"%s\" received from peer=%d\n", inv.ToString(), pfrom.GetId()); } if (best_block) { m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator( pindexBestHeader), *best_block)); LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n", pindexBestHeader->nHeight, best_block->ToString(), pfrom.GetId()); } return; } if (msg_type == NetMsgType::GETDATA) { std::vector vInv; vRecv >> vInv; if (vInv.size() > MAX_INV_SZ) { Misbehaving(pfrom, 20, strprintf("getdata message size = %u", vInv.size())); return; } LogPrint(BCLog::NET, "received getdata (%u invsz) peer=%d\n", vInv.size(), pfrom.GetId()); if (vInv.size() > 0) { LogPrint(BCLog::NET, "received getdata for: %s peer=%d\n", vInv[0].ToString(), pfrom.GetId()); } { LOCK(peer->m_getdata_requests_mutex); peer->m_getdata_requests.insert(peer->m_getdata_requests.end(), vInv.begin(), vInv.end()); ProcessGetData(config, pfrom, *peer, interruptMsgProc); } return; } if (msg_type == NetMsgType::GETBLOCKS) { CBlockLocator locator; uint256 hashStop; vRecv >> locator >> hashStop; if (locator.vHave.size() > MAX_LOCATOR_SZ) { LogPrint(BCLog::NET, "getblocks locator size %lld > %d, disconnect peer=%d\n", locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId()); pfrom.fDisconnect = true; return; } // We might have announced the currently-being-connected tip using a // compact block, which resulted in the peer sending a getblocks // request, which we would otherwise respond to without the new block. // To avoid this situation we simply verify that we are on our best // known chain now. This is super overkill, but we handle it better // for getheaders requests, and there are no known nodes which support // compact blocks but still use getblocks to request blocks. { std::shared_ptr a_recent_block; { LOCK(cs_most_recent_block); a_recent_block = most_recent_block; } BlockValidationState state; if (!m_chainman.ActiveChainstate().ActivateBestChain( config, state, a_recent_block)) { LogPrint(BCLog::NET, "failed to activate chain (%s)\n", state.ToString()); } } LOCK(cs_main); // Find the last block the caller has in the main chain const CBlockIndex *pindex = m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator); // Send the rest of the chain if (pindex) { pindex = m_chainman.ActiveChain().Next(pindex); } int nLimit = 500; LogPrint(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom.GetId()); for (; pindex; pindex = m_chainman.ActiveChain().Next(pindex)) { if (pindex->GetBlockHash() == hashStop) { LogPrint(BCLog::NET, " getblocks stopping at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); break; } // If pruning, don't inv blocks unless we have on disk and are // likely to still have for some reasonable time window (1 hour) // that block relay might require. const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / m_chainparams.GetConsensus().nPowTargetSpacing; if (fPruneMode && (!pindex->nStatus.hasData() || pindex->nHeight <= m_chainman.ActiveChain().Tip()->nHeight - nPrunedBlocksLikelyToHave)) { LogPrint( BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); break; } WITH_LOCK( peer->m_block_inv_mutex, peer->m_blocks_for_inv_relay.push_back(pindex->GetBlockHash())); if (--nLimit <= 0) { // When this block is requested, we'll send an inv that'll // trigger the peer to getblocks the next batch of inventory. LogPrint(BCLog::NET, " getblocks stopping at limit %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); WITH_LOCK(peer->m_block_inv_mutex, { peer->m_continuation_block = pindex->GetBlockHash(); }); break; } } return; } if (msg_type == NetMsgType::GETBLOCKTXN) { BlockTransactionsRequest req; vRecv >> req; std::shared_ptr recent_block; { LOCK(cs_most_recent_block); if (most_recent_block_hash == req.blockhash) { recent_block = most_recent_block; } // Unlock cs_most_recent_block to avoid cs_main lock inversion } if (recent_block) { SendBlockTransactions(pfrom, *recent_block, req); return; } { LOCK(cs_main); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(req.blockhash); if (!pindex || !pindex->nStatus.hasData()) { LogPrint( BCLog::NET, "Peer %d sent us a getblocktxn for a block we don't have\n", pfrom.GetId()); return; } if (pindex->nHeight >= m_chainman.ActiveChain().Height() - MAX_BLOCKTXN_DEPTH) { CBlock block; bool ret = ReadBlockFromDisk(block, pindex, m_chainparams.GetConsensus()); assert(ret); SendBlockTransactions(pfrom, block, req); return; } } // If an older block is requested (should never happen in practice, // but can happen in tests) send a block response instead of a // blocktxn response. Sending a full block response instead of a // small blocktxn response is preferable in the case where a peer // might maliciously send lots of getblocktxn requests to trigger // expensive disk reads, because it will require the peer to // actually receive all the data read from disk over the network. LogPrint(BCLog::NET, "Peer %d sent us a getblocktxn for a block > %i deep\n", pfrom.GetId(), MAX_BLOCKTXN_DEPTH); CInv inv; inv.type = MSG_BLOCK; inv.hash = req.blockhash; WITH_LOCK(peer->m_getdata_requests_mutex, peer->m_getdata_requests.push_back(inv)); // The message processing loop will go around again (without pausing) // and we'll respond then (without cs_main) return; } if (msg_type == NetMsgType::GETHEADERS) { CBlockLocator locator; BlockHash hashStop; vRecv >> locator >> hashStop; if (locator.vHave.size() > MAX_LOCATOR_SZ) { LogPrint(BCLog::NET, "getheaders locator size %lld > %d, disconnect peer=%d\n", locator.vHave.size(), MAX_LOCATOR_SZ, pfrom.GetId()); pfrom.fDisconnect = true; return; } LOCK(cs_main); if (m_chainman.ActiveChainstate().IsInitialBlockDownload() && !pfrom.HasPermission(PF_DOWNLOAD)) { LogPrint(BCLog::NET, "Ignoring getheaders from peer=%d because node is in " "initial block download\n", pfrom.GetId()); return; } CNodeState *nodestate = State(pfrom.GetId()); const CBlockIndex *pindex = nullptr; if (locator.IsNull()) { // If locator is null, return the hashStop block pindex = m_chainman.m_blockman.LookupBlockIndex(hashStop); if (!pindex) { return; } if (!BlockRequestAllowed(pindex, m_chainparams.GetConsensus())) { LogPrint(BCLog::NET, "%s: ignoring request from peer=%i for old block " "header that isn't in the main chain\n", __func__, pfrom.GetId()); return; } } else { // Find the last block the caller has in the main chain pindex = m_chainman.ActiveChainstate().FindForkInGlobalIndex(locator); if (pindex) { pindex = m_chainman.ActiveChain().Next(pindex); } } // we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx // count at the end std::vector vHeaders; int nLimit = MAX_HEADERS_RESULTS; LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), pfrom.GetId()); for (; pindex; pindex = m_chainman.ActiveChain().Next(pindex)) { vHeaders.push_back(pindex->GetBlockHeader()); if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop) { break; } } // pindex can be nullptr either if we sent // m_chainman.ActiveChain().Tip() OR if our peer has // m_chainman.ActiveChain().Tip() (and thus we are sending an empty // headers message). In both cases it's safe to update // pindexBestHeaderSent to be our tip. // // It is important that we simply reset the BestHeaderSent value here, // and not max(BestHeaderSent, newHeaderSent). We might have announced // the currently-being-connected tip using a compact block, which // resulted in the peer sending a headers request, which we respond to // without the new block. By resetting the BestHeaderSent, we ensure we // will re-announce the new block via headers (or compact blocks again) // in the SendMessages logic. nodestate->pindexBestHeaderSent = pindex ? pindex : m_chainman.ActiveChain().Tip(); m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::HEADERS, vHeaders)); return; } if (msg_type == NetMsgType::TX) { // Stop processing the transaction early if // 1) We are in blocks only mode and peer has no relay permission // 2) This peer is a block-relay-only peer if ((m_ignore_incoming_txs && !pfrom.HasPermission(PF_RELAY)) || (pfrom.m_tx_relay == nullptr)) { LogPrint(BCLog::NET, "transaction sent in violation of protocol peer=%d\n", pfrom.GetId()); pfrom.fDisconnect = true; return; } CTransactionRef ptx; vRecv >> ptx; const CTransaction &tx = *ptx; const TxId &txid = tx.GetId(); pfrom.AddKnownTx(txid); LOCK2(cs_main, g_cs_orphans); m_txrequest.ReceivedResponse(pfrom.GetId(), txid); if (AlreadyHaveTx(txid)) { if (pfrom.HasPermission(PF_FORCERELAY)) { // Always relay transactions received from peers with // forcerelay permission, even if they were already in the // mempool, allowing the node to function as a gateway for // nodes hidden behind it. if (!m_mempool.exists(tx.GetId())) { LogPrintf("Not relaying non-mempool transaction %s from " "forcerelay peer=%d\n", tx.GetId().ToString(), pfrom.GetId()); } else { LogPrintf("Force relaying tx %s from peer=%d\n", tx.GetId().ToString(), pfrom.GetId()); RelayTransaction(tx.GetId()); } } return; } const MempoolAcceptResult result = m_chainman.ProcessTransaction(ptx); const TxValidationState &state = result.m_state; if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) { // As this version of the transaction was acceptable, we can forget // about any requests for it. m_txrequest.ForgetInvId(tx.GetId()); RelayTransaction(tx.GetId()); m_orphanage.AddChildrenToWorkSet(tx, peer->m_orphan_work_set); pfrom.m_last_tx_time = GetTime(); LogPrint(BCLog::MEMPOOL, "AcceptToMemoryPool: peer=%d: accepted %s " "(poolsz %u txn, %u kB)\n", pfrom.GetId(), tx.GetId().ToString(), m_mempool.size(), m_mempool.DynamicMemoryUsage() / 1000); // Recursively process any orphan transactions that depended on this // one ProcessOrphanTx(config, peer->m_orphan_work_set); } else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) { // It may be the case that the orphans parents have all been // rejected. bool fRejectedParents = false; // Deduplicate parent txids, so that we don't have to loop over // the same parent txid more than once down below. std::vector unique_parents; unique_parents.reserve(tx.vin.size()); for (const CTxIn &txin : tx.vin) { // We start with all parents, and then remove duplicates below. unique_parents.push_back(txin.prevout.GetTxId()); } std::sort(unique_parents.begin(), unique_parents.end()); unique_parents.erase( std::unique(unique_parents.begin(), unique_parents.end()), unique_parents.end()); for (const TxId &parent_txid : unique_parents) { if (recentRejects->contains(parent_txid)) { fRejectedParents = true; break; } } if (!fRejectedParents) { const auto current_time = GetTime(); for (const TxId &parent_txid : unique_parents) { // FIXME: MSG_TX should use a TxHash, not a TxId. pfrom.AddKnownTx(parent_txid); if (!AlreadyHaveTx(parent_txid)) { AddTxAnnouncement(pfrom, parent_txid, current_time); } } if (m_orphanage.AddTx(ptx, pfrom.GetId())) { AddToCompactExtraTransactions(ptx); } // Once added to the orphan pool, a tx is considered // AlreadyHave, and we shouldn't request it anymore. m_txrequest.ForgetInvId(tx.GetId()); // DoS prevention: do not allow m_orphanage to grow // unbounded (see CVE-2012-3789) unsigned int nMaxOrphanTx = (unsigned int)std::max( int64_t(0), gArgs.GetIntArg("-maxorphantx", DEFAULT_MAX_ORPHAN_TRANSACTIONS)); unsigned int nEvicted = m_orphanage.LimitOrphans(nMaxOrphanTx); if (nEvicted > 0) { LogPrint(BCLog::MEMPOOL, "orphanage overflow, removed %u tx\n", nEvicted); } } else { LogPrint(BCLog::MEMPOOL, "not keeping orphan with rejected parents %s\n", tx.GetId().ToString()); // We will continue to reject this tx since it has rejected // parents so avoid re-requesting it from other peers. recentRejects->insert(tx.GetId()); m_txrequest.ForgetInvId(tx.GetId()); } } else { assert(recentRejects); recentRejects->insert(tx.GetId()); m_txrequest.ForgetInvId(tx.GetId()); if (RecursiveDynamicUsage(*ptx) < 100000) { AddToCompactExtraTransactions(ptx); } } // If a tx has been detected by recentRejects, we will have reached // this point and the tx will have been ignored. Because we haven't // submitted the tx to our mempool, we won't have computed a DoS // score for it or determined exactly why we consider it invalid. // // This means we won't penalize any peer subsequently relaying a DoSy // tx (even if we penalized the first peer who gave it to us) because // we have to account for recentRejects showing false positives. In // other words, we shouldn't penalize a peer if we aren't *sure* they // submitted a DoSy tx. // // Note that recentRejects doesn't just record DoSy or invalid // transactions, but any tx not accepted by the mempool, which may be // due to node policy (vs. consensus). So we can't blanket penalize a // peer simply for relaying a tx that our recentRejects has caught, // regardless of false positives. if (state.IsInvalid()) { LogPrint(BCLog::MEMPOOLREJ, "%s from peer=%d was not accepted: %s\n", tx.GetHash().ToString(), pfrom.GetId(), state.ToString()); MaybePunishNodeForTx(pfrom.GetId(), state); } return; } if (msg_type == NetMsgType::CMPCTBLOCK) { // Ignore cmpctblock received while importing if (fImporting || fReindex) { LogPrint(BCLog::NET, "Unexpected cmpctblock message received from peer %d\n", pfrom.GetId()); return; } CBlockHeaderAndShortTxIDs cmpctblock; try { vRecv >> cmpctblock; } catch (std::ios_base::failure &e) { // This block has non contiguous or overflowing indexes Misbehaving(pfrom, 100, "cmpctblock-bad-indexes"); return; } bool received_new_header = false; { LOCK(cs_main); if (!m_chainman.m_blockman.LookupBlockIndex( cmpctblock.header.hashPrevBlock)) { // Doesn't connect (or is genesis), instead of DoSing in // AcceptBlockHeader, request deeper headers if (!m_chainman.ActiveChainstate().IsInitialBlockDownload()) { m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator( pindexBestHeader), uint256())); } return; } if (!m_chainman.m_blockman.LookupBlockIndex( cmpctblock.header.GetHash())) { received_new_header = true; } } const CBlockIndex *pindex = nullptr; BlockValidationState state; if (!m_chainman.ProcessNewBlockHeaders(config, {cmpctblock.header}, state, &pindex)) { if (state.IsInvalid()) { MaybePunishNodeForBlock(pfrom.GetId(), state, /*via_compact_block*/ true, "invalid header via cmpctblock"); return; } } // When we succeed in decoding a block's txids from a cmpctblock // message we typically jump to the BLOCKTXN handling code, with a // dummy (empty) BLOCKTXN message, to re-use the logic there in // completing processing of the putative block (without cs_main). bool fProcessBLOCKTXN = false; CDataStream blockTxnMsg(SER_NETWORK, PROTOCOL_VERSION); // If we end up treating this as a plain headers message, call that as // well // without cs_main. bool fRevertToHeaderProcessing = false; // Keep a CBlock for "optimistic" compactblock reconstructions (see // below) std::shared_ptr pblock = std::make_shared(); bool fBlockReconstructed = false; { LOCK2(cs_main, g_cs_orphans); // If AcceptBlockHeader returned true, it set pindex assert(pindex); UpdateBlockAvailability(pfrom.GetId(), pindex->GetBlockHash()); CNodeState *nodestate = State(pfrom.GetId()); // If this was a new header with more work than our tip, update the // peer's last block announcement time if (received_new_header && pindex->nChainWork > m_chainman.ActiveChain().Tip()->nChainWork) { nodestate->m_last_block_announcement = GetTime(); } std::map::iterator>>:: iterator blockInFlightIt = mapBlocksInFlight.find(pindex->GetBlockHash()); bool fAlreadyInFlight = blockInFlightIt != mapBlocksInFlight.end(); if (pindex->nStatus.hasData()) { // Nothing to do here return; } if (pindex->nChainWork <= m_chainman.ActiveChain() .Tip() ->nChainWork || // We know something better pindex->nTx != 0) { // We had this block at some point, but pruned it if (fAlreadyInFlight) { // We requested this block for some reason, but our mempool // will probably be useless so we just grab the block via // normal getdata. std::vector vInv(1); vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash()); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv)); } return; } // If we're not close to tip yet, give up and let parallel block // fetch work its magic. if (!fAlreadyInFlight && !CanDirectFetch(m_chainparams.GetConsensus())) { return; } // We want to be a bit conservative just to be extra careful about // DoS possibilities in compact block processing... if (pindex->nHeight <= m_chainman.ActiveChain().Height() + 2) { if ((!fAlreadyInFlight && nodestate->nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) || (fAlreadyInFlight && blockInFlightIt->second.first == pfrom.GetId())) { std::list::iterator *queuedBlockIt = nullptr; if (!MarkBlockAsInFlight(config, pfrom.GetId(), pindex->GetBlockHash(), pindex, &queuedBlockIt)) { if (!(*queuedBlockIt)->partialBlock) { (*queuedBlockIt) ->partialBlock.reset( new PartiallyDownloadedBlock(config, &m_mempool)); } else { // The block was already in flight using compact // blocks from the same peer. LogPrint(BCLog::NET, "Peer sent us compact block " "we were already syncing!\n"); return; } } PartiallyDownloadedBlock &partialBlock = *(*queuedBlockIt)->partialBlock; ReadStatus status = partialBlock.InitData(cmpctblock, vExtraTxnForCompact); if (status == READ_STATUS_INVALID) { // Reset in-flight state in case Misbehaving does not // result in a disconnect MarkBlockAsReceived(pindex->GetBlockHash()); Misbehaving(pfrom, 100, "invalid compact block"); return; } else if (status == READ_STATUS_FAILED) { // Duplicate txindices, the block is now in-flight, so // just request it. std::vector vInv(1); vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash()); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv)); return; } BlockTransactionsRequest req; for (size_t i = 0; i < cmpctblock.BlockTxCount(); i++) { if (!partialBlock.IsTxAvailable(i)) { req.indices.push_back(i); } } if (req.indices.empty()) { // Dirty hack to jump to BLOCKTXN code (TODO: move // message handling into their own functions) BlockTransactions txn; txn.blockhash = cmpctblock.header.GetHash(); blockTxnMsg << txn; fProcessBLOCKTXN = true; } else { req.blockhash = pindex->GetBlockHash(); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETBLOCKTXN, req)); } } else { // This block is either already in flight from a different // peer, or this peer has too many blocks outstanding to // download from. Optimistically try to reconstruct anyway // since we might be able to without any round trips. PartiallyDownloadedBlock tempBlock(config, &m_mempool); ReadStatus status = tempBlock.InitData(cmpctblock, vExtraTxnForCompact); if (status != READ_STATUS_OK) { // TODO: don't ignore failures return; } std::vector dummy; status = tempBlock.FillBlock(*pblock, dummy); if (status == READ_STATUS_OK) { fBlockReconstructed = true; } } } else { if (fAlreadyInFlight) { // We requested this block, but its far into the future, so // our mempool will probably be useless - request the block // normally. std::vector vInv(1); vInv[0] = CInv(MSG_BLOCK, cmpctblock.header.GetHash()); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::GETDATA, vInv)); return; } else { // If this was an announce-cmpctblock, we want the same // treatment as a header message. fRevertToHeaderProcessing = true; } } } // cs_main if (fProcessBLOCKTXN) { return ProcessMessage(config, pfrom, NetMsgType::BLOCKTXN, blockTxnMsg, time_received, interruptMsgProc); } if (fRevertToHeaderProcessing) { // Headers received from HB compact block peers are permitted to be // relayed before full validation (see BIP 152), so we don't want to // disconnect the peer if the header turns out to be for an invalid // block. Note that if a peer tries to build on an invalid chain, // that will be detected and the peer will be banned. return ProcessHeadersMessage(config, pfrom, *peer, {cmpctblock.header}, /*via_compact_block=*/true); } if (fBlockReconstructed) { // If we got here, we were able to optimistically reconstruct a // block that is in flight from some other peer. { LOCK(cs_main); mapBlockSource.emplace(pblock->GetHash(), std::make_pair(pfrom.GetId(), false)); } // Setting force_processing to true means that we bypass some of // our anti-DoS protections in AcceptBlock, which filters // unrequested blocks that might be trying to waste our resources // (eg disk space). Because we only try to reconstruct blocks when // we're close to caught up (via the CanDirectFetch() requirement // above, combined with the behavior of not requesting blocks until // we have a chain with at least nMinimumChainWork), and we ignore // compact blocks with less work than our tip, it is safe to treat // reconstructed compact blocks as having been requested. ProcessBlock(config, pfrom, pblock, /*force_processing=*/true); // hold cs_main for CBlockIndex::IsValid() LOCK(cs_main); if (pindex->IsValid(BlockValidity::TRANSACTIONS)) { // Clear download state for this block, which is in process from // some other peer. We do this after calling. ProcessNewBlock so // that a malleated cmpctblock announcement can't be used to // interfere with block relay. MarkBlockAsReceived(pblock->GetHash()); } } return; } if (msg_type == NetMsgType::BLOCKTXN) { // Ignore blocktxn received while importing if (fImporting || fReindex) { LogPrint(BCLog::NET, "Unexpected blocktxn message received from peer %d\n", pfrom.GetId()); return; } BlockTransactions resp; vRecv >> resp; std::shared_ptr pblock = std::make_shared(); bool fBlockRead = false; { LOCK(cs_main); std::map::iterator>>:: iterator it = mapBlocksInFlight.find(resp.blockhash); if (it == mapBlocksInFlight.end() || !it->second.second->partialBlock || it->second.first != pfrom.GetId()) { LogPrint(BCLog::NET, "Peer %d sent us block transactions for block " "we weren't expecting\n", pfrom.GetId()); return; } PartiallyDownloadedBlock &partialBlock = *it->second.second->partialBlock; ReadStatus status = partialBlock.FillBlock(*pblock, resp.txn); if (status == READ_STATUS_INVALID) { // Reset in-flight state in case of Misbehaving does not // result in a disconnect. MarkBlockAsReceived(resp.blockhash); Misbehaving( pfrom, 100, "invalid compact block/non-matching block transactions"); return; } else if (status == READ_STATUS_FAILED) { // Might have collided, fall back to getdata now :( std::vector invs; invs.push_back(CInv(MSG_BLOCK, resp.blockhash)); m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETDATA, invs)); } else { // Block is either okay, or possibly we received // READ_STATUS_CHECKBLOCK_FAILED. // Note that CheckBlock can only fail for one of a few reasons: // 1. bad-proof-of-work (impossible here, because we've already // accepted the header) // 2. merkleroot doesn't match the transactions given (already // caught in FillBlock with READ_STATUS_FAILED, so // impossible here) // 3. the block is otherwise invalid (eg invalid coinbase, // block is too big, too many legacy sigops, etc). // So if CheckBlock failed, #3 is the only possibility. // Under BIP 152, we don't DoS-ban unless proof of work is // invalid (we don't require all the stateless checks to have // been run). This is handled below, so just treat this as // though the block was successfully read, and rely on the // handling in ProcessNewBlock to ensure the block index is // updated, etc. // it is now an empty pointer MarkBlockAsReceived(resp.blockhash); fBlockRead = true; // mapBlockSource is used for potentially punishing peers and // updating which peers send us compact blocks, so the race // between here and cs_main in ProcessNewBlock is fine. // BIP 152 permits peers to relay compact blocks after // validating the header only; we should not punish peers // if the block turns out to be invalid. mapBlockSource.emplace(resp.blockhash, std::make_pair(pfrom.GetId(), false)); } } // Don't hold cs_main when we call into ProcessNewBlock if (fBlockRead) { // Since we requested this block (it was in mapBlocksInFlight), // force it to be processed, even if it would not be a candidate for // new tip (missing previous block, chain not long enough, etc) // This bypasses some anti-DoS logic in AcceptBlock (eg to prevent // disk-space attacks), but this should be safe due to the // protections in the compact block handler -- see related comment // in compact block optimistic reconstruction handling. ProcessBlock(config, pfrom, pblock, /*force_processing=*/true); } return; } if (msg_type == NetMsgType::HEADERS) { // Ignore headers received while importing if (fImporting || fReindex) { LogPrint(BCLog::NET, "Unexpected headers message received from peer %d\n", pfrom.GetId()); return; } std::vector headers; // Bypass the normal CBlock deserialization, as we don't want to risk // deserializing 2000 full blocks. unsigned int nCount = ReadCompactSize(vRecv); if (nCount > MAX_HEADERS_RESULTS) { Misbehaving(pfrom, 20, strprintf("too-many-headers: headers message size = %u", nCount)); return; } headers.resize(nCount); for (unsigned int n = 0; n < nCount; n++) { vRecv >> headers[n]; // Ignore tx count; assume it is 0. ReadCompactSize(vRecv); } return ProcessHeadersMessage(config, pfrom, *peer, headers, /*via_compact_block=*/false); } if (msg_type == NetMsgType::BLOCK) { // Ignore block received while importing if (fImporting || fReindex) { LogPrint(BCLog::NET, "Unexpected block message received from peer %d\n", pfrom.GetId()); return; } std::shared_ptr pblock = std::make_shared(); vRecv >> *pblock; LogPrint(BCLog::NET, "received block %s peer=%d\n", pblock->GetHash().ToString(), pfrom.GetId()); // Process all blocks from whitelisted peers, even if not requested, // unless we're still syncing with the network. Such an unrequested // block may still be processed, subject to the conditions in // AcceptBlock(). bool forceProcessing = pfrom.HasPermission(PF_NOBAN) && !m_chainman.ActiveChainstate().IsInitialBlockDownload(); const BlockHash hash = pblock->GetHash(); { LOCK(cs_main); // Also always process if we requested the block explicitly, as we // may need it even though it is not a candidate for a new best tip. forceProcessing |= MarkBlockAsReceived(hash); // mapBlockSource is only used for punishing peers and setting // which peers send us compact blocks, so the race between here and // cs_main in ProcessNewBlock is fine. mapBlockSource.emplace(hash, std::make_pair(pfrom.GetId(), true)); } ProcessBlock(config, pfrom, pblock, forceProcessing); return; } if (msg_type == NetMsgType::AVAHELLO) { { bool expected = false; if (!pfrom.m_avalanche_enabled.compare_exchange_strong(expected, true)) { LogPrint( BCLog::AVALANCHE, "Ignoring avahello from peer %d: already in our node set\n", pfrom.GetId()); return; } } avalanche::Delegation delegation; vRecv >> delegation; // A delegation with an all zero limited id indicates that the peer has // no proof, so we're done. if (delegation.getLimitedProofId() != uint256::ZERO) { avalanche::DelegationState state; CPubKey pubkey; if (!delegation.verify(state, pubkey)) { Misbehaving(pfrom, 100, "invalid-delegation"); return; } pfrom.m_avalanche_pubkey = std::move(pubkey); CHashWriter sighasher(SER_GETHASH, 0); sighasher << delegation.getId(); sighasher << pfrom.nRemoteHostNonce; sighasher << pfrom.GetLocalNonce(); sighasher << pfrom.nRemoteExtraEntropy; sighasher << pfrom.GetLocalExtraEntropy(); SchnorrSig sig; vRecv >> sig; if (!(*pfrom.m_avalanche_pubkey) .VerifySchnorr(sighasher.GetHash(), sig)) { Misbehaving(pfrom, 100, "invalid-avahello-signature"); return; } // If we don't know this proof already, add it to the tracker so it // can be requested. const avalanche::ProofId proofid(delegation.getProofId()); if (!AlreadyHaveProof(proofid)) { const bool preferred = isPreferredDownloadPeer(pfrom); LOCK(cs_proofrequest); AddProofAnnouncement(pfrom, proofid, GetTime(), preferred); } // Don't check the return value. If it fails we probably don't // know about the proof yet. g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) { return pm.addNode(pfrom.GetId(), proofid); }); } // Send getavaaddr and getavaproofs to our avalanche outbound or // manual connections if (!pfrom.IsInboundConn()) { m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETAVAADDR)); WITH_LOCK(peer->m_addr_token_bucket_mutex, peer->m_addr_token_bucket += GetMaxAddrToSend()); if (pfrom.m_proof_relay && !m_chainman.ActiveChainstate().IsInitialBlockDownload()) { m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::GETAVAPROOFS)); pfrom.m_proof_relay->compactproofs_requested = true; } } return; } if (msg_type == NetMsgType::AVAPOLL) { auto now = std::chrono::steady_clock::now(); int64_t cooldown = gArgs.GetIntArg("-avacooldown", AVALANCHE_DEFAULT_COOLDOWN); { LOCK(cs_main); auto &node_state = State(pfrom.GetId())->m_avalanche_state; if (now < node_state.last_poll + std::chrono::milliseconds(cooldown)) { Misbehaving(pfrom, 20, "avapool-cooldown"); } node_state.last_poll = now; } const bool quorum_established = g_avalanche && g_avalanche->isQuorumEstablished(); uint64_t round; Unserialize(vRecv, round); unsigned int nCount = ReadCompactSize(vRecv); if (nCount > AVALANCHE_MAX_ELEMENT_POLL) { Misbehaving( pfrom, 20, strprintf("too-many-ava-poll: poll message size = %u", nCount)); return; } std::vector votes; votes.reserve(nCount); for (unsigned int n = 0; n < nCount; n++) { CInv inv; vRecv >> inv; // Default vote for unknown inv type uint32_t vote = -1; // We don't vote definitively until we have an established quorum if (!quorum_established) { votes.emplace_back(vote, inv.hash); continue; } // If inv's type is known, get a vote for its hash switch (inv.type) { case MSG_TX: { vote = getAvalancheVoteForTx(m_mempool, TxId(inv.hash)); } break; case MSG_BLOCK: { vote = WITH_LOCK(cs_main, return GetAvalancheVoteForBlock( BlockHash(inv.hash))); } break; case MSG_AVA_PROOF: { vote = getAvalancheVoteForProof(avalanche::ProofId(inv.hash)); } break; default: { LogPrint(BCLog::AVALANCHE, "poll inv type unknown from peer=%d\n", inv.type); } } votes.emplace_back(vote, inv.hash); } // Send the query to the node. g_avalanche->sendResponse( &pfrom, avalanche::Response(round, cooldown, std::move(votes))); return; } if (msg_type == NetMsgType::AVARESPONSE) { // As long as QUIC is not implemented, we need to sign response and // verify response's signatures in order to avoid any manipulation of // messages at the transport level. CHashVerifier verifier(&vRecv); avalanche::Response response; verifier >> response; SchnorrSig sig; vRecv >> sig; if (!pfrom.m_avalanche_pubkey.has_value() || !(*pfrom.m_avalanche_pubkey) .VerifySchnorr(verifier.GetHash(), sig)) { Misbehaving(pfrom, 100, "invalid-ava-response-signature"); return; } std::vector blockUpdates; std::vector proofUpdates; int banscore; std::string error; if (!g_avalanche->registerVotes(pfrom.GetId(), response, blockUpdates, proofUpdates, banscore, error)) { Misbehaving(pfrom, banscore, error); return; } pfrom.invsVoted(response.GetVotes().size()); auto logVoteUpdate = [](const auto &voteUpdate, const std::string &voteItemTypeStr, const auto &voteItemId) { std::string voteOutcome; switch (voteUpdate.getStatus()) { case avalanche::VoteStatus::Invalid: voteOutcome = "invalidated"; break; case avalanche::VoteStatus::Rejected: voteOutcome = "rejected"; break; case avalanche::VoteStatus::Accepted: voteOutcome = "accepted"; break; case avalanche::VoteStatus::Finalized: voteOutcome = "finalized"; break; case avalanche::VoteStatus::Stale: voteOutcome = "stalled"; break; // No default case, so the compiler can warn about missing // cases } LogPrint(BCLog::AVALANCHE, "Avalanche %s %s %s\n", voteOutcome, voteItemTypeStr, voteItemId.ToString()); }; for (avalanche::ProofUpdate &u : proofUpdates) { avalanche::ProofRef proof = u.getVoteItem(); const avalanche::ProofId &proofid = proof->getId(); logVoteUpdate(u, "proof", proofid); auto rejectionMode = avalanche::PeerManager::RejectionMode::DEFAULT; auto nextCooldownTimePoint = GetTime(); switch (u.getStatus()) { case avalanche::VoteStatus::Invalid: WITH_LOCK(cs_invalidProofs, invalidProofs->insert(proofid)); // Fallthrough case avalanche::VoteStatus::Stale: // Invalidate mode removes the proof from all proof pools rejectionMode = avalanche::PeerManager::RejectionMode::INVALIDATE; // Fallthrough case avalanche::VoteStatus::Rejected: if (!g_avalanche->withPeerManager( [&](avalanche::PeerManager &pm) { return pm.rejectProof(proofid, rejectionMode); })) { LogPrint(BCLog::AVALANCHE, "ERROR: Failed to reject proof: %s\n", proofid.GetHex()); } break; case avalanche::VoteStatus::Finalized: nextCooldownTimePoint += std::chrono::seconds(gArgs.GetIntArg( "-avalanchepeerreplacementcooldown", AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN)); case avalanche::VoteStatus::Accepted: if (!g_avalanche->withPeerManager( [&](avalanche::PeerManager &pm) { pm.registerProof( proof, avalanche::PeerManager:: RegistrationMode::FORCE_ACCEPT); return pm.forPeer( proofid, [&](const avalanche::Peer &peer) { pm.updateNextPossibleConflictTime( peer.peerid, nextCooldownTimePoint); if (u.getStatus() == avalanche::VoteStatus::Finalized) { pm.setFinalized(peer.peerid); } // Only fail if the peer was not // created return true; }); })) { LogPrint(BCLog::AVALANCHE, "ERROR: Failed to accept proof: %s\n", proofid.GetHex()); } break; } } if (blockUpdates.size()) { for (avalanche::BlockUpdate &u : blockUpdates) { CBlockIndex *pindex = u.getVoteItem(); logVoteUpdate(u, "block", pindex->GetBlockHash()); switch (u.getStatus()) { case avalanche::VoteStatus::Invalid: case avalanche::VoteStatus::Rejected: { BlockValidationState state; m_chainman.ActiveChainstate().ParkBlock(config, state, pindex); if (!state.IsValid()) { LogPrintf("ERROR: Database error: %s\n", state.GetRejectReason()); return; } } break; case avalanche::VoteStatus::Accepted: { LOCK(cs_main); m_chainman.ActiveChainstate().UnparkBlock(pindex); } break; case avalanche::VoteStatus::Finalized: { { LOCK(cs_main); m_chainman.ActiveChainstate().UnparkBlock(pindex); } m_chainman.ActiveChainstate().AvalancheFinalizeBlock( pindex); } break; case avalanche::VoteStatus::Stale: // Fall back on Nakamoto consensus in the absence of // Avalanche votes for other competing or descendant // blocks. break; } } BlockValidationState state; if (!m_chainman.ActiveChainstate().ActivateBestChain(config, state)) { LogPrintf("failed to activate chain (%s)\n", state.ToString()); } } return; } if (msg_type == NetMsgType::AVAPROOF) { auto proof = RCUPtr::make(); vRecv >> *proof; ReceivedAvalancheProof(pfrom, proof); return; } if (msg_type == NetMsgType::GETAVAPROOFS) { if (pfrom.m_proof_relay == nullptr) { return; } pfrom.m_proof_relay->lastSharedProofsUpdate = GetTime(); pfrom.m_proof_relay->sharedProofs = g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) { return pm.getShareableProofsSnapshot(); }); avalanche::CompactProofs compactProofs( pfrom.m_proof_relay->sharedProofs); m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::AVAPROOFS, compactProofs)); return; } if (msg_type == NetMsgType::AVAPROOFS) { if (pfrom.m_proof_relay == nullptr) { return; } // Only process the compact proofs if we requested them if (!pfrom.m_proof_relay->compactproofs_requested) { LogPrint(BCLog::AVALANCHE, "Ignoring unsollicited avaproofs\n"); return; } pfrom.m_proof_relay->compactproofs_requested = false; avalanche::CompactProofs compactProofs; try { vRecv >> compactProofs; } catch (std::ios_base::failure &e) { // This compact proofs have non contiguous or overflowing indexes Misbehaving(pfrom, 100, "avaproofs-bad-indexes"); return; } // If there are prefilled proofs, process them first std::set prefilledIndexes; for (const auto &prefilledProof : compactProofs.getPrefilledProofs()) { if (!ReceivedAvalancheProof(pfrom, prefilledProof.proof)) { // If we got an invalid proof, the peer is getting banned and we // can bail out. return; } } // If there is no shortid, avoid parsing/responding/accounting for the // message. if (compactProofs.getShortIDs().size() == 0) { LogPrint(BCLog::AVALANCHE, "Got an avaproofs message with no shortid (peer %d)\n", pfrom.GetId()); return; } // To determine the chance that the number of entries in a bucket // exceeds N, we use the fact that the number of elements in a single // bucket is binomially distributed (with n = the number of shorttxids // S, and p = 1 / the number of buckets), that in the worst case the // number of buckets is equal to S (due to std::unordered_map having a // default load factor of 1.0), and that the chance for any bucket to // exceed N elements is at most buckets * (the chance that any given // bucket is above N elements). Thus: // P(max_elements_per_bucket > N) <= // S * (1 - cdf(binomial(n=S,p=1/S), N)) // If we assume up to 21000000, allowing 15 elements per bucket should // only fail once per ~2.5 million avaproofs transfers (per peer and // connection). // TODO re-evaluate the bucket count to a more realistic value. // TODO: In the case of a shortid-collision, we should request all the // proofs which collided. For now, we only request one, which is not // that bad considering this event is expected to be very rare. auto shortIdProcessor = avalanche::ProofShortIdProcessor(compactProofs.getPrefilledProofs(), compactProofs.getShortIDs(), 15); if (shortIdProcessor.hasOutOfBoundIndex()) { // This should be catched by deserialization, but catch it here as // well as a good measure. Misbehaving(pfrom, 100, "avaproofs-bad-indexes"); return; } if (!shortIdProcessor.isEvenlyDistributed()) { // This is suspicious, don't ban but bail out return; } const auto &proofs = g_avalanche->withPeerManager([&](const avalanche::PeerManager &pm) { return pm.getShareableProofsSnapshot(); }); size_t proofCount = 0; proofs.forEachLeaf([&](const avalanche::ProofRef &proof) { uint64_t shortid = compactProofs.getShortID(proof->getId()); proofCount += shortIdProcessor.matchKnownItem(shortid, proof); // Though ideally we'd continue scanning for the // two-proofs-match-shortid case, the performance win of an early // exit here is too good to pass up and worth the extra risk. return proofCount != shortIdProcessor.getShortIdCount(); }); avalanche::ProofsRequest req; for (size_t i = 0; i < compactProofs.size(); i++) { if (shortIdProcessor.getItem(i) == nullptr) { req.indices.push_back(i); } } m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::AVAPROOFSREQ, req)); // We want to keep a count of how many nodes we successfully requested // avaproofs from as this is used to determine when we are confident our // quorum is close enough to the other participants. g_avalanche->avaproofsSent(pfrom.GetId()); return; } if (msg_type == NetMsgType::AVAPROOFSREQ) { if (pfrom.m_proof_relay == nullptr) { return; } avalanche::ProofsRequest proofreq; vRecv >> proofreq; auto requestedIndiceIt = proofreq.indices.begin(); uint32_t treeIndice = 0; pfrom.m_proof_relay->sharedProofs.forEachLeaf([&](const auto &proof) { if (requestedIndiceIt == proofreq.indices.end()) { // No more indice to process return false; } if (treeIndice++ == *requestedIndiceIt) { m_connman.PushMessage( &pfrom, msgMaker.Make(NetMsgType::AVAPROOF, *proof)); requestedIndiceIt++; } return true; }); pfrom.m_proof_relay->sharedProofs = {}; return; } if (msg_type == NetMsgType::GETADDR) { // This asymmetric behavior for inbound and outbound connections was // introduced to prevent a fingerprinting attack: an attacker can send // specific fake addresses to users' AddrMan and later request them by // sending getaddr messages. Making nodes which are behind NAT and can // only make outgoing connections ignore the getaddr message mitigates // the attack. if (!pfrom.IsInboundConn()) { LogPrint(BCLog::NET, "Ignoring \"getaddr\" from %s connection. peer=%d\n", pfrom.ConnectionTypeAsString(), pfrom.GetId()); return; } // Since this must be an inbound connection, SetupAddressRelay will // never fail. Assume(SetupAddressRelay(pfrom, *peer)); // Only send one GetAddr response per connection to reduce resource // waste and discourage addr stamping of INV announcements. if (peer->m_getaddr_recvd) { LogPrint(BCLog::NET, "Ignoring repeated \"getaddr\". peer=%d\n", pfrom.GetId()); return; } peer->m_getaddr_recvd = true; peer->m_addrs_to_send.clear(); std::vector vAddr; const size_t maxAddrToSend = GetMaxAddrToSend(); if (pfrom.HasPermission(PF_ADDR)) { vAddr = m_connman.GetAddresses(maxAddrToSend, MAX_PCT_ADDR_TO_SEND, /* network */ std::nullopt); } else { vAddr = m_connman.GetAddresses(pfrom, maxAddrToSend, MAX_PCT_ADDR_TO_SEND); } FastRandomContext insecure_rand; for (const CAddress &addr : vAddr) { PushAddress(*peer, addr, insecure_rand); } return; } if (msg_type == NetMsgType::GETAVAADDR) { auto now = GetTime(); if (now < pfrom.m_nextGetAvaAddr) { // Prevent a peer from exhausting our resources by spamming // getavaaddr messages. LogPrint(BCLog::AVALANCHE, "Ignoring repeated getavaaddr from peer %d\n", pfrom.GetId()); return; } // Only accept a getavaaddr every GETAVAADDR_INTERVAL at most pfrom.m_nextGetAvaAddr = now + GETAVAADDR_INTERVAL; if (!SetupAddressRelay(pfrom, *peer)) { LogPrint(BCLog::AVALANCHE, "Ignoring getavaaddr message from %s peer=%d\n", pfrom.ConnectionTypeAsString(), pfrom.GetId()); return; } auto availabilityScoreComparator = [](const CNode *lhs, const CNode *rhs) { double scoreLhs = lhs->getAvailabilityScore(); double scoreRhs = rhs->getAvailabilityScore(); if (scoreLhs != scoreRhs) { return scoreLhs > scoreRhs; } return lhs < rhs; }; // Get up to MAX_ADDR_TO_SEND addresses of the nodes which are the // most active in the avalanche network. Account for 0 availability as // well so we can send addresses even if we did not start polling yet. std::set avaNodes( availabilityScoreComparator); m_connman.ForEachNode([&](const CNode *pnode) { if (!pnode->m_avalanche_enabled || pnode->getAvailabilityScore() < 0.) { return; } avaNodes.insert(pnode); if (avaNodes.size() > GetMaxAddrToSend()) { avaNodes.erase(std::prev(avaNodes.end())); } }); peer->m_addrs_to_send.clear(); FastRandomContext insecure_rand; for (const CNode *pnode : avaNodes) { PushAddress(*peer, pnode->addr, insecure_rand); } return; } if (msg_type == NetMsgType::MEMPOOL) { if (!(pfrom.GetLocalServices() & NODE_BLOOM) && !pfrom.HasPermission(PF_MEMPOOL)) { if (!pfrom.HasPermission(PF_NOBAN)) { LogPrint(BCLog::NET, "mempool request with bloom filters disabled, " "disconnect peer=%d\n", pfrom.GetId()); pfrom.fDisconnect = true; } return; } if (m_connman.OutboundTargetReached(false) && !pfrom.HasPermission(PF_MEMPOOL)) { if (!pfrom.HasPermission(PF_NOBAN)) { LogPrint(BCLog::NET, "mempool request with bandwidth limit reached, " "disconnect peer=%d\n", pfrom.GetId()); pfrom.fDisconnect = true; } return; } if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_tx_inventory); pfrom.m_tx_relay->fSendMempool = true; } return; } if (msg_type == NetMsgType::PING) { if (pfrom.GetCommonVersion() > BIP0031_VERSION) { uint64_t nonce = 0; vRecv >> nonce; // Echo the message back with the nonce. This allows for two useful // features: // // 1) A remote node can quickly check if the connection is // operational. // 2) Remote nodes can measure the latency of the network thread. If // this node is overloaded it won't respond to pings quickly and the // remote node can avoid sending us more work, like chain download // requests. // // The nonce stops the remote getting confused between different // pings: without it, if the remote node sends a ping once per // second and this node takes 5 seconds to respond to each, the 5th // ping the remote sends would appear to return very quickly. m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::PONG, nonce)); } return; } if (msg_type == NetMsgType::PONG) { const auto ping_end = time_received; uint64_t nonce = 0; size_t nAvail = vRecv.in_avail(); bool bPingFinished = false; std::string sProblem; if (nAvail >= sizeof(nonce)) { vRecv >> nonce; // Only process pong message if there is an outstanding ping (old // ping without nonce should never pong) if (peer->m_ping_nonce_sent != 0) { if (nonce == peer->m_ping_nonce_sent) { // Matching pong received, this ping is no longer // outstanding bPingFinished = true; const auto ping_time = ping_end - peer->m_ping_start.load(); if (ping_time.count() >= 0) { // Let connman know about this successful ping-pong pfrom.PongReceived(ping_time); } else { // This should never happen sProblem = "Timing mishap"; } } else { // Nonce mismatches are normal when pings are overlapping sProblem = "Nonce mismatch"; if (nonce == 0) { // This is most likely a bug in another implementation // somewhere; cancel this ping bPingFinished = true; sProblem = "Nonce zero"; } } } else { sProblem = "Unsolicited pong without ping"; } } else { // This is most likely a bug in another implementation somewhere; // cancel this ping bPingFinished = true; sProblem = "Short payload"; } if (!(sProblem.empty())) { LogPrint(BCLog::NET, "pong peer=%d: %s, %x expected, %x received, %u bytes\n", pfrom.GetId(), sProblem, peer->m_ping_nonce_sent, nonce, nAvail); } if (bPingFinished) { peer->m_ping_nonce_sent = 0; } return; } if (msg_type == NetMsgType::FILTERLOAD) { if (!(pfrom.GetLocalServices() & NODE_BLOOM)) { LogPrint(BCLog::NET, "filterload received despite not offering bloom services " "from peer=%d; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; return; } CBloomFilter filter; vRecv >> filter; if (!filter.IsWithinSizeConstraints()) { // There is no excuse for sending a too-large filter Misbehaving(pfrom, 100, "too-large bloom filter"); } else if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_filter); pfrom.m_tx_relay->pfilter.reset(new CBloomFilter(filter)); pfrom.m_tx_relay->fRelayTxes = true; } return; } if (msg_type == NetMsgType::FILTERADD) { if (!(pfrom.GetLocalServices() & NODE_BLOOM)) { LogPrint(BCLog::NET, "filteradd received despite not offering bloom services " "from peer=%d; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; return; } std::vector vData; vRecv >> vData; // Nodes must NEVER send a data item > 520 bytes (the max size for a // script data object, and thus, the maximum size any matched object can // have) in a filteradd message. bool bad = false; if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) { bad = true; } else if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_filter); if (pfrom.m_tx_relay->pfilter) { pfrom.m_tx_relay->pfilter->insert(vData); } else { bad = true; } } if (bad) { // The structure of this code doesn't really allow for a good error // code. We'll go generic. Misbehaving(pfrom, 100, "bad filteradd message"); } return; } if (msg_type == NetMsgType::FILTERCLEAR) { if (!(pfrom.GetLocalServices() & NODE_BLOOM)) { LogPrint(BCLog::NET, "filterclear received despite not offering bloom services " "from peer=%d; disconnecting\n", pfrom.GetId()); pfrom.fDisconnect = true; return; } if (pfrom.m_tx_relay == nullptr) { return; } LOCK(pfrom.m_tx_relay->cs_filter); pfrom.m_tx_relay->pfilter = nullptr; pfrom.m_tx_relay->fRelayTxes = true; return; } if (msg_type == NetMsgType::FEEFILTER) { Amount newFeeFilter = Amount::zero(); vRecv >> newFeeFilter; if (MoneyRange(newFeeFilter)) { if (pfrom.m_tx_relay != nullptr) { LOCK(pfrom.m_tx_relay->cs_feeFilter); pfrom.m_tx_relay->minFeeFilter = newFeeFilter; } LogPrint(BCLog::NET, "received: feefilter of %s from peer=%d\n", CFeeRate(newFeeFilter).ToString(), pfrom.GetId()); } return; } if (msg_type == NetMsgType::GETCFILTERS) { ProcessGetCFilters(pfrom, vRecv, m_chainparams, m_connman); return; } if (msg_type == NetMsgType::GETCFHEADERS) { ProcessGetCFHeaders(pfrom, vRecv, m_chainparams, m_connman); return; } if (msg_type == NetMsgType::GETCFCHECKPT) { ProcessGetCFCheckPt(pfrom, vRecv, m_chainparams, m_connman); return; } if (msg_type == NetMsgType::NOTFOUND) { std::vector vInv; vRecv >> vInv; // A peer might send up to 1 notfound per getdata request, but no more if (vInv.size() <= PROOF_REQUEST_PARAMS.max_peer_announcements + TX_REQUEST_PARAMS.max_peer_announcements + MAX_BLOCKS_IN_TRANSIT_PER_PEER) { for (CInv &inv : vInv) { if (inv.IsMsgTx()) { // If we receive a NOTFOUND message for a tx we requested, // mark the announcement for it as completed in // InvRequestTracker. LOCK(::cs_main); m_txrequest.ReceivedResponse(pfrom.GetId(), TxId(inv.hash)); continue; } if (inv.IsMsgProof()) { LOCK(cs_proofrequest); m_proofrequest.ReceivedResponse( pfrom.GetId(), avalanche::ProofId(inv.hash)); } } } return; } // Ignore unknown commands for extensibility LogPrint(BCLog::NET, "Unknown command \"%s\" from peer=%d\n", SanitizeString(msg_type), pfrom.GetId()); return; } bool PeerManagerImpl::MaybeDiscourageAndDisconnect(CNode &pnode, Peer &peer) { { LOCK(peer.m_misbehavior_mutex); // There's nothing to do if the m_should_discourage flag isn't set if (!peer.m_should_discourage) { return false; } peer.m_should_discourage = false; } // peer.m_misbehavior_mutex if (pnode.HasPermission(PF_NOBAN)) { // We never disconnect or discourage peers for bad behavior if they have // the NOBAN permission flag LogPrintf("Warning: not punishing noban peer %d!\n", peer.m_id); return false; } if (pnode.IsManualConn()) { // 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()) { // We disconnect local peers for bad behavior but don't discourage // (since that would discourage all peers on the same local address) LogPrintf( "Warning: disconnecting but not discouraging local peer %d!\n", peer.m_id); pnode.fDisconnect = true; return true; } // Normal case: Disconnect the peer and discourage all nodes sharing the // address LogPrint(BCLog::NET, "Disconnecting and discouraging peer %d!\n", peer.m_id); if (m_banman) { m_banman->Discourage(pnode.addr); } m_connman.DisconnectNode(pnode.addr); return true; } bool PeerManagerImpl::ProcessMessages(const Config &config, CNode *pfrom, std::atomic &interruptMsgProc) { // // Message format // (4) message start // (12) command // (4) size // (4) checksum // (x) data // bool fMoreWork = false; PeerRef peer = GetPeerRef(pfrom->GetId()); if (peer == nullptr) { return false; } { LOCK(peer->m_getdata_requests_mutex); if (!peer->m_getdata_requests.empty()) { ProcessGetData(config, *pfrom, *peer, interruptMsgProc); } } { LOCK2(cs_main, g_cs_orphans); if (!peer->m_orphan_work_set.empty()) { ProcessOrphanTx(config, peer->m_orphan_work_set); } } if (pfrom->fDisconnect) { return false; } // this maintains the order of responses and prevents m_getdata_requests // from growing unbounded { LOCK(peer->m_getdata_requests_mutex); if (!peer->m_getdata_requests.empty()) { return true; } } { LOCK(g_cs_orphans); if (!peer->m_orphan_work_set.empty()) { return true; } } // Don't bother if send buffer is too full to respond anyway if (pfrom->fPauseSend) { return false; } std::list msgs; { LOCK(pfrom->cs_vProcessMsg); if (pfrom->vProcessMsg.empty()) { return false; } // Just take one message msgs.splice(msgs.begin(), pfrom->vProcessMsg, pfrom->vProcessMsg.begin()); pfrom->nProcessQueueSize -= msgs.front().m_raw_message_size; pfrom->fPauseRecv = pfrom->nProcessQueueSize > m_connman.GetReceiveFloodSize(); fMoreWork = !pfrom->vProcessMsg.empty(); } CNetMessage &msg(msgs.front()); - TRACE6(net, inbound_message, pfrom->GetId(), pfrom->GetAddrName().c_str(), + TRACE6(net, inbound_message, pfrom->GetId(), pfrom->m_addr_name.c_str(), pfrom->ConnectionTypeAsString().c_str(), msg.m_command.c_str(), msg.m_recv.size(), msg.m_recv.data()); if (gArgs.GetBoolArg("-capturemessages", false)) { CaptureMessage(pfrom->addr, msg.m_command, MakeUCharSpan(msg.m_recv), /*incoming=*/true); } msg.SetVersion(pfrom->GetCommonVersion()); // Check network magic if (!msg.m_valid_netmagic) { LogPrint(BCLog::NET, "PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.m_command), pfrom->GetId()); // Make sure we discourage where that come from for some time. if (m_banman) { m_banman->Discourage(pfrom->addr); } m_connman.DisconnectNode(pfrom->addr); pfrom->fDisconnect = true; return false; } // Check header if (!msg.m_valid_header) { LogPrint(BCLog::NET, "PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n", SanitizeString(msg.m_command), pfrom->GetId()); return fMoreWork; } const std::string &msg_type = msg.m_command; // Message size unsigned int nMessageSize = msg.m_message_size; // Checksum CDataStream &vRecv = msg.m_recv; if (!msg.m_valid_checksum) { LogPrint(BCLog::NET, "%s(%s, %u bytes): CHECKSUM ERROR peer=%d\n", __func__, SanitizeString(msg_type), nMessageSize, pfrom->GetId()); if (m_banman) { m_banman->Discourage(pfrom->addr); } m_connman.DisconnectNode(pfrom->addr); return fMoreWork; } try { ProcessMessage(config, *pfrom, msg_type, vRecv, msg.m_time, interruptMsgProc); if (interruptMsgProc) { return false; } { LOCK(peer->m_getdata_requests_mutex); if (!peer->m_getdata_requests.empty()) { fMoreWork = true; } } } catch (const std::exception &e) { LogPrint(BCLog::NET, "%s(%s, %u bytes): Exception '%s' (%s) caught\n", __func__, SanitizeString(msg_type), nMessageSize, e.what(), typeid(e).name()); } catch (...) { LogPrint(BCLog::NET, "%s(%s, %u bytes): Unknown exception caught\n", __func__, SanitizeString(msg_type), nMessageSize); } return fMoreWork; } void PeerManagerImpl::ConsiderEviction(CNode &pto, int64_t time_in_seconds) { AssertLockHeld(cs_main); CNodeState &state = *State(pto.GetId()); const CNetMsgMaker msgMaker(pto.GetCommonVersion()); if (!state.m_chain_sync.m_protect && pto.IsOutboundOrBlockRelayConn() && state.fSyncStarted) { // This is an outbound peer subject to disconnection if they don't // announce a block with as much work as the current tip within // CHAIN_SYNC_TIMEOUT + HEADERS_RESPONSE_TIME seconds (note: if their // chain has more work than ours, we should sync to it, unless it's // invalid, in which case we should find that out and disconnect from // them elsewhere). if (state.pindexBestKnownBlock != nullptr && state.pindexBestKnownBlock->nChainWork >= m_chainman.ActiveChain().Tip()->nChainWork) { if (state.m_chain_sync.m_timeout != 0) { state.m_chain_sync.m_timeout = 0; state.m_chain_sync.m_work_header = nullptr; state.m_chain_sync.m_sent_getheaders = false; } } else if (state.m_chain_sync.m_timeout == 0 || (state.m_chain_sync.m_work_header != nullptr && state.pindexBestKnownBlock != nullptr && state.pindexBestKnownBlock->nChainWork >= state.m_chain_sync.m_work_header->nChainWork)) { // Our best block known by this peer is behind our tip, and we're // either noticing that for the first time, OR this peer was able to // catch up to some earlier point where we checked against our tip. // Either way, set a new timeout based on current tip. state.m_chain_sync.m_timeout = time_in_seconds + CHAIN_SYNC_TIMEOUT; state.m_chain_sync.m_work_header = m_chainman.ActiveChain().Tip(); state.m_chain_sync.m_sent_getheaders = false; } else if (state.m_chain_sync.m_timeout > 0 && time_in_seconds > state.m_chain_sync.m_timeout) { // No evidence yet that our peer has synced to a chain with work // equal to that of our tip, when we first detected it was behind. // Send a single getheaders message to give the peer a chance to // update us. if (state.m_chain_sync.m_sent_getheaders) { // They've run out of time to catch up! LogPrintf( "Disconnecting outbound peer %d for old chain, best known " "block = %s\n", pto.GetId(), state.pindexBestKnownBlock != nullptr ? state.pindexBestKnownBlock->GetBlockHash().ToString() : ""); pto.fDisconnect = true; } else { assert(state.m_chain_sync.m_work_header); LogPrint( BCLog::NET, "sending getheaders to outbound peer=%d to verify chain " "work (current best known block:%s, benchmark blockhash: " "%s)\n", pto.GetId(), state.pindexBestKnownBlock != nullptr ? state.pindexBestKnownBlock->GetBlockHash().ToString() : "", state.m_chain_sync.m_work_header->GetBlockHash() .ToString()); m_connman.PushMessage( &pto, msgMaker.Make(NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator( state.m_chain_sync.m_work_header->pprev), uint256())); state.m_chain_sync.m_sent_getheaders = true; // 2 minutes constexpr int64_t HEADERS_RESPONSE_TIME = 120; // Bump the timeout to allow a response, which could clear the // timeout (if the response shows the peer has synced), reset // the timeout (if the peer syncs to the required work but not // to our tip), or result in disconnect (if we advance to the // timeout and pindexBestKnownBlock has not sufficiently // progressed) state.m_chain_sync.m_timeout = time_in_seconds + HEADERS_RESPONSE_TIME; } } } } void PeerManagerImpl::EvictExtraOutboundPeers(std::chrono::seconds now) { // If we have any extra block-relay-only peers, disconnect the youngest // unless it's given us a block -- in which case, compare with the // second-youngest, and out of those two, disconnect the peer who least // recently gave us a block. // The youngest block-relay-only peer would be the extra peer we connected // to temporarily in order to sync our tip; see net.cpp. // Note that we use higher nodeid as a measure for most recent connection. if (m_connman.GetExtraBlockRelayCount() > 0) { std::pair youngest_peer{-1, 0}, next_youngest_peer{-1, 0}; m_connman.ForEachNode([&](CNode *pnode) { if (!pnode->IsBlockOnlyConn() || pnode->fDisconnect) { return; } if (pnode->GetId() > youngest_peer.first) { next_youngest_peer = youngest_peer; youngest_peer.first = pnode->GetId(); youngest_peer.second = pnode->m_last_block_time; } }); NodeId to_disconnect = youngest_peer.first; if (youngest_peer.second > next_youngest_peer.second) { // Our newest block-relay-only peer gave us a block more recently; // disconnect our second youngest. to_disconnect = next_youngest_peer.first; } m_connman.ForNode( to_disconnect, [&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { AssertLockHeld(::cs_main); // Make sure we're not getting a block right now, and that we've // been connected long enough for this eviction to happen at // all. Note that we only request blocks from a peer if we learn // of a valid headers chain with at least as much work as our // tip. CNodeState *node_state = State(pnode->GetId()); if (node_state == nullptr || (now - pnode->m_connected >= MINIMUM_CONNECT_TIME && node_state->nBlocksInFlight == 0)) { pnode->fDisconnect = true; LogPrint(BCLog::NET, "disconnecting extra block-relay-only peer=%d " "(last block received at time %d)\n", pnode->GetId(), count_seconds(pnode->m_last_block_time)); return true; } else { LogPrint( BCLog::NET, "keeping block-relay-only peer=%d chosen for eviction " "(connect time: %d, blocks_in_flight: %d)\n", pnode->GetId(), count_seconds(pnode->m_connected), node_state->nBlocksInFlight); } return false; }); } // Check whether we have too many OUTBOUND_FULL_RELAY peers if (m_connman.GetExtraFullOutboundCount() <= 0) { return; } // If we have more OUTBOUND_FULL_RELAY peers than we target, disconnect one. // Pick the OUTBOUND_FULL_RELAY peer that least recently announced us a new // block, with ties broken by choosing the more recent connection (higher // node id) NodeId worst_peer = -1; int64_t oldest_block_announcement = std::numeric_limits::max(); m_connman.ForEachNode([&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED( ::cs_main) { AssertLockHeld(::cs_main); // Only consider OUTBOUND_FULL_RELAY peers that are not already marked // for disconnection if (!pnode->IsFullOutboundConn() || pnode->fDisconnect) { return; } CNodeState *state = State(pnode->GetId()); if (state == nullptr) { // shouldn't be possible, but just in case return; } // Don't evict our protected peers if (state->m_chain_sync.m_protect) { return; } if (state->m_last_block_announcement < oldest_block_announcement || (state->m_last_block_announcement == oldest_block_announcement && pnode->GetId() > worst_peer)) { worst_peer = pnode->GetId(); oldest_block_announcement = state->m_last_block_announcement; } }); if (worst_peer == -1) { return; } bool disconnected = m_connman.ForNode( worst_peer, [&](CNode *pnode) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { AssertLockHeld(::cs_main); // Only disconnect a peer that has been connected to us for some // reasonable fraction of our check-frequency, to give it time for // new information to have arrived. Also don't disconnect any peer // we're trying to download a block from. CNodeState &state = *State(pnode->GetId()); if (now - pnode->m_connected > MINIMUM_CONNECT_TIME && state.nBlocksInFlight == 0) { LogPrint(BCLog::NET, "disconnecting extra outbound peer=%d (last block " "announcement received at time %d)\n", pnode->GetId(), oldest_block_announcement); pnode->fDisconnect = true; return true; } else { LogPrint(BCLog::NET, "keeping outbound peer=%d chosen for eviction " "(connect time: %d, blocks_in_flight: %d)\n", pnode->GetId(), count_seconds(pnode->m_connected), state.nBlocksInFlight); return false; } }); if (disconnected) { // If we disconnected an extra peer, that means we successfully // connected to at least one peer after the last time we detected a // stale tip. Don't try any more extra peers until we next detect a // stale tip, to limit the load we put on the network from these extra // connections. m_connman.SetTryNewOutboundPeer(false); } } void PeerManagerImpl::CheckForStaleTipAndEvictPeers() { LOCK(cs_main); int64_t time_in_seconds = GetTime(); EvictExtraOutboundPeers(std::chrono::seconds{time_in_seconds}); if (time_in_seconds > m_stale_tip_check_time) { // Check whether our tip is stale, and if so, allow using an extra // outbound peer. if (!fImporting && !fReindex && m_connman.GetNetworkActive() && m_connman.GetUseAddrmanOutgoing() && TipMayBeStale()) { LogPrintf("Potential stale tip detected, will try using extra " "outbound peer (last tip update: %d seconds ago)\n", time_in_seconds - m_last_tip_update); m_connman.SetTryNewOutboundPeer(true); } else if (m_connman.GetTryNewOutboundPeer()) { m_connman.SetTryNewOutboundPeer(false); } m_stale_tip_check_time = time_in_seconds + STALE_CHECK_INTERVAL; } if (!m_initial_sync_finished && CanDirectFetch(m_chainparams.GetConsensus())) { m_connman.StartExtraBlockRelayPeers(); m_initial_sync_finished = true; } } void PeerManagerImpl::MaybeSendPing(CNode &node_to, Peer &peer, std::chrono::microseconds now) { if (m_connman.ShouldRunInactivityChecks( node_to, std::chrono::duration_cast(now)) && peer.m_ping_nonce_sent && now > peer.m_ping_start.load() + TIMEOUT_INTERVAL) { // The ping timeout is using mocktime. To disable the check during // testing, increase -peertimeout. LogPrint(BCLog::NET, "ping timeout: %fs peer=%d\n", 0.000001 * count_microseconds(now - peer.m_ping_start.load()), peer.m_id); node_to.fDisconnect = true; return; } const CNetMsgMaker msgMaker(node_to.GetCommonVersion()); bool pingSend = false; if (peer.m_ping_queued) { // RPC ping request by user pingSend = true; } if (peer.m_ping_nonce_sent == 0 && now > peer.m_ping_start.load() + PING_INTERVAL) { // Ping automatically sent as a latency probe & keepalive. pingSend = true; } if (pingSend) { uint64_t nonce = 0; while (nonce == 0) { GetRandBytes((uint8_t *)&nonce, sizeof(nonce)); } peer.m_ping_queued = false; peer.m_ping_start = now; if (node_to.GetCommonVersion() > BIP0031_VERSION) { peer.m_ping_nonce_sent = nonce; m_connman.PushMessage(&node_to, msgMaker.Make(NetMsgType::PING, nonce)); } else { // Peer is too old to support ping command with nonce, pong will // never arrive. peer.m_ping_nonce_sent = 0; m_connman.PushMessage(&node_to, msgMaker.Make(NetMsgType::PING)); } } } void PeerManagerImpl::MaybeSendAddr(CNode &node, Peer &peer, std::chrono::microseconds current_time) { // Nothing to do for non-address-relay peers if (!peer.m_addr_relay_enabled) { return; } LOCK(peer.m_addr_send_times_mutex); if (fListen && !m_chainman.ActiveChainstate().IsInitialBlockDownload() && peer.m_next_local_addr_send < current_time) { // If we've sent before, clear the bloom filter for the peer, so // that our self-announcement will actually go out. This might // be unnecessary if the bloom filter has already rolled over // since our last self-announcement, but there is only a small // bandwidth cost that we can incur by doing this (which happens // once a day on average). if (peer.m_next_local_addr_send != 0us) { peer.m_addr_known->reset(); } if (std::optional local_addr = GetLocalAddrForPeer(&node)) { FastRandomContext insecure_rand; PushAddress(peer, *local_addr, insecure_rand); } peer.m_next_local_addr_send = PoissonNextSend(current_time, AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL); } // We sent an `addr` message to this peer recently. Nothing more to do. if (current_time <= peer.m_next_addr_send) { return; } peer.m_next_addr_send = PoissonNextSend(current_time, AVG_ADDRESS_BROADCAST_INTERVAL); const size_t max_addr_to_send = GetMaxAddrToSend(); if (!Assume(peer.m_addrs_to_send.size() <= max_addr_to_send)) { // Should be impossible since we always check size before adding to // m_addrs_to_send. Recover by trimming the vector. peer.m_addrs_to_send.resize(max_addr_to_send); } // Remove addr records that the peer already knows about, and add new // addrs to the m_addr_known filter on the same pass. auto addr_already_known = [&peer](const CAddress &addr) { bool ret = peer.m_addr_known->contains(addr.GetKey()); if (!ret) { peer.m_addr_known->insert(addr.GetKey()); } return ret; }; peer.m_addrs_to_send.erase(std::remove_if(peer.m_addrs_to_send.begin(), peer.m_addrs_to_send.end(), addr_already_known), peer.m_addrs_to_send.end()); // No addr messages to send if (peer.m_addrs_to_send.empty()) { return; } const char *msg_type; int make_flags; if (peer.m_wants_addrv2) { msg_type = NetMsgType::ADDRV2; make_flags = ADDRV2_FORMAT; } else { msg_type = NetMsgType::ADDR; make_flags = 0; } m_connman.PushMessage( &node, CNetMsgMaker(node.GetCommonVersion()) .Make(make_flags, msg_type, peer.m_addrs_to_send)); peer.m_addrs_to_send.clear(); // we only send the big addr message once if (peer.m_addrs_to_send.capacity() > 40) { peer.m_addrs_to_send.shrink_to_fit(); } } void PeerManagerImpl::MaybeSendFeefilter( CNode &pto, std::chrono::microseconds current_time) { if (m_ignore_incoming_txs) { return; } if (!pto.m_tx_relay) { return; } if (pto.GetCommonVersion() < FEEFILTER_VERSION) { return; } // peers with the forcerelay permission should not filter txs to us if (pto.HasPermission(PF_FORCERELAY)) { return; } Amount currentFilter = m_mempool .GetMinFee( gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000) .GetFeePerK(); static FeeFilterRounder g_filter_rounder{ CFeeRate{DEFAULT_MIN_RELAY_TX_FEE_PER_KB}}; if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) { // Received tx-inv messages are discarded when the active // chainstate is in IBD, so tell the peer to not send them. currentFilter = MAX_MONEY; } else { static const Amount MAX_FILTER{g_filter_rounder.round(MAX_MONEY)}; if (pto.m_tx_relay->lastSentFeeFilter == MAX_FILTER) { // Send the current filter if we sent MAX_FILTER previously // and made it out of IBD. pto.m_tx_relay->m_next_send_feefilter = 0us; } } if (current_time > pto.m_tx_relay->m_next_send_feefilter) { Amount filterToSend = g_filter_rounder.round(currentFilter); // We always have a fee filter of at least minRelayTxFee filterToSend = std::max(filterToSend, ::minRelayTxFee.GetFeePerK()); if (filterToSend != pto.m_tx_relay->lastSentFeeFilter) { m_connman.PushMessage( &pto, CNetMsgMaker(pto.GetCommonVersion()) .Make(NetMsgType::FEEFILTER, filterToSend)); pto.m_tx_relay->lastSentFeeFilter = filterToSend; } pto.m_tx_relay->m_next_send_feefilter = PoissonNextSend(current_time, AVG_FEEFILTER_BROADCAST_INTERVAL); } // If the fee filter has changed substantially and it's still more than // MAX_FEEFILTER_CHANGE_DELAY until scheduled broadcast, then move the // broadcast to within MAX_FEEFILTER_CHANGE_DELAY. else if (current_time + MAX_FEEFILTER_CHANGE_DELAY < pto.m_tx_relay->m_next_send_feefilter && (currentFilter < 3 * pto.m_tx_relay->lastSentFeeFilter / 4 || currentFilter > 4 * pto.m_tx_relay->lastSentFeeFilter / 3)) { pto.m_tx_relay->m_next_send_feefilter = current_time + GetRandomDuration( MAX_FEEFILTER_CHANGE_DELAY); } } namespace { class CompareInvMempoolOrder { CTxMemPool *mp; public: explicit CompareInvMempoolOrder(CTxMemPool *_mempool) { mp = _mempool; } bool operator()(std::set::iterator a, std::set::iterator b) { /** * As std::make_heap produces a max-heap, we want the entries with the * fewest ancestors/highest fee to sort later. */ return mp->CompareDepthAndScore(*b, *a); } }; } // namespace bool PeerManagerImpl::SetupAddressRelay(CNode &node, Peer &peer) { // We don't participate in addr relay with outbound block-relay-only // connections to prevent providing adversaries with the additional // information of addr traffic to infer the link. if (node.IsBlockOnlyConn()) { return false; } if (!peer.m_addr_relay_enabled.exchange(true)) { // First addr message we have received from the peer, initialize // m_addr_known peer.m_addr_known = std::make_unique(5000, 0.001); } return true; } bool PeerManagerImpl::SendMessages(const Config &config, CNode *pto) { PeerRef peer = GetPeerRef(pto->GetId()); if (!peer) { return false; } const Consensus::Params &consensusParams = m_chainparams.GetConsensus(); // 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; } // Don't send anything until the version handshake is complete if (!pto->fSuccessfullyConnected || pto->fDisconnect) { return true; } // If we get here, the outgoing message serialization version is set and // can't change. const CNetMsgMaker msgMaker(pto->GetCommonVersion()); const auto current_time = GetTime(); if (pto->IsAddrFetchConn() && current_time - pto->m_connected > 10 * AVG_ADDRESS_BROADCAST_INTERVAL) { LogPrint(BCLog::NET, "addrfetch connection timeout; disconnecting peer=%d\n", pto->GetId()); pto->fDisconnect = true; return true; } MaybeSendPing(*pto, *peer, current_time); // MaybeSendPing may have marked peer for disconnection if (pto->fDisconnect) { return true; } bool fFetch; MaybeSendAddr(*pto, *peer, current_time); { LOCK(cs_main); CNodeState &state = *State(pto->GetId()); // Start block sync if (pindexBestHeader == nullptr) { pindexBestHeader = m_chainman.ActiveChain().Tip(); } // Download if this is a nice peer, or we have no nice peers and this // one might do. fFetch = state.fPreferredDownload || (nPreferredDownload == 0 && !pto->fClient && !pto->IsAddrFetchConn()); if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) { // Only actively request headers from a single peer, unless we're // close to today. if ((nSyncStarted == 0 && fFetch) || pindexBestHeader->GetBlockTime() > GetAdjustedTime() - 24 * 60 * 60) { state.fSyncStarted = true; state.m_headers_sync_timeout = current_time + HEADERS_DOWNLOAD_TIMEOUT_BASE + ( // Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to // microseconds before scaling to maintain precision std::chrono::microseconds{ HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER} * (GetAdjustedTime() - pindexBestHeader->GetBlockTime()) / consensusParams.nPowTargetSpacing); nSyncStarted++; const CBlockIndex *pindexStart = pindexBestHeader; /** * If possible, start at the block preceding the currently best * known header. This ensures that we always get a non-empty * list of headers back as long as the peer is up-to-date. With * a non-empty response, we can initialise the peer's known best * block. This wouldn't be possible if we requested starting at * pindexBestHeader and got back an empty response. */ if (pindexStart->pprev) { pindexStart = pindexStart->pprev; } LogPrint( BCLog::NET, "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->GetId(), peer->m_starting_height); m_connman.PushMessage( pto, msgMaker.Make( NetMsgType::GETHEADERS, m_chainman.ActiveChain().GetLocator(pindexStart), uint256())); } } // // Try sending block announcements via headers // { // If we have less than MAX_BLOCKS_TO_ANNOUNCE in our list of block // hashes we're relaying, and our peer wants headers announcements, // then find the first header not yet known to our peer but would // connect, and send. If no header would connect, or if we have too // many blocks, or if the peer doesn't want headers, just add all to // the inv queue. LOCK(peer->m_block_inv_mutex); std::vector vHeaders; bool fRevertToInv = ((!state.fPreferHeaders && (!state.fPreferHeaderAndIDs || peer->m_blocks_for_headers_relay.size() > 1)) || peer->m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE); // last header queued for delivery const CBlockIndex *pBestIndex = nullptr; // ensure pindexBestKnownBlock is up-to-date ProcessBlockAvailability(pto->GetId()); if (!fRevertToInv) { bool fFoundStartingHeader = false; // Try to find first header that our peer doesn't have, and then // send all headers past that one. If we come across an headers // that aren't on m_chainman.ActiveChain(), give up. for (const BlockHash &hash : peer->m_blocks_for_headers_relay) { const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hash); assert(pindex); if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) { // Bail out if we reorged away from this block fRevertToInv = true; break; } if (pBestIndex != nullptr && pindex->pprev != pBestIndex) { // This means that the list of blocks to announce don't // connect to each other. This shouldn't really be // possible to hit during regular operation (because // reorgs should take us to a chain that has some block // not on the prior chain, which should be caught by the // prior check), but one way this could happen is by // using invalidateblock / reconsiderblock repeatedly on // the tip, causing it to be added multiple times to // m_blocks_for_headers_relay. Robustly deal with this // rare situation by reverting to an inv. fRevertToInv = true; break; } pBestIndex = pindex; if (fFoundStartingHeader) { // add this to the headers message vHeaders.push_back(pindex->GetBlockHeader()); } else if (PeerHasHeader(&state, pindex)) { // Keep looking for the first new block. continue; } else if (pindex->pprev == nullptr || PeerHasHeader(&state, pindex->pprev)) { // Peer doesn't have this header but they do have the // prior one. Start sending headers. fFoundStartingHeader = true; vHeaders.push_back(pindex->GetBlockHeader()); } else { // Peer doesn't have this header or the prior one -- // nothing will connect, so bail out. fRevertToInv = true; break; } } } if (!fRevertToInv && !vHeaders.empty()) { if (vHeaders.size() == 1 && state.fPreferHeaderAndIDs) { // We only send up to 1 block as header-and-ids, as // otherwise probably means we're doing an initial-ish-sync // or they're slow. LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", __func__, vHeaders.front().GetHash().ToString(), pto->GetId()); int nSendFlags = 0; bool fGotBlockFromCache = false; { LOCK(cs_most_recent_block); if (most_recent_block_hash == pBestIndex->GetBlockHash()) { CBlockHeaderAndShortTxIDs cmpctblock( *most_recent_block); m_connman.PushMessage( pto, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock)); fGotBlockFromCache = true; } } if (!fGotBlockFromCache) { CBlock block; bool ret = ReadBlockFromDisk(block, pBestIndex, consensusParams); assert(ret); CBlockHeaderAndShortTxIDs cmpctblock(block); m_connman.PushMessage( pto, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, cmpctblock)); } state.pindexBestHeaderSent = pBestIndex; } else if (state.fPreferHeaders) { if (vHeaders.size() > 1) { LogPrint(BCLog::NET, "%s: %u headers, range (%s, %s), to peer=%d\n", __func__, vHeaders.size(), vHeaders.front().GetHash().ToString(), vHeaders.back().GetHash().ToString(), pto->GetId()); } else { LogPrint(BCLog::NET, "%s: sending header %s to peer=%d\n", __func__, vHeaders.front().GetHash().ToString(), pto->GetId()); } m_connman.PushMessage( pto, msgMaker.Make(NetMsgType::HEADERS, vHeaders)); state.pindexBestHeaderSent = pBestIndex; } else { fRevertToInv = true; } } if (fRevertToInv) { // If falling back to using an inv, just try to inv the tip. The // last entry in m_blocks_for_headers_relay was our tip at some // point in the past. if (!peer->m_blocks_for_headers_relay.empty()) { const BlockHash &hashToAnnounce = peer->m_blocks_for_headers_relay.back(); const CBlockIndex *pindex = m_chainman.m_blockman.LookupBlockIndex(hashToAnnounce); assert(pindex); // Warn if we're announcing a block that is not on the main // chain. This should be very rare and could be optimized // out. Just log for now. if (m_chainman.ActiveChain()[pindex->nHeight] != pindex) { LogPrint( BCLog::NET, "Announcing block %s not on main chain (tip=%s)\n", hashToAnnounce.ToString(), m_chainman.ActiveChain() .Tip() ->GetBlockHash() .ToString()); } // If the peer's chain has this block, don't inv it back. if (!PeerHasHeader(&state, pindex)) { peer->m_blocks_for_inv_relay.push_back(hashToAnnounce); LogPrint(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__, pto->GetId(), hashToAnnounce.ToString()); } } } peer->m_blocks_for_headers_relay.clear(); } } // release cs_main // // Message: inventory // std::vector vInv; auto addInvAndMaybeFlush = [&](uint32_t type, const uint256 &hash) { vInv.emplace_back(type, hash); if (vInv.size() == MAX_INV_SZ) { m_connman.PushMessage( pto, msgMaker.Make(NetMsgType::INV, std::move(vInv))); vInv.clear(); } }; { LOCK(cs_main); { LOCK(peer->m_block_inv_mutex); vInv.reserve(std::max(peer->m_blocks_for_inv_relay.size(), INVENTORY_BROADCAST_MAX_PER_MB * config.GetMaxBlockSize() / 1000000)); // Add blocks for (const BlockHash &hash : peer->m_blocks_for_inv_relay) { addInvAndMaybeFlush(MSG_BLOCK, hash); } peer->m_blocks_for_inv_relay.clear(); } auto computeNextInvSendTime = [&](std::chrono::microseconds &next) -> bool { bool fSendTrickle = pto->HasPermission(PF_NOBAN); if (next < current_time) { fSendTrickle = true; if (pto->IsInboundConn()) { next = m_connman.PoissonNextSendInbound( current_time, INBOUND_INVENTORY_BROADCAST_INTERVAL); } else { // Skip delay for outbound peers, as there is less privacy // concern for them. next = current_time; } } return fSendTrickle; }; // Add proofs to inventory if (pto->m_proof_relay != nullptr) { LOCK(pto->m_proof_relay->cs_proof_inventory); if (computeNextInvSendTime(pto->m_proof_relay->nextInvSend)) { auto it = pto->m_proof_relay->setInventoryProofToSend.begin(); while (it != pto->m_proof_relay->setInventoryProofToSend.end()) { const avalanche::ProofId proofid = *it; it = pto->m_proof_relay->setInventoryProofToSend.erase(it); if (pto->m_proof_relay->filterProofKnown.contains( proofid)) { continue; } pto->m_proof_relay->filterProofKnown.insert(proofid); addInvAndMaybeFlush(MSG_AVA_PROOF, proofid); State(pto->GetId()) ->m_recently_announced_proofs.insert(proofid); } } } if (pto->m_tx_relay != nullptr) { LOCK(pto->m_tx_relay->cs_tx_inventory); // Check whether periodic sends should happen const bool fSendTrickle = computeNextInvSendTime(pto->m_tx_relay->nNextInvSend); // Time to send but the peer has requested we not relay // transactions. if (fSendTrickle) { LOCK(pto->m_tx_relay->cs_filter); if (!pto->m_tx_relay->fRelayTxes) { pto->m_tx_relay->setInventoryTxToSend.clear(); } } // Respond to BIP35 mempool requests if (fSendTrickle && pto->m_tx_relay->fSendMempool) { auto vtxinfo = m_mempool.infoAll(); pto->m_tx_relay->fSendMempool = false; CFeeRate filterrate; { LOCK(pto->m_tx_relay->cs_feeFilter); filterrate = CFeeRate(pto->m_tx_relay->minFeeFilter); } LOCK(pto->m_tx_relay->cs_filter); for (const auto &txinfo : vtxinfo) { const TxId &txid = txinfo.tx->GetId(); pto->m_tx_relay->setInventoryTxToSend.erase(txid); // Don't send transactions that peers will not put into // their mempool if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) { continue; } if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate( *txinfo.tx)) { continue; } pto->m_tx_relay->filterInventoryKnown.insert(txid); // Responses to MEMPOOL requests bypass the // m_recently_announced_invs filter. addInvAndMaybeFlush(MSG_TX, txid); } pto->m_tx_relay->m_last_mempool_req = std::chrono::duration_cast( current_time); } // Determine transactions to relay if (fSendTrickle) { // Produce a vector with all candidates for sending std::vector::iterator> vInvTx; vInvTx.reserve(pto->m_tx_relay->setInventoryTxToSend.size()); for (std::set::iterator it = pto->m_tx_relay->setInventoryTxToSend.begin(); it != pto->m_tx_relay->setInventoryTxToSend.end(); it++) { vInvTx.push_back(it); } CFeeRate filterrate; { LOCK(pto->m_tx_relay->cs_feeFilter); filterrate = CFeeRate(pto->m_tx_relay->minFeeFilter); } // Topologically and fee-rate sort the inventory we send for // privacy and priority reasons. A heap is used so that not // all items need sorting if only a few are being sent. CompareInvMempoolOrder compareInvMempoolOrder(&m_mempool); std::make_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder); // No reason to drain out at many times the network's // capacity, especially since we have many peers and some // will draw much shorter delays. unsigned int nRelayedTransactions = 0; LOCK(pto->m_tx_relay->cs_filter); while (!vInvTx.empty() && nRelayedTransactions < INVENTORY_BROADCAST_MAX_PER_MB * config.GetMaxBlockSize() / 1000000) { // Fetch the top element from the heap std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder); std::set::iterator it = vInvTx.back(); vInvTx.pop_back(); const TxId txid = *it; // Remove it from the to-be-sent set pto->m_tx_relay->setInventoryTxToSend.erase(it); // Check if not in the filter already if (pto->m_tx_relay->filterInventoryKnown.contains(txid)) { continue; } // Not in the mempool anymore? don't bother sending it. auto txinfo = m_mempool.info(txid); if (!txinfo.tx) { continue; } // Peer told you to not send transactions at that // feerate? Don't bother sending it. if (txinfo.fee < filterrate.GetFee(txinfo.vsize)) { continue; } if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate( *txinfo.tx)) { continue; } // Send State(pto->GetId())->m_recently_announced_invs.insert(txid); addInvAndMaybeFlush(MSG_TX, txid); nRelayedTransactions++; { // Expire old relay messages while (!g_relay_expiration.empty() && g_relay_expiration.front().first < current_time) { mapRelay.erase(g_relay_expiration.front().second); g_relay_expiration.pop_front(); } auto ret = mapRelay.insert( std::make_pair(txid, std::move(txinfo.tx))); if (ret.second) { g_relay_expiration.push_back(std::make_pair( current_time + RELAY_TX_CACHE_TIME, ret.first)); } } pto->m_tx_relay->filterInventoryKnown.insert(txid); } } } } // release cs_main if (!vInv.empty()) { m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv)); } { LOCK(cs_main); CNodeState &state = *State(pto->GetId()); // Detect whether we're stalling if (state.m_stalling_since.count() && state.m_stalling_since < current_time - BLOCK_STALLING_TIMEOUT) { // Stalling only triggers when the block download window cannot // move. During normal steady state, the download window should be // much larger than the to-be-downloaded set of blocks, so // disconnection should only happen during initial block download. LogPrintf("Peer=%d is stalling block download, disconnecting\n", pto->GetId()); pto->fDisconnect = true; return true; } // In case there is a block that has been in flight from this peer for // block_interval * (1 + 0.5 * N) (with N the number of peers from which // we're downloading validated blocks), disconnect due to timeout. // We compensate for other peers to prevent killing off peers due to our // own downstream link being saturated. We only count validated // in-flight blocks so peers can't advertise non-existing block hashes // to unreasonably increase our timeout. if (state.vBlocksInFlight.size() > 0) { QueuedBlock &queuedBlock = state.vBlocksInFlight.front(); int nOtherPeersWithValidatedDownloads = nPeersWithValidatedDownloads - (state.nBlocksInFlightValidHeaders > 0); if (current_time > state.m_downloading_since + std::chrono::seconds{consensusParams.nPowTargetSpacing} * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) { LogPrintf("Timeout downloading block %s from peer=%d, " "disconnecting\n", queuedBlock.hash.ToString(), pto->GetId()); pto->fDisconnect = true; return true; } } // Check for headers sync timeouts if (state.fSyncStarted && state.m_headers_sync_timeout < std::chrono::microseconds::max()) { // Detect whether this is a stalling initial-headers-sync peer if (pindexBestHeader->GetBlockTime() <= GetAdjustedTime() - 24 * 60 * 60) { if (current_time > state.m_headers_sync_timeout && nSyncStarted == 1 && (nPreferredDownload - state.fPreferredDownload >= 1)) { // Disconnect a peer (without the noban permission) if it // is our only sync peer, and we have others we could be // using instead. // Note: If all our peers are inbound, then we won't // disconnect our sync peer for stalling; we have bigger // problems if we can't get any outbound peers. if (!pto->HasPermission(PF_NOBAN)) { LogPrintf("Timeout downloading headers from peer=%d, " "disconnecting\n", pto->GetId()); pto->fDisconnect = true; return true; } else { LogPrintf("Timeout downloading headers from noban " "peer=%d, not disconnecting\n", pto->GetId()); // Reset the headers sync state so that we have a chance // to try downloading from a different peer. Note: this // will also result in at least one more getheaders // message to be sent to this peer (eventually). state.fSyncStarted = false; nSyncStarted--; state.m_headers_sync_timeout = 0us; } } } else { // After we've caught up once, reset the timeout so we can't // trigger disconnect later. state.m_headers_sync_timeout = std::chrono::microseconds::max(); } } // Check that outbound peers have reasonable chains GetTime() is used by // this anti-DoS logic so we can test this using mocktime. ConsiderEviction(*pto, GetTime()); } // release cs_main std::vector vGetData; // // Message: getdata (blocks) // { LOCK(cs_main); CNodeState &state = *State(pto->GetId()); if (!pto->fClient && ((fFetch && !pto->m_limited_node) || !m_chainman.ActiveChainstate().IsInitialBlockDownload()) && state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) { std::vector vToDownload; NodeId staller = -1; FindNextBlocksToDownload(pto->GetId(), MAX_BLOCKS_IN_TRANSIT_PER_PEER - state.nBlocksInFlight, vToDownload, staller); for (const CBlockIndex *pindex : vToDownload) { vGetData.push_back(CInv(MSG_BLOCK, pindex->GetBlockHash())); MarkBlockAsInFlight(config, pto->GetId(), pindex->GetBlockHash(), pindex); LogPrint(BCLog::NET, "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(), pindex->nHeight, pto->GetId()); } if (state.nBlocksInFlight == 0 && staller != -1) { if (State(staller)->m_stalling_since == 0us) { State(staller)->m_stalling_since = current_time; LogPrint(BCLog::NET, "Stall started peer=%d\n", staller); } } } } // release cs_main auto addGetDataAndMaybeFlush = [&](uint32_t type, const uint256 &hash) { CInv inv(type, hash); LogPrint(BCLog::NET, "Requesting %s from peer=%d\n", inv.ToString(), pto->GetId()); vGetData.push_back(std::move(inv)); if (vGetData.size() >= MAX_GETDATA_SZ) { m_connman.PushMessage( pto, msgMaker.Make(NetMsgType::GETDATA, std::move(vGetData))); vGetData.clear(); } }; // // Message: getdata (proof) // { LOCK(cs_proofrequest); std::vector> expired; auto requestable = m_proofrequest.GetRequestable(pto->GetId(), current_time, &expired); for (const auto &entry : expired) { LogPrint(BCLog::AVALANCHE, "timeout of inflight proof %s from peer=%d\n", entry.second.ToString(), entry.first); } for (const auto &proofid : requestable) { if (!AlreadyHaveProof(proofid)) { addGetDataAndMaybeFlush(MSG_AVA_PROOF, proofid); m_proofrequest.RequestedData( pto->GetId(), proofid, current_time + PROOF_REQUEST_PARAMS.getdata_interval); } else { // We have already seen this proof, no need to download. // This is just a belt-and-suspenders, as this should // already be called whenever a proof becomes // AlreadyHaveProof(). m_proofrequest.ForgetInvId(proofid); } } } // release cs_proofrequest // // Message: getdata (transactions) // { LOCK(cs_main); std::vector> expired; auto requestable = m_txrequest.GetRequestable(pto->GetId(), current_time, &expired); for (const auto &entry : expired) { LogPrint(BCLog::NET, "timeout of inflight tx %s from peer=%d\n", entry.second.ToString(), entry.first); } for (const TxId &txid : requestable) { if (!AlreadyHaveTx(txid)) { addGetDataAndMaybeFlush(MSG_TX, txid); m_txrequest.RequestedData( pto->GetId(), txid, current_time + TX_REQUEST_PARAMS.getdata_interval); } else { // We have already seen this transaction, no need to download. // This is just a belt-and-suspenders, as this should already be // called whenever a transaction becomes AlreadyHaveTx(). m_txrequest.ForgetInvId(txid); } } if (!vGetData.empty()) { m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::GETDATA, vGetData)); } } // release cs_main MaybeSendFeefilter(*pto, current_time); return true; } bool PeerManagerImpl::ReceivedAvalancheProof(CNode &peer, const avalanche::ProofRef &proof) { assert(proof != nullptr); const avalanche::ProofId &proofid = proof->getId(); peer.AddKnownProof(proofid); if (m_chainman.ActiveChainstate().IsInitialBlockDownload()) { // We cannot reliably verify proofs during IBD, so bail out early and // keep the inventory as pending so it can be requested when the node // has synced. return true; } const NodeId nodeid = peer.GetId(); { LOCK(cs_proofrequest); m_proofrequest.ReceivedResponse(nodeid, proofid); if (AlreadyHaveProof(proofid)) { m_proofrequest.ForgetInvId(proofid); return true; } } // registerProof should not be called while cs_proofrequest because it // holds cs_main and that creates a potential deadlock during shutdown avalanche::ProofRegistrationState state; if (g_avalanche->withPeerManager([&](avalanche::PeerManager &pm) { return pm.registerProof(proof, state); })) { WITH_LOCK(cs_proofrequest, m_proofrequest.ForgetInvId(proofid)); RelayProof(proofid); peer.m_last_proof_time = GetTime(); LogPrint(BCLog::NET, "New avalanche proof: peer=%d, proofid %s\n", nodeid, proofid.ToString()); } if (state.GetResult() == avalanche::ProofRegistrationResult::INVALID) { WITH_LOCK(cs_invalidProofs, invalidProofs->insert(proofid)); Misbehaving(nodeid, 100, state.GetRejectReason()); return false; } if (state.GetResult() == avalanche::ProofRegistrationResult::MISSING_UTXO) { // This is possible that a proof contains a utxo we don't know yet, so // don't ban for this. return false; } if (!g_avalanche->addProofToReconcile(proof)) { LogPrint(BCLog::AVALANCHE, "Not polling the avalanche proof (%s): peer=%d, proofid %s\n", state.IsValid() ? "not-worth-polling" : state.GetRejectReason(), nodeid, proofid.ToString()); } return true; } diff --git a/src/qt/peertablemodel.cpp b/src/qt/peertablemodel.cpp index 02cac43a3..00e57a990 100644 --- a/src/qt/peertablemodel.cpp +++ b/src/qt/peertablemodel.cpp @@ -1,235 +1,235 @@ // Copyright (c) 2011-2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include bool NodeLessThan::operator()(const CNodeCombinedStats &left, const CNodeCombinedStats &right) const { const CNodeStats *pLeft = &(left.nodeStats); const CNodeStats *pRight = &(right.nodeStats); if (order == Qt::DescendingOrder) { std::swap(pLeft, pRight); } switch (column) { case PeerTableModel::NetNodeId: return pLeft->nodeid < pRight->nodeid; case PeerTableModel::Address: - return pLeft->addrName.compare(pRight->addrName) < 0; + return pLeft->m_addr_name.compare(pRight->m_addr_name) < 0; case PeerTableModel::Network: return pLeft->m_network < pRight->m_network; case PeerTableModel::Ping: return pLeft->m_min_ping_time < pRight->m_min_ping_time; case PeerTableModel::Sent: return pLeft->nSendBytes < pRight->nSendBytes; case PeerTableModel::Received: return pLeft->nRecvBytes < pRight->nRecvBytes; case PeerTableModel::Subversion: return pLeft->cleanSubVer.compare(pRight->cleanSubVer) < 0; } return false; } // private implementation class PeerTablePriv { public: /** Local cache of peer information */ QList cachedNodeStats; /** Column to sort nodes by (default to unsorted) */ int sortColumn{-1}; /** Order (ascending or descending) to sort nodes by */ Qt::SortOrder sortOrder; /** Index of rows by node ID */ std::map mapNodeRows; /** Pull a full list of peers from vNodes into our cache */ void refreshPeers(interfaces::Node &node) { { cachedNodeStats.clear(); interfaces::Node::NodesStats nodes_stats; node.getNodesStats(nodes_stats); cachedNodeStats.reserve(nodes_stats.size()); for (const auto &node_stats : nodes_stats) { CNodeCombinedStats stats; stats.nodeStats = std::get<0>(node_stats); stats.fNodeStateStatsAvailable = std::get<1>(node_stats); stats.nodeStateStats = std::get<2>(node_stats); cachedNodeStats.append(stats); } } if (sortColumn >= 0) { // sort cacheNodeStats (use stable sort to prevent rows jumping // around unnecessarily) std::stable_sort(cachedNodeStats.begin(), cachedNodeStats.end(), NodeLessThan(sortColumn, sortOrder)); } // build index map mapNodeRows.clear(); int row = 0; for (const CNodeCombinedStats &stats : cachedNodeStats) { mapNodeRows.insert( std::pair(stats.nodeStats.nodeid, row++)); } } int size() const { return cachedNodeStats.size(); } CNodeCombinedStats *index(int idx) { if (idx >= 0 && idx < cachedNodeStats.size()) { return &cachedNodeStats[idx]; } return nullptr; } }; PeerTableModel::PeerTableModel(interfaces::Node &node, QObject *parent) : QAbstractTableModel(parent), m_node(node), timer(nullptr) { priv.reset(new PeerTablePriv()); // set up timer for auto refresh timer = new QTimer(this); connect(timer, &QTimer::timeout, this, &PeerTableModel::refresh); timer->setInterval(MODEL_UPDATE_DELAY); // load initial data refresh(); } PeerTableModel::~PeerTableModel() { // Intentionally left empty } void PeerTableModel::startAutoRefresh() { timer->start(); } void PeerTableModel::stopAutoRefresh() { timer->stop(); } int PeerTableModel::rowCount(const QModelIndex &parent) const { Q_UNUSED(parent); return priv->size(); } int PeerTableModel::columnCount(const QModelIndex &parent) const { Q_UNUSED(parent); return columns.length(); } QVariant PeerTableModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) { return QVariant(); } CNodeCombinedStats *rec = static_cast(index.internalPointer()); if (role == Qt::DisplayRole) { switch (index.column()) { case NetNodeId: return (qint64)rec->nodeStats.nodeid; case Address: // prepend to peer address down-arrow symbol for inbound // connection and up-arrow for outbound connection return QString(rec->nodeStats.fInbound ? "↓ " : "↑ ") + - QString::fromStdString(rec->nodeStats.addrName); + QString::fromStdString(rec->nodeStats.m_addr_name); case Network: return GUIUtil::NetworkToQString(rec->nodeStats.m_network); case Ping: return GUIUtil::formatPingTime(rec->nodeStats.m_min_ping_time); case Sent: return GUIUtil::formatBytes(rec->nodeStats.nSendBytes); case Received: return GUIUtil::formatBytes(rec->nodeStats.nRecvBytes); case Subversion: return QString::fromStdString(rec->nodeStats.cleanSubVer); } } else if (role == Qt::TextAlignmentRole) { switch (index.column()) { case Network: return QVariant(Qt::AlignCenter); case Ping: case Sent: case Received: return QVariant(Qt::AlignRight | Qt::AlignVCenter); default: return QVariant(); } } return QVariant(); } QVariant PeerTableModel::headerData(int section, Qt::Orientation orientation, int role) const { if (orientation == Qt::Horizontal) { if (role == Qt::DisplayRole && section < columns.size()) { return columns[section]; } } return QVariant(); } Qt::ItemFlags PeerTableModel::flags(const QModelIndex &index) const { if (!index.isValid()) { return Qt::NoItemFlags; } Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled; return retval; } QModelIndex PeerTableModel::index(int row, int column, const QModelIndex &parent) const { Q_UNUSED(parent); CNodeCombinedStats *data = priv->index(row); if (data) { return createIndex(row, column, data); } return QModelIndex(); } const CNodeCombinedStats *PeerTableModel::getNodeStats(int idx) { return priv->index(idx); } void PeerTableModel::refresh() { Q_EMIT layoutAboutToBeChanged(); priv->refreshPeers(m_node); Q_EMIT layoutChanged(); } int PeerTableModel::getRowByNodeId(NodeId nodeid) { std::map::iterator it = priv->mapNodeRows.find(nodeid); if (it == priv->mapNodeRows.end()) { return -1; } return it->second; } void PeerTableModel::sort(int column, Qt::SortOrder order) { priv->sortColumn = column; priv->sortOrder = order; refresh(); } diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp index 3f5114a5d..ff5f40251 100644 --- a/src/qt/rpcconsole.cpp +++ b/src/qt/rpcconsole.cpp @@ -1,1504 +1,1504 @@ // Copyright (c) 2011-2019 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #if defined(HAVE_CONFIG_H) #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef ENABLE_WALLET #include #include #include #endif #include #include #include #include #include #include #include #include #include #include #include #include const int CONSOLE_HISTORY = 50; const int INITIAL_TRAFFIC_GRAPH_MINS = 30; const QSize FONT_RANGE(4, 40); const char fontSizeSettingsKey[] = "consoleFontSize"; const struct { const char *url; const char *source; } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"}, {"cmd-reply", ":/icons/tx_output"}, {"cmd-error", ":/icons/tx_output"}, {"misc", ":/icons/tx_inout"}, {nullptr, nullptr}}; namespace { // don't add private key handling cmd's to the history const QStringList historyFilter = QStringList() << "importprivkey" << "importmulti" << "sethdseed" << "signmessagewithprivkey" << "signrawtransactionwithkey" << "walletpassphrase" << "walletpassphrasechange" << "encryptwallet"; } // namespace /* Object for executing console RPC commands in a separate thread. */ class RPCExecutor : public QObject { Q_OBJECT public: explicit RPCExecutor(interfaces::Node &node) : m_node(node) {} public Q_SLOTS: void request(const QString &command, const WalletModel *wallet_model); Q_SIGNALS: void reply(int category, const QString &command); private: interfaces::Node &m_node; }; /** Class for handling RPC timers * (used for e.g. re-locking the wallet after a timeout) */ class QtRPCTimerBase : public QObject, public RPCTimerBase { Q_OBJECT public: QtRPCTimerBase(std::function &_func, int64_t millis) : func(_func) { timer.setSingleShot(true); connect(&timer, &QTimer::timeout, [this] { func(); }); timer.start(millis); } ~QtRPCTimerBase() {} private: QTimer timer; std::function func; }; class QtRPCTimerInterface : public RPCTimerInterface { public: ~QtRPCTimerInterface() {} const char *Name() override { return "Qt"; } RPCTimerBase *NewTimer(std::function &func, int64_t millis) override { return new QtRPCTimerBase(func, millis); } }; #include /** * Split shell command line into a list of arguments and optionally execute the * command(s). * Aims to emulate \c bash and friends. * * - Command nesting is possible with parenthesis; for example: * validateaddress(getnewaddress()) * - Arguments are delimited with whitespace or comma * - Extra whitespace at the beginning and end and between arguments will be * ignored * - Text can be "double" or 'single' quoted * - The backslash \c \ is used as escape character * - Outside quotes, any character can be escaped * - Within double quotes, only escape \c " and backslashes before a \c " or * another backslash * - Within single quotes, no escaping is possible and no special * interpretation takes place * * @param[in] node optional node to execute command on * @param[out] strResult stringified result from the executed command(chain) * @param[in] strCommand Command line to split * @param[in] fExecute set true if you want the command to be executed * @param[out] pstrFilteredOut Command line, filtered to remove any sensitive * data */ bool RPCConsole::RPCParseCommandLine(interfaces::Node *node, std::string &strResult, const std::string &strCommand, const bool fExecute, std::string *const pstrFilteredOut, const WalletModel *wallet_model) { std::vector> stack; stack.push_back(std::vector()); enum CmdParseState { STATE_EATING_SPACES, STATE_EATING_SPACES_IN_ARG, STATE_EATING_SPACES_IN_BRACKETS, STATE_ARGUMENT, STATE_SINGLEQUOTED, STATE_DOUBLEQUOTED, STATE_ESCAPE_OUTER, STATE_ESCAPE_DOUBLEQUOTED, STATE_COMMAND_EXECUTED, STATE_COMMAND_EXECUTED_INNER } state = STATE_EATING_SPACES; std::string curarg; UniValue lastResult; unsigned nDepthInsideSensitive = 0; size_t filter_begin_pos = 0, chpos; std::vector> filter_ranges; auto add_to_current_stack = [&](const std::string &strArg) { if (stack.back().empty() && (!nDepthInsideSensitive) && historyFilter.contains(QString::fromStdString(strArg), Qt::CaseInsensitive)) { nDepthInsideSensitive = 1; filter_begin_pos = chpos; } // Make sure stack is not empty before adding something if (stack.empty()) { stack.push_back(std::vector()); } stack.back().push_back(strArg); }; auto close_out_params = [&]() { if (nDepthInsideSensitive) { if (!--nDepthInsideSensitive) { assert(filter_begin_pos); filter_ranges.push_back( std::make_pair(filter_begin_pos, chpos)); filter_begin_pos = 0; } } stack.pop_back(); }; std::string strCommandTerminated = strCommand; if (strCommandTerminated.back() != '\n') { strCommandTerminated += "\n"; } for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) { char ch = strCommandTerminated[chpos]; switch (state) { case STATE_COMMAND_EXECUTED_INNER: case STATE_COMMAND_EXECUTED: { bool breakParsing = true; switch (ch) { case '[': curarg.clear(); state = STATE_COMMAND_EXECUTED_INNER; break; default: if (state == STATE_COMMAND_EXECUTED_INNER) { if (ch != ']') { // append char to the current argument (which is // also used for the query command) curarg += ch; break; } if (curarg.size() && fExecute) { // if we have a value query, query arrays with // index and objects with a string key UniValue subelement; if (lastResult.isArray()) { for (char argch : curarg) { if (!IsDigit(argch)) { throw std::runtime_error( "Invalid result query"); } } subelement = lastResult[atoi(curarg.c_str())]; } else if (lastResult.isObject()) { subelement = find_value(lastResult, curarg); } else { // no array or object: abort throw std::runtime_error( "Invalid result query"); } lastResult = subelement; } state = STATE_COMMAND_EXECUTED; break; } // don't break parsing when the char is required for the // next argument breakParsing = false; // pop the stack and return the result to the current // command arguments close_out_params(); // don't stringify the json in case of a string to avoid // doublequotes if (lastResult.isStr()) { curarg = lastResult.get_str(); } else { curarg = lastResult.write(2); } // if we have a non empty result, use it as stack // argument otherwise as general result if (curarg.size()) { if (stack.size()) { add_to_current_stack(curarg); } else { strResult = curarg; } } curarg.clear(); // assume eating space state state = STATE_EATING_SPACES; } if (breakParsing) { break; } } // FALLTHROUGH case STATE_ARGUMENT: // In or after argument case STATE_EATING_SPACES_IN_ARG: case STATE_EATING_SPACES_IN_BRACKETS: case STATE_EATING_SPACES: // Handle runs of whitespace switch (ch) { case '"': state = STATE_DOUBLEQUOTED; break; case '\'': state = STATE_SINGLEQUOTED; break; case '\\': state = STATE_ESCAPE_OUTER; break; case '(': case ')': case '\n': if (state == STATE_EATING_SPACES_IN_ARG) { throw std::runtime_error("Invalid Syntax"); } if (state == STATE_ARGUMENT) { if (ch == '(' && stack.size() && stack.back().size() > 0) { if (nDepthInsideSensitive) { ++nDepthInsideSensitive; } stack.push_back(std::vector()); } // don't allow commands after executed commands on // baselevel if (!stack.size()) { throw std::runtime_error("Invalid Syntax"); } add_to_current_stack(curarg); curarg.clear(); state = STATE_EATING_SPACES_IN_BRACKETS; } if ((ch == ')' || ch == '\n') && stack.size() > 0) { if (fExecute) { // Convert argument list to JSON objects in // method-dependent way, and pass it along with // the method name to the dispatcher. UniValue params = RPCConvertValues( stack.back()[0], std::vector( stack.back().begin() + 1, stack.back().end())); std::string method = stack.back()[0]; std::string uri; #ifdef ENABLE_WALLET if (wallet_model) { QByteArray encodedName = QUrl::toPercentEncoding( wallet_model->getWalletName()); uri = "/wallet/" + std::string(encodedName.constData(), encodedName.length()); } #endif assert(node); lastResult = node->executeRpc( GetConfig(), method, params, uri); } state = STATE_COMMAND_EXECUTED; curarg.clear(); } break; case ' ': case ',': case '\t': if (state == STATE_EATING_SPACES_IN_ARG && curarg.empty() && ch == ',') { throw std::runtime_error("Invalid Syntax"); } else if (state == STATE_ARGUMENT) { // Space ends argument add_to_current_stack(curarg); curarg.clear(); } if ((state == STATE_EATING_SPACES_IN_BRACKETS || state == STATE_ARGUMENT) && ch == ',') { state = STATE_EATING_SPACES_IN_ARG; break; } state = STATE_EATING_SPACES; break; default: curarg += ch; state = STATE_ARGUMENT; } break; case STATE_SINGLEQUOTED: // Single-quoted string switch (ch) { case '\'': state = STATE_ARGUMENT; break; default: curarg += ch; } break; case STATE_DOUBLEQUOTED: // Double-quoted string switch (ch) { case '"': state = STATE_ARGUMENT; break; case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break; default: curarg += ch; } break; case STATE_ESCAPE_OUTER: // '\' outside quotes curarg += ch; state = STATE_ARGUMENT; break; case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text if (ch != '"' && ch != '\\') { // keep '\' for everything but the quote and '\' itself curarg += '\\'; } curarg += ch; state = STATE_DOUBLEQUOTED; break; } } if (pstrFilteredOut) { if (STATE_COMMAND_EXECUTED == state) { assert(!stack.empty()); close_out_params(); } *pstrFilteredOut = strCommand; for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) { pstrFilteredOut->replace(i->first, i->second - i->first, "(…)"); } } // final state switch (state) { case STATE_COMMAND_EXECUTED: if (lastResult.isStr()) { strResult = lastResult.get_str(); } else { strResult = lastResult.write(2); } // FALLTHROUGH case STATE_ARGUMENT: case STATE_EATING_SPACES: return true; default: // ERROR to end in one of the other states return false; } } void RPCExecutor::request(const QString &command, const WalletModel *wallet_model) { try { std::string result; std::string executableCommand = command.toStdString() + "\n"; // Catch the console-only-help command before RPC call is executed and // reply with help text as-if a RPC reply. if (executableCommand == "help-console\n") { Q_EMIT reply( RPCConsole::CMD_REPLY, QString(("\n" "This console accepts RPC commands using the standard " "syntax.\n" " example: getblockhash 0\n\n" "This console can also accept RPC commands using " "parenthesized syntax.\n" " example: getblockhash(0)\n\n" "Commands may be nested when specified with the " "parenthesized syntax.\n" " example: getblock(getblockhash(0) 1)\n\n" "A space or a comma can be used to delimit arguments " "for either syntax.\n" " example: getblockhash 0\n" " getblockhash,0\n\n" "Named results can be queried with a non-quoted key " "string in brackets.\n" " example: getblock(getblockhash(0) true)[tx]\n\n" "Results without keys can be queried using an integer " "in brackets.\n" " example: " "getblock(getblockhash(0),true)[tx][0]\n\n"))); return; } if (!RPCConsole::RPCExecuteCommandLine( m_node, result, executableCommand, nullptr, wallet_model)) { Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \"")); return; } Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result)); } catch (UniValue &objError) { // Nice formatting for standard-format error try { int code = find_value(objError, "code").get_int(); std::string message = find_value(objError, "message").get_str(); Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")"); } catch (const std::runtime_error &) { // raised when converting to invalid type, i.e. missing code or // message. Show raw JSON object. Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(objError.write())); } } catch (const std::exception &e) { Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what())); } } RPCConsole::RPCConsole(interfaces::Node &node, const PlatformStyle *_platformStyle, QWidget *parent) : QWidget(parent), m_node(node), ui(new Ui::RPCConsole), platformStyle(_platformStyle) { ui->setupUi(this); QSettings settings; if (!restoreGeometry( settings.value("RPCConsoleWindowGeometry").toByteArray())) { // Restore failed (perhaps missing setting), center the window move(QGuiApplication::primaryScreen()->availableGeometry().center() - frameGeometry().center()); } QChar nonbreaking_hyphen(8209); const QString hb_list{"
  • \"" + tr("To") + "\" – " + tr("we selected the peer for high bandwidth relay") + "
  • \"" + tr("From") + "\" – " + tr("the peer selected us for high bandwidth relay") + "
  • \"" + tr("No") + "\" – " + tr("no high bandwidth relay selected") + "
"}; ui->peerHighBandwidthLabel->setToolTip( ui->peerHighBandwidthLabel->toolTip().arg(hb_list)); ui->dataDir->setToolTip( ui->dataDir->toolTip().arg(QString(nonbreaking_hyphen) + "datadir")); ui->blocksDir->setToolTip(ui->blocksDir->toolTip().arg( QString(nonbreaking_hyphen) + "blocksdir")); ui->openDebugLogfileButton->setToolTip( ui->openDebugLogfileButton->toolTip().arg(PACKAGE_NAME)); if (platformStyle->getImagesOnButtons()) { ui->openDebugLogfileButton->setIcon( platformStyle->SingleColorIcon(":/icons/export")); } ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove")); ui->fontBiggerButton->setIcon( platformStyle->SingleColorIcon(":/icons/fontbigger")); ui->fontSmallerButton->setIcon( platformStyle->SingleColorIcon(":/icons/fontsmaller")); // Install event filter for up and down arrow ui->lineEdit->installEventFilter(this); ui->lineEdit->setMaxLength(16 * 1024 * 1024); ui->messagesWidget->installEventFilter(this); connect(ui->clearButton, &QPushButton::clicked, this, &RPCConsole::clear); connect(ui->fontBiggerButton, &QPushButton::clicked, this, &RPCConsole::fontBigger); connect(ui->fontSmallerButton, &QPushButton::clicked, this, &RPCConsole::fontSmaller); connect(ui->btnClearTrafficGraph, &QPushButton::clicked, ui->trafficGraph, &TrafficGraphWidget::clear); // disable the wallet selector by default ui->WalletSelector->setVisible(false); ui->WalletSelectorLabel->setVisible(false); // set library version labels #ifdef ENABLE_WALLET ui->berkeleyDBVersion->setText( QString::fromStdString(BerkeleyDatabaseVersion())); #else ui->label_berkeleyDBVersion->hide(); ui->berkeleyDBVersion->hide(); #endif // Register RPC timer interface rpcTimerInterface = new QtRPCTimerInterface(); // avoid accidentally overwriting an existing, non QTThread // based timer interface m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface); setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS); updateDetailWidget(); consoleFontSize = settings.value(fontSizeSettingsKey, QFont().pointSize()).toInt(); clear(); GUIUtil::handleCloseWindowShortcut(this); } RPCConsole::~RPCConsole() { QSettings settings; settings.setValue("RPCConsoleWindowGeometry", saveGeometry()); m_node.rpcUnsetTimerInterface(rpcTimerInterface); delete rpcTimerInterface; delete ui; } bool RPCConsole::eventFilter(QObject *obj, QEvent *event) { // Special key handling if (event->type() == QEvent::KeyPress) { QKeyEvent *keyevt = static_cast(event); int key = keyevt->key(); Qt::KeyboardModifiers mod = keyevt->modifiers(); switch (key) { case Qt::Key_Up: if (obj == ui->lineEdit) { browseHistory(-1); return true; } break; case Qt::Key_Down: if (obj == ui->lineEdit) { browseHistory(1); return true; } break; case Qt::Key_PageUp: /* pass paging keys to messages widget */ case Qt::Key_PageDown: if (obj == ui->lineEdit) { QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt)); return true; } break; case Qt::Key_Return: case Qt::Key_Enter: // forward these events to lineEdit if (obj == autoCompleter->popup()) { QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt)); return true; } break; default: // Typing in messages widget brings focus to line edit, and // redirects key there. Exclude most combinations and keys that // emit no text, except paste shortcuts. if (obj == ui->messagesWidget && ((!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) || ((mod & Qt::ControlModifier) && key == Qt::Key_V) || ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) { ui->lineEdit->setFocus(); QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt)); return true; } } } return QWidget::eventFilter(obj, event); } void RPCConsole::setClientModel(ClientModel *model, int bestblock_height, int64_t bestblock_date, double verification_progress) { clientModel = model; bool wallet_enabled{false}; #ifdef ENABLE_WALLET wallet_enabled = WalletModel::isWalletEnabled(); #endif // ENABLE_WALLET if (model && !wallet_enabled) { // Show warning, for example if this is a prerelease version connect(model, &ClientModel::alertsChanged, this, &RPCConsole::updateAlerts); updateAlerts(model->getStatusBarWarnings()); } ui->trafficGraph->setClientModel(model); if (model && clientModel->getPeerTableModel() && clientModel->getBanTableModel()) { // Keep up to date with client setNumConnections(model->getNumConnections()); connect(model, &ClientModel::numConnectionsChanged, this, &RPCConsole::setNumConnections); setNumBlocks(bestblock_height, QDateTime::fromTime_t(bestblock_date), verification_progress, false); connect(model, &ClientModel::numBlocksChanged, this, &RPCConsole::setNumBlocks); updateNetworkState(); connect(model, &ClientModel::networkActiveChanged, this, &RPCConsole::setNetworkActive); interfaces::Node &node = clientModel->node(); updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent()); connect(model, &ClientModel::bytesChanged, this, &RPCConsole::updateTrafficStats); connect(model, &ClientModel::mempoolSizeChanged, this, &RPCConsole::setMempoolSize); // set up peer table ui->peerWidget->setModel(model->getPeerTableModel()); ui->peerWidget->verticalHeader()->hide(); ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers); ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows); ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection); ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu); ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH); ui->peerWidget->setColumnWidth(PeerTableModel::Subversion, SUBVERSION_COLUMN_WIDTH); ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH); ui->peerWidget->horizontalHeader()->setStretchLastSection(true); // create peer table context menu actions QAction *disconnectAction = new QAction(tr("&Disconnect"), this); QAction *banAction1h = new QAction(tr("Ban for") + " " + tr("1 &hour"), this); QAction *banAction24h = new QAction(tr("Ban for") + " " + tr("1 &day"), this); QAction *banAction7d = new QAction(tr("Ban for") + " " + tr("1 &week"), this); QAction *banAction365d = new QAction(tr("Ban for") + " " + tr("1 &year"), this); // create peer table context menu peersTableContextMenu = new QMenu(this); peersTableContextMenu->addAction(disconnectAction); peersTableContextMenu->addAction(banAction1h); peersTableContextMenu->addAction(banAction24h); peersTableContextMenu->addAction(banAction7d); peersTableContextMenu->addAction(banAction365d); connect(banAction1h, &QAction::triggered, [this] { banSelectedNode(60 * 60); }); connect(banAction24h, &QAction::triggered, [this] { banSelectedNode(60 * 60 * 24); }); connect(banAction7d, &QAction::triggered, [this] { banSelectedNode(60 * 60 * 24 * 7); }); connect(banAction365d, &QAction::triggered, [this] { banSelectedNode(60 * 60 * 24 * 365); }); // peer table context menu signals connect(ui->peerWidget, &QTableView::customContextMenuRequested, this, &RPCConsole::showPeersTableContextMenu); connect(disconnectAction, &QAction::triggered, this, &RPCConsole::disconnectSelectedNode); // peer table signal handling - update peer details when selecting new // node connect(ui->peerWidget->selectionModel(), &QItemSelectionModel::selectionChanged, this, &RPCConsole::updateDetailWidget); // peer table signal handling - update peer details when new nodes are // added to the model connect(model->getPeerTableModel(), &PeerTableModel::layoutChanged, this, &RPCConsole::peerLayoutChanged); // peer table signal handling - cache selected node ids connect(model->getPeerTableModel(), &PeerTableModel::layoutAboutToBeChanged, this, &RPCConsole::peerLayoutAboutToChange); // set up ban table ui->banlistWidget->setModel(model->getBanTableModel()); ui->banlistWidget->verticalHeader()->hide(); ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers); ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows); ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection); ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu); ui->banlistWidget->setColumnWidth(BanTableModel::Address, BANSUBNET_COLUMN_WIDTH); ui->banlistWidget->setColumnWidth(BanTableModel::Bantime, BANTIME_COLUMN_WIDTH); ui->banlistWidget->horizontalHeader()->setStretchLastSection(true); // create ban table context menu action QAction *unbanAction = new QAction(tr("&Unban"), this); // create ban table context menu banTableContextMenu = new QMenu(this); banTableContextMenu->addAction(unbanAction); // ban table context menu signals connect(ui->banlistWidget, &QTableView::customContextMenuRequested, this, &RPCConsole::showBanTableContextMenu); connect(unbanAction, &QAction::triggered, this, &RPCConsole::unbanSelectedNode); // ban table signal handling - clear peer details when clicking a peer // in the ban table connect(ui->banlistWidget, &QTableView::clicked, this, &RPCConsole::clearSelectedNode); // ban table signal handling - ensure ban table is shown or hidden (if // empty) connect(model->getBanTableModel(), &BanTableModel::layoutChanged, this, &RPCConsole::showOrHideBanTableIfRequired); showOrHideBanTableIfRequired(); // Provide initial values ui->clientVersion->setText(model->formatFullVersion()); ui->clientUserAgent->setText(model->formatSubVersion()); ui->dataDir->setText(model->dataDir()); ui->blocksDir->setText(model->blocksDir()); ui->startupTime->setText(model->formatClientStartupTime()); ui->networkName->setText( QString::fromStdString(Params().NetworkIDString())); // Setup autocomplete and attach it QStringList wordList; std::vector commandList = m_node.listRpcCommands(); for (size_t i = 0; i < commandList.size(); ++i) { wordList << commandList[i].c_str(); wordList << ("help " + commandList[i]).c_str(); } wordList << "help-console"; wordList.sort(); autoCompleter = new QCompleter(wordList, this); autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel); // ui->lineEdit is initially disabled because running commands is only // possible from now on. ui->lineEdit->setEnabled(true); ui->lineEdit->setCompleter(autoCompleter); autoCompleter->popup()->installEventFilter(this); // Start thread to execute RPC commands. startExecutor(); } if (!model) { // Client model is being set to 0, this means shutdown() is about to be // called. thread.quit(); thread.wait(); } } #ifdef ENABLE_WALLET void RPCConsole::addWallet(WalletModel *const walletModel) { // use name for text and wallet model for internal data object (to allow to // move to a wallet id later) ui->WalletSelector->addItem(walletModel->getDisplayName(), QVariant::fromValue(walletModel)); if (ui->WalletSelector->count() == 2 && !isVisible()) { // First wallet added, set to default so long as the window isn't // presently visible (and potentially in use) ui->WalletSelector->setCurrentIndex(1); } if (ui->WalletSelector->count() > 2) { ui->WalletSelector->setVisible(true); ui->WalletSelectorLabel->setVisible(true); } } void RPCConsole::removeWallet(WalletModel *const walletModel) { ui->WalletSelector->removeItem( ui->WalletSelector->findData(QVariant::fromValue(walletModel))); if (ui->WalletSelector->count() == 2) { ui->WalletSelector->setVisible(false); ui->WalletSelectorLabel->setVisible(false); } } #endif static QString categoryClass(int category) { switch (category) { case RPCConsole::CMD_REQUEST: return "cmd-request"; break; case RPCConsole::CMD_REPLY: return "cmd-reply"; break; case RPCConsole::CMD_ERROR: return "cmd-error"; break; default: return "misc"; } } void RPCConsole::fontBigger() { setFontSize(consoleFontSize + 1); } void RPCConsole::fontSmaller() { setFontSize(consoleFontSize - 1); } void RPCConsole::setFontSize(int newSize) { QSettings settings; // don't allow an insane font size if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) { return; } // temp. store the console content QString str = ui->messagesWidget->toHtml(); // replace font tags size in current content str.replace(QString("font-size:%1pt").arg(consoleFontSize), QString("font-size:%1pt").arg(newSize)); // store the new font size consoleFontSize = newSize; settings.setValue(fontSizeSettingsKey, consoleFontSize); // clear console (reset icon sizes, default stylesheet) and re-add the // content float oldPosFactor = 1.0 / ui->messagesWidget->verticalScrollBar()->maximum() * ui->messagesWidget->verticalScrollBar()->value(); clear(false); ui->messagesWidget->setHtml(str); ui->messagesWidget->verticalScrollBar()->setValue( oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum()); } void RPCConsole::clear(bool clearHistory) { ui->messagesWidget->clear(); if (clearHistory) { history.clear(); historyPtr = 0; } ui->lineEdit->clear(); ui->lineEdit->setFocus(); // Add smoothly scaled icon images. // (when using width/height on an img, Qt uses nearest instead of linear // interpolation) for (int i = 0; ICON_MAPPING[i].url; ++i) { ui->messagesWidget->document()->addResource( QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url), platformStyle->SingleColorImage(ICON_MAPPING[i].source) .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation)); } // Set default style sheet QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont()); ui->messagesWidget->document()->setDefaultStyleSheet( QString("table { }" "td.time { color: #808080; font-size: %2; padding-top: 3px; } " "td.message { font-family: %1; font-size: %2; " "white-space:pre-wrap; } " "td.cmd-request { color: #006060; } " "td.cmd-error { color: red; } " ".secwarning { color: red; }" "b { color: #006060; } ") .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize))); #ifdef Q_OS_MAC QString clsKey = "(⌘)-L"; #else QString clsKey = "Ctrl-L"; #endif message(CMD_REPLY, (tr("Welcome to the %1 RPC console.").arg(PACKAGE_NAME) + "
" + tr("Use up and down arrows to navigate history, and " "%1 to clear screen.") .arg("" + clsKey + "") + "
" + tr("Type %1 for an overview of available commands.") .arg("help") + "
" + tr("For more information on using this console type %1.") .arg("help-console") + "

" + tr("WARNING: Scammers have been active, telling users to type " "commands here, stealing their wallet contents. Do not use " "this console without fully understanding the ramifications " "of a command.") + ""), true); } void RPCConsole::keyPressEvent(QKeyEvent *event) { if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) { close(); } } void RPCConsole::message(int category, const QString &message, bool html) { QTime time = QTime::currentTime(); QString timeString = time.toString(); QString out; out += ""; out += ""; out += "
" + timeString + ""; if (html) { out += message; } else { out += GUIUtil::HtmlEscape(message, false); } out += "
"; ui->messagesWidget->append(out); } void RPCConsole::updateNetworkState() { QString connections = QString::number(clientModel->getNumConnections()) + " ("; connections += tr("In:") + " " + QString::number(clientModel->getNumConnections( ClientModel::CONNECTIONS_IN)) + " / "; connections += tr("Out:") + " " + QString::number(clientModel->getNumConnections( ClientModel::CONNECTIONS_OUT)) + ")"; if (!clientModel->node().getNetworkActive()) { connections += " (" + tr("Network activity disabled") + ")"; } ui->numberOfConnections->setText(connections); } void RPCConsole::setNumConnections(int count) { if (!clientModel) { return; } updateNetworkState(); } void RPCConsole::setNetworkActive(bool networkActive) { updateNetworkState(); } void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate, double nVerificationProgress, bool headers) { if (!headers) { ui->numberOfBlocks->setText(QString::number(count)); ui->lastBlockTime->setText(blockDate.toString()); } } void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) { ui->mempoolNumberTxs->setText(QString::number(numberOfTxs)); if (dynUsage < 1000000) { ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) + " KB"); } else { ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) + " MB"); } } void RPCConsole::on_lineEdit_returnPressed() { QString cmd = ui->lineEdit->text(); if (!cmd.isEmpty()) { std::string strFilteredCmd; try { std::string dummy; if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false, &strFilteredCmd)) { // Failed to parse command, so we cannot even filter it for the // history throw std::runtime_error("Invalid command line"); } } catch (const std::exception &e) { QMessageBox::critical(this, "Error", QString("Error: ") + QString::fromStdString(e.what())); return; } ui->lineEdit->clear(); cmdBeforeBrowsing = QString(); #ifdef ENABLE_WALLET WalletModel *wallet_model = ui->WalletSelector->currentData().value(); if (m_last_wallet_model != wallet_model) { if (wallet_model) { message(CMD_REQUEST, tr("Executing command using \"%1\" wallet") .arg(wallet_model->getWalletName())); } else { message(CMD_REQUEST, tr("Executing command without any wallet")); } m_last_wallet_model = wallet_model; } #endif message(CMD_REQUEST, QString::fromStdString(strFilteredCmd)); Q_EMIT cmdRequest(cmd, m_last_wallet_model); cmd = QString::fromStdString(strFilteredCmd); // Remove command, if already in history history.removeOne(cmd); // Append command to history history.append(cmd); // Enforce maximum history size while (history.size() > CONSOLE_HISTORY) { history.removeFirst(); } // Set pointer to end of history historyPtr = history.size(); // Scroll console view to end scrollToEnd(); } } void RPCConsole::browseHistory(int offset) { // store current text when start browsing through the history if (historyPtr == history.size()) { cmdBeforeBrowsing = ui->lineEdit->text(); } historyPtr += offset; if (historyPtr < 0) { historyPtr = 0; } if (historyPtr > history.size()) { historyPtr = history.size(); } QString cmd; if (historyPtr < history.size()) { cmd = history.at(historyPtr); } else if (!cmdBeforeBrowsing.isNull()) { cmd = cmdBeforeBrowsing; } ui->lineEdit->setText(cmd); } void RPCConsole::startExecutor() { RPCExecutor *executor = new RPCExecutor(m_node); executor->moveToThread(&thread); // Replies from executor object must go to this object connect(executor, &RPCExecutor::reply, this, static_cast( &RPCConsole::message)); // Requests from this object must go to executor connect(this, &RPCConsole::cmdRequest, executor, &RPCExecutor::request); // Make sure executor object is deleted in its own thread connect(&thread, &QThread::finished, executor, &RPCExecutor::deleteLater); // Default implementation of QThread::run() simply spins up an event loop in // the thread, which is what we want. thread.start(); QTimer::singleShot(0, executor, []() { util::ThreadRename("qt-rpcconsole"); }); } void RPCConsole::on_tabWidget_currentChanged(int index) { if (ui->tabWidget->widget(index) == ui->tab_console) { ui->lineEdit->setFocus(); } } void RPCConsole::on_openDebugLogfileButton_clicked() { GUIUtil::openDebugLogfile(); } void RPCConsole::scrollToEnd() { QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar(); scrollbar->setValue(scrollbar->maximum()); } void RPCConsole::on_sldGraphRange_valueChanged(int value) { const int multiplier = 5; // each position on the slider represents 5 min int mins = value * multiplier; setTrafficGraphRange(mins); } void RPCConsole::setTrafficGraphRange(int mins) { ui->trafficGraph->setGraphRangeMins(mins); ui->lblGraphRange->setText( GUIUtil::formatDurationStr(std::chrono::minutes{mins})); } void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut) { ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn)); ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut)); } void RPCConsole::peerLayoutAboutToChange() { QModelIndexList selected = ui->peerWidget->selectionModel()->selectedIndexes(); cachedNodeids.clear(); for (int i = 0; i < selected.size(); i++) { const CNodeCombinedStats *stats = clientModel->getPeerTableModel()->getNodeStats( selected.at(i).row()); cachedNodeids.append(stats->nodeStats.nodeid); } } void RPCConsole::peerLayoutChanged() { if (!clientModel || !clientModel->getPeerTableModel()) { return; } bool fUnselect = false; bool fReselect = false; // no node selected yet if (cachedNodeids.empty()) { return; } // find the currently selected row int selectedRow = -1; QModelIndexList selectedModelIndex = ui->peerWidget->selectionModel()->selectedIndexes(); if (!selectedModelIndex.isEmpty()) { selectedRow = selectedModelIndex.first().row(); } // check if our detail node has a row in the table (it may not necessarily // be at selectedRow since its position can change after a layout change) int detailNodeRow = clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first()); if (detailNodeRow < 0) { // detail node disappeared from table (node disconnected) fUnselect = true; } else { if (detailNodeRow != selectedRow) { // detail node moved position fUnselect = true; fReselect = true; } } if (fUnselect && selectedRow >= 0) { clearSelectedNode(); } if (fReselect) { for (int i = 0; i < cachedNodeids.size(); i++) { ui->peerWidget->selectRow( clientModel->getPeerTableModel()->getRowByNodeId( cachedNodeids.at(i))); } } updateDetailWidget(); } void RPCConsole::updateDetailWidget() { QModelIndexList selected_rows; auto selection_model = ui->peerWidget->selectionModel(); if (selection_model) { selected_rows = selection_model->selectedRows(); } if (!clientModel || !clientModel->getPeerTableModel() || selected_rows.size() != 1) { ui->detailWidget->hide(); ui->peerHeading->setText( tr("Select a peer to view detailed information.")); return; } const CNodeCombinedStats *stats = clientModel->getPeerTableModel()->getNodeStats( selected_rows.first().row()); // update the detail ui with latest node information - QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) + - " "); + QString peerAddrDetails( + QString::fromStdString(stats->nodeStats.m_addr_name) + " "); peerAddrDetails += tr("(peer id: %1)").arg(QString::number(stats->nodeStats.nodeid)); if (!stats->nodeStats.addrLocal.empty()) { peerAddrDetails += "
" + tr("via %1").arg(QString::fromStdString( stats->nodeStats.addrLocal)); } ui->peerHeading->setText(peerAddrDetails); ui->peerServices->setText( GUIUtil::formatServicesStr(stats->nodeStats.nServices)); ui->peerRelayTxes->setText(stats->nodeStats.fRelayTxes ? "Yes" : "No"); QString bip152_hb_settings; if (stats->nodeStats.m_bip152_highbandwidth_to) { bip152_hb_settings += "To"; } if (stats->nodeStats.m_bip152_highbandwidth_from) { bip152_hb_settings += (bip152_hb_settings == "" ? "From" : "/From"); } if (bip152_hb_settings == "") { bip152_hb_settings = "No"; } ui->peerHighBandwidth->setText(bip152_hb_settings); const auto time_now{GetTime()}; ui->peerConnTime->setText( GUIUtil::formatDurationStr(time_now - stats->nodeStats.m_connected)); ui->peerLastBlock->setText( TimeDurationField(time_now, stats->nodeStats.m_last_block_time)); ui->peerLastTx->setText( TimeDurationField(time_now, stats->nodeStats.m_last_tx_time)); ui->peerLastSend->setText( TimeDurationField(time_now, stats->nodeStats.m_last_send)); ui->peerLastRecv->setText( TimeDurationField(time_now, stats->nodeStats.m_last_recv)); ui->peerBytesSent->setText( GUIUtil::formatBytes(stats->nodeStats.nSendBytes)); ui->peerBytesRecv->setText( GUIUtil::formatBytes(stats->nodeStats.nRecvBytes)); ui->peerPingTime->setText( GUIUtil::formatPingTime(stats->nodeStats.m_last_ping_time)); ui->peerMinPing->setText( GUIUtil::formatPingTime(stats->nodeStats.m_min_ping_time)); ui->timeoffset->setText( GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset)); ui->peerVersion->setText(QString::number(stats->nodeStats.nVersion)); ui->peerSubversion->setText( QString::fromStdString(stats->nodeStats.cleanSubVer)); ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound") : tr("Outbound")); ui->peerNetwork->setText( GUIUtil::NetworkToQString(stats->nodeStats.m_network)); if (stats->nodeStats.m_permissionFlags == PF_NONE) { ui->peerPermissions->setText(tr("N/A")); } else { QStringList permissions; for (const auto &permission : NetPermissions::ToStrings(stats->nodeStats.m_permissionFlags)) { permissions.append(QString::fromStdString(permission)); } ui->peerPermissions->setText(permissions.join(" & ")); } ui->peerMappedAS->setText( stats->nodeStats.m_mapped_as != 0 ? QString::number(stats->nodeStats.m_mapped_as) : tr("N/A")); // This check fails for example if the lock was busy and // nodeStateStats couldn't be fetched. if (stats->fNodeStateStatsAvailable) { // Sync height is init to -1 if (stats->nodeStateStats.nSyncHeight > -1) { ui->peerSyncHeight->setText( QString("%1").arg(stats->nodeStateStats.nSyncHeight)); } else { ui->peerSyncHeight->setText(tr("Unknown")); } // Common height is init to -1 if (stats->nodeStateStats.nCommonHeight > -1) { ui->peerCommonHeight->setText( QString("%1").arg(stats->nodeStateStats.nCommonHeight)); } else { ui->peerCommonHeight->setText(tr("Unknown")); } ui->peerHeight->setText( QString::number(stats->nodeStateStats.m_starting_height)); ui->peerPingWait->setText( GUIUtil::formatPingTime(stats->nodeStateStats.m_ping_wait)); } ui->detailWidget->show(); } void RPCConsole::resizeEvent(QResizeEvent *event) { QWidget::resizeEvent(event); } void RPCConsole::showEvent(QShowEvent *event) { QWidget::showEvent(event); if (!clientModel || !clientModel->getPeerTableModel()) { return; } // start PeerTableModel auto refresh clientModel->getPeerTableModel()->startAutoRefresh(); } void RPCConsole::hideEvent(QHideEvent *event) { QWidget::hideEvent(event); if (!clientModel || !clientModel->getPeerTableModel()) { return; } // stop PeerTableModel auto refresh clientModel->getPeerTableModel()->stopAutoRefresh(); } void RPCConsole::showPeersTableContextMenu(const QPoint &point) { QModelIndex index = ui->peerWidget->indexAt(point); if (index.isValid()) { peersTableContextMenu->exec(QCursor::pos()); } } void RPCConsole::showBanTableContextMenu(const QPoint &point) { QModelIndex index = ui->banlistWidget->indexAt(point); if (index.isValid()) { banTableContextMenu->exec(QCursor::pos()); } } void RPCConsole::disconnectSelectedNode() { // Get selected peer addresses QList nodes = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId); for (int i = 0; i < nodes.count(); i++) { // Get currently selected peer address NodeId id = nodes.at(i).data().toLongLong(); // Find the node, disconnect it and clear the selected node if (m_node.disconnectById(id)) { clearSelectedNode(); } } } void RPCConsole::banSelectedNode(int bantime) { if (!clientModel) { return; } // Get selected peer addresses QList nodes = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId); for (int i = 0; i < nodes.count(); i++) { // Get currently selected peer address NodeId id = nodes.at(i).data().toLongLong(); // Get currently selected peer address int detailNodeRow = clientModel->getPeerTableModel()->getRowByNodeId(id); if (detailNodeRow < 0) { return; } // Find possible nodes, ban it and clear the selected node const CNodeCombinedStats *stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow); if (stats) { m_node.ban(stats->nodeStats.addr, bantime); m_node.disconnectByAddress(stats->nodeStats.addr); } } clearSelectedNode(); clientModel->getBanTableModel()->refresh(); } void RPCConsole::unbanSelectedNode() { if (!clientModel) { return; } // Get selected ban addresses QList nodes = GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address); for (int i = 0; i < nodes.count(); i++) { // Get currently selected ban address QString strNode = nodes.at(i).data().toString(); CSubNet possibleSubnet; LookupSubNet(strNode.toStdString(), possibleSubnet); if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) { clientModel->getBanTableModel()->refresh(); } } } void RPCConsole::clearSelectedNode() { ui->peerWidget->selectionModel()->clearSelection(); cachedNodeids.clear(); updateDetailWidget(); } void RPCConsole::showOrHideBanTableIfRequired() { if (!clientModel) { return; } bool visible = clientModel->getBanTableModel()->shouldShow(); ui->banlistWidget->setVisible(visible); ui->banHeading->setVisible(visible); } void RPCConsole::setTabFocus(enum TabTypes tabType) { ui->tabWidget->setCurrentIndex(int(tabType)); } QString RPCConsole::tabTitle(TabTypes tab_type) const { return ui->tabWidget->tabText(int(tab_type)); } QKeySequence RPCConsole::tabShortcut(TabTypes tab_type) const { switch (tab_type) { case TabTypes::INFO: return QKeySequence(Qt::CTRL + Qt::Key_I); case TabTypes::CONSOLE: return QKeySequence(Qt::CTRL + Qt::Key_T); case TabTypes::GRAPH: return QKeySequence(Qt::CTRL + Qt::Key_N); case TabTypes::PEERS: return QKeySequence(Qt::CTRL + Qt::Key_P); } // no default case, so the compiler can warn about missing cases assert(false); } void RPCConsole::updateAlerts(const QString &warnings) { this->ui->label_alerts->setVisible(!warnings.isEmpty()); this->ui->label_alerts->setText(warnings); } diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp index 86c31119d..475a66540 100644 --- a/src/rpc/net.cpp +++ b/src/rpc/net.cpp @@ -1,1236 +1,1236 @@ // Copyright (c) 2009-2019 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include // For banmap_t #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static RPCHelpMan getconnectioncount() { return RPCHelpMan{ "getconnectioncount", "Returns the number of connections to other nodes.\n", {}, RPCResult{RPCResult::Type::NUM, "", "The connection count"}, RPCExamples{HelpExampleCli("getconnectioncount", "") + HelpExampleRpc("getconnectioncount", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } return int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL)); }, }; } static RPCHelpMan ping() { return RPCHelpMan{ "ping", "Requests that a ping be sent to all other nodes, to measure ping " "time.\n" "Results provided in getpeerinfo, pingtime and pingwait fields are " "decimal seconds.\n" "Ping command is handled in queue with all other commands, so it " "measures processing backlog, not just network ping.\n", {}, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.peerman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } // Request that each node send a ping during next message processing // pass node.peerman->SendPings(); return NullUniValue; }, }; } static RPCHelpMan getpeerinfo() { return RPCHelpMan{ "getpeerinfo", "Returns data about each connected network node as a json array of " "objects.\n", {}, RPCResult{ RPCResult::Type::ARR, "", "", {{ RPCResult::Type::OBJ, "", "", {{ {RPCResult::Type::NUM, "id", "Peer index"}, {RPCResult::Type::STR, "addr", "(host:port) The IP address and port of the peer"}, {RPCResult::Type::STR, "addrbind", "(ip:port) Bind address of the connection to the peer"}, {RPCResult::Type::STR, "addrlocal", "(ip:port) Local address as reported by the peer"}, {RPCResult::Type::BOOL, "addr_relay_enabled", "Whether we participate in address relay with this peer"}, {RPCResult::Type::NUM, "addr_processed", "The total number of addresses processed, excluding those " "dropped due to rate limiting"}, {RPCResult::Type::NUM, "addr_rate_limited", "The total number of addresses dropped due to rate " "limiting"}, {RPCResult::Type::STR, "network", "Network (" + Join(GetNetworkNames(/* append_unroutable */ true), ", ") + ")"}, {RPCResult::Type::NUM, "mapped_as", "The AS in the BGP route to the peer used for " "diversifying\n" "peer selection (only available if the asmap config flag " "is set)\n"}, {RPCResult::Type::STR_HEX, "services", "The services offered"}, {RPCResult::Type::ARR, "servicesnames", "the services offered, in human-readable form", {{RPCResult::Type::STR, "SERVICE_NAME", "the service name if it is recognised"}}}, {RPCResult::Type::BOOL, "relaytxes", "Whether peer has asked us to relay transactions to it"}, {RPCResult::Type::NUM_TIME, "lastsend", "The " + UNIX_EPOCH_TIME + " of the last send"}, {RPCResult::Type::NUM_TIME, "lastrecv", "The " + UNIX_EPOCH_TIME + " of the last receive"}, {RPCResult::Type::NUM_TIME, "last_transaction", "The " + UNIX_EPOCH_TIME + " of the last valid transaction received from this " "peer"}, {RPCResult::Type::NUM_TIME, "last_block", "The " + UNIX_EPOCH_TIME + " of the last block received from this peer"}, {RPCResult::Type::NUM, "bytessent", "The total bytes sent"}, {RPCResult::Type::NUM, "bytesrecv", "The total bytes received"}, {RPCResult::Type::NUM_TIME, "conntime", "The " + UNIX_EPOCH_TIME + " of the connection"}, {RPCResult::Type::NUM, "timeoffset", "The time offset in seconds"}, {RPCResult::Type::NUM, "pingtime", "ping time (if available)"}, {RPCResult::Type::NUM, "minping", "minimum observed ping time (if any at all)"}, {RPCResult::Type::NUM, "pingwait", "ping wait (if non-zero)"}, {RPCResult::Type::NUM, "version", "The peer version, such as 70001"}, {RPCResult::Type::STR, "subver", "The string version"}, {RPCResult::Type::BOOL, "inbound", "Inbound (true) or Outbound (false)"}, {RPCResult::Type::BOOL, "bip152_hb_to", "Whether we selected peer as (compact blocks) " "high-bandwidth peer"}, {RPCResult::Type::BOOL, "bip152_hb_from", "Whether peer selected us as (compact blocks) " "high-bandwidth peer"}, {RPCResult::Type::STR, "connection_type", "Type of connection: \n" + Join(CONNECTION_TYPE_DOC, ",\n") + "."}, {RPCResult::Type::NUM, "startingheight", "The starting height (block) of the peer"}, {RPCResult::Type::NUM, "synced_headers", "The last header we have in common with this peer"}, {RPCResult::Type::NUM, "synced_blocks", "The last block we have in common with this peer"}, {RPCResult::Type::ARR, "inflight", "", { {RPCResult::Type::NUM, "n", "The heights of blocks we're currently asking from " "this peer"}, }}, {RPCResult::Type::NUM, "minfeefilter", "The minimum fee rate for transactions this peer accepts"}, {RPCResult::Type::OBJ_DYN, "bytessent_per_msg", "", {{RPCResult::Type::NUM, "msg", "The total bytes sent aggregated by message type\n" "When a message type is not listed in this json object, " "the bytes sent are 0.\n" "Only known message types can appear as keys in the " "object."}}}, {RPCResult::Type::OBJ, "bytesrecv_per_msg", "", {{RPCResult::Type::NUM, "msg", "The total bytes received aggregated by message type\n" "When a message type is not listed in this json object, " "the bytes received are 0.\n" "Only known message types can appear as keys in the " "object and all bytes received\n" "of unknown message types are listed under '" + NET_MESSAGE_COMMAND_OTHER + "'."}}}, {RPCResult::Type::NUM, "activity_score", "Avalanche activity score of this node (if any)"}, }}, }}, }, RPCExamples{HelpExampleCli("getpeerinfo", "") + HelpExampleRpc("getpeerinfo", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman || !node.peerman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } std::vector vstats; node.connman->GetNodeStats(vstats); UniValue ret(UniValue::VARR); for (const CNodeStats &stats : vstats) { UniValue obj(UniValue::VOBJ); CNodeStateStats statestats; bool fStateStats = node.peerman->GetNodeStateStats(stats.nodeid, statestats); obj.pushKV("id", stats.nodeid); - obj.pushKV("addr", stats.addrName); + obj.pushKV("addr", stats.m_addr_name); if (stats.addrBind.IsValid()) { obj.pushKV("addrbind", stats.addrBind.ToString()); } if (!(stats.addrLocal.empty())) { obj.pushKV("addrlocal", stats.addrLocal); } obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled); obj.pushKV("network", GetNetworkName(stats.m_network)); if (stats.m_mapped_as != 0) { obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as)); } obj.pushKV("services", strprintf("%016x", stats.nServices)); obj.pushKV("servicesnames", GetServicesNames(stats.nServices)); obj.pushKV("relaytxes", stats.fRelayTxes); obj.pushKV("lastsend", count_seconds(stats.m_last_send)); obj.pushKV("lastrecv", count_seconds(stats.m_last_recv)); obj.pushKV("last_transaction", count_seconds(stats.m_last_tx_time)); if (g_avalanche) { obj.pushKV("last_proof", count_seconds(stats.m_last_proof_time)); } obj.pushKV("last_block", count_seconds(stats.m_last_block_time)); obj.pushKV("bytessent", stats.nSendBytes); obj.pushKV("bytesrecv", stats.nRecvBytes); obj.pushKV("conntime", count_seconds(stats.m_connected)); obj.pushKV("timeoffset", stats.nTimeOffset); if (stats.m_last_ping_time > 0us) { obj.pushKV("pingtime", CountSecondsDouble(stats.m_last_ping_time)); } if (stats.m_min_ping_time < std::chrono::microseconds::max()) { obj.pushKV("minping", CountSecondsDouble(stats.m_min_ping_time)); } if (fStateStats && statestats.m_ping_wait > 0s) { obj.pushKV("pingwait", CountSecondsDouble(statestats.m_ping_wait)); } obj.pushKV("version", stats.nVersion); // Use the sanitized form of subver here, to avoid tricksy // remote peers from corrupting or modifying the JSON output by // putting special characters in their ver message. obj.pushKV("subver", stats.cleanSubVer); obj.pushKV("inbound", stats.fInbound); obj.pushKV("bip152_hb_to", stats.m_bip152_highbandwidth_to); obj.pushKV("bip152_hb_from", stats.m_bip152_highbandwidth_from); if (fStateStats) { obj.pushKV("startingheight", statestats.m_starting_height); obj.pushKV("synced_headers", statestats.nSyncHeight); obj.pushKV("synced_blocks", statestats.nCommonHeight); UniValue heights(UniValue::VARR); for (const int height : statestats.vHeightInFlight) { heights.push_back(height); } obj.pushKV("inflight", heights); obj.pushKV("addr_processed", statestats.m_addr_processed); obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited); } UniValue permissions(UniValue::VARR); for (const auto &permission : NetPermissions::ToStrings(stats.m_permissionFlags)) { permissions.push_back(permission); } obj.pushKV("permissions", permissions); obj.pushKV("minfeefilter", stats.minFeeFilter); UniValue sendPerMsgCmd(UniValue::VOBJ); for (const auto &i : stats.mapSendBytesPerMsgCmd) { if (i.second > 0) { sendPerMsgCmd.pushKV(i.first, i.second); } } obj.pushKV("bytessent_per_msg", sendPerMsgCmd); UniValue recvPerMsgCmd(UniValue::VOBJ); for (const auto &i : stats.mapRecvBytesPerMsgCmd) { if (i.second > 0) { recvPerMsgCmd.pushKV(i.first, i.second); } } obj.pushKV("bytesrecv_per_msg", recvPerMsgCmd); obj.pushKV("connection_type", stats.m_conn_type_string); if (stats.m_availabilityScore) { obj.pushKV("availability_score", *stats.m_availabilityScore); } ret.push_back(obj); } return ret; }, }; } static RPCHelpMan addnode() { return RPCHelpMan{ "addnode", "Attempts to add or remove a node from the addnode list.\n" "Or try a connection to a node once.\n" "Nodes added using addnode (or -connect) are protected from " "DoS disconnection and are not required to be\n" "full nodes as other outbound peers are (though such peers " "will not be synced from).\n", { {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The node (see getpeerinfo for nodes)"}, {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add a node to the list, 'remove' to remove a " "node from the list, 'onetry' to try a connection to the " "node once"}, }, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{ HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { std::string strCommand; if (!request.params[1].isNull()) { strCommand = request.params[1].get_str(); } if (strCommand != "onetry" && strCommand != "add" && strCommand != "remove") { throw std::runtime_error(self.ToString()); } NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } std::string strNode = request.params[0].get_str(); if (strCommand == "onetry") { CAddress addr; node.connman->OpenNetworkConnection(addr, false, nullptr, strNode.c_str(), ConnectionType::MANUAL); return NullUniValue; } if ((strCommand == "add") && (!node.connman->AddNode(strNode))) { throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added"); } else if ((strCommand == "remove") && (!node.connman->RemoveAddedNode(strNode))) { throw JSONRPCError( RPC_CLIENT_NODE_NOT_ADDED, "Error: Node could not be removed. It has not been " "added previously."); } return NullUniValue; }, }; } static RPCHelpMan addconnection() { return RPCHelpMan{ "addconnection", "\nOpen an outbound connection to a specified node. This RPC is for " "testing only.\n", { {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address and port to attempt connecting to."}, {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO, "Type of connection to open (\"outbound-full-relay\", " "\"block-relay-only\", \"addr-fetch\", \"feeler\" or " "\"avalanche\")."}, }, RPCResult{RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "address", "Address of newly added connection."}, {RPCResult::Type::STR, "connection_type", "Type of connection opened."}, }}, RPCExamples{ HelpExampleCli("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\"") + HelpExampleRpc("addconnection", "\"192.168.0.6:8333\" \"outbound-full-relay\"")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { if (config.GetChainParams().NetworkIDString() != CBaseChainParams::REGTEST) { throw std::runtime_error("addconnection is for regression " "testing (-regtest mode) only."); } RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VSTR}); const std::string address = request.params[0].get_str(); const std::string conn_type_in{ TrimString(request.params[1].get_str())}; ConnectionType conn_type{}; if (conn_type_in == "outbound-full-relay") { conn_type = ConnectionType::OUTBOUND_FULL_RELAY; } else if (conn_type_in == "block-relay-only") { conn_type = ConnectionType::BLOCK_RELAY; } else if (conn_type_in == "addr-fetch") { conn_type = ConnectionType::ADDR_FETCH; } else if (conn_type_in == "feeler") { conn_type = ConnectionType::FEELER; } else if (conn_type_in == "avalanche") { if (!g_avalanche || !isAvalancheEnabled(gArgs)) { throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: avalanche outbound requested " "but avalanche is not enabled."); } conn_type = ConnectionType::AVALANCHE_OUTBOUND; } else { throw JSONRPCError(RPC_INVALID_PARAMETER, self.ToString()); } NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled."); } const bool success = node.connman->AddConnection(address, conn_type); if (!success) { throw JSONRPCError(RPC_CLIENT_NODE_CAPACITY_REACHED, "Error: Already at capacity for specified " "connection type."); } UniValue info(UniValue::VOBJ); info.pushKV("address", address); info.pushKV("connection_type", conn_type_in); return info; }, }; } static RPCHelpMan disconnectnode() { return RPCHelpMan{ "disconnectnode", "Immediately disconnects from the specified peer node.\n" "\nStrictly one out of 'address' and 'nodeid' can be provided to " "identify the node.\n" "\nTo disconnect by nodeid, either set 'address' to the empty string, " "or call using the named 'nodeid' argument only.\n", { {"address", RPCArg::Type::STR, /* default */ "fallback to nodeid", "The IP address/port of the node"}, {"nodeid", RPCArg::Type::NUM, /* default */ "fallback to address", "The node ID (see getpeerinfo for node IDs)"}, }, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") + HelpExampleCli("disconnectnode", "\"\" 1") + HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") + HelpExampleRpc("disconnectnode", "\"\", 1")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } bool success; const UniValue &address_arg = request.params[0]; const UniValue &id_arg = request.params[1]; if (!address_arg.isNull() && id_arg.isNull()) { /* handle disconnect-by-address */ success = node.connman->DisconnectNode(address_arg.get_str()); } else if (!id_arg.isNull() && (address_arg.isNull() || (address_arg.isStr() && address_arg.get_str().empty()))) { /* handle disconnect-by-id */ NodeId nodeid = (NodeId)id_arg.get_int64(); success = node.connman->DisconnectNode(nodeid); } else { throw JSONRPCError( RPC_INVALID_PARAMS, "Only one of address and nodeid should be provided."); } if (!success) { throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes"); } return NullUniValue; }, }; } static RPCHelpMan getaddednodeinfo() { return RPCHelpMan{ "getaddednodeinfo", "Returns information about the given added node, or all added nodes\n" "(note that onetry addnodes are not listed here)\n", { {"node", RPCArg::Type::STR, /* default */ "all nodes", "If provided, return information about this specific node, " "otherwise all nodes are returned."}, }, RPCResult{ RPCResult::Type::ARR, "", "", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "addednode", "The node IP address or name (as provided to addnode)"}, {RPCResult::Type::BOOL, "connected", "If connected"}, {RPCResult::Type::ARR, "addresses", "Only when connected = true", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "address", "The bitcoin server IP and port we're " "connected to"}, {RPCResult::Type::STR, "connected", "connection, inbound or outbound"}, }}, }}, }}, }}, RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") + HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } std::vector vInfo = node.connman->GetAddedNodeInfo(); if (!request.params[0].isNull()) { bool found = false; for (const AddedNodeInfo &info : vInfo) { if (info.strAddedNode == request.params[0].get_str()) { vInfo.assign(1, info); found = true; break; } } if (!found) { throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added."); } } UniValue ret(UniValue::VARR); for (const AddedNodeInfo &info : vInfo) { UniValue obj(UniValue::VOBJ); obj.pushKV("addednode", info.strAddedNode); obj.pushKV("connected", info.fConnected); UniValue addresses(UniValue::VARR); if (info.fConnected) { UniValue address(UniValue::VOBJ); address.pushKV("address", info.resolvedAddress.ToString()); address.pushKV("connected", info.fInbound ? "inbound" : "outbound"); addresses.push_back(address); } obj.pushKV("addresses", addresses); ret.push_back(obj); } return ret; }, }; } static RPCHelpMan getnettotals() { return RPCHelpMan{ "getnettotals", "Returns information about network traffic, including bytes in, " "bytes out,\n" "and current time.\n", {}, RPCResult{ RPCResult::Type::OBJ, "", "", { {RPCResult::Type::NUM, "totalbytesrecv", "Total bytes received"}, {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"}, {RPCResult::Type::NUM_TIME, "timemillis", "Current " + UNIX_EPOCH_TIME + " in milliseconds"}, {RPCResult::Type::OBJ, "uploadtarget", "", { {RPCResult::Type::NUM, "timeframe", "Length of the measuring timeframe in seconds"}, {RPCResult::Type::NUM, "target", "Target in bytes"}, {RPCResult::Type::BOOL, "target_reached", "True if target is reached"}, {RPCResult::Type::BOOL, "serve_historical_blocks", "True if serving historical blocks"}, {RPCResult::Type::NUM, "bytes_left_in_cycle", "Bytes left in current time cycle"}, {RPCResult::Type::NUM, "time_left_in_cycle", "Seconds left in current time cycle"}, }}, }}, RPCExamples{HelpExampleCli("getnettotals", "") + HelpExampleRpc("getnettotals", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.connman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } UniValue obj(UniValue::VOBJ); obj.pushKV("totalbytesrecv", node.connman->GetTotalBytesRecv()); obj.pushKV("totalbytessent", node.connman->GetTotalBytesSent()); obj.pushKV("timemillis", GetTimeMillis()); UniValue outboundLimit(UniValue::VOBJ); outboundLimit.pushKV( "timeframe", count_seconds(node.connman->GetMaxOutboundTimeframe())); outboundLimit.pushKV("target", node.connman->GetMaxOutboundTarget()); outboundLimit.pushKV("target_reached", node.connman->OutboundTargetReached(false)); outboundLimit.pushKV("serve_historical_blocks", !node.connman->OutboundTargetReached(true)); outboundLimit.pushKV("bytes_left_in_cycle", node.connman->GetOutboundTargetBytesLeft()); outboundLimit.pushKV( "time_left_in_cycle", count_seconds(node.connman->GetMaxOutboundTimeLeftInCycle())); obj.pushKV("uploadtarget", outboundLimit); return obj; }, }; } static UniValue GetNetworksInfo() { UniValue networks(UniValue::VARR); for (int n = 0; n < NET_MAX; ++n) { enum Network network = static_cast(n); if (network == NET_UNROUTABLE || network == NET_CJDNS || network == NET_INTERNAL) { continue; } proxyType proxy; UniValue obj(UniValue::VOBJ); GetProxy(network, proxy); obj.pushKV("name", GetNetworkName(network)); obj.pushKV("limited", !IsReachable(network)); obj.pushKV("reachable", IsReachable(network)); obj.pushKV("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort() : std::string()); obj.pushKV("proxy_randomize_credentials", proxy.randomize_credentials); networks.push_back(obj); } return networks; } static RPCHelpMan getnetworkinfo() { const auto &ticker = Currency::get().ticker; return RPCHelpMan{ "getnetworkinfo", "Returns an object containing various state info regarding P2P " "networking.\n", {}, RPCResult{ RPCResult::Type::OBJ, "", "", { {RPCResult::Type::NUM, "version", "the server version"}, {RPCResult::Type::STR, "subversion", "the server subversion string"}, {RPCResult::Type::NUM, "protocolversion", "the protocol version"}, {RPCResult::Type::STR_HEX, "localservices", "the services we offer to the network"}, {RPCResult::Type::ARR, "localservicesnames", "the services we offer to the network, in human-readable form", { {RPCResult::Type::STR, "SERVICE_NAME", "the service name"}, }}, {RPCResult::Type::BOOL, "localrelay", "true if transaction relay is requested from peers"}, {RPCResult::Type::NUM, "timeoffset", "the time offset"}, {RPCResult::Type::NUM, "connections", "the total number of connections"}, {RPCResult::Type::NUM, "connections_in", "the number of inbound connections"}, {RPCResult::Type::NUM, "connections_out", "the number of outbound connections"}, {RPCResult::Type::BOOL, "networkactive", "whether p2p networking is enabled"}, {RPCResult::Type::ARR, "networks", "information per network", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "name", "network (" + Join(GetNetworkNames(), ", ") + ")"}, {RPCResult::Type::BOOL, "limited", "is the network limited using -onlynet?"}, {RPCResult::Type::BOOL, "reachable", "is the network reachable?"}, {RPCResult::Type::STR, "proxy", "(\"host:port\") the proxy that is used for this " "network, or empty if none"}, {RPCResult::Type::BOOL, "proxy_randomize_credentials", "Whether randomized credentials are used"}, }}, }}, {RPCResult::Type::NUM, "relayfee", "minimum relay fee for transactions in " + ticker + "/kB"}, {RPCResult::Type::NUM, "excessutxocharge", "minimum charge for excess utxos in " + ticker}, {RPCResult::Type::ARR, "localaddresses", "list of local addresses", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "address", "network address"}, {RPCResult::Type::NUM, "port", "network port"}, {RPCResult::Type::NUM, "score", "relative score"}, }}, }}, {RPCResult::Type::STR, "warnings", "any network and blockchain warnings"}, }}, RPCExamples{HelpExampleCli("getnetworkinfo", "") + HelpExampleRpc("getnetworkinfo", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { LOCK(cs_main); UniValue obj(UniValue::VOBJ); obj.pushKV("version", CLIENT_VERSION); obj.pushKV("subversion", userAgent(config)); obj.pushKV("protocolversion", PROTOCOL_VERSION); NodeContext &node = EnsureAnyNodeContext(request.context); if (node.connman) { ServiceFlags services = node.connman->GetLocalServices(); obj.pushKV("localservices", strprintf("%016x", services)); obj.pushKV("localservicesnames", GetServicesNames(services)); } if (node.peerman) { obj.pushKV("localrelay", !node.peerman->IgnoresIncomingTxs()); } obj.pushKV("timeoffset", GetTimeOffset()); if (node.connman) { obj.pushKV("networkactive", node.connman->GetNetworkActive()); obj.pushKV("connections", int(node.connman->GetNodeCount( CConnman::CONNECTIONS_ALL))); obj.pushKV("connections_in", int(node.connman->GetNodeCount( CConnman::CONNECTIONS_IN))); obj.pushKV("connections_out", int(node.connman->GetNodeCount( CConnman::CONNECTIONS_OUT))); } obj.pushKV("networks", GetNetworksInfo()); obj.pushKV("relayfee", ::minRelayTxFee.GetFeePerK()); obj.pushKV("excessutxocharge", config.GetExcessUTXOCharge()); UniValue localAddresses(UniValue::VARR); { LOCK(cs_mapLocalHost); for (const std::pair &item : mapLocalHost) { UniValue rec(UniValue::VOBJ); rec.pushKV("address", item.first.ToString()); rec.pushKV("port", item.second.nPort); rec.pushKV("score", item.second.nScore); localAddresses.push_back(rec); } } obj.pushKV("localaddresses", localAddresses); obj.pushKV("warnings", GetWarnings(false).original); return obj; }, }; } static RPCHelpMan setban() { return RPCHelpMan{ "setban", "Attempts to add or remove an IP/Subnet from the banned list.\n", { {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP/Subnet (see getpeerinfo for nodes IP) with an optional " "netmask (default is /32 = single IP)"}, {"command", RPCArg::Type::STR, RPCArg::Optional::NO, "'add' to add an IP/Subnet to the list, 'remove' to remove an " "IP/Subnet from the list"}, {"bantime", RPCArg::Type::NUM, /* default */ "0", "time in seconds how long (or until when if [absolute] is set) " "the IP is banned (0 or empty means using the default time of 24h " "which can also be overwritten by the -bantime startup argument)"}, {"absolute", RPCArg::Type::BOOL, /* default */ "false", "If set, the bantime must be an absolute timestamp expressed in " + UNIX_EPOCH_TIME}, }, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{ HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400") + HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"") + HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")}, [&](const RPCHelpMan &help, const Config &config, const JSONRPCRequest &request) -> UniValue { std::string strCommand; if (!request.params[1].isNull()) { strCommand = request.params[1].get_str(); } if (strCommand != "add" && strCommand != "remove") { throw std::runtime_error(help.ToString()); } NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.banman) { throw JSONRPCError(RPC_DATABASE_ERROR, "Error: Ban database not loaded"); } CSubNet subNet; CNetAddr netAddr; bool isSubnet = false; if (request.params[0].get_str().find('/') != std::string::npos) { isSubnet = true; } if (!isSubnet) { CNetAddr resolved; LookupHost(request.params[0].get_str(), resolved, false); netAddr = resolved; } else { LookupSubNet(request.params[0].get_str(), subNet); } if (!(isSubnet ? subNet.IsValid() : netAddr.IsValid())) { throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Invalid IP/Subnet"); } if (strCommand == "add") { if (isSubnet ? node.banman->IsBanned(subNet) : node.banman->IsBanned(netAddr)) { throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned"); } // Use standard bantime if not specified. int64_t banTime = 0; if (!request.params[2].isNull()) { banTime = request.params[2].get_int64(); } bool absolute = false; if (request.params[3].isTrue()) { absolute = true; } if (isSubnet) { node.banman->Ban(subNet, banTime, absolute); if (node.connman) { node.connman->DisconnectNode(subNet); } } else { node.banman->Ban(netAddr, banTime, absolute); if (node.connman) { node.connman->DisconnectNode(netAddr); } } } else if (strCommand == "remove") { if (!(isSubnet ? node.banman->Unban(subNet) : node.banman->Unban(netAddr))) { throw JSONRPCError( RPC_CLIENT_INVALID_IP_OR_SUBNET, "Error: Unban failed. Requested address/subnet " "was not previously manually banned."); } } return NullUniValue; }, }; } static RPCHelpMan listbanned() { return RPCHelpMan{ "listbanned", "List all manually banned IPs/Subnets.\n", {}, RPCResult{RPCResult::Type::ARR, "", "", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::STR, "address", ""}, {RPCResult::Type::NUM_TIME, "banned_until", ""}, {RPCResult::Type::NUM_TIME, "ban_created", ""}, {RPCResult::Type::STR, "ban_reason", ""}, }}, }}, RPCExamples{HelpExampleCli("listbanned", "") + HelpExampleRpc("listbanned", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.banman) { throw JSONRPCError(RPC_DATABASE_ERROR, "Error: Ban database not loaded"); } banmap_t banMap; node.banman->GetBanned(banMap); UniValue bannedAddresses(UniValue::VARR); for (const auto &entry : banMap) { const CBanEntry &banEntry = entry.second; UniValue rec(UniValue::VOBJ); rec.pushKV("address", entry.first.ToString()); rec.pushKV("banned_until", banEntry.nBanUntil); rec.pushKV("ban_created", banEntry.nCreateTime); bannedAddresses.push_back(rec); } return bannedAddresses; }, }; } static RPCHelpMan clearbanned() { return RPCHelpMan{ "clearbanned", "Clear all banned IPs.\n", {}, RPCResult{RPCResult::Type::NONE, "", ""}, RPCExamples{HelpExampleCli("clearbanned", "") + HelpExampleRpc("clearbanned", "")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.banman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } node.banman->ClearBanned(); return NullUniValue; }, }; } static RPCHelpMan setnetworkactive() { return RPCHelpMan{ "setnetworkactive", "Disable/enable all p2p network activity.\n", { {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO, "true to enable networking, false to disable"}, }, RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"}, RPCExamples{""}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.banman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } node.connman->SetNetworkActive(request.params[0].get_bool()); return node.connman->GetNetworkActive(); }, }; } static RPCHelpMan getnodeaddresses() { return RPCHelpMan{ "getnodeaddresses", "Return known addresses, which can potentially be used to find new " "nodes in the network.\n", { {"count", RPCArg::Type::NUM, /* default */ "1", "The maximum number of addresses to return. Specify 0 to return " "all known addresses."}, {"network", RPCArg::Type::STR, "all networks", "Return only addresses of the specified network. Can be one of: " + Join(GetNetworkNames(), ", ") + "."}, }, RPCResult{RPCResult::Type::ARR, "", "", { {RPCResult::Type::OBJ, "", "", { {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " when the node was last seen"}, {RPCResult::Type::NUM, "services", "The services offered by the node"}, {RPCResult::Type::STR, "address", "The address of the node"}, {RPCResult::Type::NUM, "port", "The port number of the node"}, {RPCResult::Type::STR, "network", "The network (" + Join(GetNetworkNames(), ", ") + ") the node connected through"}, }}, }}, RPCExamples{HelpExampleCli("getnodeaddresses", "8") + HelpExampleCli("getnodeaddresses", "4 \"i2p\"") + HelpExampleCli("-named getnodeaddresses", "network=onion count=12") + HelpExampleRpc("getnodeaddresses", "8") + HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.banman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled"); } const int count{ request.params[0].isNull() ? 1 : request.params[0].get_int()}; if (count < 0) { throw JSONRPCError(RPC_INVALID_PARAMETER, "Address count out of range"); } const std::optional network{ request.params[1].isNull() ? std::nullopt : std::optional{ ParseNetwork(request.params[1].get_str())}}; if (network == NET_UNROUTABLE) { throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Network not recognized: %s", request.params[1].get_str())); } // returns a shuffled list of CAddress const std::vector vAddr{ node.connman->GetAddresses(count, /* max_pct */ 0, network)}; UniValue ret(UniValue::VARR); for (const CAddress &addr : vAddr) { UniValue obj(UniValue::VOBJ); obj.pushKV("time", int(addr.nTime)); obj.pushKV("services", uint64_t(addr.nServices)); obj.pushKV("address", addr.ToStringIP()); obj.pushKV("port", addr.GetPort()); obj.pushKV("network", GetNetworkName(addr.GetNetClass())); ret.push_back(obj); } return ret; }, }; } static RPCHelpMan addpeeraddress() { return RPCHelpMan{ "addpeeraddress", "Add the address of a potential peer to the address manager. This " "RPC is for testing only.\n", { {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The IP address of the peer"}, {"port", RPCArg::Type::NUM, RPCArg::Optional::NO, "The port of the peer"}, {"tried", RPCArg::Type::BOOL, "false", "If true, attempt to add the peer to the tried addresses table"}, }, RPCResult{ RPCResult::Type::OBJ, "", "", { {RPCResult::Type::BOOL, "success", "whether the peer address was successfully added to the " "address manager"}, }, }, RPCExamples{ HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true") + HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")}, [&](const RPCHelpMan &self, const Config &config, const JSONRPCRequest &request) -> UniValue { NodeContext &node = EnsureAnyNodeContext(request.context); if (!node.addrman) { throw JSONRPCError( RPC_CLIENT_P2P_DISABLED, "Error: Address manager functionality missing or disabled"); } const std::string &addr_string{request.params[0].get_str()}; const uint16_t port{ static_cast(request.params[1].get_int())}; const bool tried{request.params[2].isTrue()}; UniValue obj(UniValue::VOBJ); CNetAddr net_addr; bool success{false}; if (LookupHost(addr_string, net_addr, false)) { CAddress address{{net_addr, port}, ServiceFlags(NODE_NETWORK)}; address.nTime = GetAdjustedTime(); // The source address is set equal to the address. This is // equivalent to the peer announcing itself. if (node.addrman->Add({address}, address)) { success = true; if (tried) { // Attempt to move the address to the tried addresses // table. node.addrman->Good(address); } } } obj.pushKV("success", success); return obj; }, }; } void RegisterNetRPCCommands(CRPCTable &t) { // clang-format off static const CRPCCommand commands[] = { // category actor (function) // ------------------ ---------------------- { "network", getconnectioncount, }, { "network", ping, }, { "network", getpeerinfo, }, { "network", addnode, }, { "network", disconnectnode, }, { "network", getaddednodeinfo, }, { "network", getnettotals, }, { "network", getnetworkinfo, }, { "network", setban, }, { "network", listbanned, }, { "network", clearbanned, }, { "network", setnetworkactive, }, { "network", getnodeaddresses, }, { "hidden", addconnection, }, { "hidden", addpeeraddress, }, }; // clang-format on for (const auto &c : commands) { t.appendCommand(c.name, &c); } } diff --git a/src/test/fuzz/net.cpp b/src/test/fuzz/net.cpp index ee7843abc..78920fe34 100644 --- a/src/test/fuzz/net.cpp +++ b/src/test/fuzz/net.cpp @@ -1,146 +1,140 @@ // Copyright (c) 2020 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include void initialize() { static const auto testing_setup = MakeFuzzingContext<>(CBaseChainParams::MAIN); } void test_one_input(const std::vector &buffer) { FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); const Config &config = GetConfig(); const std::optional address = ConsumeDeserializable(fuzzed_data_provider); if (!address) { return; } const std::optional address_bind = ConsumeDeserializable(fuzzed_data_provider); if (!address_bind) { return; } CNode node{ fuzzed_data_provider.ConsumeIntegral(), static_cast( fuzzed_data_provider.ConsumeIntegral()), INVALID_SOCKET, *address, fuzzed_data_provider.ConsumeIntegral(), fuzzed_data_provider.ConsumeIntegral(), fuzzed_data_provider.ConsumeIntegral(), *address_bind, fuzzed_data_provider.ConsumeRandomLengthString(32), fuzzed_data_provider.PickValueInArray( {ConnectionType::INBOUND, ConnectionType::OUTBOUND_FULL_RELAY, ConnectionType::MANUAL, ConnectionType::FEELER, ConnectionType::BLOCK_RELAY, ConnectionType::ADDR_FETCH}), fuzzed_data_provider.ConsumeBool()}; node.SetCommonVersion(fuzzed_data_provider.ConsumeIntegral()); while (fuzzed_data_provider.ConsumeBool()) { switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 8)) { case 0: { node.CloseSocketDisconnect(); break; } case 1: { - node.MaybeSetAddrName( - fuzzed_data_provider.ConsumeRandomLengthString(32)); - break; - } - case 2: { CNodeStats stats; node.copyStats(stats); break; } - case 3: { + case 2: { const CNode *add_ref_node = node.AddRef(); assert(add_ref_node == &node); break; } - case 4: { + case 3: { if (node.GetRefCount() > 0) { node.Release(); } break; } - case 5: { + case 4: { const std::optional inv_opt = ConsumeDeserializable(fuzzed_data_provider); if (!inv_opt) { break; } const TxId &txid = TxId(inv_opt->hash); node.AddKnownTx(txid); break; } - case 6: { + case 5: { const TxId &txid = TxId(ConsumeUInt256(fuzzed_data_provider)); node.PushTxInventory(txid); break; } - case 7: { + case 6: { const std::optional service_opt = ConsumeDeserializable(fuzzed_data_provider); if (!service_opt) { break; } node.SetAddrLocal(*service_opt); break; } - case 8: { + case 7: { const std::vector b = ConsumeRandomLengthByteVector(fuzzed_data_provider); bool complete; node.ReceiveMsgBytes(config, b, complete); break; } } } (void)node.GetAddrLocal(); - (void)node.GetAddrName(); (void)node.GetId(); (void)node.GetLocalNonce(); (void)node.GetLocalServices(); const int ref_count = node.GetRefCount(); assert(ref_count >= 0); (void)node.GetCommonVersion(); const NetPermissionFlags net_permission_flags = fuzzed_data_provider.ConsumeBool() ? fuzzed_data_provider.PickValueInArray( {NetPermissionFlags::PF_NONE, NetPermissionFlags::PF_BLOOMFILTER, NetPermissionFlags::PF_RELAY, NetPermissionFlags::PF_FORCERELAY, NetPermissionFlags::PF_NOBAN, NetPermissionFlags::PF_MEMPOOL, NetPermissionFlags::PF_ISIMPLICIT, NetPermissionFlags::PF_ALL}) : static_cast( fuzzed_data_provider.ConsumeIntegral()); (void)node.HasPermission(net_permission_flags); (void)node.ConnectedThroughNetwork(); }