6#include <bitcoin-build-config.h>
35#include <util/threadinterrupt.h>
47#include <unordered_map>
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.");
134 m_addr_fetches.push_back(strDest);
140 for (
const std::string& bind_arg :
gArgs.
GetArgs(
"-bind")) {
141 constexpr uint16_t dummy_port = 0;
143 const std::optional<CService> bind_addr{
Lookup(bind_arg, dummy_port,
false)};
144 if (bind_addr.has_value() && bind_addr->GetPort() != dummy_port)
return bind_addr->GetPort();
149 for (
const std::string& whitebind_arg :
gArgs.
GetArgs(
"-whitebind")) {
166 if (!
fListen)
return std::nullopt;
168 std::optional<CService> addr;
170 int nBestReachability = -1;
173 for (
const auto& [local_addr, local_service_info] : mapLocalHost) {
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;
194static std::vector<CAddress>
ConvertSeeds(
const std::vector<uint8_t> &vSeedsIn)
200 const auto one_week{7 * 24h};
201 std::vector<CAddress> vSeedsOut;
210 vSeedsOut.push_back(addr);
227 const auto it = mapLocalHost.find(addr);
228 return (it != mapLocalHost.end()) ? it->second.nScore : 0;
249 if (
node.IsInboundConn()) {
258 addrLocal.SetIP(
node.GetAddrLocal());
261 if (addrLocal.IsRoutable()) {
272 return mapLocalHost.clear();
280 if (!addr.IsRoutable())
289 LogPrintf(
"AddLocal(%s,%i)\n", addr.ToStringAddrPort(), nScore);
293 const auto [it, is_newly_added] = mapLocalHost.emplace(addr,
LocalServiceInfo());
295 if (is_newly_added || nScore >= info.
nScore) {
296 info.
nScore = nScore + (is_newly_added ? 0 : 1);
297 info.
nPort = addr.GetPort();
313 mapLocalHost.erase(addr);
320 const auto it = mapLocalHost.find(addr);
321 if (it == mapLocalHost.end())
return false;
331 return mapLocalHost.count(addr) > 0;
337 return std::ranges::any_of(m_nodes, [&host](
CNode*
node) {
return node->m_addr_name == host; });
343 return std::ranges::any_of(m_nodes, [&addr_port](
CNode*
node) {
return node->addr == addr_port; });
349 return std::ranges::any_of(m_nodes, [&addr](
CNode*
node) {
return node->addr == addr; });
355 for (
const CNode* pnode : m_nodes) {
356 if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() ==
nonce)
366 struct sockaddr_storage sockaddr_bind;
367 socklen_t sockaddr_bind_len =
sizeof(sockaddr_bind);
368 if (!sock.
GetSockName((
struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {
369 addr_bind.
SetSockAddr((
const struct sockaddr*)&sockaddr_bind, sockaddr_bind_len);
380 bool use_v2transport,
381 const std::optional<Proxy>& proxy_override)
386 if (pszDest ==
nullptr) {
400 Ticks<HoursDouble>(pszDest ? 0h : Now<NodeSeconds>() - addrConnect.
nTime));
403 const uint16_t default_port{pszDest !=
nullptr ?
GetDefaultPort(pszDest) :
407 std::vector<CAddress> connect_to{};
410 if (!resolved.empty()) {
414 for (
const auto& r : resolved) {
427 connect_to.push_back(addrConnect);
431 connect_to.push_back(addrConnect);
435 connect_to.push_back(addrConnect);
439 std::unique_ptr<Sock> sock;
443 std::unique_ptr<i2p::sam::Session> i2p_transient_session;
445 for (
auto& target_addr: connect_to) {
446 if (target_addr.IsValid()) {
448 if (proxy_override.has_value()) {
450 proxy = proxy_override.value();
452 use_proxy =
GetProxy(target_addr.GetNetwork(), proxy);
454 bool proxyConnectionFailed =
false;
456 if (target_addr.IsI2P() && use_proxy) {
458 bool connected{
false};
461 connected =
m_i2p_sam_session->Connect(target_addr, conn, proxyConnectionFailed);
465 if (m_unused_i2p_sessions.empty()) {
466 i2p_transient_session =
469 i2p_transient_session.swap(m_unused_i2p_sessions.front());
470 m_unused_i2p_sessions.pop();
473 connected = i2p_transient_session->Connect(target_addr, conn, proxyConnectionFailed);
477 m_unused_i2p_sessions.emplace(i2p_transient_session.release());
483 sock = std::move(conn.
sock);
486 }
else if (use_proxy) {
488 sock =
ConnectThroughProxy(proxy, target_addr.ToStringAddr(), target_addr.GetPort(), proxyConnectionFailed);
493 if (!proxyConnectionFailed) {
500 uint16_t port{default_port};
502 bool proxyConnectionFailed;
521 .
Write(target_addr.GetNetClass())
533 pszDest ? pszDest :
"",
539 .i2p_sam_session = std::move(i2p_transient_session),
569 m_i2p_sam_session.reset();
573 for (
const auto& subnet : ranges) {
574 if (addr.has_value() && subnet.m_subnet.Match(addr.value())) {
597 if (
Assume(!m_addr_local.IsValid())) {
598 m_addr_local = addrLocalIn;
613#define X(name) stats.name = name
636 X(mapSendBytesPerMsgType);
641 X(mapRecvBytesPerMsgType);
663 const auto time = GetTime<std::chrono::microseconds>();
665 m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);
666 nRecvBytes += msg_bytes.size();
667 while (msg_bytes.size() > 0) {
676 bool reject_message{
false};
678 if (reject_message) {
687 auto i = mapRecvBytesPerMsgType.find(
msg.m_type);
688 if (i == mapRecvBytesPerMsgType.end()) {
691 assert(i != mapRecvBytesPerMsgType.end());
692 i->second +=
msg.m_raw_message_size;
711 return strprintf(
"disconnecting peer=%d%s",
733 unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
735 memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
746 catch (
const std::exception&) {
774 unsigned int nRemaining = hdr.nMessageSize - nDataPos;
775 unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
777 if (vRecv.size() < nDataPos + nCopy) {
779 vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
782 hasher.Write(msg_bytes.first(nCopy));
783 memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
793 if (data_hash.IsNull())
794 hasher.Finalize(data_hash);
802 reject_message =
false;
808 msg.m_type = hdr.GetMessageType();
810 msg.m_message_size = hdr.nMessageSize;
820 LogDebug(
BCLog::NET,
"Header error: Wrong checksum (%s, %u bytes), expected %s was %s, peer=%d\n",
825 reject_message =
true;
826 }
else if (!hdr.IsMessageTypeValid()) {
829 reject_message =
true;
842 if (m_sending_header || m_bytes_sent < m_message_to_send.data.size())
return false;
852 m_header_to_send.clear();
856 m_message_to_send = std::move(
msg);
857 m_sending_header =
true;
866 if (m_sending_header) {
867 return {std::span{m_header_to_send}.subspan(m_bytes_sent),
870 have_next_message || !m_message_to_send.data.empty(),
871 m_message_to_send.m_type
874 return {std::span{m_message_to_send.data}.subspan(m_bytes_sent),
878 m_message_to_send.m_type
887 m_bytes_sent += bytes_sent;
888 if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {
890 m_sending_header =
false;
892 }
else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {
904 return m_message_to_send.GetMemoryUsage();
914const std::array<std::string, 33> V2_MESSAGE_IDS = {
953 std::unordered_map<std::string, uint8_t> m_map;
956 V2MessageMap() noexcept
958 for (
size_t i = 1; i < std::size(V2_MESSAGE_IDS); ++i) {
959 m_map.emplace(V2_MESSAGE_IDS[i], i);
963 std::optional<uint8_t> operator()(
const std::string& message_name)
const noexcept
965 auto it = m_map.find(message_name);
966 if (it == m_map.end())
return std::nullopt;
971const V2MessageMap V2_MESSAGE_MAP;
973std::vector<uint8_t> GenerateRandomGarbage() noexcept
975 std::vector<uint8_t>
ret;
988 Assume(m_send_buffer.empty());
992 std::copy(m_send_garbage.begin(), m_send_garbage.end(), m_send_buffer.begin() +
EllSwiftPubKey::size());
997 : m_cipher{key, ent32}, m_initiating{initiating}, m_nodeid{nodeid},
998 m_v1_fallback{nodeid},
999 m_recv_state{initiating ?
RecvState::KEY : RecvState::KEY_MAYBE_V1},
1000 m_send_garbage{std::move(garbage)},
1001 m_send_state{initiating ? SendState::AWAITING_KEY : SendState::MAYBE_V1}
1003 Assume(m_send_garbage.size() <= MAX_GARBAGE_LEN);
1007 StartSendingHandshake();
1019 switch (m_recv_state) {
1020 case RecvState::KEY_MAYBE_V1:
1024 Assume(recv_state == RecvState::GARB_GARBTERM);
1026 case RecvState::GARB_GARBTERM:
1030 Assume(recv_state == RecvState::APP);
1032 case RecvState::APP:
1033 Assume(recv_state == RecvState::APP_READY);
1035 case RecvState::APP_READY:
1036 Assume(recv_state == RecvState::APP);
1043 m_recv_state = recv_state;
1050 switch (m_send_state) {
1051 case SendState::MAYBE_V1:
1052 Assume(send_state == SendState::V1 || send_state == SendState::AWAITING_KEY);
1054 case SendState::AWAITING_KEY:
1055 Assume(send_state == SendState::READY);
1057 case SendState::READY:
1063 m_send_state = send_state;
1084 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};
1085 std::copy(std::begin(
Params().MessageStart()), std::end(
Params().MessageStart()), v1_prefix.begin());
1086 Assume(m_recv_buffer.size() <= v1_prefix.size());
1087 if (!std::equal(m_recv_buffer.begin(), m_recv_buffer.end(), v1_prefix.begin())) {
1094 }
else if (m_recv_buffer.size() == v1_prefix.size()) {
1097 std::span<const uint8_t> feedback{m_recv_buffer};
1101 Assume(feedback.empty());
1126 static constexpr std::array<uint8_t, 12> MATCH = {
'v',
'e',
'r',
's',
'i',
'o',
'n', 0, 0, 0, 0, 0};
1127 static constexpr size_t OFFSET = std::tuple_size_v<MessageStartChars>;
1128 if (!
m_initiating && m_recv_buffer.size() >= OFFSET + MATCH.size()) {
1129 if (std::equal(MATCH.begin(), MATCH.end(), m_recv_buffer.begin() + OFFSET)) {
1131 HexStr(std::span(m_recv_buffer).first(OFFSET)));
1147 m_recv_buffer.clear();
1181 m_recv_aad = std::move(m_recv_buffer);
1183 m_recv_buffer.clear();
1209 static constexpr size_t MAX_CONTENTS_LEN =
1216 if (m_recv_len > MAX_CONTENTS_LEN) {
1224 m_recv_decode_buffer.resize(m_recv_len);
1243 switch (m_recv_state) {
1272 switch (m_recv_state) {
1322 static constexpr size_t MAX_RESERVE_AHEAD = 256 * 1024;
1325 if (m_recv_state == RecvState::V1)
return m_v1_fallback.ReceivedBytes(msg_bytes);
1331 while (!msg_bytes.empty()) {
1333 size_t max_read = GetMaxBytesToProcess();
1336 if (m_recv_buffer.size() + std::min(msg_bytes.size(), max_read) > m_recv_buffer.capacity()) {
1337 switch (m_recv_state) {
1338 case RecvState::KEY_MAYBE_V1:
1340 case RecvState::GARB_GARBTERM:
1346 case RecvState::APP: {
1352 size_t alloc_add = std::min(max_read, msg_bytes.size() + MAX_RESERVE_AHEAD);
1353 m_recv_buffer.reserve(m_recv_buffer.size() + alloc_add);
1356 case RecvState::APP_READY:
1358 Assume(m_recv_buffer.empty());
1368 max_read = std::min(msg_bytes.size(), max_read);
1370 m_recv_buffer.insert(m_recv_buffer.end(),
UCharCast(msg_bytes.data()),
UCharCast(msg_bytes.data() + max_read));
1371 msg_bytes = msg_bytes.subspan(max_read);
1374 switch (m_recv_state) {
1375 case RecvState::KEY_MAYBE_V1:
1376 ProcessReceivedMaybeV1Bytes();
1377 if (m_recv_state == RecvState::V1)
return true;
1381 if (!ProcessReceivedKeyBytes())
return false;
1384 case RecvState::GARB_GARBTERM:
1385 if (!ProcessReceivedGarbageBytes())
return false;
1389 case RecvState::APP:
1390 if (!ProcessReceivedPacketBytes())
return false;
1393 case RecvState::APP_READY:
1410 if (contents.size() == 0)
return std::nullopt;
1411 uint8_t first_byte = contents[0];
1412 contents = contents.subspan(1);
1414 if (first_byte != 0) {
1416 if (first_byte < std::size(V2_MESSAGE_IDS)) {
1418 return V2_MESSAGE_IDS[first_byte];
1421 return std::nullopt;
1426 return std::nullopt;
1429 size_t msg_type_len{0};
1432 if (contents[msg_type_len] <
' ' || contents[msg_type_len] > 0x7F) {
1437 std::string
ret{
reinterpret_cast<const char*
>(contents.data()), msg_type_len};
1440 if (contents[msg_type_len] != 0)
return {};
1452 if (m_recv_state == RecvState::V1)
return m_v1_fallback.GetReceivedMessage(time, reject_message);
1454 Assume(m_recv_state == RecvState::APP_READY);
1455 std::span<const uint8_t> contents{m_recv_decode_buffer};
1456 auto msg_type = GetMessageType(contents);
1461 reject_message =
false;
1462 msg.m_type = std::move(*msg_type);
1464 msg.m_message_size = contents.size();
1465 msg.m_recv.resize(contents.size());
1466 std::copy(contents.begin(), contents.end(),
UCharCast(
msg.m_recv.data()));
1468 LogDebug(
BCLog::NET,
"V2 transport error: invalid message type (%u bytes contents), peer=%d\n", m_recv_decode_buffer.size(), m_nodeid);
1469 reject_message =
true;
1472 SetReceiveState(RecvState::APP);
1481 if (m_send_state == SendState::V1)
return m_v1_fallback.SetMessageToSend(
msg);
1485 if (!(m_send_state == SendState::READY && m_send_buffer.empty()))
return false;
1487 std::vector<uint8_t> contents;
1488 auto short_message_id = V2_MESSAGE_MAP(
msg.m_type);
1489 if (short_message_id) {
1490 contents.resize(1 +
msg.data.size());
1491 contents[0] = *short_message_id;
1492 std::copy(
msg.data.begin(),
msg.data.end(), contents.begin() + 1);
1497 std::copy(
msg.m_type.begin(),
msg.m_type.end(), contents.data() + 1);
1503 m_send_type =
msg.m_type;
1513 if (m_send_state == SendState::V1)
return m_v1_fallback.GetBytesToSend(have_next_message);
1515 if (m_send_state == SendState::MAYBE_V1)
Assume(m_send_buffer.empty());
1516 Assume(m_send_pos <= m_send_buffer.size());
1518 std::span{m_send_buffer}.subspan(m_send_pos),
1521 have_next_message && m_send_state == SendState::READY,
1530 if (m_send_state == SendState::V1)
return m_v1_fallback.MarkBytesSent(bytes_sent);
1532 if (m_send_state == SendState::AWAITING_KEY && m_send_pos == 0 && bytes_sent > 0) {
1536 m_send_pos += bytes_sent;
1537 Assume(m_send_pos <= m_send_buffer.size());
1539 m_sent_v1_header_worth =
true;
1542 if (m_send_pos == m_send_buffer.size()) {
1559 if (!m_recv_buffer.empty())
return false;
1562 return m_sent_v1_header_worth;
1597 auto it =
node.vSendMsg.begin();
1598 size_t nSentSize = 0;
1599 bool data_left{
false};
1600 std::optional<bool> expected_more;
1603 if (it !=
node.vSendMsg.end()) {
1607 size_t memusage = it->GetMemoryUsage();
1608 if (
node.m_transport->SetMessageToSend(*it)) {
1614 const auto& [
data, more, msg_type] =
node.m_transport->GetBytesToSend(it !=
node.vSendMsg.end());
1618 if (expected_more.has_value())
Assume(!
data.empty() == *expected_more);
1619 expected_more = more;
1620 data_left = !
data.empty();
1622 if (!
data.empty()) {
1639 node.m_last_send = GetTime<std::chrono::seconds>();
1640 node.nSendBytes += nBytes;
1642 node.m_transport->MarkBytesSent(nBytes);
1644 if (!msg_type.empty()) {
1645 node.AccountForSentBytes(msg_type, nBytes);
1647 nSentSize += nBytes;
1648 if ((
size_t)nBytes !=
data.size()) {
1658 node.CloseSocketDisconnect();
1667 if (it ==
node.vSendMsg.end()) {
1670 node.vSendMsg.erase(
node.vSendMsg.begin(), it);
1671 return {nSentSize, data_left};
1684 std::vector<NodeEvictionCandidate> vEvictionCandidates;
1689 if (
node->fDisconnect)
1693 .m_connected =
node->m_connected,
1694 .m_min_ping_time =
node->m_min_ping_time,
1695 .m_last_block_time =
node->m_last_block_time,
1696 .m_last_tx_time =
node->m_last_tx_time,
1697 .fRelevantServices =
node->m_has_all_wanted_services,
1698 .m_relay_txs =
node->m_relays_txs.load(),
1699 .fBloomFilter =
node->m_bloom_filter_loaded.load(),
1700 .nKeyedNetGroup =
node->nKeyedNetGroup,
1701 .prefer_evict =
node->m_prefer_evict,
1702 .m_is_local =
node->addr.IsLocal(),
1703 .m_network =
node->ConnectedThroughNetwork(),
1705 .m_conn_type =
node->m_conn_type,
1707 vEvictionCandidates.push_back(candidate);
1710 const std::optional<NodeId> node_id_to_evict =
SelectNodeToEvict(std::move(vEvictionCandidates));
1711 if (!node_id_to_evict) {
1715 for (
CNode* pnode : m_nodes) {
1716 if (pnode->GetId() == *node_id_to_evict) {
1717 LogDebug(
BCLog::NET,
"selected %s connection for eviction, %s", pnode->ConnectionTypeAsString(), pnode->DisconnectMsg(
fLogIPs));
1720 pnode->m_addr_name.c_str(),
1721 pnode->ConnectionTypeAsString().c_str(),
1722 pnode->ConnectedThroughNetwork(),
1723 Ticks<std::chrono::seconds>(pnode->m_connected));
1724 pnode->fDisconnect =
true;
1732 struct sockaddr_storage sockaddr;
1733 socklen_t len =
sizeof(sockaddr);
1734 auto sock = hListenSocket.
sock->Accept((
struct sockaddr*)&sockaddr, &len);
1745 if (!addr.
SetSockAddr((
const struct sockaddr*)&sockaddr, len)) {
1774 for (
const CNode* pnode : m_nodes) {
1775 if (pnode->IsInboundConn()) nInbound++;
1784 if (!sock->IsSelectable()) {
1792 if (sock->SetSockOpt(IPPROTO_TCP, TCP_NODELAY, &on,
sizeof(on)) ==
SOCKET_ERROR) {
1793 LogDebug(
BCLog::NET,
"connection from %s: unable to set TCP_NODELAY, continuing anyway\n",
1817 LogDebug(
BCLog::NET,
"failed to find an eviction candidate - connection dropped (full)\n");
1847 .prefer_evict = discouraged,
1852 m_msgproc->InitializeNode(*pnode, local_services);
1855 m_nodes.push_back(pnode);
1872 std::optional<int> max_connections;
1873 switch (conn_type) {
1893 return std::count_if(m_nodes.begin(), m_nodes.end(), [conn_type](
CNode*
node) { return node->m_conn_type == conn_type; }););
1896 if (max_connections != std::nullopt && existing_connections >= max_connections)
return false;
1900 if (!grant)
return false;
1913 decltype(m_reconnections) reconnections_to_add;
1919 if (!network_active) {
1921 for (
CNode* pnode : m_nodes) {
1922 if (!pnode->fDisconnect) {
1924 pnode->fDisconnect =
true;
1930 std::vector<CNode*> nodes_copy = m_nodes;
1931 for (
CNode* pnode : nodes_copy)
1933 if (pnode->fDisconnect)
1936 m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode), m_nodes.end());
1941 if (network_active && pnode->m_transport->ShouldReconnectV1()) {
1942 reconnections_to_add.push_back({
1943 .addr_connect = pnode->addr,
1944 .grant = std::move(pnode->grantOutbound),
1945 .destination = pnode->m_dest,
1946 .conn_type = pnode->m_conn_type,
1947 .use_v2transport =
false});
1948 LogDebug(
BCLog::NET,
"retrying with v1 transport protocol for peer=%d\n", pnode->GetId());
1952 pnode->grantOutbound.Release();
1955 pnode->CloseSocketDisconnect();
1958 if (pnode->IsManualOrFullOutboundConn()) --m_network_conn_counts[pnode->addr.GetNetwork()];
1969 for (
CNode* pnode : nodes_disconnected_copy)
1972 if (pnode->GetRefCount() <= 0) {
1981 m_reconnections.splice(m_reconnections.end(), std::move(reconnections_to_add));
1990 nodes_size = m_nodes.size();
2009 const auto now{GetTime<std::chrono::seconds>()};
2010 const auto last_send{
node.m_last_send.load()};
2011 const auto last_recv{
node.m_last_recv.load()};
2015 bool has_received{last_recv.count() != 0};
2016 bool has_sent{last_send.count() != 0};
2018 if (!has_received || !has_sent) {
2019 std::string has_never;
2020 if (!has_received) has_never +=
", never received from peer";
2021 if (!has_sent) has_never +=
", never sent to peer";
2023 "socket no message in first %i seconds%s, %s\n",
2033 "socket sending timeout: %is, %s\n",
count_seconds(now - last_send),
2041 "socket receive timeout: %is, %s\n",
count_seconds(now - last_recv),
2047 if (!
node.fSuccessfullyConnected) {
2064 events_per_sock.emplace(hListenSocket.sock,
Sock::Events{Sock::RECV});
2067 for (
CNode* pnode : nodes) {
2068 bool select_recv = !pnode->fPauseRecv;
2071 LOCK(pnode->cs_vSend);
2075 const auto& [to_send, more, _msg_type] = pnode->m_transport->GetBytesToSend(!pnode->vSendMsg.empty());
2076 select_send = !to_send.empty() || more;
2078 if (!select_recv && !select_send)
continue;
2080 LOCK(pnode->m_sock_mutex);
2081 if (pnode->m_sock) {
2083 events_per_sock.emplace(pnode->m_sock,
Sock::Events{event});
2087 return events_per_sock;
2106 if (events_per_sock.empty() || !events_per_sock.begin()->first->WaitMany(timeout, events_per_sock)) {
2123 for (
CNode* pnode : nodes) {
2131 bool recvSet =
false;
2132 bool sendSet =
false;
2133 bool errorSet =
false;
2135 LOCK(pnode->m_sock_mutex);
2136 if (!pnode->m_sock) {
2139 const auto it = events_per_sock.find(pnode->m_sock);
2140 if (it != events_per_sock.end()) {
2143 errorSet = it->second.occurred &
Sock::ERR;
2160 if (data_left) recvSet =
false;
2164 if (recvSet || errorSet)
2167 uint8_t pchBuf[0x10000];
2170 LOCK(pnode->m_sock_mutex);
2171 if (!pnode->m_sock) {
2174 nBytes = pnode->m_sock->Recv(pchBuf,
sizeof(pchBuf),
MSG_DONTWAIT);
2178 bool notify =
false;
2179 if (!pnode->ReceiveMsgBytes({pchBuf, (size_t)nBytes}, notify)) {
2181 "receiving message bytes failed, %s\n",
2184 pnode->CloseSocketDisconnect();
2188 pnode->MarkReceivedMsgsForProcessing();
2192 else if (nBytes == 0)
2195 if (!pnode->fDisconnect) {
2198 pnode->CloseSocketDisconnect();
2200 else if (nBytes < 0)
2206 if (!pnode->fDisconnect) {
2209 pnode->CloseSocketDisconnect();
2224 const auto it = events_per_sock.find(listen_socket.sock);
2225 if (it != events_per_sock.end() && it->second.occurred &
Sock::RECV) {
2246 fMsgProcWake =
true;
2253 int outbound_connection_count = 0;
2257 constexpr std::chrono::seconds SEEDNODE_TIMEOUT = 30
s;
2258 LogPrintf(
"-seednode enabled. Trying the provided seeds for %d seconds before defaulting to the dnsseeds.\n", SEEDNODE_TIMEOUT.count());
2267 LogPrintf(
"Couldn't connect to enough peers via seed nodes. Handing fetch logic to the DNS seeds.\n");
2273 LogPrintf(
"P2P peers available. Finished fetching data from seed nodes.\n");
2281 std::shuffle(seeds.begin(), seeds.end(), rng);
2282 int seeds_right_now = 0;
2286 seeds_right_now = seeds.size();
2291 seeds_right_now = seeds.size();
2311 for (
const std::string& seed : seeds) {
2312 if (seeds_right_now == 0) {
2316 LogPrintf(
"Waiting %d seconds before querying DNS seeds.\n", seeds_wait_time.count());
2317 std::chrono::seconds to_wait = seeds_wait_time;
2318 while (to_wait.count() > 0) {
2328 LogPrintf(
"%d addresses found from DNS seeds\n", found);
2329 LogPrintf(
"P2P peers available. Finished DNS seeding.\n");
2331 LogPrintf(
"P2P peers available. Skipped DNS seeding.\n");
2343 LogPrintf(
"Waiting for network to be reactivated before querying DNS seeds.\n");
2349 LogPrintf(
"Loading addresses from DNS seed %s\n", seed);
2355 std::vector<CAddress> vAdd;
2357 std::string host =
strprintf(
"x%x.%s", requiredServiceBits, seed);
2366 unsigned int nMaxIPs = 32;
2367 const auto addresses{
LookupHost(host, nMaxIPs,
true)};
2368 if (!addresses.empty()) {
2372 vAdd.push_back(addr);
2385 LogPrintf(
"%d addresses found from DNS seeds\n", found);
2387 LogPrintf(
"Skipping DNS seeds. Enough peers have been found\n");
2393 const auto start{SteadyClock::now()};
2398 addrman.
Size(), Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
2404 std::string strDest;
2407 if (m_addr_fetches.empty())
2409 strDest = m_addr_fetches.front();
2410 m_addr_fetches.pop_front();
2430 LogDebug(
BCLog::NET,
"setting try another outbound peer=%s\n", flag ?
"true" :
"false");
2445 for (
const CNode* pnode : m_nodes) {
2446 if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn()) ++nRelevant;
2460 int full_outbound_peers = 0;
2463 for (
const CNode* pnode : m_nodes) {
2464 if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) {
2465 ++full_outbound_peers;
2474 int block_relay_peers = 0;
2477 for (
const CNode* pnode : m_nodes) {
2478 if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsBlockOnlyConn()) {
2479 ++block_relay_peers;
2488 std::unordered_set<Network> networks{};
2489 for (
int n = 0; n <
NET_MAX; n++) {
2493 networks.insert(net);
2502 return m_network_conn_counts[net] > 1;
2511 for (
const auto net : nets) {
2527 if (!connect.empty())
2532 for (int64_t nLoop = 0;; nLoop++)
2534 for (
const std::string& strAddr : connect)
2538 for (
int i = 0; i < 10 && i < nLoop; i++)
2553 auto start = GetTime<std::chrono::microseconds>();
2561 const bool use_seednodes{!
gArgs.
GetArgs(
"-seednode").empty()};
2564 bool add_addr_fetch{
addrman.
Size() == 0 && !seed_nodes.empty()};
2565 constexpr std::chrono::seconds ADD_NEXT_SEEDNODE = 10
s;
2567 if (!add_fixed_seeds) {
2568 LogPrintf(
"Fixed seeds are disabled\n");
2572 if (add_addr_fetch) {
2573 add_addr_fetch =
false;
2578 LogInfo(
"Empty addrman, adding seednode (%s) to addrfetch\n", seed);
2580 LogInfo(
"Couldn't connect to peers from addrman after %d seconds. Adding seednode (%s) to addrfetch\n", ADD_NEXT_SEEDNODE.count(), seed);
2598 if (add_fixed_seeds && !fixed_seed_networks.empty()) {
2603 bool add_fixed_seeds_now =
false;
2605 if (GetTime<std::chrono::seconds>() > start + std::chrono::minutes{1}) {
2606 add_fixed_seeds_now =
true;
2607 LogPrintf(
"Adding fixed seeds as 60 seconds have passed and addrman is empty for at least one reachable network\n");
2611 else if (!dnsseed && !use_seednodes) {
2613 if (m_added_node_params.empty()) {
2614 add_fixed_seeds_now =
true;
2615 LogPrintf(
"Adding fixed seeds as -dnsseed=0 (or IPv4/IPv6 connections are disabled via -onlynet) and neither -addnode nor -seednode are provided\n");
2619 if (add_fixed_seeds_now) {
2627 seed_addrs.erase(std::remove_if(seed_addrs.begin(), seed_addrs.end(),
2628 [&fixed_seed_networks](
const CAddress& addr) { return fixed_seed_networks.count(addr.GetNetwork()) == 0; }),
2633 add_fixed_seeds =
false;
2634 LogPrintf(
"Added %d fixed seeds from reachable networks.\n", seed_addrs.size());
2644 int nOutboundFullRelay = 0;
2645 int nOutboundBlockRelay = 0;
2646 int outbound_privacy_network_peers = 0;
2647 std::set<std::vector<unsigned char>> outbound_ipv46_peer_netgroups;
2651 for (
const CNode* pnode : m_nodes) {
2652 if (pnode->IsFullOutboundConn()) nOutboundFullRelay++;
2653 if (pnode->IsBlockOnlyConn()) nOutboundBlockRelay++;
2656 switch (pnode->m_conn_type) {
2669 const CAddress address{pnode->addr};
2670 if (address.IsTor() || address.IsI2P() || address.IsCJDNS()) {
2678 ++outbound_privacy_network_peers;
2689 add_addr_fetch =
true;
2694 auto now = GetTime<std::chrono::microseconds>();
2695 bool anchor =
false;
2696 bool fFeeler =
false;
2697 std::optional<Network> preferred_net;
2743 }
else if (now > next_feeler) {
2749 now > next_extra_network_peer &&
2799 std::tie(addr, addr_last_try) =
addrman.
Select(
true, reachable_nets);
2808 std::tie(addr, addr_last_try) =
addrman.
Select(
true, reachable_nets);
2815 std::tie(addr, addr_last_try) = preferred_net.has_value()
2835 if (current_time - addr_last_try < 10min && nTries < 30) {
2858 preferred_net.has_value() ?
"network-specific " :
"",
2883 const bool count_failures{((int)outbound_ipv46_peer_netgroups.size() + outbound_privacy_network_peers) >= std::min(
m_max_automatic_connections - 1, 2)};
2893 std::vector<CAddress>
ret;
2895 for (
const CNode* pnode : m_nodes) {
2896 if (pnode->IsBlockOnlyConn()) {
2897 ret.push_back(pnode->addr);
2906 std::vector<AddedNodeInfo>
ret;
2908 std::list<AddedNodeParams> lAddresses(0);
2911 ret.reserve(m_added_node_params.size());
2912 std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));
2917 std::map<CService, bool> mapConnected;
2918 std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
2921 for (
const CNode* pnode : m_nodes) {
2922 if (pnode->addr.IsValid()) {
2923 mapConnected[pnode->addr] = pnode->IsInboundConn();
2925 std::string addrName{pnode->m_addr_name};
2926 if (!addrName.empty()) {
2927 mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(),
static_cast<const CService&
>(pnode->addr));
2932 for (
const auto& addr : lAddresses) {
2935 if (service.IsValid()) {
2937 auto it = mapConnected.find(service);
2938 if (it != mapConnected.end()) {
2939 if (!include_connected) {
2942 addedNode.resolvedAddress = service;
2943 addedNode.fConnected =
true;
2944 addedNode.fInbound = it->second;
2948 auto it = mapConnectedByName.find(addr.m_added_node);
2949 if (it != mapConnectedByName.end()) {
2950 if (!include_connected) {
2953 addedNode.resolvedAddress = it->second.second;
2954 addedNode.fConnected =
true;
2955 addedNode.fInbound = it->second.first;
2958 ret.emplace_back(std::move(addedNode));
2998 const char* pszDest,
3000 bool use_v2transport,
3001 const std::optional<Proxy>& proxy_override)
3016 bool banned_or_discouraged =
m_banman && (
m_banman->IsDiscouraged(addrConnect) ||
m_banman->IsBanned(addrConnect));
3033 m_nodes.push_back(pnode);
3057 bool fMoreWork =
false;
3065 for (
CNode* pnode : snap.Nodes()) {
3066 if (pnode->fDisconnect)
3071 fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
3086 fMsgProcWake =
false;
3092 static constexpr auto err_wait_begin = 1
s;
3093 static constexpr auto err_wait_cap = 5min;
3094 auto err_wait = err_wait_begin;
3096 bool advertising_listen_addr =
false;
3099 auto SleepOnFailure = [&]() {
3101 if (err_wait < err_wait_cap) {
3109 if (advertising_listen_addr && conn.
me.
IsValid()) {
3111 advertising_listen_addr =
false;
3117 if (!advertising_listen_addr) {
3119 advertising_listen_addr =
true;
3129 err_wait = err_wait_begin;
3138 struct sockaddr_storage sockaddr;
3139 socklen_t len =
sizeof(sockaddr);
3140 if (!addrBind.
GetSockAddr((
struct sockaddr*)&sockaddr, &len))
3156 if (sock->SetSockOpt(SOL_SOCKET, SO_REUSEADDR, &nOne,
sizeof(
int)) ==
SOCKET_ERROR) {
3165 if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_V6ONLY, &nOne,
sizeof(
int)) ==
SOCKET_ERROR) {
3171 int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
3172 if (sock->SetSockOpt(IPPROTO_IPV6, IPV6_PROTECTION_LEVEL, &nProtLevel,
sizeof(
int)) ==
SOCKET_ERROR) {
3179 if (sock->Bind(
reinterpret_cast<struct sockaddr*
>(&sockaddr), len) ==
SOCKET_ERROR) {
3182 strError =
strprintf(
_(
"Unable to bind to %s on this computer. %s is probably already running."), addrBind.
ToStringAddrPort(), CLIENT_NAME);
3209 LogPrintf(
"%s: %s\n", __func__, addr.ToStringAddr());
3215 LogPrintf(
"%s: %s\n", __func__, active);
3233 bool network_active,
3234 std::shared_ptr<CThreadInterrupt> interrupt_net)
3235 : addrman(addrman_in)
3236 , m_netgroupman{netgroupman}
3239 , m_interrupt_net{interrupt_net}
3251 return nLastNodeId.fetch_add(1, std::memory_order_relaxed);
3286 for (
const auto& addrBind : options.
vBinds) {
3291 for (
const auto& addrBind : options.
vWhiteBinds) {
3296 for (
const auto& addr_bind : options.
onion_binds) {
3308 struct in_addr inaddr_any;
3309 inaddr_any.s_addr = htonl(INADDR_ANY);
3326 _(
"Failed to listen on any port. Use -listen=0 if you want this."),
3339 std::vector<std::string> seed_nodes = connOptions.
vSeedNodes;
3340 if (!seed_nodes.empty()) {
3350 LogPrintf(
"%i block-relay-only anchors will be tried for connections.\n",
m_anchors.size());
3377 fMsgProcWake =
false;
3394 _(
"Cannot provide specific connections and have addrman find outgoing connections at the same time."),
3402 [
this, connect = connOptions.
m_specified_outgoing, seed_nodes = std::move(seed_nodes)] { ThreadOpenConnections(connect, seed_nodes); });
3448 (*m_interrupt_net)();
3498 std::vector<CNode*> nodes;
3500 for (
CNode* pnode : nodes) {
3502 pnode->CloseSocketDisconnect();
3530 std::vector<CAddress> addresses =
addrman.
GetAddr(max_addresses, max_pct, network, filtered);
3532 addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
3533 [
this](
const CAddress& addr){return m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr);}),
3543 const auto current_time = GetTime<std::chrono::microseconds>();
3581 const bool resolved_is_valid{resolved.
IsValid()};
3584 for (
const auto& it : m_added_node_params) {
3588 m_added_node_params.push_back(add);
3595 for (
auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {
3596 if (strNode == it->m_added_node) {
3597 m_added_node_params.erase(it);
3610 return (m_added_node_params.size() < 24
3611 && std::any_of(m_added_node_params.cbegin(), m_added_node_params.cend(),
3612 [&](
const auto& p) { return p.m_added_node == addr_str || p.m_added_node == addr_port_str; }));
3619 return m_nodes.size();
3622 for (
const auto& pnode : m_nodes) {
3635 return mapLocalHost;
3647 vstats.reserve(m_nodes.size());
3648 for (
CNode* pnode : m_nodes) {
3649 vstats.emplace_back();
3650 pnode->CopyStats(vstats.back());
3651 vstats.back().m_mapped_as =
GetMappedAS(pnode->addr);
3658 auto it = std::ranges::find_if(m_nodes, [&strNode](
CNode*
node) {
return node->m_addr_name == strNode; });
3659 if (it != m_nodes.end()) {
3662 node->fDisconnect =
true;
3670 bool disconnected =
false;
3672 for (
CNode* pnode : m_nodes) {
3673 if (subnet.
Match(pnode->addr)) {
3675 pnode->fDisconnect =
true;
3676 disconnected =
true;
3679 return disconnected;
3690 for(
CNode* pnode : m_nodes) {
3691 if (
id == pnode->GetId()) {
3693 pnode->fDisconnect =
true;
3710 nTotalBytesSent += bytes;
3712 const auto now = GetTime<std::chrono::seconds>();
3716 nMaxOutboundCycleStartTime = now;
3717 nMaxOutboundTotalBytesSentInCycle = 0;
3720 nMaxOutboundTotalBytesSentInCycle += bytes;
3749 if (nMaxOutboundCycleStartTime.count() == 0)
3753 const auto now = GetTime<std::chrono::seconds>();
3754 return (cycleEndTime < now) ? 0
s : cycleEndTime - now;
3764 if (historicalBlockServingLimit)
3797 return nTotalBytesSent;
3807 if (use_v2transport) {
3808 return std::make_unique<V2Transport>(
id, !inbound);
3810 return std::make_unique<V1Transport>(
id);
3815 std::shared_ptr<Sock> sock,
3817 uint64_t nKeyedNetGroupIn,
3818 uint64_t nLocalHostNonceIn,
3820 const std::string& addrNameIn,
3823 uint64_t network_key,
3826 m_permission_flags{node_opts.permission_flags},
3828 m_connected{
GetTime<
std::chrono::seconds>()},
3830 addrBind{addrBindIn},
3831 m_addr_name{addrNameIn.empty() ? addr.ToStringAddrPort() : addrNameIn},
3833 m_inbound_onion{inbound_onion},
3834 m_prefer_evict{node_opts.prefer_evict},
3835 nKeyedNetGroup{nKeyedNetGroupIn},
3836 m_network_key{network_key},
3837 m_conn_type{conn_type_in},
3839 nLocalHostNonce{nLocalHostNonceIn},
3840 m_recv_flood_size{node_opts.recv_flood_size},
3841 m_i2p_sam_session{
std::move(node_opts.i2p_sam_session)}
3846 mapRecvBytesPerMsgType[
msg] = 0;
3861 size_t nSizeAdded = 0;
3865 nSizeAdded +=
msg.GetMemoryUsage();
3869 m_msg_process_queue.splice(m_msg_process_queue.end(),
vRecvMsg);
3870 m_msg_process_queue_size += nSizeAdded;
3877 if (m_msg_process_queue.empty())
return std::nullopt;
3879 std::list<CNetMessage> msgs;
3881 msgs.splice(msgs.begin(), m_msg_process_queue, m_msg_process_queue.begin());
3882 m_msg_process_queue_size -= msgs.front().GetMemoryUsage();
3885 return std::make_pair(std::move(msgs.front()), !m_msg_process_queue.empty());
3896 size_t nMessageSize =
msg.data.size();
3911 size_t nBytesSent = 0;
3916 const auto& [to_send, more, _msg_type] =
3918 const bool queue_was_empty{to_send.empty() && pnode->vSendMsg.empty()};
3921 pnode->m_send_memusage +=
msg.GetMemoryUsage();
3924 pnode->vSendMsg.push_back(std::move(
msg));
3933 if (queue_was_empty && more) {
3942 CNode* found =
nullptr;
3944 for (
auto&& pnode : m_nodes) {
3945 if(pnode->
GetId() ==
id) {
3971 decltype(m_reconnections) todo;
3974 if (m_reconnections.empty())
break;
3975 todo.splice(todo.end(), m_reconnections, m_reconnections.begin());
3978 auto& item = *todo.begin();
3985 std::move(item.grant),
3986 item.destination.empty() ?
nullptr : item.destination.c_str(),
3988 item.use_v2transport);
3996 std::vector<CNetAddr> clearnet_addrs;
3997 clearnet_addrs.reserve(v4_addrs.size() + v6_addrs.size());
3998 std::transform(v4_addrs.begin(), v4_addrs.end(), std::back_inserter(clearnet_addrs),
3999 [](
const CAddress& addr) { return static_cast<CNetAddr>(addr); });
4000 std::transform(v6_addrs.begin(), v6_addrs.end(), std::back_inserter(clearnet_addrs),
4001 [](
const CAddress& addr) { return static_cast<CNetAddr>(addr); });
4007 const std::string& msg_type,
4008 std::span<const unsigned char>
data,
4015 auto now = GetTime<std::chrono::microseconds>();
4019 std::replace(clean_addr.begin(), clean_addr.end(),
':',
'_');
4024 fs::path path = base_path / (is_incoming ?
"msgs_recv.dat" :
"msgs_sent.dat");
4028 f << std::span{msg_type};
4032 uint32_t size =
data.size();
4036 if (f.fclose() != 0) {
4037 throw std::ios_base::failure(
4042std::function<void(
const CAddress& addr,
4043 const std::string& msg_type,
4044 std::span<const unsigned char>
data,
bool DumpPeerAddresses(const ArgsManager &args, const AddrMan &addr)
std::vector< CAddress > ReadAnchors(const fs::path &anchors_db_path)
Read the anchor IP address database (anchors.dat)
void DumpAnchors(const fs::path &anchors_db_path, const std::vector< CAddress > &anchors)
Dump the anchor IP address database (anchors.dat)
const CChainParams & Params()
Return the currently selected parameters.
#define Assume(val)
Assume is the identity function.
Stochastic address manager.
std::pair< CAddress, NodeSeconds > Select(bool new_only=false, const std::unordered_set< Network > &networks={}) const
Choose an address to connect to.
void Attempt(const CService &addr, bool fCountFailure, NodeSeconds time=Now< NodeSeconds >())
Mark an entry as connection attempted to.
size_t Size(std::optional< Network > net=std::nullopt, std::optional< bool > in_new=std::nullopt) const
Return size information about addrman.
void ResolveCollisions()
See if any to-be-evicted tried table entries have been tested and if so resolve the collisions.
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.
std::pair< CAddress, NodeSeconds > SelectTriedCollision()
Randomly select an address in the tried table that another address is attempting to evict.
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.
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.
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Non-refcounted RAII wrapper for FILE*.
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.
std::span< const std::byte > GetSendGarbageTerminator() const noexcept
Get the Garbage Terminator to send.
static constexpr unsigned GARBAGE_TERMINATOR_LEN
unsigned DecryptLength(std::span< const std::byte > input) noexcept
Decrypt the length of a packet.
std::span< const std::byte > GetSessionID() const noexcept
Get the Session ID.
const EllSwiftPubKey & GetOurPubKey() const noexcept
Retrieve our public key.
std::span< const std::byte > GetReceiveGarbageTerminator() const noexcept
Get the expected Garbage Terminator to receive.
static constexpr unsigned LENGTH_LEN
static constexpr unsigned EXPANSION
void Initialize(const EllSwiftPubKey &their_pubkey, bool initiator, bool self_decrypt=false) noexcept
Initialize when the other side's public key is received.
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.
A CService with information about it as peer.
ServiceFlags nServices
Serialized as uint64_t in V1, and as CompactSize in V2.
NodeSeconds nTime
Always included in serialization. The behavior is unspecified if the value is not representable as ui...
static constexpr SerParams V2_NETWORK
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
const MessageStartChars & MessageStart() const
uint16_t GetDefaultPort() const
const std::vector< std::string > & DNSSeeds() const
Return the list of hostnames to look up for DNS seeds.
const std::vector< uint8_t > & FixedSeeds() const
RAII helper to atomically create a copy of m_nodes and add a reference to each of the nodes.
std::unordered_set< Network > GetReachableEmptyNetworks() const
Return reachable networks for which we have no addresses in addrman and therefore may require loading...
std::condition_variable condMsgProc
std::thread threadMessageHandler
void ThreadMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
void DisconnectNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex
m_max_outbound_full_relay
void DeleteNode(CNode *pnode)
bool RemoveAddedNode(const std::string &node) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
bool AttemptToEvictConnection()
Try to find a connection to evict when the node is full.
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.
bool GetTryNewOutboundPeer() const
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.
const bool use_v2transport(GetLocalServices() &NODE_P2P_V2)
uint16_t GetDefaultPort(Network net) const
void PerformReconnections() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex
Attempt reconnections, if m_reconnections non-empty.
std::thread threadI2PAcceptIncoming
std::vector< CAddress > GetAddresses(CNode &requestor, size_t max_addresses, size_t max_pct)
Return addresses from the per-requestor cache.
void SetTryNewOutboundPeer(bool flag)
CNode * ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport, const std::optional< Proxy > &proxy_override) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex)
Open a new P2P connection.
std::atomic< bool > flagInterruptMsgProc
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...
void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
std::map< CNetAddr, LocalServiceInfo > getNetLocalAddresses() const
void ThreadDNSAddressSeed() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex
int GetFullOutboundConnCount() const
std::atomic< NodeId > nLastNodeId
int GetExtraBlockRelayCount() const
void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc)
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,...
uint64_t GetMaxOutboundTarget() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
std::thread threadDNSAddressSeed
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.
void ThreadI2PAcceptIncoming()
void StartExtraBlockRelayPeers()
const NetGroupManager & m_netgroupman
std::vector< CAddress > m_anchors
Addresses that were saved during the previous clean shutdown.
std::chrono::seconds GetMaxOutboundTimeframe() const
uint64_t CalculateKeyedNetGroup(const CNetAddr &ad) const
unsigned int nPrevNodeCount
void AddWhitelistPermissionFlags(NetPermissionFlags &flags, std::optional< CNetAddr > addr, const std::vector< NetWhitelistPermissions > &ranges) const
void NotifyNumConnectionsChanged()
ServiceFlags GetLocalServices() const
Used to convey which local services we are offering peers during node connection.
bool AddNode(const AddedNodeParams &add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
bool DisconnectNode(const std::string &node)
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...
bool InitBinds(const Options &options)
vWhitelistedRangeOutgoing
void AddAddrFetch(const std::string &strDest) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex)
std::vector< ListenSocket > vhListenSocket
bool AlreadyConnectedToAddress(const CNetAddr &addr) const
Determine whether we're already connected to a given address.
std::vector< CAddress > GetCurrentBlockRelayOnlyConns() const
Return vector of current BLOCK_RELAY peers.
CSipHasher GetDeterministicRandomizer(uint64_t id) const
Get a unique deterministic randomizer.
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.
Mutex m_total_bytes_sent_mutex
std::vector< AddedNodeInfo > GetAddedNodeInfo(bool include_connected) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex
bool Bind(const CService &addr, unsigned int flags, NetPermissionFlags permissions)
std::thread threadOpenConnections
size_t GetNodeCount(ConnectionDirection) const
uint32_t GetMappedAS(const CNetAddr &addr) const
void ProcessAddrFetch() EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex
Mutex m_addr_fetches_mutex
bool InactivityCheck(const CNode &node) const
Return true if the peer is inactive and should be disconnected.
Mutex m_reconnections_mutex
Mutex protecting m_reconnections.
void GetNodeStats(std::vector< CNodeStats > &vstats) const
bool Start(CScheduler &scheduler, const Options &options) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex
const uint64_t nSeed0
SipHasher seeds for deterministic randomness.
void SocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex
Check connected and listening sockets for IO readiness and process them accordingly.
int GetExtraFullOutboundCount() const
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
uint64_t GetTotalBytesRecv() const
bool OpenNetworkConnection(const CAddress &addrConnect, bool fCountFailure, CountingSemaphoreGrant<> &&grant_outbound, const char *pszDest, ConnectionType conn_type, bool use_v2transport, const std::optional< Proxy > &proxy_override=std::nullopt) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex)
Open a new P2P connection and initialize it with the PeerManager at m_msgproc.
std::pair< size_t, bool > SocketSendData(CNode &node) const EXCLUSIVE_LOCKS_REQUIRED(node.cs_vSend)
(Try to) send data from node's vSendMsg.
RecursiveMutex m_nodes_mutex
m_max_outbound_block_relay
static bool NodeFullyConnected(const CNode *pnode)
std::unique_ptr< std::counting_semaphore<> > semOutbound
const CChainParams & m_params
void SetNetworkActive(bool active)
bool MultipleManualOrFullOutboundConns(Network net) const EXCLUSIVE_LOCKS_REQUIRED(m_nodes_mutex)
bool AddedNodesContain(const CAddress &addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex)
std::chrono::seconds GetMaxOutboundTimeLeftInCycle() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
const std::shared_ptr< CThreadInterrupt > m_interrupt_net
This is signaled when network activity should cease.
m_max_automatic_connections
void ThreadOpenConnections(std::vector< std::string > connect, std::span< const std::string > seed_nodes) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex
bool fAddressesInitialized
std::thread threadOpenAddedConnections
Mutex m_added_nodes_mutex
vWhitelistedRangeIncoming
void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex
void RecordBytesSent(uint64_t bytes) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
bool CheckIncomingNonce(uint64_t nonce)
void Init(const Options &connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex
bool AlreadyConnectedToHost(const std::string &host) const
Determine whether we're already connected to a given "host:port".
Mutex m_unused_i2p_sessions_mutex
Mutex protecting m_i2p_sam_sessions.
uint64_t GetTotalBytesSent() const EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
std::unique_ptr< std::counting_semaphore<> > semAddnode
bool MaybePickPreferredNetwork(std::optional< Network > &network)
Search for a "preferred" network, a reachable network to which we currently don't have any OUTBOUND_F...
void RecordBytesRecv(uint64_t bytes)
bool ShouldRunInactivityChecks(const CNode &node, std::chrono::seconds now) const
Return true if we should disconnect the peer for failing an inactivity check.
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...
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg) EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex)
std::list< CNode * > m_nodes_disconnected
std::unique_ptr< i2p::sam::Session > m_i2p_sam_session
I2P SAM session.
std::map< uint64_t, CachedAddrResponse > m_addr_response_caches
Addr responses stored in different caches per (network, local socket) prevent cross-network node iden...
Sock::EventsPerSock GenerateWaitSockets(std::span< CNode *const > nodes)
Generate a collection of sockets to check for IO readiness.
std::atomic< uint64_t > nTotalBytesRecv
std::atomic< bool > fNetworkActive
std::atomic_bool m_start_extra_block_relay_peers
flag for initiating extra block-relay-only peer connections.
void SocketHandlerListening(const Sock::EventsPerSock &events_per_sock)
Accept incoming connections, one from each read-ready listening socket.
CConnman(uint64_t seed0, uint64_t seed1, AddrMan &addrman, const NetGroupManager &netgroupman, const CChainParams ¶ms, bool network_active=true, std::shared_ptr< CThreadInterrupt > interrupt_net=std::make_shared< CThreadInterrupt >())
bool AlreadyConnectedToAddressPort(const CService &addr_port) const
Determine whether we're already connected to a given address:port.
std::thread threadSocketHandler
void AcceptConnection(const ListenSocket &hListenSocket)
bool BindListenPort(const CService &bindAddr, bilingual_str &strError, NetPermissionFlags permissions)
An encapsulated private key.
Network GetNetClass() const
std::string ToStringAddr() const
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
std::vector< unsigned char > GetAddrBytes() const
bool IsPrivacyNet() const
Whether this object is a privacy network.
bool SetInternal(const std::string &name)
Create an "internal" address that represents a name or FQDN.
enum Network GetNetwork() const
Transport protocol agnostic message container.
size_t GetMemoryUsage() const noexcept
Compute total memory usage of this object (own memory + any dynamic memory).
DataStream m_recv
received message data
Information about a peer.
const std::chrono::seconds m_connected
Unix epoch time at peer connection.
std::atomic< int > nVersion
bool IsInboundConn() const
CountingSemaphoreGrant grantOutbound
std::atomic_bool fPauseRecv
const std::string m_addr_name
bool IsConnectedThroughPrivacyNet() const
Whether this peer connected through a privacy network.
void CopyStats(CNodeStats &stats) EXCLUSIVE_LOCKS_REQUIRED(!m_subver_mutex
std::string ConnectionTypeAsString() const
std::atomic< bool > m_bip152_highbandwidth_to
std::list< CNetMessage > vRecvMsg
std::atomic< bool > m_bip152_highbandwidth_from
std::atomic_bool fSuccessfullyConnected
fSuccessfullyConnected is set to true on receiving VERACK from the peer.
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.
void SetAddrLocal(const CService &addrLocalIn) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex)
May not be called more than once.
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, uint64_t network_key, CNodeOptions &&node_opts={})
void MarkReceivedMsgsForProcessing() EXCLUSIVE_LOCKS_REQUIRED(!m_msg_process_queue_mutex)
Move all messages from the received queue to the processing queue.
const uint64_t m_network_key
Network key used to prevent fingerprinting our node across networks.
std::atomic_bool fPauseSend
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.
Mutex m_msg_process_queue_mutex
const ConnectionType m_conn_type
Network ConnectedThroughNetwork() const
Get network the peer connected through.
const size_t m_recv_flood_size
std::atomic< std::chrono::microseconds > m_last_ping_time
Last measured round-trip time.
bool IsManualOrFullOutboundConn() const
std::string LogIP(bool log_ip) const
Helper function to optionally log the IP address.
const std::unique_ptr< Transport > m_transport
Transport serializer/deserializer.
const NetPermissionFlags m_permission_flags
const bool m_inbound_onion
Whether this peer is an inbound onion, i.e. connected via our Tor onion service.
std::atomic< std::chrono::microseconds > m_min_ping_time
Lowest measured round-trip time.
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....
std::string DisconnectMsg(bool log_ip) const
Helper function to log disconnects.
std::atomic_bool fDisconnect
std::atomic< std::chrono::seconds > m_last_recv
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....
CService GetAddrLocal() const EXCLUSIVE_LOCKS_REQUIRED(!m_addr_local_mutex)
void CloseSocketDisconnect() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex)
std::atomic< std::chrono::seconds > m_last_send
std::string m_session_id
BIP324 session id string in hex, if any.
TransportProtocolType m_transport_type
Transport protocol type.
Simple class for background tasks that should be run periodically or once "after a while".
void scheduleEvery(Function f, std::chrono::milliseconds delta) EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex)
Repeat f until the scheduler is stopped.
A combination of a network address (CNetAddr) and a (TCP) port.
bool SetSockAddr(const struct sockaddr *paddr, socklen_t addrlen)
Set CService from a network sockaddr.
sa_family_t GetSAFamily() const
Get the address family.
bool GetSockAddr(struct sockaddr *paddr, socklen_t *addrlen) const
Obtain the IPv4/6 socket address this represents.
std::string ToStringAddrPort() const
uint64_t Finalize() const
Compute the 64-bit SipHash-2-4 of the data written so far.
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 ...
std::string ToString() const
bool Match(const CNetAddr &addr) const
std::chrono::steady_clock Clock
RAII-style semaphore lock.
Double ended buffer combining vector and stream-like interfaces.
size_t GetMemoryUsage() const noexcept
Compute total memory usage of this object (own memory + any dynamic memory).
void fillrand(std::span< std::byte > output) noexcept
Fill a byte span with random bytes.
Different type to mark Mutex at global scope.
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
bool UsingASMap() const
Indicates whether ASMap is being used for clearnet bucketing.
void ASMapHealthCheck(const std::vector< CNetAddr > &clearnet_addrs) const
Analyze and log current health of ASMap based buckets.
std::vector< unsigned char > GetGroup(const CNetAddr &address) const
Get the canonical identifier of the network group for address.
uint32_t GetMappedAS(const CNetAddr &address) const
Get the autonomous system on the BGP path to address.
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.
std::string ToString() const
Tp rand_uniform_delay(const Tp &time, typename Tp::duration range) noexcept
Return the time point advanced by a uniform random duration.
Chrono::duration rand_uniform_duration(typename Chrono::duration range) noexcept
Generate a uniform random duration in the range from 0 (inclusive) to range (exclusive).
I randrange(I range) noexcept
Generate a random integer in the range [0..range), with range > 0.
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...
uint64_t randbits(int bits) noexcept
Generate a random (bits)-bit integer.
std::unordered_set< Network > All() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
RAII helper class that manages a socket and closes it automatically when it goes out of scope.
static constexpr Event SEND
If passed to Wait(), then it will wait for readiness to send to the socket.
virtual int GetSockName(sockaddr *name, socklen_t *name_len) const
getsockname(2) wrapper.
static constexpr Event ERR
Ignored if passed to Wait(), but could be set in the occurred events if an exceptional condition has ...
static constexpr Event RECV
If passed to Wait(), then it will wait for readiness to read from the socket.
std::unordered_map< std::shared_ptr< const Sock >, Events, HashSharedPtrSock, EqualSharedPtrSock > EventsPerSock
On which socket to wait for what events in WaitMany().
std::tuple< std::span< const uint8_t >, bool, const std::string & > BytesToSend
Return type for GetBytesToSend, consisting of:
bool SetMessageToSend(CSerializedNetMsg &msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex)
Set the next message to send.
Info GetInfo() const noexcept override
Retrieve information about this transport.
int readData(std::span< const uint8_t > msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Mutex m_send_mutex
Lock for sending state.
const MessageStartChars m_magic_bytes
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.
const uint256 & GetMessageHash() const EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
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.
int readHeader(std::span< const uint8_t > msg_bytes) EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
V1Transport(const NodeId node_id) noexcept
bool CompleteInternal() const noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
bool ReceivedBytes(std::span< const uint8_t > &msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Feed wire bytes to the transport.
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.
void Reset() EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Mutex m_recv_mutex
Lock for receive state.
bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Returns true if the current message is complete (so GetReceivedMessage can be called).
CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool &reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Retrieve a completed message from transport.
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.
static constexpr uint32_t MAX_GARBAGE_LEN
const NodeId m_nodeid
NodeId (for debug logging).
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).
BIP324Cipher m_cipher
Cipher state.
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.
void ProcessReceivedMaybeV1Bytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex
Process bytes in m_recv_buffer, while in KEY_MAYBE_V1 state.
SendState
State type that controls the sender side.
@ 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.
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...
void StartSendingHandshake() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_send_mutex)
Put our public key + garbage in the send buffer.
bool ProcessReceivedPacketBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Process bytes in m_recv_buffer, while in VERSION/APP state.
bool ProcessReceivedKeyBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex
Process bytes in m_recv_buffer, while in KEY state.
const bool m_initiating
Whether we are the initiator side.
Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Retrieve information about this transport.
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.
void SetReceiveState(RecvState recv_state) noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Change the receive state.
bool ProcessReceivedGarbageBytes() noexcept EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex)
Process bytes in m_recv_buffer, while in GARB_GARBTERM state.
bool ReceivedMessageComplete() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Returns true if the current message is complete (so GetReceivedMessage can be called).
CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool &reject_message) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
Retrieve a completed message from transport.
static constexpr std::array< std::byte, 0 > VERSION_CONTENTS
Contents of the version packet to send.
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.
bool ReceivedBytes(std::span< const uint8_t > &msg_bytes) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex
Feed wire bytes to the transport.
bool ShouldReconnectV1() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex
Whether upon disconnections, a reconnect with V1 is warranted.
bool SetMessageToSend(CSerializedNetMsg &msg) noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex)
Set the next message to send.
V2Transport(NodeId nodeid, bool initiating) noexcept
Construct a V2 transport with securely generated random keys.
RecvState
State type that defines the current contents of the receive buffer and/or how the next received bytes...
@ 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.
constexpr unsigned char * begin()
#define WSAGetLastError()
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.
@ 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)
uint32_t ReadLE32(const B *ptr)
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,...
static path u8path(const std::string &utf8_str)
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...
static std::string PathToString(const path &path)
Convert path object to a byte string.
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
CKey GenerateRandomKey(bool compressed) noexcept
#define LogPrintLevel(category, level,...)
#define LogDebug(category,...)
constexpr const char * FILTERCLEAR
The filterclear message tells the receiving peer to remove a previously-set bloom filter.
constexpr const char * FEEFILTER
The feefilter message tells the receiving peer not to inv us any txs which do not meet the specified ...
constexpr const char * GETBLOCKS
The getblocks message requests an inv message that provides block header hashes starting from a parti...
constexpr const char * HEADERS
The headers message sends one or more block headers to a node which previously requested certain head...
constexpr const char * ADDR
The addr (IP address) message relays connection information for peers on the network.
constexpr const char * GETBLOCKTXN
Contains a BlockTransactionsRequest Peer should respond with "blocktxn" message.
constexpr const char * CMPCTBLOCK
Contains a CBlockHeaderAndShortTxIDs object - providing a header and list of "short txids".
constexpr const char * CFCHECKPT
cfcheckpt is a response to a getcfcheckpt request containing a vector of evenly spaced filter headers...
constexpr const char * GETCFILTERS
getcfilters requests compact filters for a range of blocks.
constexpr const char * PONG
The pong message replies to a ping message, proving to the pinging node that the ponging node is stil...
constexpr const char * BLOCKTXN
Contains a BlockTransactions.
constexpr const char * CFHEADERS
cfheaders is a response to a getcfheaders request containing a filter header and a vector of filter h...
constexpr const char * PING
The ping message is sent periodically to help confirm that the receiving peer is still connected.
constexpr const char * FILTERLOAD
The filterload message tells the receiving peer to filter all relayed transactions and requested merk...
constexpr const char * ADDRV2
The addrv2 message relays connection information for peers on the network just like the addr message,...
constexpr const char * GETHEADERS
The getheaders message requests a headers message that provides block headers starting from a particu...
constexpr const char * FILTERADD
The filteradd message tells the receiving peer to add a single element to a previously-set bloom filt...
constexpr const char * CFILTER
cfilter is a response to a getcfilters request containing a single compact filter.
constexpr const char * GETDATA
The getdata message requests one or more data objects from another node.
constexpr const char * SENDCMPCT
Contains a 1-byte bool and 8-byte LE version number.
constexpr const char * GETCFCHECKPT
getcfcheckpt requests evenly spaced compact filter headers, enabling parallelized download and valida...
constexpr const char * INV
The inv message (inventory message) transmits one or more inventories of objects known to the transmi...
constexpr const char * TX
The tx message transmits a single transaction.
constexpr const char * MEMPOOL
The mempool message requests the TXIDs of transactions that the receiving node has verified as valid ...
constexpr const char * NOTFOUND
The notfound message is a reply to a getdata message which requested an object the receiving node doe...
constexpr const char * MERKLEBLOCK
The merkleblock message is a reply to a getdata message which requested a block using the inventory t...
constexpr const char * BLOCK
The block message transmits a single serialized block.
constexpr const char * GETCFHEADERS
getcfheaders requests a compact filter header and the filter hashes for a range of blocks,...
FILE * fopen(const fs::path &p, const char *mode)
static size_t DynamicUsage(const int8_t &v)
Dynamic memory usage for built-in types is zero.
static const unsigned char VERSION[]
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE
Number of DNS seeds to query when the number of connections is low.
bool IsLocal(const CService &addr)
check whether a given address is potentially local
static const uint64_t RANDOMIZER_ID_NETGROUP
static const uint64_t SELECT_TIMEOUT_MILLISECONDS
static const uint64_t RANDOMIZER_ID_NETWORKKEY
void RemoveLocal(const CService &addr)
BindFlags
Used to pass flags to the Bind() function.
@ BF_DONT_ADVERTISE
Do not call AddLocal() for our special addresses, e.g., for incoming Tor connections,...
static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE
static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL
static constexpr auto EXTRA_NETWORK_PEER_INTERVAL
Frequency to attempt extra connections to reachable networks we're not connected to yet.
static constexpr int SEED_OUTBOUND_CONNECTION_THRESHOLD
Minimum number of outbound connections under which we will keep fetching our address seeds.
static CService GetBindAddress(const Sock &sock)
Get the bind address for a socket as CService.
bool AddLocal(const CService &addr_, int nScore)
static constexpr auto FEELER_SLEEP_WINDOW
static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD
static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS
Maximum number of block-relay-only anchor connections.
static bool IsPeerAddrLocalGood(CNode *pnode)
static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS
How long to delay before querying DNS seeds.
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
std::optional< CService > GetLocalAddrForPeer(CNode &node)
Returns a local address that we should advertise to this peer.
const std::string NET_MESSAGE_TYPE_OTHER
TRACEPOINT_SEMAPHORE(net, closed_connection)
static std::unique_ptr< Transport > MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept
const char *const ANCHORS_DATABASE_FILENAME
Anchor IP address database file name.
static std::vector< CAddress > ConvertSeeds(const std::vector< uint8_t > &vSeedsIn)
Convert the serialized seeds into usable address objects.
static void CaptureMessageToFile(const CAddress &addr, const std::string &msg_type, std::span< const unsigned char > data, bool is_incoming)
CService GetLocalAddress(const CNode &peer)
GlobalMutex g_maplocalhost_mutex
std::map< CNetAddr, LocalServiceInfo > mapLocalHost GUARDED_BY(g_maplocalhost_mutex)
static std::optional< CService > GetLocal(const CNode &peer)
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.
static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS
static int GetnScore(const CService &addr)
static CNetCleanup instance_of_cnetcleanup
static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME
The default timeframe for -maxuploadtarget.
void Discover()
Look up IP addresses from all interfaces on the machine and add them to the list of local addresses t...
bool SeenLocal(const CService &addr)
vote for a local address
static constexpr std::chrono::minutes TIMEOUT_INTERVAL
Time after which to disconnect, after waiting for a ping response (or inactivity).
static constexpr bool DEFAULT_FIXEDSEEDS
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH
Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable).
static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL
Run the extra block-relay-only connection loop once every 5 minutes.
static constexpr bool DEFAULT_FORCEDNSSEED
static constexpr bool DEFAULT_DNSSEED
static constexpr std::chrono::hours ASMAP_HEALTH_CHECK_INTERVAL
Interval for ASMap Health Check.
static constexpr auto FEELER_INTERVAL
Run the feeler connection loop once every 2 minutes.
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS
Maximum number of automatic outgoing nodes over which we'll relay everything (blocks,...
static const int MAX_BLOCK_RELAY_ONLY_CONNECTIONS
Maximum number of block-relay-only outgoing connections.
static constexpr uint16_t I2P_SAM31_PORT
SAM 3.1 and earlier do not support specifying ports and force the port to 0.
@ NET_MAX
Dummy value to indicate the number of NET_* constants.
@ NET_ONION
TOR (v2 or v3)
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
std::unique_ptr< Sock > ConnectDirectly(const CService &dest, bool manual_connection)
Create a socket and try to connect to the specified service.
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.
std::string GetNetworkName(enum Network net)
CThreadInterrupt g_socks5_interrupt
Interrupt SOCKS5 reads or writes.
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.
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...
ReachableNets g_reachable_nets
bool GetProxy(enum Network net, Proxy &proxyInfoOut)
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...
std::function< std::unique_ptr< Sock >(int, int, int)> CreateSock
Socket factory.
bool GetNameProxy(Proxy &nameProxyOut)
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.
bool IsBadPort(uint16_t port)
Determine if a port is "bad" from the perspective of attempting to connect to a node on that port.
std::vector< CNetAddr > GetLocalAddresses()
Return all local non-loopback IPv4 and IPv6 network addresses.
const std::array ALL_NET_MESSAGE_TYPES
All known message types (see above).
constexpr ServiceFlags SeedsServiceFlags()
State independent service flags.
ServiceFlags
nServices flags
static bool MayHaveUsefulAddressDB(ServiceFlags services)
Checks if a peer with the given service flags may be capable of having a robust address-storage DB.
void RandAddEvent(const uint32_t event_info) noexcept
Gathers entropy from the low bits of the time at which events occur.
uint256 GetRandHash() noexcept
Generate a random uint256.
void ser_writedata32(Stream &s, uint32_t obj)
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...
void ser_writedata64(Stream &s, uint64_t obj)
std::string NetworkErrorString(int err)
Return readable error string for a network error code.
auto MakeByteSpan(const V &v) noexcept
constexpr auto MakeUCharSpan(const V &v) -> decltype(UCharSpanCast(std::span{v}))
Like the std::span constructor, but for (const) unsigned char member types only.
T & SpanPopBack(std::span< T > &span)
A span is an object that can refer to a contiguous sequence of objects.
auto MakeWritableByteSpan(V &&v) noexcept
unsigned char * UCharCast(char *c)
Cache responses to addr requests to minimize privacy leak.
std::chrono::microseconds m_cache_entry_expiration
std::vector< CAddress > m_addrs_response_cache
void AddSocketPermissionFlags(NetPermissionFlags &flags) const
std::shared_ptr< Sock > sock
std::vector< NetWhitebindPermissions > vWhiteBinds
std::vector< CService > onion_binds
std::vector< std::string > m_specified_outgoing
std::vector< CService > vBinds
bool m_i2p_accept_incoming
std::vector< std::string > vSeedNodes
bool m_use_addrman_outgoing
bool bind_on_any
True if the user did not specify -bind= or -whitebind= and thus we should bind on 0....
NetPermissionFlags permission_flags
std::vector< unsigned char > data
size_t GetMemoryUsage() const noexcept
Compute total memory usage of this object (own memory + any dynamic memory).
An ElligatorSwift-encoded public key.
static constexpr size_t size()
static time_point now() noexcept
Return current system time or mocked time, if set.
Auxiliary requested/occurred events to wait for in WaitMany().
std::optional< uint256 > session_id
TransportProtocolType transport_type
An established connection with another peer.
std::unique_ptr< Sock > sock
Connected socket.
CService me
Our I2P address.
CService peer
The peer's I2P address.
#define WAIT_LOCK(cs, name)
#define AssertLockNotHeld(cs)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
#define TRACEPOINT(context,...)
consteval auto _(util::TranslatedLiteral str)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
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.
constexpr int64_t count_seconds(std::chrono::seconds t)
std::chrono::time_point< NodeClock, std::chrono::seconds > NodeSeconds
void ClearShrink(V &v) noexcept
Clear a vector (or std::deque) and release its allocated memory.