1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <net.h>
9
10#include <addrdb.h>
11#include <addrman.h>
12#include <banman.h>
13#include <clientversion.h>
14#include <common/args.h>
15#include <common/netif.h>
16#include <compat/compat.h>
17#include <consensus/consensus.h>
18#include <crypto/sha256.h>
19#include <i2p.h>
20#include <key.h>
21#include <logging.h>
22#include <memusage.h>
23#include <net_permissions.h>
24#include <netaddress.h>
25#include <netbase.h>
26#include <node/eviction.h>
27#include <node/interface_ui.h>
28#include <protocol.h>
29#include <random.h>
30#include <scheduler.h>
31#include <util/fs.h>
32#include <util/overflow.h>
33#include <util/sock.h>
34#include <util/strencodings.h>
35#include <util/thread.h>
36#include <util/threadinterrupt.h>
37#include <util/trace.h>
38#include <util/translation.h>
39#include <util/vector.h>
40
41#include <algorithm>
42#include <array>
43#include <cmath>
44#include <cstdint>
45#include <cstring>
46#include <functional>
47#include <optional>
48#include <string_view>
49#include <unordered_map>
50
51TRACEPOINT_SEMAPHORE(net, closed_connection);
52TRACEPOINT_SEMAPHORE(net, evicted_inbound_connection);
53TRACEPOINT_SEMAPHORE(net, inbound_connection);
54TRACEPOINT_SEMAPHORE(net, outbound_connection);
55TRACEPOINT_SEMAPHORE(net, outbound_message);
56
57/** Maximum number of block-relay-only anchor connections */
58static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
59static_assert (MAX_BLOCK_RELAY_ONLY_ANCHORS <= static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS), "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");
60/** Anchor IP address database file name */
61const char* const ANCHORS_DATABASE_FILENAME = "anchors.dat";
62
63// How often to dump addresses to peers.dat
64static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};
65
66/** Number of DNS seeds to query when the number of connections is low. */
67static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;
68
69/** Minimum number of outbound connections under which we will keep fetching our address seeds. */
70static constexpr int SEED_OUTBOUND_CONNECTION_THRESHOLD = 2;
71
72/** How long to delay before querying DNS seeds
73 *
74 * If we have more than THRESHOLD entries in addrman, then it's likely
75 * that we got those addresses from having previously connected to the P2P
76 * network, and that we'll be able to successfully reconnect to the P2P
77 * network via contacting one of them. So if that's the case, spend a
78 * little longer trying to connect to known peers before querying the
79 * DNS seeds.
80 */
81static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};
82static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};
83static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000; // "many" vs "few" peers
84
85/** The default timeframe for -maxuploadtarget. 1 day. */
86static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};
87
88// A random time period (0 to 1 seconds) is added to feeler connections to prevent synchronization.
89static constexpr auto FEELER_SLEEP_WINDOW{1s};
90
91/** Frequency to attempt extra connections to reachable networks we're not connected to yet **/
92static constexpr auto EXTRA_NETWORK_PEER_INTERVAL{5min};
93
94/** Used to pass flags to the Bind() function */
95enum BindFlags {
96    BF_NONE         = 0,
97    BF_REPORT_ERROR = (1U << 0),
98    /**
99     * Do not call AddLocal() for our special addresses, e.g., for incoming
100     * Tor connections, to prevent gossiping them over the network.
101     */
102    BF_DONT_ADVERTISE = (1U << 1),
103};
104
105// The set of sockets cannot be modified while waiting
106// The sleep time needs to be small to avoid new sockets stalling
107static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;
108
109const std::string NET_MESSAGE_TYPE_OTHER = "*other*";
110
111static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]
112static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]
113static const uint64_t RANDOMIZER_ID_NETWORKKEY = 0x0e8a2b136c592a7dULL; // SHA256("networkkey")[0:8]
114//
115// Global state variables
116//
117bool fDiscover = true;
118bool fListen = true;
119GlobalMutex g_maplocalhost_mutex;
120std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
121std::string strSubVersion;
122
123size_t CSerializedNetMsg::GetMemoryUsage() const noexcept
124{
125    return sizeof(*this) + memusage::DynamicUsage(m_type) + memusage::DynamicUsage(data);
126}
127
128size_t CNetMessage::GetMemoryUsage() const noexcept
129{
130    return sizeof(*this) + memusage::DynamicUsage(m_type) + m_recv.GetMemoryUsage();
131}
132
133void CConnman::AddAddrFetch(const std::string& strDest)
134{
135    LOCK(m_addr_fetches_mutex);
136    m_addr_fetches.push_back(strDest);
137}
138
139uint16_t GetListenPort()
140{
141    // If -bind= is provided with ":port" part, use that (first one if multiple are provided).
142    for (const std::string& bind_arg : gArgs.GetArgs("-bind")) {
143        constexpr uint16_t dummy_port = 0;
144
145        const std::optional<CService> bind_addr{Lookup(bind_arg, dummy_port, /*fAllowLookup=*/false)};
146        if (bind_addr.has_value() && bind_addr->GetPort() != dummy_port) return bind_addr->GetPort();
147    }
148
149    // Otherwise, if -whitebind= without NetPermissionFlags::NoBan is provided, use that
150    // (-whitebind= is required to have ":port").
151    for (const std::string& whitebind_arg : gArgs.GetArgs("-whitebind")) {
152        NetWhitebindPermissions whitebind;
153        bilingual_str error;
154        if (NetWhitebindPermissions::TryParse(whitebind_arg, whitebind, error)) {
155            if (!NetPermissions::HasFlag(whitebind.m_flags, NetPermissionFlags::NoBan)) {
156                return whitebind.m_service.GetPort();
157            }
158        }
159    }
160
161    // Otherwise, if -port= is provided, use that. Otherwise use the default port.
162    return static_cast<uint16_t>(gArgs.GetIntArg("-port", Params().GetDefaultPort()));
163}
164
165// Determine the "best" local address for a particular peer.
166[[nodiscard]] static std::optional<CService> GetLocal(const CNode& peer)
167{
168    if (!fListen) return std::nullopt;
169
170    std::optional<CService> addr;
171    int nBestScore = -1;
172    int nBestReachability = -1;
173    {
174        LOCK(g_maplocalhost_mutex);
175        for (const auto& [local_addr, local_service_info] : mapLocalHost) {
176            // For privacy reasons, don't advertise our privacy-network address
177            // to other networks and don't advertise our other-network address
178            // to privacy networks.
179            if (local_addr.GetNetwork() != peer.ConnectedThroughNetwork()
180                && (local_addr.IsPrivacyNet() || peer.IsConnectedThroughPrivacyNet())) {
181                continue;
182            }
183            const int nScore{local_service_info.nScore};
184            const int nReachability{local_addr.GetReachabilityFrom(peer.addr)};
185            if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {
186                addr.emplace(CService{local_addr, local_service_info.nPort});
187                nBestReachability = nReachability;
188                nBestScore = nScore;
189            }
190        }
191    }
192    return addr;
193}
194
195//! Convert the serialized seeds into usable address objects.
196static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)
197{
198    // It'll only connect to one or two seed nodes because once it connects,
199    // it'll get a pile of addresses with newer timestamps.
200    // Seed nodes are given a random 'last seen time' of between one and two
201    // weeks ago.
202    const auto one_week{7 * 24h};
203    std::vector<CAddress> vSeedsOut;
204    FastRandomContext rng;
205    ParamsStream s{SpanReader{vSeedsIn}, CAddress::V2_NETWORK};
206    while (!s.empty()) {
207        CService endpoint;
208        s >> endpoint;
209        CAddress addr{endpoint, SeedsAssumedServiceFlags()};
210        addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - one_week, -one_week);
211        LogDebug(BCLog::NET, "Added hardcoded seed: %s\n", addr.ToStringAddrPort());
212        vSeedsOut.push_back(addr);
213    }
214    return vSeedsOut;
215}
216
217// Determine the "best" local address for a particular peer.
218// If none, return the unroutable 0.0.0.0 but filled in with
219// the normal parameters, since the IP may be changed to a useful
220// one by discovery.
221CService GetLocalAddress(const CNode& peer)
222{
223    return GetLocal(peer).value_or(CService{CNetAddr(), GetListenPort()});
224}
225
226static int GetnScore(const CService& addr)
227{
228    LOCK(g_maplocalhost_mutex);
229    const auto it = mapLocalHost.find(addr);
230    return (it != mapLocalHost.end()) ? it->second.nScore : 0;
231}
232
233// Is our peer's addrLocal potentially useful as an external IP source?
234[[nodiscard]] static bool IsPeerAddrLocalGood(CNode *pnode)
235{
236    CService addrLocal = pnode->GetAddrLocal();
237    return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
238           g_reachable_nets.Contains(addrLocal);
239}
240
241std::optional<CService> GetLocalAddrForPeer(CNode& node)
242{
243    CService addrLocal{GetLocalAddress(node)};
244    // If discovery is enabled, sometimes give our peer the address it
245    // tells us that it sees us as in case it has a better idea of our
246    // address than we do.
247    FastRandomContext rng;
248    if (IsPeerAddrLocalGood(&node) && (!addrLocal.IsRoutable() ||
249         rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0))
250    {