Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 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 : : #if defined(HAVE_CONFIG_H)
7 : : #include <config/bitcoin-config.h>
8 : : #endif
9 : :
10 : : #include <net.h>
11 : :
12 : : #include <addrdb.h>
13 : : #include <addrman.h>
14 : : #include <banman.h>
15 : : #include <clientversion.h>
16 : : #include <common/args.h>
17 [ + - ]: 173 : #include <compat/compat.h>
18 [ + - ]: 173 : #include <consensus/consensus.h>
19 : : #include <crypto/sha256.h>
20 : : #include <i2p.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/sock.h>
33 : : #include <util/strencodings.h>
34 : : #include <util/thread.h>
35 : : #include <util/threadinterrupt.h>
36 : : #include <util/trace.h>
37 : : #include <util/translation.h>
38 : : #include <util/vector.h>
39 : :
40 : : #ifdef WIN32
41 : : #include <string.h>
42 : : #endif
43 : :
44 : : #if HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS
45 : : #include <ifaddrs.h>
46 : : #endif
47 : :
48 : : #include <algorithm>
49 : : #include <array>
50 : : #include <cstdint>
51 : : #include <functional>
52 : : #include <optional>
53 : : #include <unordered_map>
54 : :
55 : : #include <math.h>
56 : :
57 : : /** Maximum number of block-relay-only anchor connections */
58 : : static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
59 : : static_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 */
61 : : const char* const ANCHORS_DATABASE_FILENAME = "anchors.dat";
62 : :
63 : : // How often to dump addresses to peers.dat
64 : : static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};
65 : :
66 : : /** Number of DNS seeds to query when the number of connections is low. */
67 : : static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;
68 : :
69 : : /** How long to delay before querying DNS seeds
70 : : *
71 : : * If we have more than THRESHOLD entries in addrman, then it's likely
72 : : * that we got those addresses from having previously connected to the P2P
73 : : * network, and that we'll be able to successfully reconnect to the P2P
74 : 173 : * network via contacting one of them. So if that's the case, spend a
75 : : * little longer trying to connect to known peers before querying the
76 : : * DNS seeds.
77 : : */
78 : : static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};
79 : : static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};
80 : : static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000; // "many" vs "few" peers
81 : :
82 : : /** The default timeframe for -maxuploadtarget. 1 day. */
83 [ + - ]: 173 : static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};
84 : :
85 : : // A random time period (0 to 1 seconds) is added to feeler connections to prevent synchronization.
86 : : static constexpr auto FEELER_SLEEP_WINDOW{1s};
87 : :
88 : : /** Frequency to attempt extra connections to reachable networks we're not connected to yet **/
89 : : static constexpr auto EXTRA_NETWORK_PEER_INTERVAL{5min};
90 : :
91 : : /** Used to pass flags to the Bind() function */
92 : : enum BindFlags {
93 : : BF_NONE = 0,
94 : : BF_REPORT_ERROR = (1U << 0),
95 : : /**
96 : : * Do not call AddLocal() for our special addresses, e.g., for incoming
97 : : * Tor connections, to prevent gossiping them over the network.
98 : : */
99 : : BF_DONT_ADVERTISE = (1U << 1),
100 : : };
101 : :
102 : : // The set of sockets cannot be modified while waiting
103 : : // The sleep time needs to be small to avoid new sockets stalling
104 : : static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;
105 : :
106 [ + - ]: 173 : const std::string NET_MESSAGE_TYPE_OTHER = "*other*";
107 : :
108 : : static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL; // SHA256("netgroup")[0:8]
109 : : static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL; // SHA256("localhostnonce")[0:8]
110 : : static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL; // SHA256("addrcache")[0:8]
111 : : //
112 : : // Global state variables
113 : : //
114 : : bool fDiscover = true;
115 : : bool fListen = true;
116 : : GlobalMutex g_maplocalhost_mutex;
117 : 173 : std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
118 : : static bool vfLimited[NET_MAX] GUARDED_BY(g_maplocalhost_mutex) = {};
119 : 173 : std::string strSubVersion;
120 : :
121 : 594835 : size_t CSerializedNetMsg::GetMemoryUsage() const noexcept
122 : : {
123 : : // Don't count the dynamic memory used for the m_type string, by assuming it fits in the
124 : : // "small string" optimization area (which stores data inside the object itself, up to some
125 : : // size; 15 bytes in modern libstdc++).
126 [ + - ]: 594835 : return sizeof(*this) + memusage::DynamicUsage(data);
127 : : }
128 : :
129 : 0 : void CConnman::AddAddrFetch(const std::string& strDest)
130 : : {
131 : 0 : LOCK(m_addr_fetches_mutex);
132 [ # # ]: 0 : m_addr_fetches.push_back(strDest);
133 : 0 : }
134 : :
135 : 3072 : uint16_t GetListenPort()
136 : : {
137 : : // If -bind= is provided with ":port" part, use that (first one if multiple are provided).
138 [ + - + - : 3072 : for (const std::string& bind_arg : gArgs.GetArgs("-bind")) {
+ - - + ]
139 : 0 : constexpr uint16_t dummy_port = 0;
140 : :
141 [ # # # # ]: 0 : const std::optional<CService> bind_addr{Lookup(bind_arg, dummy_port, /*fAllowLookup=*/false)};
142 [ # # # # : 0 : if (bind_addr.has_value() && bind_addr->GetPort() != dummy_port) return bind_addr->GetPort();
# # # # #
# # # ]
143 [ # # ]: 0 : }
144 : :
145 : : // Otherwise, if -whitebind= without NetPermissionFlags::NoBan is provided, use that
146 : : // (-whitebind= is required to have ":port").
147 [ + - + - : 3072 : for (const std::string& whitebind_arg : gArgs.GetArgs("-whitebind")) {
- + - + ]
148 [ # # ]: 0 : NetWhitebindPermissions whitebind;
149 : 0 : bilingual_str error;
150 [ # # # # ]: 0 : if (NetWhitebindPermissions::TryParse(whitebind_arg, whitebind, error)) {
151 [ # # # # ]: 0 : if (!NetPermissions::HasFlag(whitebind.m_flags, NetPermissionFlags::NoBan)) {
152 [ # # ]: 0 : return whitebind.m_service.GetPort();
153 : : }
154 : 0 : }
155 [ # # ]: 0 : }
156 : :
157 : : // Otherwise, if -port= is provided, use that. Otherwise use the default port.
158 [ + - + - : 3072 : return static_cast<uint16_t>(gArgs.GetIntArg("-port", Params().GetDefaultPort()));
+ - + - ]
159 : 3072 : }
160 : :
161 : : // Determine the "best" local address for a particular peer.
162 : 3070 : [[nodiscard]] static std::optional<CService> GetLocal(const CNode& peer)
163 : : {
164 [ - + ]: 3070 : if (!fListen) return std::nullopt;
165 : :
166 : 3070 : std::optional<CService> addr;
167 : 3070 : int nBestScore = -1;
168 : 3070 : int nBestReachability = -1;
169 : : {
170 [ + - + - ]: 3070 : LOCK(g_maplocalhost_mutex);
171 [ - + ]: 3070 : for (const auto& [local_addr, local_service_info] : mapLocalHost) {
172 : : // For privacy reasons, don't advertise our privacy-network address
173 : : // to other networks and don't advertise our other-network address
174 : : // to privacy networks.
175 [ # # # # : 0 : if (local_addr.GetNetwork() != peer.ConnectedThroughNetwork()
# # ]
176 [ # # # # : 0 : && (local_addr.IsPrivacyNet() || peer.IsConnectedThroughPrivacyNet())) {
# # # # ]
177 : 0 : continue;
178 : : }
179 : 0 : const int nScore{local_service_info.nScore};
180 [ # # ]: 0 : const int nReachability{local_addr.GetReachabilityFrom(peer.addr)};
181 [ # # # # : 0 : if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {
# # ]
182 [ # # # # ]: 0 : addr.emplace(CService{local_addr, local_service_info.nPort});
183 : 0 : nBestReachability = nReachability;
184 : 0 : nBestScore = nScore;
185 : 0 : }
186 : : }
187 : 3070 : }
188 : 3070 : return addr;
189 [ + - ]: 6140 : }
190 : :
191 : : //! Convert the serialized seeds into usable address objects.
192 : 0 : static std::vector<CAddress> ConvertSeeds(const std::vector<uint8_t> &vSeedsIn)
193 : : {
194 : : // It'll only connect to one or two seed nodes because once it connects,
195 : : // it'll get a pile of addresses with newer timestamps.
196 : : // Seed nodes are given a random 'last seen time' of between one and two
197 : : // weeks ago.
198 : 0 : const auto one_week{7 * 24h};
199 : 0 : std::vector<CAddress> vSeedsOut;
200 : 0 : FastRandomContext rng;
201 [ # # # # ]: 0 : DataStream underlying_stream{vSeedsIn};
202 [ # # ]: 0 : ParamsStream s{CAddress::V2_NETWORK, underlying_stream};
203 [ # # # # ]: 0 : while (!s.eof()) {
204 [ # # ]: 0 : CService endpoint;
205 [ # # ]: 0 : s >> endpoint;
206 [ # # # # : 0 : CAddress addr{endpoint, GetDesirableServiceFlags(NODE_NONE)};
# # ]
207 [ # # # # : 0 : addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - one_week, -one_week);
# # # # #
# ]
208 [ # # # # : 0 : LogPrint(BCLog::NET, "Added hardcoded seed: %s\n", addr.ToStringAddrPort());
# # # # #
# # # ]
209 [ # # ]: 0 : vSeedsOut.push_back(addr);
210 : 0 : }
211 : 0 : return vSeedsOut;
212 [ # # ]: 0 : }
213 : :
214 : : // Determine the "best" local address for a particular peer.
215 : : // If none, return the unroutable 0.0.0.0 but filled in with
216 : : // the normal parameters, since the IP may be changed to a useful
217 : : // one by discovery.
218 : 3070 : CService GetLocalAddress(const CNode& peer)
219 : : {
220 [ + - + - : 3070 : return GetLocal(peer).value_or(CService{CNetAddr(), GetListenPort()});
+ - - + ]
221 : 0 : }
222 : :
223 : 0 : static int GetnScore(const CService& addr)
224 : : {
225 : 0 : LOCK(g_maplocalhost_mutex);
226 [ # # ]: 0 : const auto it = mapLocalHost.find(addr);
227 [ # # ]: 0 : return (it != mapLocalHost.end()) ? it->second.nScore : 0;
228 : 0 : }
229 : :
230 : : // Is our peer's addrLocal potentially useful as an external IP source?
231 : 3070 : [[nodiscard]] static bool IsPeerAddrLocalGood(CNode *pnode)
232 : : {
233 : 3070 : CService addrLocal = pnode->GetAddrLocal();
234 [ - + + - : 3070 : return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
+ + + - -
+ ]
235 [ # # # # ]: 0 : IsReachable(addrLocal.GetNetwork());
236 : 3070 : }
237 : :
238 : 3070 : std::optional<CService> GetLocalAddrForPeer(CNode& node)
239 : : {
240 : 3070 : CService addrLocal{GetLocalAddress(node)};
241 [ + - + - : 3070 : if (gArgs.GetBoolArg("-addrmantest", false)) {
+ - ]
242 : : // use IPv4 loopback during addrmantest
243 [ # # # # : 0 : addrLocal = CService(LookupNumeric("127.0.0.1", GetListenPort()));
# # # # ]
244 : 0 : }
245 : : // If discovery is enabled, sometimes give our peer the address it
246 : : // tells us that it sees us as in case it has a better idea of our
247 : : // address than we do.
248 : 3070 : FastRandomContext rng;
249 [ + - - + : 3070 : if (IsPeerAddrLocalGood(&node) && (!addrLocal.IsRoutable() ||
# # # # ]
250 [ # # ]: 0 : rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0))
251 : : {
252 [ # # # # ]: 0 : if (node.IsInboundConn()) {
253 : : // For inbound connections, assume both the address and the port
254 : : // as seen from the peer.
255 [ # # ]: 0 : addrLocal = CService{node.GetAddrLocal()};
256 : 0 : } else {
257 : : // For outbound connections, assume just the address as seen from
258 : : // the peer and leave the port in `addrLocal` as returned by
259 : : // `GetLocalAddress()` above. The peer has no way to observe our
260 : : // listening port when we have initiated the connection.
261 [ # # # # ]: 0 : addrLocal.SetIP(node.GetAddrLocal());
262 : : }
263 : 0 : }
264 [ + - - + : 3070 : if (addrLocal.IsRoutable() || gArgs.GetBoolArg("-addrmantest", false))
+ - + - -
+ - + - +
# # # # ]
265 : : {
266 [ # # # # : 0 : LogPrint(BCLog::NET, "Advertising address %s to peer=%d\n", addrLocal.ToStringAddrPort(), node.GetId());
# # # # #
# # # #
# ]
267 [ # # ]: 0 : return addrLocal;
268 : : }
269 : : // Address is unroutable. Don't advertise.
270 : 3070 : return std::nullopt;
271 : 3070 : }
272 : :
273 : : /**
274 : : * If an IPv6 address belongs to the address range used by the CJDNS network and
275 : : * the CJDNS network is reachable (-cjdnsreachable config is set), then change
276 : : * the type from NET_IPV6 to NET_CJDNS.
277 : : * @param[in] service Address to potentially convert.
278 : : * @return a copy of `service` either unmodified or changed to CJDNS.
279 : : */
280 : 3237 : CService MaybeFlipIPv6toCJDNS(const CService& service)
281 : : {
282 : 3237 : CService ret{service};
283 [ + - + + : 3237 : if (ret.IsIPv6() && ret.HasCJDNSPrefix() && IsReachable(NET_CJDNS)) {
+ - - + #
# # # ]
284 : 0 : ret.m_net = NET_CJDNS;
285 : 0 : }
286 : 3237 : return ret;
287 [ + - ]: 3237 : }
288 : :
289 : : // learn a new local address
290 : 2970 : bool AddLocal(const CService& addr_, int nScore)
291 : : {
292 : 2970 : CService addr{MaybeFlipIPv6toCJDNS(addr_)};
293 : :
294 [ + - + + ]: 2970 : if (!addr.IsRoutable())
295 : 2956 : return false;
296 : :
297 [ - + # # ]: 14 : if (!fDiscover && nScore < LOCAL_MANUAL)
298 : 0 : return false;
299 : :
300 [ + - + - ]: 14 : if (!IsReachable(addr))
301 : 0 : return false;
302 : :
303 [ + - + - : 14 : LogPrintf("AddLocal(%s,%i)\n", addr.ToStringAddrPort(), nScore);
+ - + - ]
304 : :
305 : : {
306 [ + - + - ]: 14 : LOCK(g_maplocalhost_mutex);
307 [ + - ]: 14 : const auto [it, is_newly_added] = mapLocalHost.emplace(addr, LocalServiceInfo());
308 : 14 : LocalServiceInfo &info = it->second;
309 [ - + # # ]: 14 : if (is_newly_added || nScore >= info.nScore) {
310 : 28 : info.nScore = nScore + (is_newly_added ? 0 : 1);
311 [ + - ]: 14 : info.nPort = addr.GetPort();
312 : 14 : }
313 : 14 : }
314 : :
315 : 14 : return true;
316 : 2970 : }
317 : :
318 : 0 : bool AddLocal(const CNetAddr &addr, int nScore)
319 : : {
320 [ # # ]: 0 : return AddLocal(CService(addr, GetListenPort()), nScore);
321 : 0 : }
322 : :
323 : 0 : void RemoveLocal(const CService& addr)
324 : : {
325 : 0 : LOCK(g_maplocalhost_mutex);
326 [ # # # # : 0 : LogPrintf("RemoveLocal(%s)\n", addr.ToStringAddrPort());
# # # # ]
327 [ # # ]: 0 : mapLocalHost.erase(addr);
328 : 0 : }
329 : :
330 : 0 : void SetReachable(enum Network net, bool reachable)
331 : : {
332 [ # # # # ]: 0 : if (net == NET_UNROUTABLE || net == NET_INTERNAL)
333 : 0 : return;
334 : 0 : LOCK(g_maplocalhost_mutex);
335 : 0 : vfLimited[net] = !reachable;
336 : 0 : }
337 : :
338 : 370768 : bool IsReachable(enum Network net)
339 : : {
340 : 370768 : LOCK(g_maplocalhost_mutex);
341 : 370768 : return !vfLimited[net];
342 : 370768 : }
343 : :
344 : 370758 : bool IsReachable(const CNetAddr &addr)
345 : : {
346 : 370758 : return IsReachable(addr.GetNetwork());
347 : : }
348 : :
349 : : /** vote for a local address */
350 : 0 : bool SeenLocal(const CService& addr)
351 : : {
352 : 0 : LOCK(g_maplocalhost_mutex);
353 [ # # ]: 0 : const auto it = mapLocalHost.find(addr);
354 [ # # ]: 0 : if (it == mapLocalHost.end()) return false;
355 : 0 : ++it->second.nScore;
356 : 0 : return true;
357 : 0 : }
358 : :
359 : :
360 : : /** check whether a given address is potentially local */
361 : 191 : bool IsLocal(const CService& addr)
362 : : {
363 : 191 : LOCK(g_maplocalhost_mutex);
364 [ + - ]: 191 : return mapLocalHost.count(addr) > 0;
365 : 191 : }
366 : :
367 : 100 : CNode* CConnman::FindNode(const CNetAddr& ip)
368 : : {
369 : 100 : LOCK(m_nodes_mutex);
370 [ + + ]: 1212 : for (CNode* pnode : m_nodes) {
371 [ + - + - : 1121 : if (static_cast<CNetAddr>(pnode->addr) == ip) {
+ + ]
372 : 9 : return pnode;
373 : : }
374 : : }
375 : 91 : return nullptr;
376 : 100 : }
377 : :
378 : 0 : CNode* CConnman::FindNode(const CSubNet& subNet)
379 : : {
380 : 0 : LOCK(m_nodes_mutex);
381 [ # # ]: 0 : for (CNode* pnode : m_nodes) {
382 [ # # # # : 0 : if (subNet.Match(static_cast<CNetAddr>(pnode->addr))) {
# # ]
383 : 0 : return pnode;
384 : : }
385 : : }
386 : 0 : return nullptr;
387 : 0 : }
388 : :
389 : 1591 : CNode* CConnman::FindNode(const std::string& addrName)
390 : : {
391 : 1591 : LOCK(m_nodes_mutex);
392 [ + + ]: 132408 : for (CNode* pnode : m_nodes) {
393 [ + + ]: 131002 : if (pnode->m_addr_name == addrName) {
394 : 185 : return pnode;
395 : : }
396 : : }
397 : 1406 : return nullptr;
398 : 1591 : }
399 : :
400 : 91 : CNode* CConnman::FindNode(const CService& addr)
401 : : {
402 : 91 : LOCK(m_nodes_mutex);
403 [ + + ]: 1186 : for (CNode* pnode : m_nodes) {
404 [ + - + - : 1095 : if (static_cast<CService>(pnode->addr) == addr) {
+ - ]
405 : 0 : return pnode;
406 : : }
407 : : }
408 : 91 : return nullptr;
409 : 91 : }
410 : :
411 : 100 : bool CConnman::AlreadyConnectedToAddress(const CAddress& addr)
412 : : {
413 [ + - + + : 100 : return FindNode(static_cast<CNetAddr>(addr)) || FindNode(addr.ToStringAddrPort());
+ - + - +
+ # # ]
414 : 0 : }
415 : :
416 : 2092 : bool CConnman::CheckIncomingNonce(uint64_t nonce)
417 : : {
418 : 2092 : LOCK(m_nodes_mutex);
419 [ + + ]: 7336 : for (const CNode* pnode : m_nodes) {
420 [ + + + - : 5313 : if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() == nonce)
+ + + - +
+ ]
421 : 69 : return false;
422 : : }
423 : 2023 : return true;
424 : 2092 : }
425 : :
426 : : /** Get the bind address for a socket as CAddress */
427 : 3 : static CAddress GetBindAddress(const Sock& sock)
428 : : {
429 : 16548 : CAddress addr_bind;
430 : : struct sockaddr_storage sockaddr_bind;
431 : 16548 : socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);
432 [ + - + + ]: 3 : if (!sock.GetSockName((struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {
433 [ + - ]: 2 : addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind);
434 : 2 : } else {
435 [ + - - + : 1 : LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "getsockname failed\n");
+ - + - -
+ ]
436 : : }
437 : 3 : return addr_bind;
438 [ + - ]: 3 : }
439 : :
440 : 98 : CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport)
441 : : {
442 : 98 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
443 [ + - ]: 98 : assert(conn_type != ConnectionType::INBOUND);
444 : :
445 [ + + ]: 98 : if (pszDest == nullptr) {
446 [ - + ]: 91 : if (IsLocal(addrConnect))
447 : 0 : return nullptr;
448 : :
449 : : // Look for an existing connection
450 [ + - ]: 91 : CNode* pnode = FindNode(static_cast<CService>(addrConnect));
451 [ - + ]: 91 : if (pnode)
452 : : {
453 [ # # # # : 0 : LogPrintf("Failed to open new connection, already connected\n");
# # ]
454 : 0 : return nullptr;
455 : : }
456 : 91 : }
457 : :
458 [ + - # # : 98 : LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying %s connection %s lastseen=%.1fhrs\n",
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
459 : : use_v2transport ? "v2" : "v1",
460 : : pszDest ? pszDest : addrConnect.ToStringAddrPort(),
461 : : Ticks<HoursDouble>(pszDest ? 0h : Now<NodeSeconds>() - addrConnect.nTime));
462 : :
463 : : // Resolve
464 [ + + + - : 189 : const uint16_t default_port{pszDest != nullptr ? GetDefaultPort(pszDest) :
+ - + + +
+ # # #
# ]
465 [ + - ]: 91 : m_params.GetDefaultPort()};
466 [ + + ]: 98 : if (pszDest) {
467 [ + - + - : 7 : const std::vector<CService> resolved{Lookup(pszDest, default_port, fNameLookup && !HaveNameProxy(), 256)};
+ - + - +
- ]
468 [ + - ]: 7 : if (!resolved.empty()) {
469 : 0 : const CService& rnd{resolved[GetRand(resolved.size())]};
470 [ # # # # ]: 0 : addrConnect = CAddress{MaybeFlipIPv6toCJDNS(rnd), NODE_NONE};
471 [ # # # # ]: 0 : if (!addrConnect.IsValid()) {
472 [ # # # # : 0 : LogPrint(BCLog::NET, "Resolver returned invalid address %s for %s\n", addrConnect.ToStringAddrPort(), pszDest);
# # # # #
# # # ]
473 : 0 : return nullptr;
474 : : }
475 : : // It is possible that we already have a connection to the IP/port pszDest resolved to.
476 : : // In that case, drop the connection that was just created.
477 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
478 [ # # # # ]: 0 : CNode* pnode = FindNode(static_cast<CService>(addrConnect));
479 [ # # ]: 0 : if (pnode) {
480 [ # # # # : 0 : LogPrintf("Failed to open new connection, already connected\n");
# # ]
481 : 0 : return nullptr;
482 : : }
483 [ # # ]: 0 : }
484 [ - - + ]: 7 : }
485 : :
486 : : // Connect
487 : 98 : bool connected = false;
488 : 98 : std::unique_ptr<Sock> sock;
489 [ + - ]: 98 : Proxy proxy;
490 [ + - ]: 98 : CAddress addr_bind;
491 [ + - + - ]: 98 : assert(!addr_bind.IsValid());
492 : 98 : std::unique_ptr<i2p::sam::Session> i2p_transient_session;
493 : :
494 [ + - + + ]: 98 : if (addrConnect.IsValid()) {
495 [ + - + - ]: 29 : const bool use_proxy{GetProxy(addrConnect.GetNetwork(), proxy)};
496 : 29 : bool proxyConnectionFailed = false;
497 : :
498 [ + - - + : 29 : if (addrConnect.IsI2P() && use_proxy) {
# # ]
499 [ # # ]: 0 : i2p::Connection conn;
500 : :
501 [ # # ]: 0 : if (m_i2p_sam_session) {
502 [ # # ]: 0 : connected = m_i2p_sam_session->Connect(addrConnect, conn, proxyConnectionFailed);
503 : 0 : } else {
504 : : {
505 [ # # # # ]: 0 : LOCK(m_unused_i2p_sessions_mutex);
506 [ # # # # ]: 0 : if (m_unused_i2p_sessions.empty()) {
507 : 0 : i2p_transient_session =
508 [ # # ]: 0 : std::make_unique<i2p::sam::Session>(proxy.proxy, &interruptNet);
509 : 0 : } else {
510 [ # # ]: 0 : i2p_transient_session.swap(m_unused_i2p_sessions.front());
511 [ # # ]: 0 : m_unused_i2p_sessions.pop();
512 : : }
513 : 0 : }
514 [ # # ]: 0 : connected = i2p_transient_session->Connect(addrConnect, conn, proxyConnectionFailed);
515 [ # # ]: 0 : if (!connected) {
516 [ # # # # ]: 0 : LOCK(m_unused_i2p_sessions_mutex);
517 [ # # # # ]: 0 : if (m_unused_i2p_sessions.size() < MAX_UNUSED_I2P_SESSIONS_SIZE) {
518 [ # # ]: 0 : m_unused_i2p_sessions.emplace(i2p_transient_session.release());
519 : 0 : }
520 : 0 : }
521 : : }
522 : :
523 [ # # ]: 0 : if (connected) {
524 : 0 : sock = std::move(conn.sock);
525 [ # # # # ]: 0 : addr_bind = CAddress{conn.me, NODE_NONE};
526 : 0 : }
527 [ - + ]: 29 : } else if (use_proxy) {
528 [ # # ]: 0 : sock = CreateSock(proxy.proxy);
529 [ # # ]: 0 : if (!sock) {
530 : 0 : return nullptr;
531 : : }
532 [ # # # # : 0 : connected = ConnectThroughProxy(proxy, addrConnect.ToStringAddr(), addrConnect.GetPort(),
# # ]
533 [ # # ]: 0 : *sock, nConnectTimeout, proxyConnectionFailed);
534 : 0 : } else {
535 : : // no proxy needed (none set for target network)
536 [ + - ]: 29 : sock = CreateSock(addrConnect);
537 [ + - ]: 29 : if (!sock) {
538 : 0 : return nullptr;
539 : : }
540 [ + - + - : 29 : connected = ConnectSocketDirectly(addrConnect, *sock, nConnectTimeout,
+ - ]
541 : 29 : conn_type == ConnectionType::MANUAL);
542 : : }
543 [ + - ]: 29 : if (!proxyConnectionFailed) {
544 : : // If a connection to the node was attempted, and failure (if any) is not caused by a problem connecting to
545 : : // the proxy, mark this as an attempt.
546 [ + - + - ]: 29 : addrman.Attempt(addrConnect, fCountFailure);
547 : 29 : }
548 [ + + + - : 98 : } else if (pszDest && GetNameProxy(proxy)) {
- + ]
549 [ # # ]: 0 : sock = CreateSock(proxy.proxy);
550 [ # # ]: 0 : if (!sock) {
551 : 0 : return nullptr;
552 : : }
553 : 0 : std::string host;
554 : 0 : uint16_t port{default_port};
555 [ # # # # ]: 0 : SplitHostPort(std::string(pszDest), port, host);
556 : : bool proxyConnectionFailed;
557 [ # # # # ]: 0 : connected = ConnectThroughProxy(proxy, host, port, *sock, nConnectTimeout,
558 : : proxyConnectionFailed);
559 : 0 : }
560 [ + + ]: 98 : if (!connected) {
561 : 95 : return nullptr;
562 : : }
563 : :
564 : : // Add node
565 [ + - ]: 3 : NodeId id = GetNewNodeId();
566 [ + - + - : 3 : uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
+ - ]
567 [ + - + - ]: 3 : if (!addr_bind.IsValid()) {
568 [ + - + - ]: 3 : addr_bind = GetBindAddress(*sock);
569 : 3 : }
570 [ + - + - : 6 : CNode* pnode = new CNode(id,
# # ]
571 [ + - ]: 3 : std::move(sock),
572 : : addrConnect,
573 [ + - ]: 3 : CalculateKeyedNetGroup(addrConnect),
574 : 3 : nonce,
575 : : addr_bind,
576 [ + + + - ]: 3 : pszDest ? pszDest : "",
577 : 3 : conn_type,
578 : : /*inbound_onion=*/false,
579 : 12 : CNodeOptions{
580 : 3 : .i2p_sam_session = std::move(i2p_transient_session),
581 : 3 : .recv_flood_size = nReceiveFloodSize,
582 : 3 : .use_v2transport = use_v2transport,
583 : : });
584 [ + - ]: 3 : pnode->AddRef();
585 : :
586 : : // We're making a new connection, harvest entropy from the time (and our peer count)
587 : 3 : RandAddEvent((uint32_t)id);
588 : :
589 : 3 : return pnode;
590 : 98 : }
591 : :
592 : 7123 : void CNode::CloseSocketDisconnect()
593 : : {
594 : 7123 : fDisconnect = true;
595 : 7123 : LOCK(m_sock_mutex);
596 [ + - + + ]: 7123 : if (m_sock) {
597 [ + - + - : 6104 : LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);
# # # # #
# ]
598 : 6104 : m_sock.reset();
599 : 6104 : }
600 : 7123 : m_i2p_sam_session.reset();
601 : 7123 : }
602 : :
603 : 548 : void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr) const {
604 [ - + ]: 548 : for (const auto& subnet : vWhitelistedRange) {
605 [ # # ]: 777 : if (subnet.m_subnet.Match(addr)) NetPermissions::AddFlag(flags, subnet.m_flags);
606 : : }
607 : 548 : }
608 : :
609 : 19252 : CService CNode::GetAddrLocal() const
610 : : {
611 : 19252 : AssertLockNotHeld(m_addr_local_mutex);
612 : 19252 : LOCK(m_addr_local_mutex);
613 [ + - ]: 19252 : return addrLocal;
614 : 19252 : }
615 : :
616 : 4284 : void CNode::SetAddrLocal(const CService& addrLocalIn) {
617 : 4284 : AssertLockNotHeld(m_addr_local_mutex);
618 : 4284 : LOCK(m_addr_local_mutex);
619 [ + - - + ]: 4284 : if (addrLocal.IsValid()) {
620 [ # # # # : 0 : error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());
# # ]
621 : 0 : } else {
622 [ + - ]: 4284 : addrLocal = addrLocalIn;
623 : : }
624 : 4284 : }
625 : 777 :
626 : 20555 : Network CNode::ConnectedThroughNetwork() const
627 : : {
628 [ + + ]: 20555 : return m_inbound_onion ? NET_ONION : addr.GetNetClass();
629 : : }
630 : :
631 : 0 : bool CNode::IsConnectedThroughPrivacyNet() const
632 : : {
633 [ # # ]: 777 : return m_inbound_onion || addr.IsPrivacyNet();
634 : : }
635 : :
636 : : #undef X
637 : : #define X(name) stats.name = name
638 : 15727 : void CNode::CopyStats(CNodeStats& stats)
639 : : {
640 : 15727 : stats.nodeid = this->GetId();
641 : 15727 : X(addr);
642 : 15727 : X(addrBind);
643 : 15727 : stats.m_network = ConnectedThroughNetwork();
644 : 15727 : X(m_last_send);
645 : 15727 : X(m_last_recv);
646 : 15727 : X(m_last_tx_time);
647 : 15727 : X(m_last_block_time);
648 : 15727 : X(m_connected);
649 : 15727 : X(nTimeOffset);
650 : 15727 : X(m_addr_name);
651 : 15727 : X(nVersion);
652 : : {
653 : 15727 : LOCK(m_subver_mutex);
654 [ + - ]: 15727 : X(cleanSubVer);
655 : 15727 : }
656 : 15727 : stats.fInbound = IsInboundConn();
657 : 15727 : X(m_bip152_highbandwidth_to);
658 : 15727 : X(m_bip152_highbandwidth_from);
659 : : {
660 : 15727 : LOCK(cs_vSend);
661 [ + - ]: 15727 : X(mapSendBytesPerMsgType);
662 : 15727 : X(nSendBytes);
663 : 15727 : }
664 : : {
665 : 15727 : LOCK(cs_vRecv);
666 [ + - ]: 15727 : X(mapRecvBytesPerMsgType);
667 : 15727 : X(nRecvBytes);
668 : 15727 : Transport::Info info = m_transport->GetInfo();
669 : 15727 : stats.m_transport_type = info.transport_type;
670 [ - + # # : 15727 : if (info.session_id) stats.m_session_id = HexStr(*info.session_id);
# # # # ]
671 : 15727 : }
672 : 15727 : X(m_permission_flags);
673 : :
674 : 15727 : X(m_last_ping_time);
675 : 15727 : X(m_min_ping_time);
676 : :
677 : : // Leave string empty if addrLocal invalid (not filled in yet)
678 : 15727 : CService addrLocalUnlocked = GetAddrLocal();
679 [ + - + + : 15727 : stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToStringAddrPort() : "";
+ - - + +
+ # # ]
680 : :
681 : 15727 : X(m_conn_type);
682 : 15727 : }
683 : : #undef X
684 : :
685 : 2599898 : bool CNode::ReceiveMsgBytes(Span<const uint8_t> msg_bytes, bool& complete)
686 : : {
687 : 2599898 : complete = false;
688 : 2599898 : const auto time = GetTime<std::chrono::microseconds>();
689 : 2599898 : LOCK(cs_vRecv);
690 [ + - ]: 2599898 : m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);
691 : 2599898 : nRecvBytes += msg_bytes.size();
692 [ + + ]: 5192379 : while (msg_bytes.size() > 0) {
693 : : // absorb network data
694 [ + - + + ]: 2605018 : if (!m_transport->ReceivedBytes(msg_bytes)) {
695 : : // Serious transport problem, disconnect from the peer.
696 : 12537 : return false;
697 : : }
698 : :
699 [ + - + + ]: 2592481 : if (m_transport->ReceivedMessageComplete()) {
700 : : // decompose a transport agnostic CNetMessage from the deserializer
701 : 1272248 : bool reject_message{false};
702 [ + - ]: 1272248 : CNetMessage msg = m_transport->GetReceivedMessage(time, reject_message);
703 [ + + ]: 1272248 : if (reject_message) {
704 : : // Message deserialization failed. Drop the message but don't disconnect the peer.
705 : : // store the size of the corrupt message
706 [ + - ]: 152609 : mapRecvBytesPerMsgType.at(NET_MESSAGE_TYPE_OTHER) += msg.m_raw_message_size;
707 : 152609 : continue;
708 : : }
709 : :
710 : : // Store received bytes per message type.
711 : : // To prevent a memory DOS, only allow known message types.
712 [ + - ]: 1119639 : auto i = mapRecvBytesPerMsgType.find(msg.m_type);
713 [ + + ]: 1119639 : if (i == mapRecvBytesPerMsgType.end()) {
714 [ + - ]: 95740 : i = mapRecvBytesPerMsgType.find(NET_MESSAGE_TYPE_OTHER);
715 : 110598 : }
716 [ - + ]: 1119639 : assert(i != mapRecvBytesPerMsgType.end());
717 : 1134497 : i->second += msg.m_raw_message_size;
718 : :
719 : : // push the message to the process queue,
720 [ + - ]: 1119639 : vRecvMsg.push_back(std::move(msg));
721 : :
722 : 1119639 : complete = true;
723 [ - + + ]: 1272248 : }
724 : 14858 : }
725 : :
726 [ + - ]: 2602219 : return true;
727 [ + - ]: 2614756 : }
728 : :
729 [ + - + - : 66180 : V1Transport::V1Transport(const NodeId node_id, int nTypeIn, int nVersionIn) noexcept :
+ - + - ]
730 [ + - + - ]: 47948 : m_node_id(node_id), hdrbuf(nTypeIn, nVersionIn), vRecv(nTypeIn, nVersionIn)
731 : 16545 : {
732 [ + - + - : 16545 : assert(std::size(Params().MessageStart()) == std::size(m_magic_bytes));
- + ]
733 [ + - + - ]: 16545 : m_magic_bytes = Params().MessageStart();
734 [ + - + - ]: 16545 : LOCK(m_recv_mutex);
735 [ + - ]: 16545 : Reset();
736 : 16545 : }
737 : :
738 : 18358 : Transport::Info V1Transport::GetInfo() const noexcept
739 : : {
740 : 33216 : return {.transport_type = TransportProtocolType::V1, .session_id = {}};
741 : : }
742 : :
743 : 1331417 : int V1Transport::readHeader(Span<const uint8_t> msg_bytes)
744 : : {
745 : 1331417 : AssertLockHeld(m_recv_mutex);
746 : 14858 : // copy data to temporary parsing buffer
747 : 1331417 : unsigned int nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
748 : 1331417 : unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
749 : :
750 : 1331417 : memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
751 : 1331417 : nHdrPos += nCopy;
752 : 14858 :
753 : : // if header incomplete, exit
754 [ + + ]: 1331417 : if (nHdrPos < CMessageHeader::HEADER_SIZE)
755 : 30320 : return nCopy;
756 : :
757 : 14858 : // deserialize to CMessageHeader
758 : : try {
759 [ + - ]: 1315955 : hdrbuf >> hdr;
760 [ # # ]: 1330813 : }
761 : 14858 : catch (const std::exception&) {
762 [ # # # # : 0 : LogPrint(BCLog::NET, "Header error: Unable to deserialize, peer=%d\n", m_node_id);
# # # # #
# ]
763 : 0 : return -1;
764 [ # # ]: 0 : }
765 : :
766 : : // Check start string, network magic
767 [ + + ]: 1315955 : if (hdr.pchMessageStart != m_magic_bytes) {
768 [ + - # # : 11503 : LogPrint(BCLog::NET, "Header error: Wrong MessageStart %s received, peer=%d\n", HexStr(hdr.pchMessageStart), m_node_id);
# # # # #
# # # ]
769 : 11503 : return -1;
770 : : }
771 : :
772 : : // reject messages larger than MAX_SIZE or MAX_PROTOCOL_MESSAGE_LENGTH
773 [ + + + + ]: 1304452 : if (hdr.nMessageSize > MAX_SIZE || hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
774 [ + - # # : 1067 : LogPrint(BCLog::NET, "Header error: Size too large (%s, %u bytes), peer=%d\n", SanitizeString(hdr.GetCommand()), hdr.nMessageSize, m_node_id);
# # # # #
# # # ]
775 : 1067 : return -1;
776 : : }
777 : :
778 : : // switch state to reading message data
779 : 1303385 : in_data = true;
780 : :
781 : 1303385 : return nCopy;
782 : 1331417 : }
783 : :
784 : 1330436 : int V1Transport::readData(Span<const uint8_t> msg_bytes)
785 : : {
786 : 1330436 : AssertLockHeld(m_recv_mutex);
787 : 1330436 : unsigned int nRemaining = hdr.nMessageSize - nDataPos;
788 : 1330436 : unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
789 : :
790 [ + + ]: 1330436 : if (vRecv.size() < nDataPos + nCopy) {
791 : : // Allocate up to 256 KiB ahead, but never more than the total message size.
792 : 1261922 : vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
793 : 1261922 : }
794 : :
795 : 1330436 : hasher.Write(msg_bytes.first(nCopy));
796 : 1330436 : memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
797 : 1330436 : nDataPos += nCopy;
798 : :
799 : 1330436 : return nCopy;
800 : : }
801 : :
802 : 1303321 : const uint256& V1Transport::GetMessageHash() const
803 : : {
804 : 1303321 : AssertLockHeld(m_recv_mutex);
805 [ + - ]: 1303321 : assert(CompleteInternal());
806 [ - + ]: 1303321 : if (data_hash.IsNull())
807 : 1303321 : hasher.Finalize(data_hash);
808 : 1303321 : return data_hash;
809 : : }
810 : :
811 : 1303321 : CNetMessage V1Transport::GetReceivedMessage(const std::chrono::microseconds time, bool& reject_message)
812 : : {
813 : 1303321 : AssertLockNotHeld(m_recv_mutex);
814 : : // Initialize out parameter
815 : 1303321 : reject_message = false;
816 : : // decompose a single CNetMessage from the TransportDeserializer
817 : 1303321 : LOCK(m_recv_mutex);
818 [ + - ]: 1303321 : CNetMessage msg(std::move(vRecv));
819 : :
820 : : // store message type string, time, and sizes
821 [ + - ]: 1303321 : msg.m_type = hdr.GetCommand();
822 : 1303321 : msg.m_time = time;
823 : 1303321 : msg.m_message_size = hdr.nMessageSize;
824 : 1303321 : msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
825 : :
826 [ + - ]: 1303321 : uint256 hash = GetMessageHash();
827 : :
828 : : // We just received a message off the wire, harvest entropy from the time (and the message checksum)
829 [ + - + - ]: 1303321 : RandAddEvent(ReadLE32(hash.begin()));
830 : :
831 : : // Check checksum and header message type string
832 [ + - + + ]: 1303321 : if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {
833 [ + - + - : 9240 : LogPrint(BCLog::NET, "Header error: Wrong checksum (%s, %u bytes), expected %s was %s, peer=%d\n",
# # # # #
# # # # #
# # # # ]
834 : : SanitizeString(msg.m_type), msg.m_message_size,
835 : : HexStr(Span{hash}.first(CMessageHeader::CHECKSUM_SIZE)),
836 : : HexStr(hdr.pchChecksum),
837 : : m_node_id);
838 : 9240 : reject_message = true;
839 [ + - + + ]: 1303321 : } else if (!hdr.IsCommandValid()) {
840 [ + - + - : 155417 : LogPrint(BCLog::NET, "Header error: Invalid message type (%s, %u bytes), peer=%d\n",
# # # # #
# # # #
# ]
841 : : SanitizeString(hdr.GetCommand()), msg.m_message_size, m_node_id);
842 : 155417 : reject_message = true;
843 : 155417 : }
844 : :
845 : : // Always reset the network deserializer (prepare for the next message)
846 [ + - ]: 1303321 : Reset();
847 : 1303321 : return msg;
848 [ + - ]: 1303321 : }
849 : :
850 : 1461742 : bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
851 : : {
852 [ + - ]: 1461742 : AssertLockNotHeld(m_send_mutex);
853 : : // Determine whether a new message can be set.
854 [ + - + - ]: 1461742 : LOCK(m_send_mutex);
855 [ + + + + ]: 1461742 : if (m_sending_header || m_bytes_sent < m_message_to_send.data.size()) return false;
856 : :
857 : : // create dbl-sha256 checksum
858 [ + - ]: 1439032 : uint256 hash = Hash(msg.data);
859 : :
860 : : // create header
861 [ + - ]: 1439032 : CMessageHeader hdr(m_magic_bytes, msg.m_type.c_str(), msg.data.size());
862 [ + - ]: 1439032 : memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
863 : :
864 : : // serialize header
865 : 1439032 : m_header_to_send.clear();
866 [ + - ]: 1439032 : CVectorWriter{INIT_PROTO_VERSION, m_header_to_send, 0, hdr};
867 : :
868 : : // update state
869 : 1439032 : m_message_to_send = std::move(msg);
870 : 1453890 : m_sending_header = true;
871 : 1439032 : m_bytes_sent = 0;
872 : 1453890 : return true;
873 : 1461742 : }
874 : :
875 : 5886791 : Transport::BytesToSend V1Transport::GetBytesToSend(bool have_next_message) const noexcept
876 : : {
877 [ + - ]: 5871933 : AssertLockNotHeld(m_send_mutex);
878 [ + - + - ]: 5871933 : LOCK(m_send_mutex);
879 [ + + ]: 5886791 : if (m_sending_header) {
880 [ + - ]: 2999997 : return {Span{m_header_to_send}.subspan(m_bytes_sent),
881 : : // We have more to send after the header if the message has payload, or if there
882 : : // is a next message after that.
883 [ + + ]: 1538806 : have_next_message || !m_message_to_send.data.empty(),
884 : 1523948 : m_message_to_send.m_type
885 : : };
886 : : } else {
887 [ + - ]: 4347985 : return {Span{m_message_to_send.data}.subspan(m_bytes_sent),
888 : : // We only have more to send after this message's payload if there is another
889 : : // message.
890 [ + - ]: 14858 : have_next_message,
891 : 4347985 : m_message_to_send.m_type
892 : : };
893 : : }
894 : 5871933 : }
895 : :
896 [ + - ]: 2861044 : void V1Transport::MarkBytesSent(size_t bytes_sent) noexcept
897 : : {
898 [ + - ]: 2846186 : AssertLockNotHeld(m_send_mutex);
899 [ + - + - : 2861044 : LOCK(m_send_mutex);
+ - ]
900 : 2846186 : m_bytes_sent += bytes_sent;
901 [ + + + + ]: 2846186 : if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {
902 : : // We're done sending a message's header. Switch to sending its data bytes.
903 : 1452580 : m_sending_header = false;
904 : 1437722 : m_bytes_sent = 0;
905 [ + + + + ]: 2846186 : } else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {
906 : : // We're done sending a message's data. Wipe the data vector to reduce memory consumption.
907 : 1392310 : ClearShrink(m_message_to_send.data);
908 : 1392310 : m_bytes_sent = 0;
909 : 1392310 : }
910 : 2846186 : }
911 : :
912 : 297417 : size_t V1Transport::GetSendMemoryUsage() const noexcept
913 : : {
914 [ + - ]: 297417 : AssertLockNotHeld(m_send_mutex);
915 [ + - + - ]: 297417 : LOCK(m_send_mutex);
916 : : // Don't count sending-side fields besides m_message_to_send, as they're all small and bounded.
917 : 297417 : return m_message_to_send.GetMemoryUsage();
918 : 297417 : }
919 : :
920 : : namespace {
921 : :
922 : : /** List of short messages as defined in BIP324, in order.
923 : : *
924 : : * Only message types that are actually implemented in this codebase need to be listed, as other
925 : : * messages get ignored anyway - whether we know how to decode them or not.
926 : : */
927 [ # # ]: 173 : const std::array<std::string, 33> V2_MESSAGE_IDS = {
928 [ + - ]: 173 : "", // 12 bytes follow encoding the message type like in V1
929 [ + - ]: 173 : NetMsgType::ADDR,
930 [ + - ]: 173 : NetMsgType::BLOCK,
931 [ + - ]: 173 : NetMsgType::BLOCKTXN,
932 [ + - ]: 173 : NetMsgType::CMPCTBLOCK,
933 [ + - ]: 173 : NetMsgType::FEEFILTER,
934 [ + - ]: 173 : NetMsgType::FILTERADD,
935 [ + - ]: 173 : NetMsgType::FILTERCLEAR,
936 [ + - ]: 173 : NetMsgType::FILTERLOAD,
937 [ + - ]: 173 : NetMsgType::GETBLOCKS,
938 [ + - ]: 173 : NetMsgType::GETBLOCKTXN,
939 [ + - ]: 173 : NetMsgType::GETDATA,
940 [ + - ]: 173 : NetMsgType::GETHEADERS,
941 [ + - ]: 173 : NetMsgType::HEADERS,
942 [ + - ]: 173 : NetMsgType::INV,
943 [ + - ]: 173 : NetMsgType::MEMPOOL,
944 [ + - ]: 173 : NetMsgType::MERKLEBLOCK,
945 [ + - ]: 173 : NetMsgType::NOTFOUND,
946 [ + - ]: 173 : NetMsgType::PING,
947 [ + - ]: 173 : NetMsgType::PONG,
948 [ + - ]: 173 : NetMsgType::SENDCMPCT,
949 [ + - ]: 173 : NetMsgType::TX,
950 [ + - ]: 173 : NetMsgType::GETCFILTERS,
951 [ + - ]: 173 : NetMsgType::CFILTER,
952 [ + - ]: 173 : NetMsgType::GETCFHEADERS,
953 [ + - ]: 173 : NetMsgType::CFHEADERS,
954 [ + - ]: 173 : NetMsgType::GETCFCHECKPT,
955 [ + - ]: 173 : NetMsgType::CFCHECKPT,
956 [ + - ]: 173 : NetMsgType::ADDRV2,
957 : : // Unimplemented message types that are assigned in BIP324:
958 [ + - ]: 173 : "",
959 [ + - ]: 173 : "",
960 [ + - ]: 173 : "",
961 [ + - ]: 173 : ""
962 : : };
963 : :
964 : : class V2MessageMap
965 : : {
966 : : std::unordered_map<std::string, uint8_t> m_map;
967 : :
968 : : public:
969 : 173 : V2MessageMap() noexcept
970 : : {
971 [ + + ]: 5709 : for (size_t i = 1; i < std::size(V2_MESSAGE_IDS); ++i) {
972 [ + - ]: 5536 : m_map.emplace(V2_MESSAGE_IDS[i], i);
973 : 5536 : }
974 : 173 : }
975 : :
976 : 1924 : std::optional<uint8_t> operator()(const std::string& message_name) const noexcept
977 : : {
978 [ + - ]: 1924 : auto it = m_map.find(message_name);
979 [ + + ]: 1924 : if (it == m_map.end()) return std::nullopt;
980 [ + - ]: 1136 : return it->second;
981 : 1924 : }
982 : : };
983 : 14858 :
984 : 173 : const V2MessageMap V2_MESSAGE_MAP;
985 : :
986 : 1 : CKey GenerateRandomKey() noexcept
987 : : {
988 : 1 : CKey key;
989 [ + - ]: 1 : key.MakeNewKey(/*fCompressed=*/true);
990 : 14859 : return key;
991 [ + - ]: 1 : }
992 : :
993 : 1 : std::vector<uint8_t> GenerateRandomGarbage() noexcept
994 : : {
995 : 1 : std::vector<uint8_t> ret;
996 : 1 : FastRandomContext rng;
997 [ + - ]: 1 : ret.resize(rng.randrange(V2Transport::MAX_GARBAGE_LEN + 1));
998 [ + - ]: 1 : rng.fillrand(MakeWritableByteSpan(ret));
999 : 1 : return ret;
1000 [ + - ]: 1 : }
1001 : :
1002 : : } // namespace
1003 : :
1004 : 552 : void V2Transport::StartSendingHandshake() noexcept
1005 : : {
1006 [ + - ]: 552 : AssertLockHeld(m_send_mutex);
1007 [ + - ]: 552 : Assume(m_send_state == SendState::AWAITING_KEY);
1008 [ + - ]: 552 : Assume(m_send_buffer.empty());
1009 : : // Initialize the send buffer with ellswift pubkey + provided garbage.
1010 [ + - + - ]: 552 : m_send_buffer.resize(EllSwiftPubKey::size() + m_send_garbage.size());
1011 [ + - + - : 552 : std::copy(std::begin(m_cipher.GetOurPubKey()), std::end(m_cipher.GetOurPubKey()), MakeWritableByteSpan(m_send_buffer).begin());
+ - ]
1012 [ + - + - ]: 552 : std::copy(m_send_garbage.begin(), m_send_garbage.end(), m_send_buffer.begin() + EllSwiftPubKey::size());
1013 : : // We cannot wipe m_send_garbage as it will still be used as AAD later in the handshake.
1014 : 552 : }
1015 : :
1016 : 3885 : V2Transport::V2Transport(NodeId nodeid, bool initiating, int type_in, int version_in, const CKey& key, Span<const std::byte> ent32, std::vector<uint8_t> garbage) noexcept :
1017 : 777 : m_cipher{key, ent32}, m_initiating{initiating}, m_nodeid{nodeid},
1018 : 1554 : m_v1_fallback{nodeid, type_in, version_in}, m_recv_type{type_in}, m_recv_version{version_in},
1019 : 777 : m_recv_state{initiating ? RecvState::KEY : RecvState::KEY_MAYBE_V1},
1020 : 777 : m_send_garbage{std::move(garbage)},
1021 : 777 : m_send_state{initiating ? SendState::AWAITING_KEY : SendState::MAYBE_V1}
1022 : 777 : {
1023 [ + - ]: 777 : Assume(m_send_garbage.size() <= MAX_GARBAGE_LEN);
1024 : : // Start sending immediately if we're the initiator of the connection.
1025 [ + + ]: 777 : if (initiating) {
1026 [ + - + - ]: 282 : LOCK(m_send_mutex);
1027 : 282 : StartSendingHandshake();
1028 : 282 : }
1029 : 777 : }
1030 : :
1031 : 1 : V2Transport::V2Transport(NodeId nodeid, bool initiating, int type_in, int version_in) noexcept :
1032 : 2 : V2Transport{nodeid, initiating, type_in, version_in, GenerateRandomKey(),
1033 : 2 : MakeByteSpan(GetRandHash()), GenerateRandomGarbage()} { }
1034 : :
1035 : 5932 : void V2Transport::SetReceiveState(RecvState recv_state) noexcept
1036 : : {
1037 [ + - ]: 5932 : AssertLockHeld(m_recv_mutex);
1038 : : // Enforce allowed state transitions.
1039 [ + + + + : 5932 : switch (m_recv_state) {
+ + - - ]
1040 : : case RecvState::KEY_MAYBE_V1:
1041 [ + + + - ]: 464 : Assume(recv_state == RecvState::KEY || recv_state == RecvState::V1);
1042 : 464 : break;
1043 : : case RecvState::KEY:
1044 [ + - ]: 540 : Assume(recv_state == RecvState::GARB_GARBTERM);
1045 : 540 : break;
1046 : : case RecvState::GARB_GARBTERM:
1047 [ + - ]: 540 : Assume(recv_state == RecvState::VERSION);
1048 : 540 : break;
1049 : : case RecvState::VERSION:
1050 [ + - ]: 540 : Assume(recv_state == RecvState::APP);
1051 : 540 : break;
1052 : : case RecvState::APP:
1053 [ + - ]: 1924 : Assume(recv_state == RecvState::APP_READY);
1054 : 1924 : break;
1055 : : case RecvState::APP_READY:
1056 [ + - ]: 1924 : Assume(recv_state == RecvState::APP);
1057 : 1924 : break;
1058 : : case RecvState::V1:
1059 [ # # ]: 0 : Assume(false); // V1 state cannot be left
1060 : 0 : break;
1061 : : }
1062 : : // Change state.
1063 : 5932 : m_recv_state = recv_state;
1064 : 5932 : }
1065 : :
1066 : 1004 : void V2Transport::SetSendState(SendState send_state) noexcept
1067 : : {
1068 [ + - ]: 1004 : AssertLockHeld(m_send_mutex);
1069 : : // Enforce allowed state transitions.
1070 [ + + - - ]: 1004 : switch (m_send_state) {
1071 : : case SendState::MAYBE_V1:
1072 [ + + + - ]: 464 : Assume(send_state == SendState::V1 || send_state == SendState::AWAITING_KEY);
1073 : 464 : break;
1074 : : case SendState::AWAITING_KEY:
1075 [ + - ]: 540 : Assume(send_state == SendState::READY);
1076 : 540 : break;
1077 : : case SendState::READY:
1078 : : case SendState::V1:
1079 [ # # ]: 0 : Assume(false); // Final states
1080 : 0 : break;
1081 : : }
1082 : : // Change state.
1083 : 1004 : m_send_state = send_state;
1084 : 1004 : }
1085 : :
1086 : 8815 : bool V2Transport::ReceivedMessageComplete() const noexcept
1087 : : {
1088 [ + - ]: 8815 : AssertLockNotHeld(m_recv_mutex);
1089 [ + - + - ]: 8815 : LOCK(m_recv_mutex);
1090 [ + + + - ]: 8815 : if (m_recv_state == RecvState::V1) return m_v1_fallback.ReceivedMessageComplete();
1091 : :
1092 : 4928 : return m_recv_state == RecvState::APP_READY;
1093 : 8815 : }
1094 : :
1095 : 516 : void V2Transport::ProcessReceivedMaybeV1Bytes() noexcept
1096 : : {
1097 [ + - ]: 516 : AssertLockHeld(m_recv_mutex);
1098 [ + - ]: 516 : AssertLockNotHeld(m_send_mutex);
1099 [ + - ]: 516 : Assume(m_recv_state == RecvState::KEY_MAYBE_V1);
1100 : : // We still have to determine if this is a v1 or v2 connection. The bytes being received could
1101 : : // be the beginning of either a v1 packet (network magic + "version\x00"), or of a v2 public
1102 : : // key. BIP324 specifies that a mismatch with this 12-byte string should trigger sending of the
1103 : : // key.
1104 : 516 : std::array<uint8_t, V1_PREFIX_LEN> v1_prefix = {0, 0, 0, 0, 'v', 'e', 'r', 's', 'i', 'o', 'n', 0};
1105 [ + - + - : 516 : std::copy(std::begin(Params().MessageStart()), std::end(Params().MessageStart()), v1_prefix.begin());
+ - + - +
- + - +
- ]
1106 [ + - ]: 516 : Assume(m_recv_buffer.size() <= v1_prefix.size());
1107 [ + - + + ]: 516 : if (!std::equal(m_recv_buffer.begin(), m_recv_buffer.end(), v1_prefix.begin())) {
1108 : : // Mismatch with v1 prefix, so we can assume a v2 connection.
1109 : 270 : SetReceiveState(RecvState::KEY); // Convert to KEY state, leaving received bytes around.
1110 : : // Transition the sender to AWAITING_KEY state and start sending.
1111 [ + - + - ]: 270 : LOCK(m_send_mutex);
1112 : 270 : SetSendState(SendState::AWAITING_KEY);
1113 : 270 : StartSendingHandshake();
1114 [ + + ]: 516 : } else if (m_recv_buffer.size() == v1_prefix.size()) {
1115 : : // Full match with the v1 prefix, so fall back to v1 behavior.
1116 [ + - + - ]: 194 : LOCK(m_send_mutex);
1117 [ + - ]: 194 : Span<const uint8_t> feedback{m_recv_buffer};
1118 : : // Feed already received bytes to v1 transport. It should always accept these, because it's
1119 : : // less than the size of a v1 header, and these are the first bytes fed to m_v1_fallback.
1120 [ + - ]: 194 : bool ret = m_v1_fallback.ReceivedBytes(feedback);
1121 [ + - ]: 194 : Assume(feedback.empty());
1122 [ + - ]: 194 : Assume(ret);
1123 : 194 : SetReceiveState(RecvState::V1);
1124 : 194 : SetSendState(SendState::V1);
1125 : : // Reset v2 transport buffers to save memory.
1126 : 194 : ClearShrink(m_recv_buffer);
1127 : 194 : ClearShrink(m_send_buffer);
1128 : 194 : } else {
1129 : : // We have not received enough to distinguish v1 from v2 yet. Wait until more bytes come.
1130 : : }
1131 : 516 : }
1132 : :
1133 : 1028 : bool V2Transport::ProcessReceivedKeyBytes() noexcept
1134 : : {
1135 [ + - ]: 1028 : AssertLockHeld(m_recv_mutex);
1136 [ + - ]: 1028 : AssertLockNotHeld(m_send_mutex);
1137 [ + - ]: 1028 : Assume(m_recv_state == RecvState::KEY);
1138 [ + - + - ]: 1028 : Assume(m_recv_buffer.size() <= EllSwiftPubKey::size());
1139 : :
1140 : : // As a special exception, if bytes 4-16 of the key on a responder connection match the
1141 : : // corresponding bytes of a V1 version message, but bytes 0-4 don't match the network magic
1142 : : // (if they did, we'd have switched to V1 state already), assume this is a peer from
1143 : : // another network, and disconnect them. They will almost certainly disconnect us too when
1144 : : // they receive our uniformly random key and garbage, but detecting this case specially
1145 : : // means we can log it.
1146 : : static constexpr std::array<uint8_t, 12> MATCH = {'v', 'e', 'r', 's', 'i', 'o', 'n', 0, 0, 0, 0, 0};
1147 : : static constexpr size_t OFFSET = std::tuple_size_v<MessageStartChars>;
1148 [ + + + + ]: 1028 : if (!m_initiating && m_recv_buffer.size() >= OFFSET + MATCH.size()) {
1149 [ + - - + ]: 617 : if (std::equal(MATCH.begin(), MATCH.end(), m_recv_buffer.begin() + OFFSET)) {
1150 [ # # # # : 0 : LogPrint(BCLog::NET, "V2 transport error: V1 peer with wrong MessageStart %s\n",
# # # # #
# # # #
# ]
1151 : : HexStr(Span(m_recv_buffer).first(OFFSET)));
1152 : 0 : return false;
1153 : : }
1154 : 617 : }
1155 : :
1156 [ + - + + ]: 1028 : if (m_recv_buffer.size() == EllSwiftPubKey::size()) {
1157 : : // Other side's key has been fully received, and can now be Diffie-Hellman combined with
1158 : : // our key to initialize the encryption ciphers.
1159 : :
1160 : : // Initialize the ciphers.
1161 : 540 : EllSwiftPubKey ellswift(MakeByteSpan(m_recv_buffer));
1162 [ + - + - ]: 540 : LOCK(m_send_mutex);
1163 : 540 : m_cipher.Initialize(ellswift, m_initiating);
1164 : :
1165 : : // Switch receiver state to GARB_GARBTERM.
1166 : 540 : SetReceiveState(RecvState::GARB_GARBTERM);
1167 : 540 : m_recv_buffer.clear();
1168 : :
1169 : : // Switch sender state to READY.
1170 : 540 : SetSendState(SendState::READY);
1171 : :
1172 : : // Append the garbage terminator to the send buffer.
1173 [ + - ]: 540 : m_send_buffer.resize(m_send_buffer.size() + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1174 [ + - + - ]: 1080 : std::copy(m_cipher.GetSendGarbageTerminator().begin(),
1175 : 540 : m_cipher.GetSendGarbageTerminator().end(),
1176 : 540 : MakeWritableByteSpan(m_send_buffer).last(BIP324Cipher::GARBAGE_TERMINATOR_LEN).begin());
1177 : :
1178 : : // Construct version packet in the send buffer, with the sent garbage data as AAD.
1179 [ + - ]: 540 : m_send_buffer.resize(m_send_buffer.size() + BIP324Cipher::EXPANSION + VERSION_CONTENTS.size());
1180 : 540 : m_cipher.Encrypt(
1181 [ + - ]: 540 : /*contents=*/VERSION_CONTENTS,
1182 : 540 : /*aad=*/MakeByteSpan(m_send_garbage),
1183 : : /*ignore=*/false,
1184 : 540 : /*output=*/MakeWritableByteSpan(m_send_buffer).last(BIP324Cipher::EXPANSION + VERSION_CONTENTS.size()));
1185 : : // We no longer need the garbage.
1186 : 540 : ClearShrink(m_send_garbage);
1187 : 540 : } else {
1188 : : // We still have to receive more key bytes.
1189 : : }
1190 : 1028 : return true;
1191 : 1028 : }
1192 : :
1193 : 9945 : bool V2Transport::ProcessReceivedGarbageBytes() noexcept
1194 : : {
1195 [ + - ]: 9945 : AssertLockHeld(m_recv_mutex);
1196 [ + - ]: 9945 : Assume(m_recv_state == RecvState::GARB_GARBTERM);
1197 [ + - ]: 9945 : Assume(m_recv_buffer.size() <= MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1198 [ + + ]: 9945 : if (m_recv_buffer.size() >= BIP324Cipher::GARBAGE_TERMINATOR_LEN) {
1199 [ + + ]: 1845 : if (MakeByteSpan(m_recv_buffer).last(BIP324Cipher::GARBAGE_TERMINATOR_LEN) == m_cipher.GetReceiveGarbageTerminator()) {
1200 : : // Garbage terminator received. Store garbage to authenticate it as AAD later.
1201 : 540 : m_recv_aad = std::move(m_recv_buffer);
1202 [ + - ]: 540 : m_recv_aad.resize(m_recv_aad.size() - BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1203 : 540 : m_recv_buffer.clear();
1204 : 540 : SetReceiveState(RecvState::VERSION);
1205 [ - + ]: 1845 : } else if (m_recv_buffer.size() == MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN) {
1206 : : // We've reached the maximum length for garbage + garbage terminator, and the
1207 : : // terminator still does not match. Abort.
1208 [ # # # # : 0 : LogPrint(BCLog::NET, "V2 transport error: missing garbage terminator, peer=%d\n", m_nodeid);
# # # # #
# ]
1209 : 0 : return false;
1210 : : } else {
1211 : : // We still need to receive more garbage and/or garbage terminator bytes.
1212 : : }
1213 : 1845 : } else {
1214 : : // We have less than GARBAGE_TERMINATOR_LEN (16) bytes, so we certainly need to receive
1215 : : // more first.
1216 : : }
1217 : 9945 : return true;
1218 : 9945 : }
1219 : :
1220 : 6593 : bool V2Transport::ProcessReceivedPacketBytes() noexcept
1221 : : {
1222 [ + - ]: 6593 : AssertLockHeld(m_recv_mutex);
1223 [ + + + - ]: 6593 : Assume(m_recv_state == RecvState::VERSION || m_recv_state == RecvState::APP);
1224 : :
1225 : : // The maximum permitted contents length for a packet, consisting of:
1226 : : // - 0x00 byte: indicating long message type encoding
1227 : : // - 12 bytes of message type
1228 : : // - payload
1229 : : static constexpr size_t MAX_CONTENTS_LEN =
1230 : : 1 + CMessageHeader::COMMAND_SIZE +
1231 : : std::min<size_t>(MAX_SIZE, MAX_PROTOCOL_MESSAGE_LENGTH);
1232 : :
1233 [ + + ]: 6593 : if (m_recv_buffer.size() == BIP324Cipher::LENGTH_LEN) {
1234 : : // Length descriptor received.
1235 : 2464 : m_recv_len = m_cipher.DecryptLength(MakeByteSpan(m_recv_buffer));
1236 [ - + ]: 2464 : if (m_recv_len > MAX_CONTENTS_LEN) {
1237 [ # # # # : 0 : LogPrint(BCLog::NET, "V2 transport error: packet too large (%u bytes), peer=%d\n", m_recv_len, m_nodeid);
# # # # #
# ]
1238 : 0 : return false;
1239 : : }
1240 [ + + + + ]: 6593 : } else if (m_recv_buffer.size() > BIP324Cipher::LENGTH_LEN && m_recv_buffer.size() == m_recv_len + BIP324Cipher::EXPANSION) {
1241 : : // Ciphertext received, decrypt it into m_recv_decode_buffer.
1242 : : // Note that it is impossible to reach this branch without hitting the branch above first,
1243 : : // as GetMaxBytesToProcess only allows up to LENGTH_LEN into the buffer before that point.
1244 [ + - ]: 2464 : m_recv_decode_buffer.resize(m_recv_len);
1245 : 2464 : bool ignore{false};
1246 : 4928 : bool ret = m_cipher.Decrypt(
1247 : 2464 : /*input=*/MakeByteSpan(m_recv_buffer).subspan(BIP324Cipher::LENGTH_LEN),
1248 : 2464 : /*aad=*/MakeByteSpan(m_recv_aad),
1249 : : /*ignore=*/ignore,
1250 : 2464 : /*contents=*/MakeWritableByteSpan(m_recv_decode_buffer));
1251 [ + - ]: 2464 : if (!ret) {
1252 [ # # # # : 0 : LogPrint(BCLog::NET, "V2 transport error: packet decryption failure (%u bytes), peer=%d\n", m_recv_len, m_nodeid);
# # # # #
# ]
1253 : 0 : return false;
1254 : : }
1255 : : // We have decrypted a valid packet with the AAD we expected, so clear the expected AAD.
1256 : 2464 : ClearShrink(m_recv_aad);
1257 : : // Feed the last 4 bytes of the Poly1305 authentication tag (and its timing) into our RNG.
1258 [ + - ]: 2464 : RandAddEvent(ReadLE32(m_recv_buffer.data() + m_recv_buffer.size() - 4));
1259 : :
1260 : : // At this point we have a valid packet decrypted into m_recv_decode_buffer. If it's not a
1261 : : // decoy, which we simply ignore, use the current state to decide what to do with it.
1262 [ - + ]: 2464 : if (!ignore) {
1263 [ - + + ]: 2464 : switch (m_recv_state) {
1264 : : case RecvState::VERSION:
1265 : : // Version message received; transition to application phase. The contents is
1266 : : // ignored, but can be used for future extensions.
1267 : 540 : SetReceiveState(RecvState::APP);
1268 : 540 : break;
1269 : : case RecvState::APP:
1270 : : // Application message decrypted correctly. It can be extracted using GetMessage().
1271 : 1924 : SetReceiveState(RecvState::APP_READY);
1272 : 1924 : break;
1273 : : default:
1274 : : // Any other state is invalid (this function should not have been called).
1275 [ # # ]: 0 : Assume(false);
1276 : 0 : }
1277 : 2464 : }
1278 : : // Wipe the receive buffer where the next packet will be received into.
1279 : 2464 : ClearShrink(m_recv_buffer);
1280 : : // In all but APP_READY state, we can wipe the decoded contents.
1281 [ + + ]: 2464 : if (m_recv_state != RecvState::APP_READY) ClearShrink(m_recv_decode_buffer);
1282 : 2464 : } else {
1283 : : // We either have less than 3 bytes, so we don't know the packet's length yet, or more
1284 : : // than 3 bytes but less than the packet's full ciphertext. Wait until those arrive.
1285 : : }
1286 : 6593 : return true;
1287 : 6593 : }
1288 : :
1289 : 19789 : size_t V2Transport::GetMaxBytesToProcess() noexcept
1290 : : {
1291 [ + - ]: 19789 : AssertLockHeld(m_recv_mutex);
1292 [ + + - - : 19789 : switch (m_recv_state) {
+ + + ]
1293 : : case RecvState::KEY_MAYBE_V1:
1294 : : // During the KEY_MAYBE_V1 state we do not allow more than the length of v1 prefix into the
1295 : : // receive buffer.
1296 [ + - ]: 516 : Assume(m_recv_buffer.size() <= V1_PREFIX_LEN);
1297 : : // As long as we're not sure if this is a v1 or v2 connection, don't receive more than what
1298 : : // is strictly necessary to distinguish the two (12 bytes). If we permitted more than
1299 : : // the v1 header size (24 bytes), we may not be able to feed the already-received bytes
1300 : : // back into the m_v1_fallback V1 transport.
1301 : 516 : return V1_PREFIX_LEN - m_recv_buffer.size();
1302 : : case RecvState::KEY:
1303 : : // During the KEY state, we only allow the 64-byte key into the receive buffer.
1304 [ + - + - ]: 1028 : Assume(m_recv_buffer.size() <= EllSwiftPubKey::size());
1305 : : // As long as we have not received the other side's public key, don't receive more than
1306 : : // that (64 bytes), as garbage follows, and locating the garbage terminator requires the
1307 : : // key exchange first.
1308 [ + - ]: 1028 : return EllSwiftPubKey::size() - m_recv_buffer.size();
1309 : : case RecvState::GARB_GARBTERM:
1310 : : // Process garbage bytes one by one (because terminator may appear anywhere).
1311 : 9945 : return 1;
1312 : : case RecvState::VERSION:
1313 : : case RecvState::APP:
1314 : : // These three states all involve decoding a packet. Process the length descriptor first,
1315 : : // so that we know where the current packet ends (and we don't process bytes from the next
1316 : : // packet or decoy yet). Then, process the ciphertext bytes of the current packet.
1317 [ + + ]: 6593 : if (m_recv_buffer.size() < BIP324Cipher::LENGTH_LEN) {
1318 : 2504 : return BIP324Cipher::LENGTH_LEN - m_recv_buffer.size();
1319 : : } else {
1320 : : // Note that BIP324Cipher::EXPANSION is the total difference between contents size
1321 : : // and encoded packet size, which includes the 3 bytes due to the packet length.
1322 : : // When transitioning from receiving the packet length to receiving its ciphertext,
1323 : : // the encrypted packet length is left in the receive buffer.
1324 : 4089 : return BIP324Cipher::EXPANSION + m_recv_len - m_recv_buffer.size();
1325 : : }
1326 : : case RecvState::APP_READY:
1327 : : // No bytes can be processed until GetMessage() is called.
1328 : 1707 : return 0;
1329 : : case RecvState::V1:
1330 : : // Not allowed (must be dealt with by the caller).
1331 [ # # ]: 0 : Assume(false);
1332 : 0 : return 0;
1333 : : }
1334 [ # # ]: 0 : Assume(false); // unreachable
1335 : 0 : return 0;
1336 : 19789 : }
1337 : :
1338 : 18671 : bool V2Transport::ReceivedBytes(Span<const uint8_t>& msg_bytes) noexcept
1339 : : {
1340 [ + + ]: 28527 : AssertLockNotHeld(m_recv_mutex);
1341 : : /** How many bytes to allocate in the receive buffer at most above what is received so far. */
1342 : : static constexpr size_t MAX_RESERVE_AHEAD = 256 * 1024;
1343 : :
1344 [ + - + - ]: 8815 : LOCK(m_recv_mutex);
1345 [ + + + - ]: 8815 : if (m_recv_state == RecvState::V1) return m_v1_fallback.ReceivedBytes(msg_bytes);
1346 : :
1347 : : // Process the provided bytes in msg_bytes in a loop. In each iteration a nonzero number of
1348 : : // bytes (decided by GetMaxBytesToProcess) are taken from the beginning om msg_bytes, and
1349 : : // appended to m_recv_buffer. Then, depending on the receiver state, one of the
1350 : : // ProcessReceived*Bytes functions is called to process the bytes in that buffer.
1351 [ + + ]: 23010 : while (!msg_bytes.empty()) {
1352 : : // Decide how many bytes to copy from msg_bytes to m_recv_buffer.
1353 : 19789 : size_t max_read = GetMaxBytesToProcess();
1354 : :
1355 : : // Reserve space in the buffer if there is not enough.
1356 [ + - + + ]: 19789 : if (m_recv_buffer.size() + std::min(msg_bytes.size(), max_read) > m_recv_buffer.capacity()) {
1357 [ - - + - ]: 5662 : switch (m_recv_state) {
1358 : : case RecvState::KEY_MAYBE_V1:
1359 : : case RecvState::KEY:
1360 : : case RecvState::GARB_GARBTERM:
1361 : : // During the initial states (key/garbage), allocate once to fit the maximum (4111
1362 : : // bytes).
1363 [ + + ]: 5662 : m_recv_buffer.reserve(MAX_GARBAGE_LEN + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1364 : 734 : break;
1365 : : case RecvState::VERSION:
1366 : : case RecvState::APP: {
1367 : : // During states where a packet is being received, as much as is expected but never
1368 : : // more than MAX_RESERVE_AHEAD bytes in addition to what is received so far.
1369 : : // This means attackers that want to cause us to waste allocated memory are limited
1370 : : // to MAX_RESERVE_AHEAD above the largest allowed message contents size, and to
1371 : : // MAX_RESERVE_AHEAD more than they've actually sent us.
1372 [ + + ]: 0 : size_t alloc_add = std::min(max_read, msg_bytes.size() + MAX_RESERVE_AHEAD);
1373 [ + - ]: 4928 : m_recv_buffer.reserve(m_recv_buffer.size() + alloc_add);
1374 : 4928 : break;
1375 : : }
1376 : : case RecvState::APP_READY:
1377 : : // The buffer is empty in this state.
1378 [ # # ]: 0 : Assume(m_recv_buffer.empty());
1379 : 0 : break;
1380 : : case RecvState::V1:
1381 : : // Should have bailed out above.
1382 [ # # ]: 0 : Assume(false);
1383 : 0 : break;
1384 : : }
1385 : 5662 : }
1386 : :
1387 : : // Can't read more than provided input.
1388 [ + - ]: 19789 : max_read = std::min(msg_bytes.size(), max_read);
1389 : : // Copy data to buffer.
1390 [ + - + - : 19789 : m_recv_buffer.insert(m_recv_buffer.end(), UCharCast(msg_bytes.data()), UCharCast(msg_bytes.data() + max_read));
+ - ]
1391 : 19789 : msg_bytes = msg_bytes.subspan(max_read);
1392 : :
1393 : : // Process data in the buffer.
1394 [ - + - + : 19789 : switch (m_recv_state) {
+ + + ]
1395 : : case RecvState::KEY_MAYBE_V1:
1396 : 516 : ProcessReceivedMaybeV1Bytes();
1397 [ + + ]: 516 : if (m_recv_state == RecvState::V1) return true;
1398 : 322 : break;
1399 : :
1400 : : case RecvState::KEY:
1401 [ + - ]: 1028 : if (!ProcessReceivedKeyBytes()) return false;
1402 : 1712 : break;
1403 : 684 :
1404 : : case RecvState::GARB_GARBTERM:
1405 [ + - ]: 9945 : if (!ProcessReceivedGarbageBytes()) return false;
1406 : 10629 : break;
1407 [ + - ]: 684 :
1408 : : case RecvState::VERSION:
1409 : : case RecvState::APP:
1410 [ + - ]: 6593 : if (!ProcessReceivedPacketBytes()) return false;
1411 : 6593 : break;
1412 : :
1413 : : case RecvState::APP_READY:
1414 : 1707 : return true;
1415 : :
1416 : : case RecvState::V1:
1417 : 684 : // We should have bailed out before.
1418 [ # # ]: 684 : Assume(false);
1419 : 0 : break;
1420 : : }
1421 : 684 : // Make sure we have made progress before continuing.
1422 [ + - ]: 18572 : Assume(max_read > 0);
1423 : : }
1424 : :
1425 : 3221 : return true;
1426 : 8815 : }
1427 : :
1428 : 1924 : std::optional<std::string> V2Transport::GetMessageType(Span<const uint8_t>& contents) noexcept
1429 : : {
1430 [ + - ]: 1924 : if (contents.size() == 0) return std::nullopt; // Empty contents
1431 : 1924 : uint8_t first_byte = contents[0];
1432 : 1924 : contents = contents.subspan(1); // Strip first byte.
1433 : :
1434 [ + + ]: 1924 : if (first_byte != 0) {
1435 : 684 : // Short (1 byte) encoding.
1436 [ + - ]: 1820 : if (first_byte < std::size(V2_MESSAGE_IDS)) {
1437 : : // Valid short message id.
1438 [ + - ]: 1136 : return V2_MESSAGE_IDS[first_byte];
1439 : 684 : } else {
1440 : : // Unknown short message id.
1441 : 0 : return std::nullopt;
1442 : : }
1443 : : }
1444 : :
1445 [ - + ]: 788 : if (contents.size() < CMessageHeader::COMMAND_SIZE) {
1446 : 0 : return std::nullopt; // Long encoding needs 12 message type bytes.
1447 : : }
1448 : :
1449 [ + - ]: 1050 : size_t msg_type_len{0};
1450 [ + + + + ]: 6054 : while (msg_type_len < CMessageHeader::COMMAND_SIZE && contents[msg_type_len] != 0) {
1451 : : // Verify that message type bytes before the first 0x00 are in range.
1452 [ + - + - ]: 5266 : if (contents[msg_type_len] < ' ' || contents[msg_type_len] > 0x7F) {
1453 : 0 : return {};
1454 : : }
1455 : 5266 : ++msg_type_len;
1456 : : }
1457 [ + - ]: 788 : std::string ret{reinterpret_cast<const char*>(contents.data()), msg_type_len};
1458 [ + + ]: 4978 : while (msg_type_len < CMessageHeader::COMMAND_SIZE) {
1459 : : // Verify that message type bytes after the first 0x00 are also 0x00.
1460 [ + - ]: 4190 : if (contents[msg_type_len] != 0) return {};
1461 : 4190 : ++msg_type_len;
1462 : : }
1463 : : // Strip message type bytes of contents.
1464 : 788 : contents = contents.subspan(CMessageHeader::COMMAND_SIZE);
1465 [ + - ]: 788 : return {std::move(ret)};
1466 : 1924 : }
1467 : :
1468 : 3870 : CNetMessage V2Transport::GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) noexcept
1469 : : {
1470 [ + - ]: 3870 : AssertLockNotHeld(m_recv_mutex);
1471 [ + - + - ]: 3870 : LOCK(m_recv_mutex);
1472 [ + + + - ]: 3870 : if (m_recv_state == RecvState::V1) return m_v1_fallback.GetReceivedMessage(time, reject_message);
1473 : :
1474 [ + - ]: 1924 : Assume(m_recv_state == RecvState::APP_READY);
1475 [ + - ]: 1924 : Span<const uint8_t> contents{m_recv_decode_buffer};
1476 : 1924 : auto msg_type = GetMessageType(contents);
1477 [ + - ]: 1924 : CDataStream ret(m_recv_type, m_recv_version);
1478 [ + - ]: 1924 : CNetMessage msg{std::move(ret)};
1479 : : // Note that BIP324Cipher::EXPANSION also includes the length descriptor size.
1480 : 1924 : msg.m_raw_message_size = m_recv_decode_buffer.size() + BIP324Cipher::EXPANSION;
1481 [ + - ]: 1924 : if (msg_type) {
1482 : 1924 : reject_message = false;
1483 [ + - ]: 1924 : msg.m_type = std::move(*msg_type);
1484 : 1924 : msg.m_time = time;
1485 : 1924 : msg.m_message_size = contents.size();
1486 [ + - ]: 1924 : msg.m_recv.resize(contents.size());
1487 [ + - + - : 1924 : std::copy(contents.begin(), contents.end(), UCharCast(msg.m_recv.data()));
+ - ]
1488 : 1924 : } else {
1489 [ # # # # : 0 : LogPrint(BCLog::NET, "V2 transport error: invalid message type (%u bytes contents), peer=%d\n", m_recv_decode_buffer.size(), m_nodeid);
# # # # #
# ]
1490 : 0 : reject_message = true;
1491 : : }
1492 : 1924 : ClearShrink(m_recv_decode_buffer);
1493 : 1924 : SetReceiveState(RecvState::APP);
1494 : :
1495 : 1924 : return msg;
1496 [ + - ]: 3870 : }
1497 : :
1498 : 12659 : bool V2Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
1499 : : {
1500 [ + - ]: 12659 : AssertLockNotHeld(m_send_mutex);
1501 [ + - + - ]: 12659 : LOCK(m_send_mutex);
1502 [ + + ]: 12659 : if (m_send_state == SendState::V1) return m_v1_fallback.SetMessageToSend(msg);
1503 : : // We only allow adding a new message to be sent when in the READY state (so the packet cipher
1504 : : // is available) and the send buffer is empty. This limits the number of messages in the send
1505 : : // buffer to just one, and leaves the responsibility for queueing them up to the caller.
1506 [ + + + + ]: 11420 : if (!(m_send_state == SendState::READY && m_send_buffer.empty())) return false;
1507 : : // Construct contents (encoding message type + payload).
1508 : 1924 : std::vector<uint8_t> contents;
1509 : 1924 : auto short_message_id = V2_MESSAGE_MAP(msg.m_type);
1510 [ + + ]: 1924 : if (short_message_id) {
1511 [ + - ]: 1136 : contents.resize(1 + msg.data.size());
1512 [ + - ]: 1136 : contents[0] = *short_message_id;
1513 [ + - ]: 1136 : std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1);
1514 : 1820 : } else {
1515 : : // Initialize with zeroes, and then write the message type string starting at offset 1.
1516 : : // This means contents[0] and the unused positions in contents[1..13] remain 0x00.
1517 [ + - ]: 788 : contents.resize(1 + CMessageHeader::COMMAND_SIZE + msg.data.size(), 0);
1518 [ + - ]: 788 : std::copy(msg.m_type.begin(), msg.m_type.end(), contents.data() + 1);
1519 [ + - ]: 788 : std::copy(msg.data.begin(), msg.data.end(), contents.begin() + 1 + CMessageHeader::COMMAND_SIZE);
1520 : : }
1521 : : // Construct ciphertext in send buffer.
1522 [ + - ]: 1924 : m_send_buffer.resize(contents.size() + BIP324Cipher::EXPANSION);
1523 : 1924 : m_cipher.Encrypt(MakeByteSpan(contents), {}, false, MakeWritableByteSpan(m_send_buffer));
1524 [ + - ]: 1924 : m_send_type = msg.m_type;
1525 : : // Release memory
1526 : 1924 : ClearShrink(msg.data);
1527 : 1924 : return true;
1528 : 12659 : }
1529 : :
1530 : 103923 : Transport::BytesToSend V2Transport::GetBytesToSend(bool have_next_message) const noexcept
1531 : : {
1532 [ + - ]: 103923 : AssertLockNotHeld(m_send_mutex);
1533 [ + - + - ]: 103923 : LOCK(m_send_mutex);
1534 [ + + ]: 103923 : if (m_send_state == SendState::V1) return m_v1_fallback.GetBytesToSend(have_next_message);
1535 : :
1536 [ + + + - ]: 83709 : if (m_send_state == SendState::MAYBE_V1) Assume(m_send_buffer.empty());
1537 [ + - ]: 83709 : Assume(m_send_pos <= m_send_buffer.size());
1538 : 83709 : return {
1539 [ + - ]: 83709 : Span{m_send_buffer}.subspan(m_send_pos),
1540 : : // We only have more to send after the current m_send_buffer if there is a (next)
1541 : : // message to be sent, and we're capable of sending packets. */
1542 [ + + ]: 83709 : have_next_message && m_send_state == SendState::READY,
1543 : 83709 : m_send_type
1544 : : };
1545 : 103923 : }
1546 : :
1547 : 10304 : void V2Transport::MarkBytesSent(size_t bytes_sent) noexcept
1548 : : {
1549 [ + - ]: 9620 : AssertLockNotHeld(m_send_mutex);
1550 [ + - + - ]: 9620 : LOCK(m_send_mutex);
1551 [ + + ]: 9620 : if (m_send_state == SendState::V1) return m_v1_fallback.MarkBytesSent(bytes_sent);
1552 : :
1553 [ + + + + : 8073 : if (m_send_state == SendState::AWAITING_KEY && m_send_pos == 0 && bytes_sent > 0) {
- + ]
1554 [ + - - + : 301 : LogPrint(BCLog::NET, "start sending v2 handshake to peer=%d\n", m_nodeid);
# # # # #
# ]
1555 : 301 : }
1556 : :
1557 : 8073 : m_send_pos += bytes_sent;
1558 [ + - ]: 8073 : Assume(m_send_pos <= m_send_buffer.size());
1559 [ + + ]: 8073 : if (m_send_pos >= CMessageHeader::HEADER_SIZE) {
1560 : 5628 : m_sent_v1_header_worth = true;
1561 : 5628 : }
1562 : : // Wipe the buffer when everything is sent.
1563 [ + + ]: 8073 : if (m_send_pos == m_send_buffer.size()) {
1564 : 2757 : m_send_pos = 0;
1565 : 2757 : ClearShrink(m_send_buffer);
1566 : 2757 : }
1567 [ - + ]: 9620 : }
1568 : :
1569 : 0 : bool V2Transport::ShouldReconnectV1() const noexcept
1570 : : {
1571 [ # # ]: 0 : AssertLockNotHeld(m_send_mutex);
1572 [ # # ]: 0 : AssertLockNotHeld(m_recv_mutex);
1573 : : // Only outgoing connections need reconnection.
1574 [ # # ]: 0 : if (!m_initiating) return false;
1575 : :
1576 [ # # # # ]: 0 : LOCK(m_recv_mutex);
1577 : : // We only reconnect in the very first state and when the receive buffer is empty. Together
1578 : : // these conditions imply nothing has been received so far.
1579 [ # # ]: 0 : if (m_recv_state != RecvState::KEY) return false;
1580 [ # # ]: 0 : if (!m_recv_buffer.empty()) return false;
1581 : : // Check if we've sent enough for the other side to disconnect us (if it was V1).
1582 [ # # # # ]: 0 : LOCK(m_send_mutex);
1583 : 0 : return m_sent_v1_header_worth;
1584 : 0 : }
1585 : :
1586 : 1 : size_t V2Transport::GetSendMemoryUsage() const noexcept
1587 : : {
1588 [ + - ]: 1 : AssertLockNotHeld(m_send_mutex);
1589 [ + - + - ]: 1 : LOCK(m_send_mutex);
1590 [ + - ]: 1 : if (m_send_state == SendState::V1) return m_v1_fallback.GetSendMemoryUsage();
1591 : :
1592 [ + - ]: 1 : return sizeof(m_send_buffer) + memusage::DynamicUsage(m_send_buffer);
1593 : 1 : }
1594 : :
1595 : 765 : Transport::Info V2Transport::GetInfo() const noexcept
1596 : : {
1597 [ + - ]: 765 : AssertLockNotHeld(m_recv_mutex);
1598 [ + - + - ]: 765 : LOCK(m_recv_mutex);
1599 [ + + ]: 765 : if (m_recv_state == RecvState::V1) return m_v1_fallback.GetInfo();
1600 : :
1601 : 571 : Transport::Info info;
1602 : :
1603 : : // Do not report v2 and session ID until the version packet has been received
1604 : : // and verified (confirming that the other side very likely has the same keys as us).
1605 [ + + + + : 1111 : if (m_recv_state != RecvState::KEY_MAYBE_V1 && m_recv_state != RecvState::KEY &&
+ - ]
1606 [ + - ]: 540 : m_recv_state != RecvState::GARB_GARBTERM && m_recv_state != RecvState::VERSION) {
1607 : 540 : info.transport_type = TransportProtocolType::V2;
1608 [ + - + - : 540 : info.session_id = uint256(MakeUCharSpan(m_cipher.GetSessionID()));
+ - ]
1609 : 540 : } else {
1610 : 31 : info.transport_type = TransportProtocolType::DETECTING;
1611 : : }
1612 : :
1613 : 571 : return info;
1614 : 765 : }
1615 : :
1616 : 143260 : std::pair<size_t, bool> CConnman::SocketSendData(CNode& node) const
1617 : : {
1618 : 143260 : auto it = node.vSendMsg.begin();
1619 : 143260 : size_t nSentSize = 0;
1620 : 143260 : bool data_left{false}; //!< second return value (whether unsent data remains)
1621 : 143260 : std::optional<bool> expected_more;
1622 : :
1623 : 411360 : while (true) {
1624 [ + + ]: 411360 : if (it != node.vSendMsg.end()) {
1625 : : // If possible, move one message from the send queue to the transport. This fails when
1626 : : // there is an existing message still being sent, or (for v2 transports) when the
1627 : : // handshake has not yet completed.
1628 : 143260 : size_t memusage = it->GetMemoryUsage();
1629 [ - + ]: 143260 : if (node.m_transport->SetMessageToSend(*it)) {
1630 : : // Update memory usage of send buffer (as *it will be deleted).
1631 : 143260 : node.m_send_memusage -= memusage;
1632 : 143260 : ++it;
1633 : 143260 : }
1634 : 143260 : }
1635 : 1226033 : const auto& [data, more, msg_type] = node.m_transport->GetBytesToSend(it != node.vSendMsg.end());
1636 : : // We rely on the 'more' value returned by GetBytesToSend to correctly predict whether more
1637 : : // bytes are still to be sent, to correctly set the MSG_MORE flag. As a sanity check,
1638 : : // verify that the previously returned 'more' was correct.
1639 [ + + ]: 411360 : if (expected_more.has_value()) Assume(!data.empty() == *expected_more);
1640 : 411360 : expected_more = more;
1641 : 411360 : data_left = !data.empty(); // will be overwritten on next loop if all of data gets sent
1642 : 411360 : int nBytes = 0;
1643 [ + + ]: 411360 : if (!data.empty()) {
1644 : 274021 : LOCK(node.m_sock_mutex);
1645 : : // There is no socket in case we've already disconnected, or in test cases without
1646 : : // real connections. In these cases, we bail out immediately and just leave things
1647 : : // in the send queue and transport.
1648 [ + - + + ]: 274021 : if (!node.m_sock) {
1649 : 12 : break;
1650 : : }
1651 : 274009 : int flags = MSG_NOSIGNAL | MSG_DONTWAIT;
1652 : : #ifdef MSG_MORE
1653 [ + + ]: 274009 : if (more) {
1654 : 134101 : flags |= MSG_MORE;
1655 : 134101 : }
1656 : : #endif
1657 [ + - + - : 822027 : nBytes = node.m_sock->Send(reinterpret_cast<const char*>(data.data()), data.size(), flags);
+ - ]
1658 [ - + + ]: 274021 : }
1659 [ + + ]: 411348 : if (nBytes > 0) {
1660 : 272462 : node.m_last_send = GetTime<std::chrono::seconds>();
1661 : 272462 : node.nSendBytes += nBytes;
1662 : : // Notify transport that bytes have been processed.
1663 : 272462 : node.m_transport->MarkBytesSent(nBytes);
1664 : : // Update statistics per message type.
1665 [ + + ]: 272462 : if (!msg_type.empty()) { // don't report v2 handshake bytes for now
1666 : 543970 : node.AccountForSentBytes(msg_type, nBytes);
1667 : 271985 : }
1668 : 272462 : nSentSize += nBytes;
1669 [ + + + + ]: 544924 : if ((size_t)nBytes != data.size()) {
1670 : : // could not send full message; stop sending more
1671 : 4362 : break;
1672 : : }
1673 : 268100 : } else {
1674 [ + + ]: 138886 : if (nBytes < 0) {
1675 : : // error
1676 : 1182 : int nErr = WSAGetLastError();
1677 [ + + + + : 1182 : if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
+ + - + ]
1678 [ + - # # : 1002 : LogPrint(BCLog::NET, "socket send error for peer=%d: %s\n", node.GetId(), NetworkErrorString(nErr));
# # # # #
# # # ]
1679 : 1002 : node.CloseSocketDisconnect();
1680 : 1002 : }
1681 : 1182 : }
1682 : 138886 : break;
1683 : : }
1684 : : }
1685 : :
1686 : 143260 : node.fPauseSend = node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize;
1687 : :
1688 [ - + ]: 143260 : if (it == node.vSendMsg.end()) {
1689 [ + - ]: 143260 : assert(node.m_send_memusage == 0);
1690 : 143260 : }
1691 : 143260 : node.vSendMsg.erase(node.vSendMsg.begin(), it);
1692 : 143260 : return {nSentSize, data_left};
1693 : 0 : }
1694 : :
1695 : : /** Try to find a connection to evict when the node is full.
1696 : : * Extreme care must be taken to avoid opening the node to attacker
1697 : : * triggered network partitioning.
1698 : : * The strategy used here is to protect a small number of peers
1699 : : * for each of several distinct characteristics which are difficult
1700 : : * to forge. In order to partition a node the attacker must be
1701 : : * simultaneously better at all of them than honest peers.
1702 : : */
1703 : 457 : bool CConnman::AttemptToEvictConnection()
1704 : : {
1705 : 457 : std::vector<NodeEvictionCandidate> vEvictionCandidates;
1706 : : {
1707 : :
1708 [ + - + - ]: 457 : LOCK(m_nodes_mutex);
1709 [ + + ]: 4616 : for (const CNode* node : m_nodes) {
1710 [ + + ]: 4159 : if (node->fDisconnect)
1711 : 48 : continue;
1712 : 4111 : NodeEvictionCandidate candidate{
1713 [ + - ]: 4111 : .id = node->GetId(),
1714 : 4111 : .m_connected = node->m_connected,
1715 : 4111 : .m_min_ping_time = node->m_min_ping_time,
1716 : 4111 : .m_last_block_time = node->m_last_block_time,
1717 : 4111 : .m_last_tx_time = node->m_last_tx_time,
1718 : 4111 : .fRelevantServices = node->m_has_all_wanted_services,
1719 : 4111 : .m_relay_txs = node->m_relays_txs.load(),
1720 : 4111 : .fBloomFilter = node->m_bloom_filter_loaded.load(),
1721 : 4111 : .nKeyedNetGroup = node->nKeyedNetGroup,
1722 : 4111 : .prefer_evict = node->m_prefer_evict,
1723 [ + - ]: 4111 : .m_is_local = node->addr.IsLocal(),
1724 [ + - ]: 4111 : .m_network = node->ConnectedThroughNetwork(),
1725 [ + - ]: 4111 : .m_noban = node->HasPermission(NetPermissionFlags::NoBan),
1726 : 4111 : .m_conn_type = node->m_conn_type,
1727 : : };
1728 [ + - ]: 4111 : vEvictionCandidates.push_back(candidate);
1729 : : }
1730 : 457 : }
1731 [ + - ]: 457 : const std::optional<NodeId> node_id_to_evict = SelectNodeToEvict(std::move(vEvictionCandidates));
1732 [ - + ]: 457 : if (!node_id_to_evict) {
1733 : 457 : return false;
1734 : : }
1735 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
1736 [ # # ]: 0 : for (CNode* pnode : m_nodes) {
1737 [ # # # # : 0 : if (pnode->GetId() == *node_id_to_evict) {
# # ]
1738 [ # # # # : 0 : LogPrint(BCLog::NET, "selected %s connection for eviction peer=%d; disconnecting\n", pnode->ConnectionTypeAsString(), pnode->GetId());
# # # # #
# # # #
# ]
1739 : 0 : pnode->fDisconnect = true;
1740 : 0 : return true;
1741 : : }
1742 : : }
1743 : 0 : return false;
1744 : 457 : }
1745 : :
1746 : 2 : void CConnman::AcceptConnection(const ListenSocket& hListenSocket) {
1747 : : struct sockaddr_storage sockaddr;
1748 : 2 : socklen_t len = sizeof(sockaddr);
1749 : 2 : auto sock = hListenSocket.sock->Accept((struct sockaddr*)&sockaddr, &len);
1750 [ + - ]: 2 : CAddress addr;
1751 : :
1752 [ - + ]: 2 : if (!sock) {
1753 : 2 : const int nErr = WSAGetLastError();
1754 [ - + ]: 2 : if (nErr != WSAEWOULDBLOCK) {
1755 [ + - + - : 2 : LogPrintf("socket error accept failed: %s\n", NetworkErrorString(nErr));
+ - + - ]
1756 : 2 : }
1757 : 2 : return;
1758 : : }
1759 : :
1760 [ # # # # ]: 0 : if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr)) {
1761 [ # # # # : 0 : LogPrintLevel(BCLog::NET, BCLog::Level::Warning, "Unknown socket family\n");
# # # # #
# ]
1762 : 0 : } else {
1763 [ # # # # ]: 0 : addr = CAddress{MaybeFlipIPv6toCJDNS(addr), NODE_NONE};
1764 : : }
1765 : :
1766 [ # # # # : 0 : const CAddress addr_bind{MaybeFlipIPv6toCJDNS(GetBindAddress(*sock)), NODE_NONE};
# # # # ]
1767 : :
1768 : 0 : NetPermissionFlags permission_flags = NetPermissionFlags::None;
1769 [ # # ]: 0 : hListenSocket.AddSocketPermissionFlags(permission_flags);
1770 : :
1771 [ # # ]: 0 : CreateNodeFromAcceptedSocket(std::move(sock), permission_flags, addr_bind, addr);
1772 [ - + ]: 2 : }
1773 : :
1774 : 548 : void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
1775 : : NetPermissionFlags permission_flags,
1776 : : const CAddress& addr_bind,
1777 : : const CAddress& addr)
1778 : : {
1779 : 548 : int nInbound = 0;
1780 : 548 : int nMaxInbound = nMaxConnections - m_max_outbound;
1781 : :
1782 : 548 : AddWhitelistPermissionFlags(permission_flags, addr);
1783 [ + + ]: 548 : if (NetPermissions::HasFlag(permission_flags, NetPermissionFlags::Implicit)) {
1784 : 13 : NetPermissions::ClearFlag(permission_flags, NetPermissionFlags::Implicit);
1785 [ + - + - : 13 : if (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) NetPermissions::AddFlag(permission_flags, NetPermissionFlags::ForceRelay);
+ - ]
1786 [ + - + - : 13 : if (gArgs.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY)) NetPermissions::AddFlag(permission_flags, NetPermissionFlags::Relay);
- + ]
1787 : 13 : NetPermissions::AddFlag(permission_flags, NetPermissionFlags::Mempool);
1788 : 13 : NetPermissions::AddFlag(permission_flags, NetPermissionFlags::NoBan);
1789 : 13 : }
1790 : :
1791 : : {
1792 : 548 : LOCK(m_nodes_mutex);
1793 [ + + ]: 6190 : for (const CNode* pnode : m_nodes) {
1794 [ + - + + ]: 5642 : if (pnode->IsInboundConn()) nInbound++;
1795 : : }
1796 : 548 : }
1797 : :
1798 [ + - ]: 548 : if (!fNetworkActive) {
1799 [ # # # # : 0 : LogPrint(BCLog::NET, "connection from %s dropped: not accepting new connections\n", addr.ToStringAddrPort());
# # # # #
# ]
1800 : 0 : return;
1801 : : }
1802 : :
1803 [ + + ]: 548 : if (!sock->IsSelectable()) {
1804 [ + - + - : 91 : LogPrintf("connection from %s dropped: non-selectable socket\n", addr.ToStringAddrPort());
+ - + - ]
1805 : 91 : return;
1806 : : }
1807 : :
1808 : : // According to the internet TCP_NODELAY is not carried into accepted sockets
1809 : : // on all platforms. Set it again here just to be sure.
1810 : 457 : const int on{1};
1811 [ + + ]: 457 : if (sock->SetSockOpt(IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) == SOCKET_ERROR) {
1812 [ + - # # : 347 : LogPrint(BCLog::NET, "connection from %s: unable to set TCP_NODELAY, continuing anyway\n",
# # # # #
# ]
1813 : : addr.ToStringAddrPort());
1814 : 347 : }
1815 : :
1816 : : // Don't accept connections from banned peers.
1817 [ + - ]: 457 : bool banned = m_banman && m_banman->IsBanned(addr);
1818 [ + + + - ]: 457 : if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && banned)
1819 : : {
1820 [ # # # # : 0 : LogPrint(BCLog::NET, "connection from %s dropped (banned)\n", addr.ToStringAddrPort());
# # # # #
# ]
1821 : 0 : return;
1822 : : }
1823 : :
1824 : : // Only accept connections from discouraged peers if our inbound slots aren't (almost) full.
1825 [ + - ]: 457 : bool discouraged = m_banman && m_banman->IsDiscouraged(addr);
1826 [ + + + - : 457 : if (!NetPermissions::HasFlag(permission_flags, NetPermissionFlags::NoBan) && nInbound + 1 >= nMaxInbound && discouraged)
+ - ]
1827 : : {
1828 [ # # # # : 0 : LogPrint(BCLog::NET, "connection from %s dropped (discouraged)\n", addr.ToStringAddrPort());
# # # # #
# ]
1829 : 0 : return;
1830 : : }
1831 : :
1832 [ - + ]: 457 : if (nInbound >= nMaxInbound)
1833 : : {
1834 [ - + ]: 457 : if (!AttemptToEvictConnection()) {
1835 : : // No connection to evict, disconnect the new connection
1836 [ + - # # : 457 : LogPrint(BCLog::NET, "failed to find an eviction candidate - connection dropped (full)\n");
# # # # ]
1837 : 457 : return;
1838 : : }
1839 : 0 : }
1840 : :
1841 : 0 : NodeId id = GetNewNodeId();
1842 : 0 : uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
1843 : :
1844 : 0 : ServiceFlags nodeServices = nLocalServices;
1845 [ # # ]: 0 : if (NetPermissions::HasFlag(permission_flags, NetPermissionFlags::BloomFilter)) {
1846 : 0 : nodeServices = static_cast<ServiceFlags>(nodeServices | NODE_BLOOM);
1847 : 0 : }
1848 : :
1849 : 0 : const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
1850 : : // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is
1851 : : // detected, so use it whenever we signal NODE_P2P_V2.
1852 : 0 : const bool use_v2transport(nodeServices & NODE_P2P_V2);
1853 : :
1854 [ # # # # ]: 0 : CNode* pnode = new CNode(id,
1855 [ # # ]: 0 : std::move(sock),
1856 : 0 : addr,
1857 [ # # ]: 0 : CalculateKeyedNetGroup(addr),
1858 : 0 : nonce,
1859 : 0 : addr_bind,
1860 [ # # ]: 0 : /*addrNameIn=*/"",
1861 : : ConnectionType::INBOUND,
1862 : 0 : inbound_onion,
1863 : 0 : CNodeOptions{
1864 : 0 : .permission_flags = permission_flags,
1865 : 0 : .prefer_evict = discouraged,
1866 : 0 : .recv_flood_size = nReceiveFloodSize,
1867 : 0 : .use_v2transport = use_v2transport,
1868 : : });
1869 : 0 : pnode->AddRef();
1870 : 0 : m_msgproc->InitializeNode(*pnode, nodeServices);
1871 : :
1872 [ # # # # : 0 : LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToStringAddrPort());
# # # # #
# ]
1873 : :
1874 : : {
1875 : 0 : LOCK(m_nodes_mutex);
1876 [ # # ]: 0 : m_nodes.push_back(pnode);
1877 : 0 : }
1878 : :
1879 : : // We received a new connection, harvest entropy from the time (and our peer count)
1880 : 0 : RandAddEvent((uint32_t)id);
1881 : 548 : }
1882 : :
1883 : 0 : bool CConnman::AddConnection(const std::string& address, ConnectionType conn_type)
1884 : : {
1885 : 0 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
1886 : 0 : std::optional<int> max_connections;
1887 [ # # # # : 0 : switch (conn_type) {
# # ]
1888 : : case ConnectionType::INBOUND:
1889 : : case ConnectionType::MANUAL:
1890 : 0 : return false;
1891 : : case ConnectionType::OUTBOUND_FULL_RELAY:
1892 : 0 : max_connections = m_max_outbound_full_relay;
1893 : 0 : break;
1894 : : case ConnectionType::BLOCK_RELAY:
1895 : 0 : max_connections = m_max_outbound_block_relay;
1896 : 0 : break;
1897 : : // no limit for ADDR_FETCH because -seednode has no limit either
1898 : : case ConnectionType::ADDR_FETCH:
1899 : 0 : break;
1900 : : // no limit for FEELER connections since they're short-lived
1901 : : case ConnectionType::FEELER:
1902 : 0 : break;
1903 : : } // no default case, so the compiler can warn about missing cases
1904 : :
1905 : : // Count existing connections
1906 [ # # ]: 0 : int existing_connections = WITH_LOCK(m_nodes_mutex,
1907 : : return std::count_if(m_nodes.begin(), m_nodes.end(), [conn_type](CNode* node) { return node->m_conn_type == conn_type; }););
1908 : :
1909 : : // Max connections of specified type already exist
1910 [ # # # # ]: 0 : if (max_connections != std::nullopt && existing_connections >= max_connections) return false;
1911 : :
1912 : : // Max total outbound connections already exist
1913 : 0 : CSemaphoreGrant grant(*semOutbound, true);
1914 [ # # ]: 0 : if (!grant) return false;
1915 : :
1916 [ # # # # ]: 0 : OpenNetworkConnection(CAddress(), false, std::move(grant), address.c_str(), conn_type, /*use_v2transport=*/false);
1917 : 0 : return true;
1918 : 0 : }
1919 : :
1920 : 0 : void CConnman::DisconnectNodes()
1921 : : {
1922 : 0 : AssertLockNotHeld(m_nodes_mutex);
1923 : 0 : AssertLockNotHeld(m_reconnections_mutex);
1924 : :
1925 : : // Use a temporary variable to accumulate desired reconnections, so we don't need
1926 : : // m_reconnections_mutex while holding m_nodes_mutex.
1927 : 0 : decltype(m_reconnections) reconnections_to_add;
1928 : :
1929 : : {
1930 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
1931 : :
1932 [ # # ]: 0 : if (!fNetworkActive) {
1933 : : // Disconnect any connected nodes
1934 [ # # ]: 0 : for (CNode* pnode : m_nodes) {
1935 [ # # ]: 0 : if (!pnode->fDisconnect) {
1936 [ # # # # : 0 : LogPrint(BCLog::NET, "Network not active, dropping peer=%d\n", pnode->GetId());
# # # # #
# # # ]
1937 : 0 : pnode->fDisconnect = true;
1938 : 0 : }
1939 : : }
1940 : 0 : }
1941 : :
1942 : : // Disconnect unused nodes
1943 [ # # ]: 0 : std::vector<CNode*> nodes_copy = m_nodes;
1944 [ # # ]: 0 : for (CNode* pnode : nodes_copy)
1945 : : {
1946 [ # # ]: 0 : if (pnode->fDisconnect)
1947 : : {
1948 : : // remove from m_nodes
1949 [ # # # # ]: 0 : m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
1950 : :
1951 : : // Add to reconnection list if appropriate. We don't reconnect right here, because
1952 : : // the creation of a connection is a blocking operation (up to several seconds),
1953 : : // and we don't want to hold up the socket handler thread for that long.
1954 [ # # ]: 0 : if (pnode->m_transport->ShouldReconnectV1()) {
1955 [ # # # # ]: 0 : reconnections_to_add.push_back({
1956 [ # # ]: 0 : .addr_connect = pnode->addr,
1957 : 0 : .grant = std::move(pnode->grantOutbound),
1958 [ # # ]: 0 : .destination = pnode->m_dest,
1959 : 0 : .conn_type = pnode->m_conn_type,
1960 : : .use_v2transport = false});
1961 [ # # # # : 0 : LogPrint(BCLog::NET, "retrying with v1 transport protocol for peer=%d\n", pnode->GetId());
# # # # #
# # # ]
1962 : 0 : }
1963 : :
1964 : : // release outbound grant (if any)
1965 : 0 : pnode->grantOutbound.Release();
1966 : :
1967 : : // close socket and cleanup
1968 [ # # ]: 0 : pnode->CloseSocketDisconnect();
1969 : :
1970 : : // update connection count by network
1971 [ # # # # : 0 : if (pnode->IsManualOrFullOutboundConn()) --m_network_conn_counts[pnode->addr.GetNetwork()];
# # ]
1972 : :
1973 : : // hold in disconnected pool until all refs are released
1974 [ # # ]: 0 : pnode->Release();
1975 [ # # ]: 0 : m_nodes_disconnected.push_back(pnode);
1976 : 0 : }
1977 : : }
1978 : 0 : }
1979 : : {
1980 : : // Delete disconnected nodes
1981 [ # # ]: 0 : std::list<CNode*> nodes_disconnected_copy = m_nodes_disconnected;
1982 [ # # ]: 0 : for (CNode* pnode : nodes_disconnected_copy)
1983 : : {
1984 : : // Destroy the object only after other threads have stopped using it.
1985 [ # # # # ]: 0 : if (pnode->GetRefCount() <= 0) {
1986 [ # # ]: 0 : m_nodes_disconnected.remove(pnode);
1987 [ # # ]: 0 : DeleteNode(pnode);
1988 : 0 : }
1989 : : }
1990 : 0 : }
1991 : : {
1992 : : // Move entries from reconnections_to_add to m_reconnections.
1993 [ # # # # ]: 0 : LOCK(m_reconnections_mutex);
1994 : 0 : m_reconnections.splice(m_reconnections.end(), std::move(reconnections_to_add));
1995 : 0 : }
1996 : 0 : }
1997 : :
1998 : 0 : void CConnman::NotifyNumConnectionsChanged()
1999 : : {
2000 : : size_t nodes_size;
2001 : : {
2002 : 0 : LOCK(m_nodes_mutex);
2003 : 0 : nodes_size = m_nodes.size();
2004 : 0 : }
2005 [ # # ]: 0 : if(nodes_size != nPrevNodeCount) {
2006 : 0 : nPrevNodeCount = nodes_size;
2007 [ # # ]: 0 : if (m_client_interface) {
2008 : 0 : m_client_interface->NotifyNumConnectionsChanged(nodes_size);
2009 : 0 : }
2010 : 0 : }
2011 : 0 : }
2012 : :
2013 : 1092731 : bool CConnman::ShouldRunInactivityChecks(const CNode& node, std::chrono::seconds now) const
2014 : : {
2015 : 1092731 : return node.m_connected + m_peer_connect_timeout < now;
2016 : : }
2017 : :
2018 : 845 : bool CConnman::InactivityCheck(const CNode& node) const
2019 : : {
2020 : : // Tests that see disconnects after using mocktime can start nodes with a
2021 : : // large timeout. For example, -peertimeout=999999999.
2022 : 845 : const auto now{GetTime<std::chrono::seconds>()};
2023 : 845 : const auto last_send{node.m_last_send.load()};
2024 : 845 : const auto last_recv{node.m_last_recv.load()};
2025 : :
2026 [ + - ]: 845 : if (!ShouldRunInactivityChecks(node, now)) return false;
2027 : :
2028 [ # # # # ]: 0 : if (last_recv.count() == 0 || last_send.count() == 0) {
2029 [ # # # # : 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());
# # # # #
# # # # #
# # ]
2030 : 0 : return true;
2031 : : }
2032 : :
2033 [ # # ]: 0 : if (now > last_send + TIMEOUT_INTERVAL) {
2034 [ # # # # : 0 : LogPrint(BCLog::NET, "socket sending timeout: %is peer=%d\n", count_seconds(now - last_send), node.GetId());
# # # # #
# # # #
# ]
2035 : 0 : return true;
2036 : : }
2037 : :
2038 [ # # ]: 0 : if (now > last_recv + TIMEOUT_INTERVAL) {
2039 [ # # # # : 0 : LogPrint(BCLog::NET, "socket receive timeout: %is peer=%d\n", count_seconds(now - last_recv), node.GetId());
# # # # #
# # # #
# ]
2040 : 0 : return true;
2041 : : }
2042 : :
2043 [ # # ]: 0 : if (!node.fSuccessfullyConnected) {
2044 [ # # # # : 0 : LogPrint(BCLog::NET, "version handshake timeout peer=%d\n", node.GetId());
# # # # #
# ]
2045 : 0 : return true;
2046 : : }
2047 : :
2048 : 0 : return false;
2049 : 845 : }
2050 : :
2051 : 54 : Sock::EventsPerSock CConnman::GenerateWaitSockets(Span<CNode* const> nodes)
2052 : : {
2053 : 54 : Sock::EventsPerSock events_per_sock;
2054 : :
2055 [ + + ]: 56 : for (const ListenSocket& hListenSocket : vhListenSocket) {
2056 [ + - + - ]: 2 : events_per_sock.emplace(hListenSocket.sock, Sock::Events{Sock::RECV});
2057 : : }
2058 : :
2059 [ + + ]: 1157 : for (CNode* pnode : nodes) {
2060 : 1103 : bool select_recv = !pnode->fPauseRecv;
2061 : : bool select_send;
2062 : : {
2063 [ + - + - ]: 1103 : LOCK(pnode->cs_vSend);
2064 : : // Sending is possible if either there are bytes to send right now, or if there will be
2065 : : // once a potential message from vSendMsg is handed to the transport. GetBytesToSend
2066 : : // determines both of these in a single call.
2067 : 1103 : const auto& [to_send, more, _msg_type] = pnode->m_transport->GetBytesToSend(!pnode->vSendMsg.empty());
2068 [ - + ]: 1103 : select_send = !to_send.empty() || more;
2069 : 1103 : }
2070 [ - + # # ]: 1103 : if (!select_recv && !select_send) continue;
2071 : :
2072 [ + - + - ]: 1103 : LOCK(pnode->m_sock_mutex);
2073 [ + - + + ]: 1103 : if (pnode->m_sock) {
2074 : 845 : Sock::Event event = (select_send ? Sock::SEND : 0) | (select_recv ? Sock::RECV : 0);
2075 [ + - + - ]: 845 : events_per_sock.emplace(pnode->m_sock, Sock::Events{event});
2076 : 845 : }
2077 : 1103 : }
2078 : :
2079 : 54 : return events_per_sock;
2080 [ + - ]: 54 : }
2081 : :
2082 : 54 : void CConnman::SocketHandler()
2083 : : {
2084 : 54 : AssertLockNotHeld(m_total_bytes_sent_mutex);
2085 : :
2086 : 54 : Sock::EventsPerSock events_per_sock;
2087 : :
2088 : : {
2089 [ + - ]: 54 : const NodesSnapshot snap{*this, /*shuffle=*/false};
2090 : :
2091 : 54 : const auto timeout = std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS);
2092 : :
2093 : : // Check for the readiness of the already connected sockets and the
2094 : : // listening sockets in one call ("readiness" as in poll(2) or
2095 : : // select(2)). If none are ready, wait for a short while and return
2096 : : // empty sets.
2097 [ + - + - : 54 : events_per_sock = GenerateWaitSockets(snap.Nodes());
+ - ]
2098 [ + + + - : 54 : if (events_per_sock.empty() || !events_per_sock.begin()->first->WaitMany(timeout, events_per_sock)) {
+ + ]
2099 [ + - + - ]: 17 : interruptNet.sleep_for(timeout);
2100 : 17 : }
2101 : :
2102 : : // Service (send/receive) each of the already connected nodes.
2103 [ + - + - ]: 54 : SocketHandlerConnected(snap.Nodes(), events_per_sock);
2104 : 54 : }
2105 : :
2106 : : // Accept new connections from listening sockets.
2107 [ + - ]: 54 : SocketHandlerListening(events_per_sock);
2108 : 54 : }
2109 : :
2110 : 54 : void CConnman::SocketHandlerConnected(const std::vector<CNode*>& nodes,
2111 : : const Sock::EventsPerSock& events_per_sock)
2112 : : {
2113 : 54 : AssertLockNotHeld(m_total_bytes_sent_mutex);
2114 : :
2115 [ + + ]: 1157 : for (CNode* pnode : nodes) {
2116 [ + - ]: 1103 : if (interruptNet)
2117 : 0 : return;
2118 : :
2119 : : //
2120 : : // Receive
2121 : : //
2122 : 1103 : bool recvSet = false;
2123 : 1103 : bool sendSet = false;
2124 : 1103 : bool errorSet = false;
2125 : : {
2126 : 1103 : LOCK(pnode->m_sock_mutex);
2127 [ + - + + ]: 1103 : if (!pnode->m_sock) {
2128 : 258 : continue;
2129 : : }
2130 [ + - ]: 845 : const auto it = events_per_sock.find(pnode->m_sock);
2131 [ - + ]: 845 : if (it != events_per_sock.end()) {
2132 : 845 : recvSet = it->second.occurred & Sock::RECV;
2133 : 845 : sendSet = it->second.occurred & Sock::SEND;
2134 : 845 : errorSet = it->second.occurred & Sock::ERR;
2135 : 845 : }
2136 [ + + ]: 1103 : }
2137 : :
2138 [ + - ]: 845 : if (sendSet) {
2139 : : // Send data
2140 [ # # ]: 0 : auto [bytes_sent, data_left] = WITH_LOCK(pnode->cs_vSend, return SocketSendData(*pnode));
2141 [ # # ]: 0 : if (bytes_sent) {
2142 : 0 : RecordBytesSent(bytes_sent);
2143 : :
2144 : : // If both receiving and (non-optimistic) sending were possible, we first attempt
2145 : : // sending. If that succeeds, but does not fully drain the send queue, do not
2146 : : // attempt to receive. This avoids needlessly queueing data if the remote peer
2147 : : // is slow at receiving data, by means of TCP flow control. We only do this when
2148 : : // sending actually succeeded to make sure progress is always made; otherwise a
2149 : : // deadlock would be possible when both sides have data to send, but neither is
2150 : : // receiving.
2151 [ # # ]: 0 : if (data_left) recvSet = false;
2152 : 0 : }
2153 : 0 : }
2154 : :
2155 [ + + - + ]: 845 : if (recvSet || errorSet)
2156 : : {
2157 : : // typical socket buffer is 8K-64K
2158 : : uint8_t pchBuf[0x10000];
2159 : 747 : int nBytes = 0;
2160 : : {
2161 : 747 : LOCK(pnode->m_sock_mutex);
2162 [ + - + - ]: 747 : if (!pnode->m_sock) {
2163 : 0 : continue;
2164 : : }
2165 [ + - ]: 747 : nBytes = pnode->m_sock->Recv(pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
2166 [ - + ]: 747 : }
2167 [ + + ]: 747 : if (nBytes > 0)
2168 : : {
2169 : 38 : bool notify = false;
2170 [ - + ]: 38 : if (!pnode->ReceiveMsgBytes({pchBuf, (size_t)nBytes}, notify)) {
2171 : 38 : pnode->CloseSocketDisconnect();
2172 : 38 : }
2173 : 38 : RecordBytesRecv(nBytes);
2174 [ + - ]: 38 : if (notify) {
2175 : 0 : pnode->MarkReceivedMsgsForProcessing();
2176 : 0 : WakeMessageHandler();
2177 : 0 : }
2178 : 38 : }
2179 [ + + ]: 709 : else if (nBytes == 0)
2180 : : {
2181 : : // socket closed gracefully
2182 [ + + ]: 500 : if (!pnode->fDisconnect) {
2183 [ + - # # : 487 : LogPrint(BCLog::NET, "socket closed for peer=%d\n", pnode->GetId());
# # # # #
# ]
2184 : 487 : }
2185 : 500 : pnode->CloseSocketDisconnect();
2186 : 500 : }
2187 [ - + ]: 209 : else if (nBytes < 0)
2188 : : {
2189 : : // error
2190 : 209 : int nErr = WSAGetLastError();
2191 [ + + + - : 209 : if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
+ - - + ]
2192 : : {
2193 [ + + ]: 189 : if (!pnode->fDisconnect) {
2194 [ + - # # : 185 : LogPrint(BCLog::NET, "socket recv error for peer=%d: %s\n", pnode->GetId(), NetworkErrorString(nErr));
# # # # #
# # # ]
2195 : 185 : }
2196 : 189 : pnode->CloseSocketDisconnect();
2197 : 189 : }
2198 : 209 : }
2199 : 747 : }
2200 : :
2201 [ + - ]: 845 : if (InactivityCheck(*pnode)) pnode->fDisconnect = true;
2202 : : }
2203 : 54 : }
2204 : :
2205 : 54 : void CConnman::SocketHandlerListening(const Sock::EventsPerSock& events_per_sock)
2206 : : {
2207 [ + + ]: 56 : for (const ListenSocket& listen_socket : vhListenSocket) {
2208 [ + - ]: 2 : if (interruptNet) {
2209 : 0 : return;
2210 : : }
2211 [ - + ]: 2 : const auto it = events_per_sock.find(listen_socket.sock);
2212 [ - + - + ]: 2 : if (it != events_per_sock.end() && it->second.occurred & Sock::RECV) {
2213 : 2 : AcceptConnection(listen_socket);
2214 : 2 : }
2215 : : }
2216 : 54 : }
2217 : :
2218 : 0 : void CConnman::ThreadSocketHandler()
2219 : : {
2220 : 0 : AssertLockNotHeld(m_total_bytes_sent_mutex);
2221 : :
2222 [ # # ]: 0 : while (!interruptNet)
2223 : : {
2224 : 0 : DisconnectNodes();
2225 : 0 : NotifyNumConnectionsChanged();
2226 : 0 : SocketHandler();
2227 : : }
2228 : 0 : }
2229 : :
2230 : 0 : void CConnman::WakeMessageHandler()
2231 : : {
2232 : : {
2233 : 0 : LOCK(mutexMsgProc);
2234 : 0 : fMsgProcWake = true;
2235 : 0 : }
2236 : 0 : condMsgProc.notify_one();
2237 : 0 : }
2238 : :
2239 : 0 : void CConnman::ThreadDNSAddressSeed()
2240 : : {
2241 : 0 : FastRandomContext rng;
2242 [ # # # # ]: 0 : std::vector<std::string> seeds = m_params.DNSSeeds();
2243 [ # # ]: 0 : Shuffle(seeds.begin(), seeds.end(), rng);
2244 : 0 : int seeds_right_now = 0; // Number of seeds left before testing if we have enough connections
2245 : 0 : int found = 0;
2246 : :
2247 [ # # # # : 0 : if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
# # ]
2248 : : // When -forcednsseed is provided, query all.
2249 : 0 : seeds_right_now = seeds.size();
2250 [ # # # # ]: 0 : } else if (addrman.Size() == 0) {
2251 : : // If we have no known peers, query all.
2252 : : // This will occur on the first run, or if peers.dat has been
2253 : : // deleted.
2254 : 0 : seeds_right_now = seeds.size();
2255 : 0 : }
2256 : :
2257 : : // goal: only query DNS seed if address need is acute
2258 : : // * If we have a reasonable number of peers in addrman, spend
2259 : : // some time trying them first. This improves user privacy by
2260 : : // creating fewer identifying DNS requests, reduces trust by
2261 : : // giving seeds less influence on the network topology, and
2262 : : // reduces traffic to the seeds.
2263 : : // * When querying DNS seeds query a few at once, this ensures
2264 : : // that we don't give DNS seeds the ability to eclipse nodes
2265 : : // that query them.
2266 : : // * If we continue having problems, eventually query all the
2267 : : // DNS seeds, and if that fails too, also try the fixed seeds.
2268 : : // (done in ThreadOpenConnections)
2269 [ # # # # : 0 : const std::chrono::seconds seeds_wait_time = (addrman.Size() >= DNSSEEDS_DELAY_PEER_THRESHOLD ? DNSSEEDS_DELAY_MANY_PEERS : DNSSEEDS_DELAY_FEW_PEERS);
# # ]
2270 : :
2271 [ # # ]: 0 : for (const std::string& seed : seeds) {
2272 [ # # ]: 0 : if (seeds_right_now == 0) {
2273 : 0 : seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
2274 : :
2275 [ # # # # ]: 0 : if (addrman.Size() > 0) {
2276 [ # # # # : 0 : LogPrintf("Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
# # # # ]
2277 : 0 : std::chrono::seconds to_wait = seeds_wait_time;
2278 [ # # # # ]: 0 : while (to_wait.count() > 0) {
2279 : : // if sleeping for the MANY_PEERS interval, wake up
2280 : : // early to see if we have enough peers and can stop
2281 : : // this thread entirely freeing up its resources
2282 [ # # ]: 0 : std::chrono::seconds w = std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
2283 [ # # # # : 0 : if (!interruptNet.sleep_for(w)) return;
# # ]
2284 [ # # ]: 0 : to_wait -= w;
2285 : :
2286 : 0 : int nRelevant = 0;
2287 : : {
2288 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
2289 [ # # ]: 0 : for (const CNode* pnode : m_nodes) {
2290 [ # # # # : 0 : if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
# # ]
2291 : : }
2292 : 0 : }
2293 [ # # ]: 0 : if (nRelevant >= 2) {
2294 [ # # ]: 0 : if (found > 0) {
2295 [ # # # # : 0 : LogPrintf("%d addresses found from DNS seeds\n", found);
# # ]
2296 [ # # # # : 0 : LogPrintf("P2P peers available. Finished DNS seeding.\n");
# # ]
2297 : 0 : } else {
2298 [ # # # # : 0 : LogPrintf("P2P peers available. Skipped DNS seeding.\n");
# # ]
2299 : : }
2300 : 0 : return;
2301 : : }
2302 : : }
2303 : 0 : }
2304 : 0 : }
2305 : :
2306 [ # # # # ]: 0 : if (interruptNet) return;
2307 : :
2308 : : // hold off on querying seeds if P2P network deactivated
2309 [ # # ]: 0 : if (!fNetworkActive) {
2310 [ # # # # : 0 : LogPrintf("Waiting for network to be reactivated before querying DNS seeds.\n");
# # ]
2311 : 0 : do {
2312 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::seconds{1})) return;
# # # # ]
2313 [ # # ]: 0 : } while (!fNetworkActive);
2314 : 0 : }
2315 : :
2316 [ # # # # : 0 : LogPrintf("Loading addresses from DNS seed %s\n", seed);
# # ]
2317 : : // If -proxy is in use, we make an ADDR_FETCH connection to the DNS resolved peer address
2318 : : // for the base dns seed domain in chainparams
2319 [ # # # # ]: 0 : if (HaveNameProxy()) {
2320 [ # # ]: 0 : AddAddrFetch(seed);
2321 : 0 : } else {
2322 : 0 : std::vector<CAddress> vAdd;
2323 [ # # ]: 0 : ServiceFlags requiredServiceBits = GetDesirableServiceFlags(NODE_NONE);
2324 [ # # ]: 0 : std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
2325 [ # # ]: 0 : CNetAddr resolveSource;
2326 [ # # # # ]: 0 : if (!resolveSource.SetInternal(host)) {
2327 : 0 : continue;
2328 : : }
2329 : 0 : unsigned int nMaxIPs = 256; // Limits number of IPs learned from a DNS seed
2330 [ # # # # ]: 0 : const auto addresses{LookupHost(host, nMaxIPs, true)};
2331 [ # # ]: 0 : if (!addresses.empty()) {
2332 [ # # ]: 0 : for (const CNetAddr& ip : addresses) {
2333 [ # # # # : 0 : CAddress addr = CAddress(CService(ip, m_params.GetDefaultPort()), requiredServiceBits);
# # ]
2334 [ # # # # : 0 : addr.nTime = rng.rand_uniform_delay(Now<NodeSeconds>() - 3 * 24h, -4 * 24h); // use a random age between 3 and 7 days old
# # # # #
# # # # #
# # ]
2335 [ # # ]: 0 : vAdd.push_back(addr);
2336 : 0 : found++;
2337 : 0 : }
2338 [ # # # # ]: 0 : addrman.Add(vAdd, resolveSource);
2339 : 0 : } else {
2340 : : // If the seed does not support a subdomain with our desired service bits,
2341 : : // we make an ADDR_FETCH connection to the DNS resolved peer address for the
2342 : : // base dns seed domain in chainparams
2343 [ # # ]: 0 : AddAddrFetch(seed);
2344 : : }
2345 [ # # ]: 0 : }
2346 : 0 : --seeds_right_now;
2347 : : }
2348 [ # # # # : 0 : LogPrintf("%d addresses found from DNS seeds\n", found);
# # ]
2349 : 0 : }
2350 : :
2351 : 0 : void CConnman::DumpAddresses()
2352 : : {
2353 : 0 : const auto start{SteadyClock::now()};
2354 : :
2355 : 0 : DumpPeerAddresses(::gArgs, addrman);
2356 : :
2357 [ # # # # : 0 : LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat %dms\n",
# # # # #
# # # #
# ]
2358 : : addrman.Size(), Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
2359 : 0 : }
2360 : :
2361 : 0 : void CConnman::ProcessAddrFetch()
2362 : : {
2363 : 0 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2364 : 0 : std::string strDest;
2365 : : {
2366 [ # # # # ]: 0 : LOCK(m_addr_fetches_mutex);
2367 [ # # ]: 0 : if (m_addr_fetches.empty())
2368 : 0 : return;
2369 [ # # ]: 0 : strDest = m_addr_fetches.front();
2370 : 0 : m_addr_fetches.pop_front();
2371 [ # # ]: 0 : }
2372 [ # # ]: 0 : CAddress addr;
2373 [ # # ]: 0 : CSemaphoreGrant grant(*semOutbound, /*fTry=*/true);
2374 [ # # ]: 0 : if (grant) {
2375 [ # # ]: 0 : OpenNetworkConnection(addr, false, std::move(grant), strDest.c_str(), ConnectionType::ADDR_FETCH, /*use_v2transport=*/false);
2376 : 0 : }
2377 [ # # ]: 0 : }
2378 : :
2379 : 460 : bool CConnman::GetTryNewOutboundPeer() const
2380 : : {
2381 : 460 : return m_try_another_outbound_peer;
2382 : : }
2383 : :
2384 : 773 : void CConnman::SetTryNewOutboundPeer(bool flag)
2385 : : {
2386 : 773 : m_try_another_outbound_peer = flag;
2387 [ + - # # : 773 : LogPrint(BCLog::NET, "setting try another outbound peer=%s\n", flag ? "true" : "false");
# # # # ]
2388 : 773 : }
2389 : :
2390 : 0 : void CConnman::StartExtraBlockRelayPeers()
2391 : : {
2392 [ # # # # : 0 : LogPrint(BCLog::NET, "enabling extra block-relay-only peers\n");
# # # # ]
2393 : 0 : m_start_extra_block_relay_peers = true;
2394 : 0 : }
2395 : :
2396 : : // Return the number of peers we have over our outbound connection limit
2397 : : // Exclude peers that are marked for disconnect, or are going to be
2398 : : // disconnected soon (eg ADDR_FETCH and FEELER)
2399 : : // Also exclude peers that haven't finished initial connection handshake yet
2400 : : // (so that we don't decide we're over our desired connection limit, and then
2401 : : // evict some peer that has finished the handshake)
2402 : 460 : int CConnman::GetExtraFullOutboundCount() const
2403 : : {
2404 : 460 : int full_outbound_peers = 0;
2405 : : {
2406 : 460 : LOCK(m_nodes_mutex);
2407 [ + + ]: 9129 : for (const CNode* pnode : m_nodes) {
2408 [ - + # # : 8669 : if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) {
# # # # ]
2409 : 0 : ++full_outbound_peers;
2410 : 0 : }
2411 : : }
2412 : 460 : }
2413 : 460 : return std::max(full_outbound_peers - m_max_outbound_full_relay, 0);
2414 : 0 : }
2415 : :
2416 : 0 : int CConnman::GetExtraBlockRelayCount() const
2417 : : {
2418 : 0 : int block_relay_peers = 0;
2419 : : {
2420 : 0 : LOCK(m_nodes_mutex);
2421 [ # # ]: 0 : for (const CNode* pnode : m_nodes) {
2422 [ # # # # : 0 : if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsBlockOnlyConn()) {
# # # # ]
2423 : 0 : ++block_relay_peers;
2424 : 0 : }
2425 : : }
2426 : 0 : }
2427 : 0 : return std::max(block_relay_peers - m_max_outbound_block_relay, 0);
2428 : 0 : }
2429 : :
2430 : 0 : std::unordered_set<Network> CConnman::GetReachableEmptyNetworks() const
2431 : : {
2432 : 0 : std::unordered_set<Network> networks{};
2433 [ # # ]: 0 : for (int n = 0; n < NET_MAX; n++) {
2434 : 0 : enum Network net = (enum Network)n;
2435 [ # # # # ]: 0 : if (net == NET_UNROUTABLE || net == NET_INTERNAL) continue;
2436 [ # # # # : 0 : if (IsReachable(net) && addrman.Size(net, std::nullopt) == 0) {
# # # # #
# ]
2437 [ # # ]: 0 : networks.insert(net);
2438 : 0 : }
2439 : 0 : }
2440 : 0 : return networks;
2441 [ # # ]: 0 : }
2442 : :
2443 : 0 : bool CConnman::MultipleManualOrFullOutboundConns(Network net) const
2444 : : {
2445 : 0 : AssertLockHeld(m_nodes_mutex);
2446 : 0 : return m_network_conn_counts[net] > 1;
2447 : : }
2448 : :
2449 : 0 : bool CConnman::MaybePickPreferredNetwork(std::optional<Network>& network)
2450 : : {
2451 : 0 : std::array<Network, 5> nets{NET_IPV4, NET_IPV6, NET_ONION, NET_I2P, NET_CJDNS};
2452 [ # # ]: 0 : Shuffle(nets.begin(), nets.end(), FastRandomContext());
2453 : :
2454 : 0 : LOCK(m_nodes_mutex);
2455 [ # # ]: 0 : for (const auto net : nets) {
2456 [ # # # # : 0 : if (IsReachable(net) && m_network_conn_counts[net] == 0 && addrman.Size(net) != 0) {
# # # # #
# # # ]
2457 [ # # ]: 0 : network = net;
2458 : 0 : return true;
2459 : : }
2460 : : }
2461 : :
2462 : 0 : return false;
2463 : 0 : }
2464 : :
2465 : 0 : void CConnman::ThreadOpenConnections(const std::vector<std::string> connect)
2466 : : {
2467 : 0 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2468 : 0 : AssertLockNotHeld(m_reconnections_mutex);
2469 : 0 : FastRandomContext rng;
2470 : : // Connect to specific addresses
2471 [ # # ]: 0 : if (!connect.empty())
2472 : : {
2473 : 0 : for (int64_t nLoop = 0;; nLoop++)
2474 : : {
2475 [ # # ]: 0 : for (const std::string& strAddr : connect)
2476 : : {
2477 [ # # # # ]: 0 : CAddress addr(CService(), NODE_NONE);
2478 [ # # ]: 0 : OpenNetworkConnection(addr, false, {}, strAddr.c_str(), ConnectionType::MANUAL, /*use_v2transport=*/false);
2479 [ # # # # ]: 0 : for (int i = 0; i < 10 && i < nLoop; i++)
2480 : : {
2481 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
# # # # ]
2482 : 0 : return;
2483 : 0 : }
2484 [ # # ]: 0 : }
2485 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
# # # # ]
2486 : 0 : return;
2487 : 0 : }
2488 : : }
2489 : :
2490 : : // Initiate network connections
2491 [ # # ]: 0 : auto start = GetTime<std::chrono::microseconds>();
2492 : :
2493 : : // Minimum time before next feeler connection (in microseconds).
2494 [ # # # # ]: 0 : auto next_feeler = GetExponentialRand(start, FEELER_INTERVAL);
2495 [ # # # # ]: 0 : auto next_extra_block_relay = GetExponentialRand(start, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
2496 [ # # # # ]: 0 : auto next_extra_network_peer{GetExponentialRand(start, EXTRA_NETWORK_PEER_INTERVAL)};
2497 [ # # # # ]: 0 : const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
2498 [ # # # # ]: 0 : bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);
2499 [ # # # # ]: 0 : const bool use_seednodes{gArgs.IsArgSet("-seednode")};
2500 : :
2501 [ # # ]: 0 : if (!add_fixed_seeds) {
2502 [ # # # # : 0 : LogPrintf("Fixed seeds are disabled\n");
# # ]
2503 : 0 : }
2504 : :
2505 [ # # # # ]: 0 : while (!interruptNet)
2506 : : {
2507 [ # # ]: 0 : ProcessAddrFetch();
2508 : :
2509 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::milliseconds(500)))
# # # # ]
2510 : 0 : return;
2511 : :
2512 [ # # ]: 0 : PerformReconnections();
2513 : :
2514 [ # # ]: 0 : CSemaphoreGrant grant(*semOutbound);
2515 [ # # # # ]: 0 : if (interruptNet)
2516 : 0 : return;
2517 : :
2518 [ # # ]: 0 : const std::unordered_set<Network> fixed_seed_networks{GetReachableEmptyNetworks()};
2519 [ # # # # ]: 0 : if (add_fixed_seeds && !fixed_seed_networks.empty()) {
2520 : : // When the node starts with an empty peers.dat, there are a few other sources of peers before
2521 : : // we fallback on to fixed seeds: -dnsseed, -seednode, -addnode
2522 : : // If none of those are available, we fallback on to fixed seeds immediately, else we allow
2523 : : // 60 seconds for any of those sources to populate addrman.
2524 : 0 : bool add_fixed_seeds_now = false;
2525 : : // It is cheapest to check if enough time has passed first.
2526 [ # # # # : 0 : if (GetTime<std::chrono::seconds>() > start + std::chrono::minutes{1}) {
# # # # #
# ]
2527 : 0 : add_fixed_seeds_now = true;
2528 [ # # # # : 0 : LogPrintf("Adding fixed seeds as 60 seconds have passed and addrman is empty for at least one reachable network\n");
# # ]
2529 : 0 : }
2530 : :
2531 : : // Perform cheap checks before locking a mutex.
2532 [ # # # # ]: 0 : else if (!dnsseed && !use_seednodes) {
2533 [ # # # # ]: 0 : LOCK(m_added_nodes_mutex);
2534 [ # # ]: 0 : if (m_added_node_params.empty()) {
2535 : 0 : add_fixed_seeds_now = true;
2536 [ # # # # : 0 : LogPrintf("Adding fixed seeds as -dnsseed=0 (or IPv4/IPv6 connections are disabled via -onlynet) and neither -addnode nor -seednode are provided\n");
# # ]
2537 : 0 : }
2538 : 0 : }
2539 : :
2540 [ # # ]: 0 : if (add_fixed_seeds_now) {
2541 [ # # # # ]: 0 : std::vector<CAddress> seed_addrs{ConvertSeeds(m_params.FixedSeeds())};
2542 : : // We will not make outgoing connections to peers that are unreachable
2543 : : // (e.g. because of -onlynet configuration).
2544 : : // Therefore, we do not add them to addrman in the first place.
2545 : : // In case previously unreachable networks become reachable
2546 : : // (e.g. in case of -onlynet changes by the user), fixed seeds will
2547 : : // be loaded only for networks for which we have no addresses.
2548 [ # # # # : 0 : seed_addrs.erase(std::remove_if(seed_addrs.begin(), seed_addrs.end(),
# # # # ]
2549 : 0 : [&fixed_seed_networks](const CAddress& addr) { return fixed_seed_networks.count(addr.GetNetwork()) == 0; }),
2550 : 0 : seed_addrs.end());
2551 [ # # ]: 0 : CNetAddr local;
2552 [ # # # # ]: 0 : local.SetInternal("fixedseeds");
2553 [ # # # # ]: 0 : addrman.Add(seed_addrs, local);
2554 : 0 : add_fixed_seeds = false;
2555 [ # # # # : 0 : LogPrintf("Added %d fixed seeds from reachable networks.\n", seed_addrs.size());
# # ]
2556 : 0 : }
2557 : 0 : }
2558 : :
2559 : : //
2560 : : // Choose an address to connect to based on most recently seen
2561 : : //
2562 [ # # ]: 0 : CAddress addrConnect;
2563 : :
2564 : : // Only connect out to one peer per ipv4/ipv6 network group (/16 for IPv4).
2565 : 0 : int nOutboundFullRelay = 0;
2566 : 0 : int nOutboundBlockRelay = 0;
2567 : 0 : int outbound_privacy_network_peers = 0;
2568 : 0 : std::set<std::vector<unsigned char>> outbound_ipv46_peer_netgroups;
2569 : :
2570 : : {
2571 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
2572 [ # # ]: 0 : for (const CNode* pnode : m_nodes) {
2573 [ # # # # ]: 0 : if (pnode->IsFullOutboundConn()) nOutboundFullRelay++;
2574 [ # # # # ]: 0 : if (pnode->IsBlockOnlyConn()) nOutboundBlockRelay++;
2575 : :
2576 : : // Make sure our persistent outbound slots to ipv4/ipv6 peers belong to different netgroups.
2577 [ # # # ]: 0 : switch (pnode->m_conn_type) {
2578 : : // We currently don't take inbound connections into account. Since they are
2579 : : // free to make, an attacker could make them to prevent us from connecting to
2580 : : // certain peers.
2581 : : case ConnectionType::INBOUND:
2582 : : // Short-lived outbound connections should not affect how we select outbound
2583 : : // peers from addrman.
2584 : : case ConnectionType::ADDR_FETCH:
2585 : : case ConnectionType::FEELER:
2586 : 0 : break;
2587 : : case ConnectionType::MANUAL:
2588 : : case ConnectionType::OUTBOUND_FULL_RELAY:
2589 : : case ConnectionType::BLOCK_RELAY:
2590 [ # # ]: 0 : const CAddress address{pnode->addr};
2591 [ # # # # : 0 : if (address.IsTor() || address.IsI2P() || address.IsCJDNS()) {
# # # # #
# # # ]
2592 : : // Since our addrman-groups for these networks are
2593 : : // random, without relation to the route we
2594 : : // take to connect to these peers or to the
2595 : : // difficulty in obtaining addresses with diverse
2596 : : // groups, we don't worry about diversity with
2597 : : // respect to our addrman groups when connecting to
2598 : : // these networks.
2599 : 0 : ++outbound_privacy_network_peers;
2600 : 0 : } else {
2601 [ # # # # ]: 0 : outbound_ipv46_peer_netgroups.insert(m_netgroupman.GetGroup(address));
2602 : : }
2603 : 0 : } // no default case, so the compiler can warn about missing cases
2604 : : }
2605 : 0 : }
2606 : :
2607 : 0 : ConnectionType conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
2608 [ # # ]: 0 : auto now = GetTime<std::chrono::microseconds>();
2609 : 0 : bool anchor = false;
2610 : 0 : bool fFeeler = false;
2611 : 0 : std::optional<Network> preferred_net;
2612 : :
2613 : : // Determine what type of connection to open. Opening
2614 : : // BLOCK_RELAY connections to addresses from anchors.dat gets the highest
2615 : : // priority. Then we open OUTBOUND_FULL_RELAY priority until we
2616 : : // meet our full-relay capacity. Then we open BLOCK_RELAY connection
2617 : : // until we hit our block-relay-only peer limit.
2618 : : // GetTryNewOutboundPeer() gets set when a stale tip is detected, so we
2619 : : // try opening an additional OUTBOUND_FULL_RELAY connection. If none of
2620 : : // these conditions are met, check to see if it's time to try an extra
2621 : : // block-relay-only peer (to confirm our tip is current, see below) or the next_feeler
2622 : : // timer to decide if we should open a FEELER.
2623 : :
2624 [ # # # # ]: 0 : if (!m_anchors.empty() && (nOutboundBlockRelay < m_max_outbound_block_relay)) {
2625 : 0 : conn_type = ConnectionType::BLOCK_RELAY;
2626 : 0 : anchor = true;
2627 [ # # ]: 0 : } else if (nOutboundFullRelay < m_max_outbound_full_relay) {
2628 : : // OUTBOUND_FULL_RELAY
2629 [ # # ]: 0 : } else if (nOutboundBlockRelay < m_max_outbound_block_relay) {
2630 : 0 : conn_type = ConnectionType::BLOCK_RELAY;
2631 [ # # ]: 0 : } else if (GetTryNewOutboundPeer()) {
2632 : : // OUTBOUND_FULL_RELAY
2633 [ # # # # : 0 : } else if (now > next_extra_block_relay && m_start_extra_block_relay_peers) {
# # ]
2634 : : // Periodically connect to a peer (using regular outbound selection
2635 : : // methodology from addrman) and stay connected long enough to sync
2636 : : // headers, but not much else.
2637 : : //
2638 : : // Then disconnect the peer, if we haven't learned anything new.
2639 : : //
2640 : : // The idea is to make eclipse attacks very difficult to pull off,
2641 : : // because every few minutes we're finding a new peer to learn headers
2642 : : // from.
2643 : : //
2644 : : // This is similar to the logic for trying extra outbound (full-relay)
2645 : : // peers, except:
2646 : : // - we do this all the time on an exponential timer, rather than just when
2647 : : // our tip is stale
2648 : : // - we potentially disconnect our next-youngest block-relay-only peer, if our
2649 : : // newest block-relay-only peer delivers a block more recently.
2650 : : // See the eviction logic in net_processing.cpp.
2651 : : //
2652 : : // Because we can promote these connections to block-relay-only
2653 : : // connections, they do not get their own ConnectionType enum
2654 : : // (similar to how we deal with extra outbound peers).
2655 [ # # # # ]: 0 : next_extra_block_relay = GetExponentialRand(now, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
2656 : 0 : conn_type = ConnectionType::BLOCK_RELAY;
2657 [ # # # # ]: 0 : } else if (now > next_feeler) {
2658 [ # # # # ]: 0 : next_feeler = GetExponentialRand(now, FEELER_INTERVAL);
2659 : 0 : conn_type = ConnectionType::FEELER;
2660 : 0 : fFeeler = true;
2661 [ # # # # ]: 0 : } else if (nOutboundFullRelay == m_max_outbound_full_relay &&
2662 [ # # ]: 0 : m_max_outbound_full_relay == MAX_OUTBOUND_FULL_RELAY_CONNECTIONS &&
2663 [ # # # # ]: 0 : now > next_extra_network_peer &&
2664 [ # # ]: 0 : MaybePickPreferredNetwork(preferred_net)) {
2665 : : // Full outbound connection management: Attempt to get at least one
2666 : : // outbound peer from each reachable network by making extra connections
2667 : : // and then protecting "only" peers from a network during outbound eviction.
2668 : : // This is not attempted if the user changed -maxconnections to a value
2669 : : // so low that less than MAX_OUTBOUND_FULL_RELAY_CONNECTIONS are made,
2670 : : // to prevent interactions with otherwise protected outbound peers.
2671 [ # # # # ]: 0 : next_extra_network_peer = GetExponentialRand(now, EXTRA_NETWORK_PEER_INTERVAL);
2672 : 0 : } else {
2673 : : // skip to next iteration of while loop
2674 : 0 : continue;
2675 : : }
2676 : :
2677 [ # # ]: 0 : addrman.ResolveCollisions();
2678 : :
2679 : 0 : const auto current_time{NodeClock::now()};
2680 : 0 : int nTries = 0;
2681 [ # # # # ]: 0 : while (!interruptNet)
2682 : : {
2683 [ # # # # ]: 0 : if (anchor && !m_anchors.empty()) {
2684 [ # # ]: 0 : const CAddress addr = m_anchors.back();
2685 : 0 : m_anchors.pop_back();
2686 [ # # # # : 0 : if (!addr.IsValid() || IsLocal(addr) || !IsReachable(addr) ||
# # # # #
# # # # #
# # # # ]
2687 [ # # # # ]: 0 : !HasAllDesirableServiceFlags(addr.nServices) ||
2688 [ # # # # ]: 0 : outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) continue;
2689 [ # # ]: 0 : addrConnect = addr;
2690 [ # # # # : 0 : LogPrint(BCLog::NET, "Trying to make an anchor connection to %s\n", addrConnect.ToStringAddrPort());
# # # # #
# # # ]
2691 : 0 : break;
2692 : 0 : }
2693 : :
2694 : : // If we didn't find an appropriate destination after trying 100 addresses fetched from addrman,
2695 : : // stop this loop, and let the outer loop run again (which sleeps, adds seed nodes, recalculates
2696 : : // already-connected network ranges, ...) before trying new addrman addresses.
2697 : 0 : nTries++;
2698 [ # # ]: 0 : if (nTries > 100)
2699 : 0 : break;
2700 : :
2701 [ # # ]: 0 : CAddress addr;
2702 [ # # # # ]: 0 : NodeSeconds addr_last_try{0s};
2703 : :
2704 [ # # ]: 0 : if (fFeeler) {
2705 : : // First, try to get a tried table collision address. This returns
2706 : : // an empty (invalid) address if there are no collisions to try.
2707 [ # # ]: 0 : std::tie(addr, addr_last_try) = addrman.SelectTriedCollision();
2708 : :
2709 [ # # # # ]: 0 : if (!addr.IsValid()) {
2710 : : // No tried table collisions. Select a new table address
2711 : : // for our feeler.
2712 [ # # ]: 0 : std::tie(addr, addr_last_try) = addrman.Select(true);
2713 [ # # # # ]: 0 : } else if (AlreadyConnectedToAddress(addr)) {
2714 : : // If test-before-evict logic would have us connect to a
2715 : : // peer that we're already connected to, just mark that
2716 : : // address as Good(). We won't be able to initiate the
2717 : : // connection anyway, so this avoids inadvertently evicting
2718 : : // a currently-connected peer.
2719 [ # # # # ]: 0 : addrman.Good(addr);
2720 : : // Select a new table address for our feeler instead.
2721 [ # # ]: 0 : std::tie(addr, addr_last_try) = addrman.Select(true);
2722 : 0 : }
2723 : 0 : } else {
2724 : : // Not a feeler
2725 : : // If preferred_net has a value set, pick an extra outbound
2726 : : // peer from that network. The eviction logic in net_processing
2727 : : // ensures that a peer from another network will be evicted.
2728 [ # # ]: 0 : std::tie(addr, addr_last_try) = addrman.Select(false, preferred_net);
2729 : : }
2730 : :
2731 : : // Require outbound IPv4/IPv6 connections, other than feelers, to be to distinct network groups
2732 [ # # # # : 0 : if (!fFeeler && outbound_ipv46_peer_netgroups.count(m_netgroupman.GetGroup(addr))) {
# # # # #
# # # ]
2733 : 0 : continue;
2734 : : }
2735 : :
2736 : : // if we selected an invalid or local address, restart
2737 [ # # # # : 0 : if (!addr.IsValid() || IsLocal(addr)) {
# # # # ]
2738 : 0 : break;
2739 : : }
2740 : :
2741 [ # # # # ]: 0 : if (!IsReachable(addr))
2742 : 0 : continue;
2743 : :
2744 : : // only consider very recently tried nodes after 30 failed attempts
2745 [ # # # # : 0 : if (current_time - addr_last_try < 10min && nTries < 30) {
# # # # #
# ]
2746 : 0 : continue;
2747 : : }
2748 : :
2749 : : // for non-feelers, require all the services we'll want,
2750 : : // for feelers, only require they be a full node (only because most
2751 : : // SPV clients don't have a good address DB available)
2752 [ # # # # : 0 : if (!fFeeler && !HasAllDesirableServiceFlags(addr.nServices)) {
# # ]
2753 : 0 : continue;
2754 [ # # # # : 0 : } else if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) {
# # ]
2755 : 0 : continue;
2756 : : }
2757 : :
2758 : : // Do not connect to bad ports, unless 50 invalid addresses have been selected already.
2759 [ # # # # : 0 : if (nTries < 50 && (addr.IsIPv4() || addr.IsIPv6()) && IsBadPort(addr.GetPort())) {
# # # # #
# # # #
# ]
2760 : 0 : continue;
2761 : : }
2762 : :
2763 [ # # ]: 0 : addrConnect = addr;
2764 : 0 : break;
2765 : 0 : }
2766 : :
2767 [ # # # # ]: 0 : if (addrConnect.IsValid()) {
2768 [ # # ]: 0 : if (fFeeler) {
2769 : : // Add small amount of random noise before connection to avoid synchronization.
2770 [ # # # # : 0 : if (!interruptNet.sleep_for(rng.rand_uniform_duration<CThreadInterrupt::Clock>(FEELER_SLEEP_WINDOW))) {
# # ]
2771 : 0 : return;
2772 : : }
2773 [ # # # # : 0 : LogPrint(BCLog::NET, "Making feeler connection to %s\n", addrConnect.ToStringAddrPort());
# # # # #
# # # ]
2774 : 0 : }
2775 : :
2776 [ # # # # : 0 : if (preferred_net != std::nullopt) LogPrint(BCLog::NET, "Making network specific connection to %s on %s.\n", addrConnect.ToStringAddrPort(), GetNetworkName(preferred_net.value()));
# # # # #
# # # # #
# # # # ]
2777 : :
2778 : : // Record addrman failure attempts when node has at least 2 persistent outbound connections to peers with
2779 : : // different netgroups in ipv4/ipv6 networks + all peers in Tor/I2P/CJDNS networks.
2780 : : // Don't record addrman failure attempts when node is offline. This can be identified since all local
2781 : : // network connections (if any) belong in the same netgroup, and the size of `outbound_ipv46_peer_netgroups` would only be 1.
2782 [ # # ]: 0 : const bool count_failures{((int)outbound_ipv46_peer_netgroups.size() + outbound_privacy_network_peers) >= std::min(nMaxConnections - 1, 2)};
2783 : : // Use BIP324 transport when both us and them have NODE_V2_P2P set.
2784 [ # # ]: 0 : const bool use_v2transport(addrConnect.nServices & GetLocalServices() & NODE_P2P_V2);
2785 [ # # ]: 0 : OpenNetworkConnection(addrConnect, count_failures, std::move(grant), /*strDest=*/nullptr, conn_type, use_v2transport);
2786 : 0 : }
2787 [ # # # ]: 0 : }
2788 : 0 : }
2789 : :
2790 : 0 : std::vector<CAddress> CConnman::GetCurrentBlockRelayOnlyConns() const
2791 : : {
2792 : 0 : std::vector<CAddress> ret;
2793 [ # # # # ]: 0 : LOCK(m_nodes_mutex);
2794 [ # # ]: 0 : for (const CNode* pnode : m_nodes) {
2795 [ # # # # ]: 0 : if (pnode->IsBlockOnlyConn()) {
2796 [ # # ]: 0 : ret.push_back(pnode->addr);
2797 : 0 : }
2798 : : }
2799 : :
2800 : 0 : return ret;
2801 [ # # ]: 0 : }
2802 : :
2803 : 463 : std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo() const
2804 : : {
2805 : 463 : std::vector<AddedNodeInfo> ret;
2806 : :
2807 [ + - ]: 463 : std::list<AddedNodeParams> lAddresses(0);
2808 : : {
2809 [ + - + - ]: 463 : LOCK(m_added_nodes_mutex);
2810 [ + - ]: 463 : ret.reserve(m_added_node_params.size());
2811 [ + - + - ]: 463 : std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));
2812 : 463 : }
2813 : :
2814 : :
2815 : : // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
2816 : 463 : std::map<CService, bool> mapConnected;
2817 : 463 : std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
2818 : : {
2819 [ + - + - ]: 463 : LOCK(m_nodes_mutex);
2820 [ + + ]: 9132 : for (const CNode* pnode : m_nodes) {
2821 [ + - + + ]: 8669 : if (pnode->addr.IsValid()) {
2822 [ + - + - ]: 8257 : mapConnected[pnode->addr] = pnode->IsInboundConn();
2823 : 8257 : }
2824 [ + - ]: 8669 : std::string addrName{pnode->m_addr_name};
2825 [ - + ]: 8669 : if (!addrName.empty()) {
2826 [ + - + - : 8669 : mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(), static_cast<const CService&>(pnode->addr));
+ - ]
2827 : 8669 : }
2828 : 8669 : }
2829 : 463 : }
2830 : :
2831 [ + + ]: 492 : for (const auto& addr : lAddresses) {
2832 [ + - + - : 29 : CService service(LookupNumeric(addr.m_added_node, GetDefaultPort(addr.m_added_node)));
+ - ]
2833 [ + - + - ]: 29 : AddedNodeInfo addedNode{addr, CService(), false, false};
2834 [ + - + + ]: 29 : if (service.IsValid()) {
2835 : : // strAddNode is an IP:port
2836 [ + - ]: 10 : auto it = mapConnected.find(service);
2837 [ - + ]: 10 : if (it != mapConnected.end()) {
2838 [ # # ]: 0 : addedNode.resolvedAddress = service;
2839 : 0 : addedNode.fConnected = true;
2840 : 0 : addedNode.fInbound = it->second;
2841 : 0 : }
2842 : 10 : } else {
2843 : : // strAddNode is a name
2844 [ + - ]: 19 : auto it = mapConnectedByName.find(addr.m_added_node);
2845 [ + + ]: 19 : if (it != mapConnectedByName.end()) {
2846 [ + - ]: 1 : addedNode.resolvedAddress = it->second.second;
2847 : 1 : addedNode.fConnected = true;
2848 : 1 : addedNode.fInbound = it->second.first;
2849 : 1 : }
2850 : : }
2851 [ + - ]: 29 : ret.emplace_back(std::move(addedNode));
2852 : 29 : }
2853 : :
2854 : 463 : return ret;
2855 [ + - ]: 463 : }
2856 : :
2857 : 0 : void CConnman::ThreadOpenAddedConnections()
2858 : : {
2859 : 0 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2860 : 0 : AssertLockNotHeld(m_reconnections_mutex);
2861 : 0 : while (true)
2862 : : {
2863 : 0 : CSemaphoreGrant grant(*semAddnode);
2864 [ # # ]: 0 : std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo();
2865 : 0 : bool tried = false;
2866 [ # # ]: 0 : for (const AddedNodeInfo& info : vInfo) {
2867 [ # # ]: 0 : if (!info.fConnected) {
2868 [ # # ]: 0 : if (!grant) {
2869 : : // If we've used up our semaphore and need a new one, let's not wait here since while we are waiting
2870 : : // the addednodeinfo state might change.
2871 : 0 : break;
2872 : : }
2873 : 0 : tried = true;
2874 [ # # # # ]: 0 : CAddress addr(CService(), NODE_NONE);
2875 [ # # ]: 0 : OpenNetworkConnection(addr, false, std::move(grant), info.m_params.m_added_node.c_str(), ConnectionType::MANUAL, info.m_params.m_use_v2transport);
2876 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) return;
# # # # ]
2877 [ # # ]: 0 : grant = CSemaphoreGrant(*semAddnode, /*fTry=*/true);
2878 [ # # ]: 0 : }
2879 : : }
2880 : : // Retry every 60 seconds if a connection was attempted, otherwise two seconds
2881 [ # # # # : 0 : if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2)))
# # # # ]
2882 : 0 : return;
2883 : : // See if any reconnections are desired.
2884 [ # # ]: 0 : PerformReconnections();
2885 [ # # # ]: 0 : }
2886 : 0 : }
2887 : :
2888 : : // if successful, this moves the passed grant to the constructed node
2889 : 411 : void CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant&& grant_outbound, const char *pszDest, ConnectionType conn_type, bool use_v2transport)
2890 : : {
2891 : 411 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
2892 [ + - ]: 411 : assert(conn_type != ConnectionType::INBOUND);
2893 : :
2894 : : //
2895 : : // Initiate outbound network connection
2896 : : //
2897 [ - + ]: 411 : if (interruptNet) {
2898 : 0 : return;
2899 : : }
2900 [ + + ]: 411 : if (!fNetworkActive) {
2901 : 304 : return;
2902 : : }
2903 [ + + ]: 107 : if (!pszDest) {
2904 [ + - # # ]: 100 : bool banned_or_discouraged = m_banman && (m_banman->IsDiscouraged(addrConnect) || m_banman->IsBanned(addrConnect));
2905 [ + - + - : 100 : if (IsLocal(addrConnect) || banned_or_discouraged || AlreadyConnectedToAddress(addrConnect)) {
+ + ]
2906 : 9 : return;
2907 : : }
2908 [ + - + - : 98 : } else if (FindNode(std::string(pszDest)))
- + ]
2909 : 0 : return;
2910 : :
2911 [ - + ]: 98 : CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type, use_v2transport);
2912 : :
2913 [ + + ]: 98 : if (!pnode)
2914 : 95 : return;
2915 : 3 : pnode->grantOutbound = std::move(grant_outbound);
2916 : :
2917 : 3 : m_msgproc->InitializeNode(*pnode, nLocalServices);
2918 : : {
2919 : 3 : LOCK(m_nodes_mutex);
2920 [ + - ]: 3 : m_nodes.push_back(pnode);
2921 : :
2922 : : // update connection count by network
2923 [ + - + - : 3 : if (pnode->IsManualOrFullOutboundConn()) ++m_network_conn_counts[pnode->addr.GetNetwork()];
+ - ]
2924 : 3 : }
2925 : 411 : }
2926 : :
2927 : : Mutex NetEventsInterface::g_msgproc_mutex;
2928 : :
2929 : 0 : void CConnman::ThreadMessageHandler()
2930 : : {
2931 : 0 : LOCK(NetEventsInterface::g_msgproc_mutex);
2932 : :
2933 [ # # ]: 0 : while (!flagInterruptMsgProc)
2934 : : {
2935 : 0 : bool fMoreWork = false;
2936 : :
2937 : : {
2938 : : // Randomize the order in which we process messages from/to our peers.
2939 : : // This prevents attacks in which an attacker exploits having multiple
2940 : : // consecutive connections in the m_nodes list.
2941 [ # # ]: 0 : const NodesSnapshot snap{*this, /*shuffle=*/true};
2942 : :
2943 [ # # # # ]: 0 : for (CNode* pnode : snap.Nodes()) {
2944 [ # # ]: 0 : if (pnode->fDisconnect)
2945 : 0 : continue;
2946 : :
2947 : : // Receive messages
2948 [ # # ]: 0 : bool fMoreNodeWork = m_msgproc->ProcessMessages(pnode, flagInterruptMsgProc);
2949 [ # # ]: 0 : fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
2950 [ # # ]: 0 : if (flagInterruptMsgProc)
2951 : 0 : return;
2952 : : // Send messages
2953 [ # # ]: 0 : m_msgproc->SendMessages(pnode);
2954 : :
2955 [ # # ]: 0 : if (flagInterruptMsgProc)
2956 : 0 : return;
2957 : : }
2958 [ # # ]: 0 : }
2959 : :
2960 [ # # # # ]: 0 : WAIT_LOCK(mutexMsgProc, lock);
2961 [ # # ]: 0 : if (!fMoreWork) {
2962 [ # # # # : 0 : condMsgProc.wait_until(lock, std::chrono::steady_clock::now() + std::chrono::milliseconds(100), [this]() EXCLUSIVE_LOCKS_REQUIRED(mutexMsgProc) { return fMsgProcWake; });
# # ]
2963 : 0 : }
2964 : 0 : fMsgProcWake = false;
2965 : 0 : }
2966 [ # # ]: 0 : }
2967 : :
2968 : 0 : void CConnman::ThreadI2PAcceptIncoming()
2969 : : {
2970 : : static constexpr auto err_wait_begin = 1s;
2971 : : static constexpr auto err_wait_cap = 5min;
2972 : 0 : auto err_wait = err_wait_begin;
2973 : :
2974 : 0 : bool advertising_listen_addr = false;
2975 : 0 : i2p::Connection conn;
2976 : :
2977 [ # # # # ]: 0 : while (!interruptNet) {
2978 : :
2979 [ # # # # ]: 0 : if (!m_i2p_sam_session->Listen(conn)) {
2980 [ # # # # : 0 : if (advertising_listen_addr && conn.me.IsValid()) {
# # ]
2981 [ # # ]: 0 : RemoveLocal(conn.me);
2982 : 0 : advertising_listen_addr = false;
2983 : 0 : }
2984 : :
2985 [ # # # # ]: 0 : interruptNet.sleep_for(err_wait);
2986 [ # # # # ]: 0 : if (err_wait < err_wait_cap) {
2987 [ # # ]: 0 : err_wait *= 2;
2988 : 0 : }
2989 : :
2990 : 0 : continue;
2991 : : }
2992 : :
2993 [ # # ]: 0 : if (!advertising_listen_addr) {
2994 [ # # ]: 0 : AddLocal(conn.me, LOCAL_MANUAL);
2995 : 0 : advertising_listen_addr = true;
2996 : 0 : }
2997 : :
2998 [ # # # # ]: 0 : if (!m_i2p_sam_session->Accept(conn)) {
2999 : 0 : continue;
3000 : : }
3001 : :
3002 [ # # ]: 0 : CreateNodeFromAcceptedSocket(std::move(conn.sock), NetPermissionFlags::None,
3003 [ # # # # : 0 : CAddress{conn.me, NODE_NONE}, CAddress{conn.peer, NODE_NONE});
# # # # ]
3004 : : }
3005 : 0 : }
3006 : :
3007 : 267 : bool CConnman::BindListenPort(const CService& addrBind, bilingual_str& strError, NetPermissionFlags permissions)
3008 : : {
3009 : 267 : int nOne = 1;
3010 : :
3011 : : // Create socket for listening for incoming connections
3012 : : struct sockaddr_storage sockaddr;
3013 : 267 : socklen_t len = sizeof(sockaddr);
3014 [ + + ]: 267 : if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
3015 : : {
3016 [ + - + - : 132 : strError = strprintf(Untranslated("Bind address family for %s not supported"), addrBind.ToStringAddrPort());
+ - + - ]
3017 [ - + + - : 132 : LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
+ - + - ]
3018 : 132 : return false;
3019 : : }
3020 : :
3021 : 135 : std::unique_ptr<Sock> sock = CreateSock(addrBind);
3022 [ + - ]: 135 : if (!sock) {
3023 [ # # # # : 0 : strError = strprintf(Untranslated("Couldn't open socket for incoming connections (socket returned error %s)"), NetworkErrorString(WSAGetLastError()));
# # # # ]
3024 [ # # # # : 0 : LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
# # # # #
# ]
3025 : 0 : return false;
3026 : : }
3027 : :
3028 : : // Allow binding if the port is still in TIME_WAIT state after
3029 : : // the program was closed and restarted.
3030 [ + - + + ]: 135 : if (sock->SetSockOpt(SOL_SOCKET, SO_REUSEADDR, (sockopt_arg_type)&nOne, sizeof(int)) == SOCKET_ERROR) {
3031 [ + - + - : 91 : strError = strprintf(Untranslated("Error setting SO_REUSEADDR on socket: %s, continuing anyway"), NetworkErrorString(WSAGetLastError()));
+ - + - ]
3032 [ + - + - : 91 : LogPrintf("%s\n", strError.original);
+ - ]
3033 : 91 : }
3034 : :
3035 : : // some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
3036 : : // and enable it by default or not. Try to enable it, if possible.
3037 [ + - + + ]: 135 : if (addrBind.IsIPv6()) {
3038 : : #ifdef IPV6_V6ONLY
3039 [ + - + + ]: 87 : if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_V6ONLY, (sockopt_arg_type)&nOne, sizeof(int)) == SOCKET_ERROR) {
3040 [ + - + - : 66 : strError = strprintf(Untranslated("Error setting IPV6_V6ONLY on socket: %s, continuing anyway"), NetworkErrorString(WSAGetLastError()));
+ - + - ]
3041 [ + - + - : 66 : LogPrintf("%s\n", strError.original);
+ - ]
3042 : 66 : }
3043 : : #endif
3044 : : #ifdef WIN32
3045 : : int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
3046 : : if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, (const char*)&nProtLevel, sizeof(int)) == SOCKET_ERROR) {
3047 : : strError = strprintf(Untranslated("Error setting IPV6_PROTECTION_LEVEL on socket: %s, continuing anyway"), NetworkErrorString(WSAGetLastError()));
3048 : : LogPrintf("%s\n", strError.original);
3049 : : }
3050 : : #endif
3051 : 87 : }
3052 : :
3053 [ + - + + ]: 135 : if (sock->Bind(reinterpret_cast<struct sockaddr*>(&sockaddr), len) == SOCKET_ERROR) {
3054 : 90 : int nErr = WSAGetLastError();
3055 [ + + ]: 90 : if (nErr == WSAEADDRINUSE)
3056 [ + - + - : 49 : strError = strprintf(_("Unable to bind to %s on this computer. %s is probably already running."), addrBind.ToStringAddrPort(), PACKAGE_NAME);
+ - ]
3057 : : else
3058 [ + - + - : 41 : strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %s)"), addrBind.ToStringAddrPort(), NetworkErrorString(nErr));
+ - + - ]
3059 [ + - - + : 90 : LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
+ - + - +
- ]
3060 : 90 : return false;
3061 : : }
3062 [ + - + - : 45 : LogPrintf("Bound to %s\n", addrBind.ToStringAddrPort());
+ - + - ]
3063 : :
3064 : : // Listen for incoming connections
3065 [ + - + + ]: 45 : if (sock->Listen(SOMAXCONN) == SOCKET_ERROR)
3066 : : {
3067 [ + - + - : 7 : strError = strprintf(_("Listening for incoming connections failed (listen returned error %s)"), NetworkErrorString(WSAGetLastError()));
+ - ]
3068 [ + - - + : 7 : LogPrintLevel(BCLog::NET, BCLog::Level::Error, "%s\n", strError.original);
+ - + - -
+ ]
3069 : 7 : return false;
3070 : : }
3071 : :
3072 [ + - ]: 38 : vhListenSocket.emplace_back(std::move(sock), permissions);
3073 : 38 : return true;
3074 : 267 : }
3075 : :
3076 : 0 : void Discover()
3077 : : {
3078 [ # # ]: 0 : if (!fDiscover)
3079 : 0 : return;
3080 : :
3081 : : #ifdef WIN32
3082 : : // Get local host IP
3083 : : char pszHostName[256] = "";
3084 : : if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
3085 : : {
3086 : : const std::vector<CNetAddr> addresses{LookupHost(pszHostName, 0, true)};
3087 : : for (const CNetAddr& addr : addresses)
3088 : : {
3089 : : if (AddLocal(addr, LOCAL_IF))
3090 : : LogPrintf("%s: %s - %s\n", __func__, pszHostName, addr.ToStringAddr());
3091 : : }
3092 : : }
3093 : : #elif (HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS)
3094 : : // Get local host ip
3095 : : struct ifaddrs* myaddrs;
3096 [ # # ]: 0 : if (getifaddrs(&myaddrs) == 0)
3097 : : {
3098 [ # # ]: 0 : for (struct ifaddrs* ifa = myaddrs; ifa != nullptr; ifa = ifa->ifa_next)
3099 : : {
3100 [ # # ]: 0 : if (ifa->ifa_addr == nullptr) continue;
3101 [ # # ]: 0 : if ((ifa->ifa_flags & IFF_UP) == 0) continue;
3102 [ # # ]: 0 : if (strcmp(ifa->ifa_name, "lo") == 0) continue;
3103 [ # # ]: 0 : if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
3104 [ # # ]: 0 : if (ifa->ifa_addr->sa_family == AF_INET)
3105 : : {
3106 : 0 : struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
3107 : 0 : CNetAddr addr(s4->sin_addr);
3108 [ # # # # ]: 0 : if (AddLocal(addr, LOCAL_IF))
3109 [ # # # # : 0 : LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name, addr.ToStringAddr());
# # # # ]
3110 : 0 : }
3111 [ # # ]: 0 : else if (ifa->ifa_addr->sa_family == AF_INET6)
3112 : : {
3113 : 0 : struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
3114 : 0 : CNetAddr addr(s6->sin6_addr);
3115 [ # # # # ]: 0 : if (AddLocal(addr, LOCAL_IF))
3116 [ # # # # : 0 : LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name, addr.ToStringAddr());
# # # # ]
3117 : 0 : }
3118 : 0 : }
3119 : 0 : freeifaddrs(myaddrs);
3120 : 0 : }
3121 : : #endif
3122 : 0 : }
3123 : :
3124 : 1328 : void CConnman::SetNetworkActive(bool active)
3125 : : {
3126 [ + - + - : 1328 : LogPrintf("%s: %s\n", __func__, active);
- + ]
3127 : :
3128 [ + + ]: 1328 : if (fNetworkActive == active) {
3129 : 1130 : return;
3130 : : }
3131 : :
3132 : 198 : fNetworkActive = active;
3133 : :
3134 [ - + ]: 198 : if (m_client_interface) {
3135 : 0 : m_client_interface->NotifyNetworkActiveChanged(fNetworkActive);
3136 : 0 : }
3137 : 1328 : }
3138 : :
3139 [ + - + - : 684 : CConnman::CConnman(uint64_t nSeed0In, uint64_t nSeed1In, AddrMan& addrman_in,
+ - + - +
- + - + -
+ - + - ]
3140 : : const NetGroupManager& netgroupman, const CChainParams& params, bool network_active)
3141 : 684 : : addrman(addrman_in)
3142 : 684 : , m_netgroupman{netgroupman}
3143 : 684 : , nSeed0(nSeed0In)
3144 : 684 : , nSeed1(nSeed1In)
3145 : 684 : , m_params(params)
3146 : : {
3147 [ - + ]: 684 : SetTryNewOutboundPeer(false);
3148 : :
3149 : 684 : Options connOptions;
3150 [ + - ]: 684 : Init(connOptions);
3151 [ + - ]: 684 : SetNetworkActive(network_active);
3152 : 684 : }
3153 : :
3154 : 3 : NodeId CConnman::GetNewNodeId()
3155 : : {
3156 : 3 : return nLastNodeId.fetch_add(1, std::memory_order_relaxed);
3157 : : }
3158 : :
3159 : 0 : uint16_t CConnman::GetDefaultPort(Network net) const
3160 : : {
3161 [ # # ]: 0 : return net == NET_I2P ? I2P_SAM31_PORT : m_params.GetDefaultPort();
3162 : : }
3163 : :
3164 : 36 : uint16_t CConnman::GetDefaultPort(const std::string& addr) const
3165 : : {
3166 : 36 : CNetAddr a;
3167 [ + - - + : 36 : return a.SetSpecial(addr) ? GetDefaultPort(a.GetNetwork()) : m_params.GetDefaultPort();
# # # # +
- ]
3168 : 36 : }
3169 : :
3170 : 267 : bool CConnman::Bind(const CService& addr_, unsigned int flags, NetPermissionFlags permissions)
3171 : : {
3172 : 267 : const CService addr{MaybeFlipIPv6toCJDNS(addr_)};
3173 : :
3174 : 267 : bilingual_str strError;
3175 [ + - + + ]: 267 : if (!BindListenPort(addr, strError, permissions)) {
3176 [ + + + - ]: 229 : if ((flags & BF_REPORT_ERROR) && m_client_interface) {
3177 [ # # # # ]: 0 : m_client_interface->ThreadSafeMessageBox(strError, "", CClientUIInterface::MSG_ERROR);
3178 : 0 : }
3179 : 229 : return false;
3180 : : }
3181 : :
3182 [ + - + + : 38 : if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) && !NetPermissions::HasFlag(permissions, NetPermissionFlags::NoBan)) {
+ - + + +
- + + ]
3183 [ + - ]: 14 : AddLocal(addr, LOCAL_BIND);
3184 : 14 : }
3185 : :
3186 : 38 : return true;
3187 : 267 : }
3188 : :
3189 : 39 : bool CConnman::InitBinds(const Options& options)
3190 : : {
3191 : 39 : bool fBound = false;
3192 [ + + ]: 147 : for (const auto& addrBind : options.vBinds) {
3193 : 108 : fBound |= Bind(addrBind, BF_REPORT_ERROR, NetPermissionFlags::None);
3194 : : }
3195 [ + + ]: 119 : for (const auto& addrBind : options.vWhiteBinds) {
3196 : 80 : fBound |= Bind(addrBind.m_service, BF_REPORT_ERROR, addrBind.m_flags);
3197 : : }
3198 [ + + ]: 116 : for (const auto& addr_bind : options.onion_binds) {
3199 : 77 : fBound |= Bind(addr_bind, BF_DONT_ADVERTISE, NetPermissionFlags::None);
3200 : : }
3201 [ + + ]: 39 : if (options.bind_on_any) {
3202 : : struct in_addr inaddr_any;
3203 : 1 : inaddr_any.s_addr = htonl(INADDR_ANY);
3204 : 1 : struct in6_addr inaddr6_any = IN6ADDR_ANY_INIT;
3205 [ + - ]: 1 : fBound |= Bind(CService(inaddr6_any, GetListenPort()), BF_NONE, NetPermissionFlags::None);
3206 [ - + ]: 1 : fBound |= Bind(CService(inaddr_any, GetListenPort()), !fBound ? BF_REPORT_ERROR : BF_NONE, NetPermissionFlags::None);
3207 : 1 : }
3208 : 39 : return fBound;
3209 : 0 : }
3210 : :
3211 : 0 : bool CConnman::Start(CScheduler& scheduler, const Options& connOptions)
3212 : : {
3213 : 0 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3214 : 0 : Init(connOptions);
3215 : :
3216 [ # # # # ]: 0 : if (fListen && !InitBinds(connOptions)) {
3217 [ # # ]: 0 : if (m_client_interface) {
3218 [ # # ]: 0 : m_client_interface->ThreadSafeMessageBox(
3219 : 0 : _("Failed to listen on any port. Use -listen=0 if you want this."),
3220 [ # # ]: 0 : "", CClientUIInterface::MSG_ERROR);
3221 : 0 : }
3222 : 0 : return false;
3223 : : }
3224 : :
3225 : 0 : Proxy i2p_sam;
3226 [ # # # # : 0 : if (GetProxy(NET_I2P, i2p_sam) && connOptions.m_i2p_accept_incoming) {
# # ]
3227 [ # # # # : 0 : m_i2p_sam_session = std::make_unique<i2p::sam::Session>(gArgs.GetDataDirNet() / "i2p_private_key",
# # # # ]
3228 : 0 : i2p_sam.proxy, &interruptNet);
3229 : 0 : }
3230 : :
3231 [ # # ]: 0 : for (const auto& strDest : connOptions.vSeedNodes) {
3232 [ # # ]: 0 : AddAddrFetch(strDest);
3233 : : }
3234 : :
3235 [ # # ]: 0 : if (m_use_addrman_outgoing) {
3236 : : // Load addresses from anchors.dat
3237 [ # # # # : 0 : m_anchors = ReadAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME);
# # # # ]
3238 [ # # ]: 0 : if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
3239 [ # # ]: 0 : m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
3240 : 0 : }
3241 [ # # # # : 0 : LogPrintf("%i block-relay-only anchors will be tried for connections.\n", m_anchors.size());
# # ]
3242 : 0 : }
3243 : :
3244 [ # # ]: 0 : if (m_client_interface) {
3245 [ # # # # ]: 0 : m_client_interface->InitMessage(_("Starting network threads…").translated);
3246 : 0 : }
3247 : :
3248 : 0 : fAddressesInitialized = true;
3249 : :
3250 [ # # ]: 0 : if (semOutbound == nullptr) {
3251 : : // initialize semaphore
3252 [ # # # # ]: 0 : semOutbound = std::make_unique<CSemaphore>(std::min(m_max_outbound, nMaxConnections));
3253 : 0 : }
3254 [ # # ]: 0 : if (semAddnode == nullptr) {
3255 : : // initialize semaphore
3256 [ # # ]: 0 : semAddnode = std::make_unique<CSemaphore>(nMaxAddnode);
3257 : 0 : }
3258 : :
3259 : : //
3260 : : // Start threads
3261 : : //
3262 [ # # ]: 0 : assert(m_msgproc);
3263 [ # # ]: 0 : InterruptSocks5(false);
3264 [ # # ]: 0 : interruptNet.reset();
3265 : 0 : flagInterruptMsgProc = false;
3266 : :
3267 : : {
3268 [ # # # # ]: 0 : LOCK(mutexMsgProc);
3269 : 0 : fMsgProcWake = false;
3270 : 0 : }
3271 : :
3272 : : // Send and receive from sockets, accept connections
3273 [ # # ]: 0 : threadSocketHandler = std::thread(&util::TraceThread, "net", [this] { ThreadSocketHandler(); });
3274 : :
3275 [ # # # # : 0 : if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED))
# # ]
3276 [ # # # # : 0 : LogPrintf("DNS seeding disabled\n");
# # ]
3277 : : else
3278 [ # # ]: 0 : threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed", [this] { ThreadDNSAddressSeed(); });
3279 : :
3280 : : // Initiate manual connections
3281 [ # # ]: 0 : threadOpenAddedConnections = std::thread(&util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); });
3282 : :
3283 [ # # # # ]: 0 : if (connOptions.m_use_addrman_outgoing && !connOptions.m_specified_outgoing.empty()) {
3284 [ # # ]: 0 : if (m_client_interface) {
3285 [ # # ]: 0 : m_client_interface->ThreadSafeMessageBox(
3286 [ # # ]: 0 : _("Cannot provide specific connections and have addrman find outgoing connections at the same time."),
3287 [ # # ]: 0 : "", CClientUIInterface::MSG_ERROR);
3288 : 0 : }
3289 : 0 : return false;
3290 : : }
3291 [ # # ]: 0 : if (connOptions.m_use_addrman_outgoing || !connOptions.m_specified_outgoing.empty()) {
3292 [ # # ]: 0 : threadOpenConnections = std::thread(
3293 : 0 : &util::TraceThread, "opencon",
3294 [ # # # # ]: 0 : [this, connect = connOptions.m_specified_outgoing] { ThreadOpenConnections(connect); });
3295 : 0 : }
3296 : :
3297 : : // Process messages
3298 [ # # ]: 0 : threadMessageHandler = std::thread(&util::TraceThread, "msghand", [this] { ThreadMessageHandler(); });
3299 : :
3300 [ # # ]: 0 : if (m_i2p_sam_session) {
3301 : 0 : threadI2PAcceptIncoming =
3302 [ # # ]: 0 : std::thread(&util::TraceThread, "i2paccept", [this] { ThreadI2PAcceptIncoming(); });
3303 : 0 : }
3304 : :
3305 : : // Dump network addresses
3306 [ # # # # : 0 : scheduler.scheduleEvery([this] { DumpAddresses(); }, DUMP_PEERS_INTERVAL);
# # ]
3307 : :
3308 : 0 : return true;
3309 : 0 : }
3310 : :
3311 : : class CNetCleanup
3312 : : {
3313 : : public:
3314 : : CNetCleanup() = default;
3315 : :
3316 : 173 : ~CNetCleanup()
3317 : : {
3318 : : #ifdef WIN32
3319 : : // Shutdown Windows Sockets
3320 : : WSACleanup();
3321 : : #endif
3322 : 173 : }
3323 : : };
3324 : : static CNetCleanup instance_of_cnetcleanup;
3325 : :
3326 : 684 : void CConnman::Interrupt()
3327 : : {
3328 : : {
3329 : 684 : LOCK(mutexMsgProc);
3330 : 684 : flagInterruptMsgProc = true;
3331 : 684 : }
3332 : 684 : condMsgProc.notify_all();
3333 : :
3334 : 684 : interruptNet();
3335 : 684 : InterruptSocks5(true);
3336 : :
3337 [ + - ]: 684 : if (semOutbound) {
3338 [ # # ]: 0 : for (int i=0; i<m_max_outbound; i++) {
3339 : 0 : semOutbound->post();
3340 : 0 : }
3341 : 0 : }
3342 : :
3343 [ + - ]: 684 : if (semAddnode) {
3344 [ # # ]: 0 : for (int i=0; i<nMaxAddnode; i++) {
3345 : 0 : semAddnode->post();
3346 : 0 : }
3347 : 0 : }
3348 : 684 : }
3349 : :
3350 : 684 : void CConnman::StopThreads()
3351 : : {
3352 [ + - ]: 684 : if (threadI2PAcceptIncoming.joinable()) {
3353 : 0 : threadI2PAcceptIncoming.join();
3354 : 0 : }
3355 [ + - ]: 684 : if (threadMessageHandler.joinable())
3356 : 0 : threadMessageHandler.join();
3357 [ + - ]: 684 : if (threadOpenConnections.joinable())
3358 : 0 : threadOpenConnections.join();
3359 [ + - ]: 684 : if (threadOpenAddedConnections.joinable())
3360 : 0 : threadOpenAddedConnections.join();
3361 [ + - ]: 684 : if (threadDNSAddressSeed.joinable())
3362 : 0 : threadDNSAddressSeed.join();
3363 [ + - ]: 684 : if (threadSocketHandler.joinable())
3364 : 0 : threadSocketHandler.join();
3365 : 684 : }
3366 : :
3367 : 4054 : void CConnman::StopNodes()
3368 : : {
3369 [ + - ]: 4054 : if (fAddressesInitialized) {
3370 : 0 : DumpAddresses();
3371 : 0 : fAddressesInitialized = false;
3372 : :
3373 [ # # ]: 0 : if (m_use_addrman_outgoing) {
3374 : : // Anchor connections are only dumped during clean shutdown.
3375 : 0 : std::vector<CAddress> anchors_to_dump = GetCurrentBlockRelayOnlyConns();
3376 [ # # ]: 0 : if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
3377 [ # # ]: 0 : anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
3378 : 0 : }
3379 [ # # # # : 0 : DumpAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump);
# # # # ]
3380 : 0 : }
3381 : 0 : }
3382 : :
3383 : : // Delete peer connections.
3384 : 4054 : std::vector<CNode*> nodes;
3385 [ + - + - ]: 8108 : WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes));
3386 [ + + ]: 9328 : for (CNode* pnode : nodes) {
3387 [ + - ]: 5274 : pnode->CloseSocketDisconnect();
3388 [ + - ]: 5274 : DeleteNode(pnode);
3389 : : }
3390 : :
3391 [ + - ]: 4054 : for (CNode* pnode : m_nodes_disconnected) {
3392 [ # # ]: 0 : DeleteNode(pnode);
3393 : : }
3394 : 4054 : m_nodes_disconnected.clear();
3395 : 4054 : vhListenSocket.clear();
3396 : 4054 : semOutbound.reset();
3397 : 4054 : semAddnode.reset();
3398 : 4054 : }
3399 : :
3400 : 5274 : void CConnman::DeleteNode(CNode* pnode)
3401 : : {
3402 [ + - ]: 5274 : assert(pnode);
3403 : 5274 : m_msgproc->FinalizeNode(*pnode);
3404 [ - + ]: 5274 : delete pnode;
3405 : 5274 : }
3406 : :
3407 : 684 : CConnman::~CConnman()
3408 : : {
3409 [ + - ]: 684 : Interrupt();
3410 [ + - ]: 684 : Stop();
3411 : 684 : }
3412 : :
3413 : 288 : std::vector<CAddress> CConnman::GetAddresses(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
3414 : : {
3415 : 288 : std::vector<CAddress> addresses = addrman.GetAddr(max_addresses, max_pct, network);
3416 [ + - ]: 288 : if (m_banman) {
3417 [ # # # # : 0 : addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
# # # # ]
3418 [ # # ]: 0 : [this](const CAddress& addr){return m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr);}),
3419 : 0 : addresses.end());
3420 : 0 : }
3421 : 288 : return addresses;
3422 [ + - ]: 288 : }
3423 : :
3424 : 262 : std::vector<CAddress> CConnman::GetAddresses(CNode& requestor, size_t max_addresses, size_t max_pct)
3425 : : {
3426 : 262 : auto local_socket_bytes = requestor.addrBind.GetAddrBytes();
3427 [ + - ]: 524 : uint64_t cache_id = GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE)
3428 [ + - + - ]: 262 : .Write(requestor.ConnectedThroughNetwork())
3429 [ + - + - ]: 262 : .Write(local_socket_bytes)
3430 : : // For outbound connections, the port of the bound address is randomly
3431 : : // assigned by the OS and would therefore not be useful for seeding.
3432 [ + - + + : 262 : .Write(requestor.IsInboundConn() ? requestor.addrBind.GetPort() : 0)
+ - + - ]
3433 [ + - ]: 262 : .Finalize();
3434 [ + - ]: 262 : const auto current_time = GetTime<std::chrono::microseconds>();
3435 [ + - ]: 262 : auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{});
3436 : 262 : CachedAddrResponse& cache_entry = r.first->second;
3437 [ + - + + ]: 262 : if (cache_entry.m_cache_entry_expiration < current_time) { // If emplace() added new one it has expiration 0.
3438 [ + - ]: 201 : cache_entry.m_addrs_response_cache = GetAddresses(max_addresses, max_pct, /*network=*/std::nullopt);
3439 : : // Choosing a proper cache lifetime is a trade-off between the privacy leak minimization
3440 : : // and the usefulness of ADDR responses to honest users.
3441 : : //
3442 : : // Longer cache lifetime makes it more difficult for an attacker to scrape
3443 : : // enough AddrMan data to maliciously infer something useful.
3444 : : // By the time an attacker scraped enough AddrMan records, most of
3445 : : // the records should be old enough to not leak topology info by
3446 : : // e.g. analyzing real-time changes in timestamps.
3447 : : //
3448 : : // It takes only several hundred requests to scrape everything from an AddrMan containing 100,000 nodes,
3449 : : // so ~24 hours of cache lifetime indeed makes the data less inferable by the time
3450 : : // most of it could be scraped (considering that timestamps are updated via
3451 : : // ADDR self-announcements and when nodes communicate).
3452 : : // We also should be robust to those attacks which may not require scraping *full* victim's AddrMan
3453 : : // (because even several timestamps of the same handful of nodes may leak privacy).
3454 : : //
3455 : : // On the other hand, longer cache lifetime makes ADDR responses
3456 : : // outdated and less useful for an honest requestor, e.g. if most nodes
3457 : : // in the ADDR response are no longer active.
3458 : : //
3459 : : // However, the churn in the network is known to be rather low. Since we consider
3460 : : // nodes to be "terrible" (see IsTerrible()) if the timestamps are older than 30 days,
3461 : : // max. 24 hours of "penalty" due to cache shouldn't make any meaningful difference
3462 : : // in terms of the freshness of the response.
3463 [ + - + - : 201 : cache_entry.m_cache_entry_expiration = current_time + std::chrono::hours(21) + GetRandMillis(std::chrono::hours(6));
+ - + - +
- ]
3464 : 201 : }
3465 [ + - ]: 262 : return cache_entry.m_addrs_response_cache;
3466 : 262 : }
3467 : :
3468 : 421 : bool CConnman::AddNode(const AddedNodeParams& add)
3469 : : {
3470 : 421 : LOCK(m_added_nodes_mutex);
3471 [ + + ]: 632 : for (const auto& it : m_added_node_params) {
3472 [ + + ]: 598 : if (add.m_added_node == it.m_added_node) return false;
3473 : : }
3474 : :
3475 [ + - ]: 34 : m_added_node_params.push_back(add);
3476 : 34 : return true;
3477 : 421 : }
3478 : :
3479 : 195 : bool CConnman::RemoveAddedNode(const std::string& strNode)
3480 : : {
3481 : 195 : LOCK(m_added_nodes_mutex);
3482 [ + + ]: 197 : for (auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {
3483 [ + + ]: 7 : if (strNode == it->m_added_node) {
3484 [ - + ]: 5 : m_added_node_params.erase(it);
3485 : 5 : return true;
3486 : : }
3487 : 2 : }
3488 : 190 : return false;
3489 : 195 : }
3490 : :
3491 : 310 : size_t CConnman::GetNodeCount(ConnectionDirection flags) const
3492 : : {
3493 : 310 : LOCK(m_nodes_mutex);
3494 [ + + ]: 310 : if (flags == ConnectionDirection::Both) // Shortcut if we want total
3495 : 65 : return m_nodes.size();
3496 : :
3497 : 245 : int nNum = 0;
3498 [ + + ]: 4889 : for (const auto& pnode : m_nodes) {
3499 [ + - + - : 4644 : if (flags & (pnode->IsInboundConn() ? ConnectionDirection::In : ConnectionDirection::Out)) {
+ + ]
3500 : 48 : nNum++;
3501 : 48 : }
3502 : : }
3503 : :
3504 : 245 : return nNum;
3505 : 310 : }
3506 : :
3507 : 14755 : uint32_t CConnman::GetMappedAS(const CNetAddr& addr) const
3508 : : {
3509 : 14755 : return m_netgroupman.GetMappedAS(addr);
3510 : : }
3511 : :
3512 : 461 : void CConnman::GetNodeStats(std::vector<CNodeStats>& vstats) const
3513 : : {
3514 : 461 : vstats.clear();
3515 : 461 : LOCK(m_nodes_mutex);
3516 [ + - ]: 461 : vstats.reserve(m_nodes.size());
3517 [ + + ]: 9130 : for (CNode* pnode : m_nodes) {
3518 [ + - ]: 8669 : vstats.emplace_back();
3519 [ + - ]: 8669 : pnode->CopyStats(vstats.back());
3520 [ + - ]: 8669 : vstats.back().m_mapped_as = GetMappedAS(pnode->addr);
3521 : : }
3522 : 461 : }
3523 : :
3524 : 1493 : bool CConnman::DisconnectNode(const std::string& strNode)
3525 : : {
3526 : 1493 : LOCK(m_nodes_mutex);
3527 [ + - + + ]: 1493 : if (CNode* pnode = FindNode(strNode)) {
3528 [ + - + - : 185 : LogPrint(BCLog::NET, "disconnect by address%s matched peer=%d; disconnecting\n", (fLogIPs ? strprintf("=%s", strNode) : ""), pnode->GetId());
# # # # #
# # # # #
# # # # #
# # # ]
3529 : 185 : pnode->fDisconnect = true;
3530 : 185 : return true;
3531 : : }
3532 : 1308 : return false;
3533 : 1493 : }
3534 : :
3535 : 474 : bool CConnman::DisconnectNode(const CSubNet& subnet)
3536 : : {
3537 : 474 : bool disconnected = false;
3538 : 474 : LOCK(m_nodes_mutex);
3539 [ + + ]: 10424 : for (CNode* pnode : m_nodes) {
3540 [ + - + + ]: 9950 : if (subnet.Match(pnode->addr)) {
3541 [ + - + - : 119 : LogPrint(BCLog::NET, "disconnect by subnet%s matched peer=%d; disconnecting\n", (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""), pnode->GetId());
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
3542 : 119 : pnode->fDisconnect = true;
3543 : 119 : disconnected = true;
3544 : 119 : }
3545 : : }
3546 : 474 : return disconnected;
3547 : 474 : }
3548 : :
3549 : 358 : bool CConnman::DisconnectNode(const CNetAddr& addr)
3550 : : {
3551 [ + - ]: 358 : return DisconnectNode(CSubNet(addr));
3552 : 0 : }
3553 : :
3554 : 305 : bool CConnman::DisconnectNode(NodeId id)
3555 : : {
3556 : 305 : LOCK(m_nodes_mutex);
3557 [ + + ]: 5072 : for(CNode* pnode : m_nodes) {
3558 [ + - + + ]: 4795 : if (id == pnode->GetId()) {
3559 [ + - + - : 28 : LogPrint(BCLog::NET, "disconnect by id peer=%d; disconnecting\n", pnode->GetId());
# # # # #
# # # ]
3560 : 28 : pnode->fDisconnect = true;
3561 : 28 : return true;
3562 : : }
3563 : : }
3564 : 277 : return false;
3565 : 305 : }
3566 : :
3567 : 38 : void CConnman::RecordBytesRecv(uint64_t bytes)
3568 : : {
3569 : 38 : nTotalBytesRecv += bytes;
3570 : 38 : }
3571 : :
3572 : 141887 : void CConnman::RecordBytesSent(uint64_t bytes)
3573 : : {
3574 : 141887 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3575 : 141887 : LOCK(m_total_bytes_sent_mutex);
3576 : :
3577 : 141887 : nTotalBytesSent += bytes;
3578 : :
3579 [ + - ]: 141887 : const auto now = GetTime<std::chrono::seconds>();
3580 [ + - + - : 141887 : if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now)
+ + ]
3581 : : {
3582 : : // timeframe expired, reset cycle
3583 : 82 : nMaxOutboundCycleStartTime = now;
3584 : 82 : nMaxOutboundTotalBytesSentInCycle = 0;
3585 : 82 : }
3586 : :
3587 : 141887 : nMaxOutboundTotalBytesSentInCycle += bytes;
3588 : 141887 : }
3589 : :
3590 : 461 : uint64_t CConnman::GetMaxOutboundTarget() const
3591 : : {
3592 : 461 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3593 : 461 : LOCK(m_total_bytes_sent_mutex);
3594 : 461 : return nMaxOutboundLimit;
3595 : 461 : }
3596 : :
3597 : 461 : std::chrono::seconds CConnman::GetMaxOutboundTimeframe() const
3598 : : {
3599 : 461 : return MAX_UPLOAD_TIMEFRAME;
3600 : : }
3601 : :
3602 : 461 : std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle() const
3603 : : {
3604 : 461 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3605 : 461 : LOCK(m_total_bytes_sent_mutex);
3606 [ + - ]: 461 : return GetMaxOutboundTimeLeftInCycle_();
3607 : 461 : }
3608 : :
3609 : 461 : std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle_() const
3610 : : {
3611 : 461 : AssertLockHeld(m_total_bytes_sent_mutex);
3612 : :
3613 [ - + ]: 461 : if (nMaxOutboundLimit == 0)
3614 : 461 : return 0s;
3615 : :
3616 [ # # ]: 0 : if (nMaxOutboundCycleStartTime.count() == 0)
3617 : 0 : return MAX_UPLOAD_TIMEFRAME;
3618 : :
3619 : 0 : const std::chrono::seconds cycleEndTime = nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME;
3620 : 0 : const auto now = GetTime<std::chrono::seconds>();
3621 [ # # ]: 0 : return (cycleEndTime < now) ? 0s : cycleEndTime - now;
3622 : 461 : }
3623 : :
3624 : 37979 : bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) const
3625 : : {
3626 : 37979 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3627 : 37979 : LOCK(m_total_bytes_sent_mutex);
3628 [ - + ]: 37979 : if (nMaxOutboundLimit == 0)
3629 : 37979 : return false;
3630 : :
3631 [ # # ]: 0 : if (historicalBlockServingLimit)
3632 : : {
3633 : : // keep a large enough buffer to at least relay each block once
3634 [ # # ]: 0 : const std::chrono::seconds timeLeftInCycle = GetMaxOutboundTimeLeftInCycle_();
3635 [ # # # # ]: 0 : const uint64_t buffer = timeLeftInCycle / std::chrono::minutes{10} * MAX_BLOCK_SERIALIZED_SIZE;
3636 [ # # # # ]: 0 : if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
3637 : 0 : return true;
3638 : 0 : }
3639 [ # # ]: 0 : else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
3640 : 0 : return true;
3641 : :
3642 : 0 : return false;
3643 : 37979 : }
3644 : :
3645 : 461 : uint64_t CConnman::GetOutboundTargetBytesLeft() const
3646 : : {
3647 : 461 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3648 : 461 : LOCK(m_total_bytes_sent_mutex);
3649 [ - + ]: 461 : if (nMaxOutboundLimit == 0)
3650 : 461 : return 0;
3651 : :
3652 [ # # ]: 0 : return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
3653 : 461 : }
3654 : :
3655 : 461 : uint64_t CConnman::GetTotalBytesRecv() const
3656 : : {
3657 : 461 : return nTotalBytesRecv;
3658 : : }
3659 : :
3660 : 461 : uint64_t CConnman::GetTotalBytesSent() const
3661 : : {
3662 : 461 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3663 : 461 : LOCK(m_total_bytes_sent_mutex);
3664 : 461 : return nTotalBytesSent;
3665 : 461 : }
3666 : :
3667 : 461 : ServiceFlags CConnman::GetLocalServices() const
3668 : : {
3669 : 461 : return nLocalServices;
3670 : : }
3671 : :
3672 : 14858 : static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept
3673 : : {
3674 [ + + ]: 14858 : if (use_v2transport) {
3675 [ + - ]: 1 : return std::make_unique<V2Transport>(id, /*initiating=*/!inbound, SER_NETWORK, INIT_PROTO_VERSION);
3676 : : } else {
3677 [ + - ]: 14857 : return std::make_unique<V1Transport>(id, SER_NETWORK, INIT_PROTO_VERSION);
3678 : : }
3679 : 14858 : }
3680 : :
3681 [ + - + - : 89148 : CNode::CNode(NodeId idIn,
+ - + - ]
3682 : : std::shared_ptr<Sock> sock,
3683 : : const CAddress& addrIn,
3684 : : uint64_t nKeyedNetGroupIn,
3685 : : uint64_t nLocalHostNonceIn,
3686 : : const CAddress& addrBindIn,
3687 : : const std::string& addrNameIn,
3688 : : ConnectionType conn_type_in,
3689 : : bool inbound_onion,
3690 : : CNodeOptions&& node_opts)
3691 : 14858 : : m_transport{MakeTransport(idIn, node_opts.use_v2transport, conn_type_in == ConnectionType::INBOUND)},
3692 : 14858 : m_permission_flags{node_opts.permission_flags},
3693 : 14858 : m_sock{sock},
3694 [ + - ]: 14858 : m_connected{GetTime<std::chrono::seconds>()},
3695 [ + - ]: 14858 : addr{addrIn},
3696 [ + - ]: 14858 : addrBind{addrBindIn},
3697 [ + + + - : 14858 : m_addr_name{addrNameIn.empty() ? addr.ToStringAddrPort() : addrNameIn},
+ - ]
3698 [ + - ]: 14858 : m_dest(addrNameIn),
3699 : 14858 : m_inbound_onion{inbound_onion},
3700 : 14858 : m_prefer_evict{node_opts.prefer_evict},
3701 : 14858 : nKeyedNetGroup{nKeyedNetGroupIn},
3702 : 14858 : m_conn_type{conn_type_in},
3703 : 14858 : id{idIn},
3704 : 14858 : nLocalHostNonce{nLocalHostNonceIn},
3705 : 14858 : m_recv_flood_size{node_opts.recv_flood_size},
3706 : 14858 : m_i2p_sam_session{std::move(node_opts.i2p_sam_session)}
3707 : : {
3708 [ + + + - ]: 14858 : if (inbound_onion) assert(conn_type_in == ConnectionType::INBOUND);
3709 : :
3710 [ + - + + ]: 534888 : for (const std::string &msg : getAllNetMessageTypes())
3711 [ + - ]: 520030 : mapRecvBytesPerMsgType[msg] = 0;
3712 [ + - ]: 14858 : mapRecvBytesPerMsgType[NET_MESSAGE_TYPE_OTHER] = 0;
3713 : :
3714 [ - + ]: 14858 : if (fLogIPs) {
3715 [ # # # # : 0 : LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", m_addr_name, id);
# # # # #
# ]
3716 : 0 : } else {
3717 [ + - + - : 14858 : LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
# # # # #
# ]
3718 : : }
3719 : 14858 : }
3720 : :
3721 : 1116095 : void CNode::MarkReceivedMsgsForProcessing()
3722 : : {
3723 : 1116095 : AssertLockNotHeld(m_msg_process_queue_mutex);
3724 : :
3725 : 1116095 : size_t nSizeAdded = 0;
3726 [ + + ]: 2232190 : for (const auto& msg : vRecvMsg) {
3727 : : // vRecvMsg contains only completed CNetMessage
3728 : : // the single possible partially deserialized message are held by TransportDeserializer
3729 : 1116095 : nSizeAdded += msg.m_raw_message_size;
3730 : : }
3731 : :
3732 : 1116095 : LOCK(m_msg_process_queue_mutex);
3733 : 1116095 : m_msg_process_queue.splice(m_msg_process_queue.end(), vRecvMsg);
3734 : 1116095 : m_msg_process_queue_size += nSizeAdded;
3735 : 1116095 : fPauseRecv = m_msg_process_queue_size > m_recv_flood_size;
3736 : 1116095 : }
3737 : :
3738 : 1117464 : std::optional<std::pair<CNetMessage, bool>> CNode::PollMessage()
3739 : : {
3740 : 1117464 : LOCK(m_msg_process_queue_mutex);
3741 [ + + ]: 1117464 : if (m_msg_process_queue.empty()) return std::nullopt;
3742 : :
3743 : 999021 : std::list<CNetMessage> msgs;
3744 : : // Just take one message
3745 : 999021 : msgs.splice(msgs.begin(), m_msg_process_queue, m_msg_process_queue.begin());
3746 : 999021 : m_msg_process_queue_size -= msgs.front().m_raw_message_size;
3747 : 999021 : fPauseRecv = m_msg_process_queue_size > m_recv_flood_size;
3748 : :
3749 [ + - - + ]: 999021 : return std::make_pair(std::move(msgs.front()), !m_msg_process_queue.empty());
3750 : 1117464 : }
3751 : :
3752 : 68 : bool CConnman::NodeFullyConnected(const CNode* pnode)
3753 : : {
3754 [ + - + - ]: 68 : return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
3755 : : }
3756 : :
3757 : 154158 : void CConnman::PushMessage(CNode* pnode, CSerializedNetMsg&& msg)
3758 : : {
3759 : 154158 : AssertLockNotHeld(m_total_bytes_sent_mutex);
3760 : 154158 : size_t nMessageSize = msg.data.size();
3761 [ + - # # : 154158 : LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n", msg.m_type, nMessageSize, pnode->GetId());
# # # # #
# ]
3762 [ + - + - : 154158 : if (gArgs.GetBoolArg("-capturemessages", false)) {
+ - ]
3763 : 0 : CaptureMessage(pnode->addr, msg.m_type, msg.data, /*is_incoming=*/false);
3764 : 0 : }
3765 : :
3766 : : TRACE6(net, outbound_message,
3767 : : pnode->GetId(),
3768 : : pnode->m_addr_name.c_str(),
3769 : : pnode->ConnectionTypeAsString().c_str(),
3770 : : msg.m_type.c_str(),
3771 : : msg.data.size(),
3772 : : msg.data.data()
3773 : : );
3774 : :
3775 : 154158 : size_t nBytesSent = 0;
3776 : : {
3777 : 154158 : LOCK(pnode->cs_vSend);
3778 : : // Check if the transport still has unsent bytes, and indicate to it that we're about to
3779 : : // give it a message to send.
3780 : 297418 : const auto& [to_send, more, _msg_type] =
3781 : 154158 : pnode->m_transport->GetBytesToSend(/*have_next_message=*/true);
3782 [ + + ]: 154158 : const bool queue_was_empty{to_send.empty() && pnode->vSendMsg.empty()};
3783 : :
3784 : : // Update memory usage of send buffer.
3785 : 154158 : pnode->m_send_memusage += msg.GetMemoryUsage();
3786 [ - + ]: 154158 : if (pnode->m_send_memusage + pnode->m_transport->GetSendMemoryUsage() > nSendBufferMaxSize) pnode->fPauseSend = true;
3787 : : // Move message to vSendMsg queue.
3788 [ + - ]: 154158 : pnode->vSendMsg.push_back(std::move(msg));
3789 : :
3790 : : // If there was nothing to send before, and there is now (predicted by the "more" value
3791 : : // returned by the GetBytesToSend call above), attempt "optimistic write":
3792 : : // because the poll/select loop may pause for SELECT_TIMEOUT_MILLISECONDS before actually
3793 : : // doing a send, try sending from the calling thread if the queue was empty before.
3794 : : // With a V1Transport, more will always be true here, because adding a message always
3795 : : // results in sendable bytes there, but with V2Transport this is not the case (it may
3796 : : // still be in the handshake).
3797 [ + + + - ]: 154158 : if (queue_was_empty && more) {
3798 [ + - + - ]: 143260 : std::tie(nBytesSent, std::ignore) = SocketSendData(*pnode);
3799 : 143260 : }
3800 : 154158 : }
3801 [ + + ]: 154158 : if (nBytesSent) RecordBytesSent(nBytesSent);
3802 : 154158 : }
3803 : :
3804 : 54 : bool CConnman::ForNode(NodeId id, std::function<bool(CNode* pnode)> func)
3805 : : {
3806 : 54 : CNode* found = nullptr;
3807 : 54 : LOCK(m_nodes_mutex);
3808 [ + + ]: 311 : for (auto&& pnode : m_nodes) {
3809 [ + - + + ]: 258 : if(pnode->GetId() == id) {
3810 : 1 : found = pnode;
3811 : 1 : break;
3812 : : }
3813 : : }
3814 [ + + - + : 54 : return found != nullptr && NodeFullyConnected(found) && func(found);
# # ]
3815 : 54 : }
3816 : :
3817 : 492 : CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const
3818 : : {
3819 : 492 : return CSipHasher(nSeed0, nSeed1).Write(id);
3820 : : }
3821 : :
3822 : 3 : uint64_t CConnman::CalculateKeyedNetGroup(const CAddress& address) const
3823 : : {
3824 : 3 : std::vector<unsigned char> vchNetGroup(m_netgroupman.GetGroup(address));
3825 : :
3826 [ + - + - : 3 : return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP).Write(vchNetGroup).Finalize();
+ - + - ]
3827 : 3 : }
3828 : :
3829 : 0 : void CConnman::PerformReconnections()
3830 : : {
3831 : 0 : AssertLockNotHeld(m_reconnections_mutex);
3832 : 0 : AssertLockNotHeld(m_unused_i2p_sessions_mutex);
3833 : 0 : while (true) {
3834 : : // Move first element of m_reconnections to todo (avoiding an allocation inside the lock).
3835 : 0 : decltype(m_reconnections) todo;
3836 : : {
3837 [ # # # # ]: 0 : LOCK(m_reconnections_mutex);
3838 [ # # ]: 0 : if (m_reconnections.empty()) break;
3839 : 0 : todo.splice(todo.end(), m_reconnections, m_reconnections.begin());
3840 [ # # ]: 0 : }
3841 : :
3842 : 0 : auto& item = *todo.begin();
3843 [ # # ]: 0 : OpenNetworkConnection(item.addr_connect,
3844 : : // We only reconnect if the first attempt to connect succeeded at
3845 : : // connection time, but then failed after the CNode object was
3846 : : // created. Since we already know connecting is possible, do not
3847 : : // count failure to reconnect.
3848 : : /*fCountFailure=*/false,
3849 : 0 : std::move(item.grant),
3850 [ # # ]: 0 : item.destination.empty() ? nullptr : item.destination.c_str(),
3851 : 0 : item.conn_type,
3852 : 0 : item.use_v2transport);
3853 [ # # # ]: 0 : }
3854 : 0 : }
3855 : :
3856 : : // Dump binary message to file, with timestamp.
3857 : 0 : static void CaptureMessageToFile(const CAddress& addr,
3858 : : const std::string& msg_type,
3859 : : Span<const unsigned char> data,
3860 : : bool is_incoming)
3861 : : {
3862 : : // Note: This function captures the message at the time of processing,
3863 : : // not at socket receive/send time.
3864 : : // This ensures that the messages are always in order from an application
3865 : : // layer (processing) perspective.
3866 : 0 : auto now = GetTime<std::chrono::microseconds>();
3867 : :
3868 : : // Windows folder names cannot include a colon
3869 : 0 : std::string clean_addr = addr.ToStringAddrPort();
3870 [ # # ]: 0 : std::replace(clean_addr.begin(), clean_addr.end(), ':', '_');
3871 : :
3872 [ # # # # : 0 : fs::path base_path = gArgs.GetDataDirNet() / "message_capture" / fs::u8path(clean_addr);
# # # # #
# ]
3873 [ # # ]: 0 : fs::create_directories(base_path);
3874 : :
3875 [ # # # # : 0 : fs::path path = base_path / (is_incoming ? "msgs_recv.dat" : "msgs_sent.dat");
# # ]
3876 [ # # # # ]: 0 : AutoFile f{fsbridge::fopen(path, "ab")};
3877 : :
3878 [ # # ]: 0 : ser_writedata64(f, now.count());
3879 [ # # # # ]: 0 : f << Span{msg_type};
3880 [ # # ]: 0 : for (auto i = msg_type.length(); i < CMessageHeader::COMMAND_SIZE; ++i) {
3881 [ # # ]: 0 : f << uint8_t{'\0'};
3882 : 0 : }
3883 : 0 : uint32_t size = data.size();
3884 [ # # ]: 0 : ser_writedata32(f, size);
3885 [ # # ]: 0 : f << data;
3886 : 0 : }
3887 : :
3888 : : std::function<void(const CAddress& addr,
3889 : : const std::string& msg_type,
3890 : : Span<const unsigned char> data,
3891 : : bool is_incoming)>
3892 : 173 : CaptureMessage = CaptureMessageToFile;
|
