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