2010-08-29 18:58:15 +02:00
|
|
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
2020-01-14 20:17:38 +01:00
|
|
|
// Copyright (c) 2009-2020 The Bitcoin Core developers
|
2014-12-13 05:09:33 +01:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2012-05-18 16:02:28 +02:00
|
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
2013-04-13 07:13:08 +02:00
|
|
|
|
2011-05-15 09:11:04 +02:00
|
|
|
#ifndef BITCOIN_NET_H
|
|
|
|
#define BITCOIN_NET_H
|
|
|
|
|
2017-11-10 01:57:53 +01:00
|
|
|
#include <addrdb.h>
|
|
|
|
#include <addrman.h>
|
|
|
|
#include <amount.h>
|
|
|
|
#include <bloom.h>
|
|
|
|
#include <compat.h>
|
2018-08-24 23:48:23 +02:00
|
|
|
#include <crypto/siphash.h>
|
2017-11-10 01:57:53 +01:00
|
|
|
#include <hash.h>
|
|
|
|
#include <limitedmap.h>
|
|
|
|
#include <netaddress.h>
|
2019-06-20 11:37:51 +02:00
|
|
|
#include <net_permissions.h>
|
2017-11-10 01:57:53 +01:00
|
|
|
#include <policy/feerate.h>
|
|
|
|
#include <protocol.h>
|
|
|
|
#include <random.h>
|
|
|
|
#include <streams.h>
|
|
|
|
#include <sync.h>
|
|
|
|
#include <uint256.h>
|
|
|
|
#include <threadinterrupt.h>
|
2013-04-13 07:13:08 +02:00
|
|
|
|
2016-05-20 18:19:26 +02:00
|
|
|
#include <atomic>
|
2011-05-15 09:11:04 +02:00
|
|
|
#include <deque>
|
2013-04-13 07:13:08 +02:00
|
|
|
#include <stdint.h>
|
2016-12-27 23:12:44 +01:00
|
|
|
#include <thread>
|
2016-04-16 20:47:18 +02:00
|
|
|
#include <memory>
|
2016-12-27 23:12:44 +01:00
|
|
|
#include <condition_variable>
|
2011-05-15 09:11:04 +02:00
|
|
|
|
2011-10-07 17:02:21 +02:00
|
|
|
#ifndef WIN32
|
2011-05-15 09:11:04 +02:00
|
|
|
#include <arpa/inet.h>
|
|
|
|
#endif
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2013-06-06 09:04:33 +02:00
|
|
|
|
2015-04-02 18:04:59 +02:00
|
|
|
class CScheduler;
|
2013-04-13 07:13:08 +02:00
|
|
|
class CNode;
|
2017-10-05 22:40:43 +02:00
|
|
|
class BanMan;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2019-08-16 10:45:13 +02:00
|
|
|
/** Default for -whitelistrelay. */
|
|
|
|
static const bool DEFAULT_WHITELISTRELAY = true;
|
|
|
|
/** Default for -whitelistforcerelay. */
|
|
|
|
static const bool DEFAULT_WHITELISTFORCERELAY = false;
|
|
|
|
|
2013-10-15 00:34:20 +02:00
|
|
|
/** Time between pings automatically sent out for latency probing and keepalive (in seconds). */
|
|
|
|
static const int PING_INTERVAL = 2 * 60;
|
|
|
|
/** Time after which to disconnect, after waiting for a ping response (or inactivity). */
|
|
|
|
static const int TIMEOUT_INTERVAL = 20 * 60;
|
2016-06-17 06:10:07 +02:00
|
|
|
/** Run the feeler connection loop once every 2 minutes or 120 seconds. **/
|
|
|
|
static const int FEELER_INTERVAL = 120;
|
2013-04-13 07:13:08 +02:00
|
|
|
/** The maximum number of entries in an 'inv' protocol message */
|
|
|
|
static const unsigned int MAX_INV_SZ = 50000;
|
2018-08-07 22:37:45 +02:00
|
|
|
/** The maximum number of entries in a locator */
|
|
|
|
static const unsigned int MAX_LOCATOR_SZ = 101;
|
2014-11-21 12:22:11 +01:00
|
|
|
/** The maximum number of new addresses to accumulate before announcing. */
|
|
|
|
static const unsigned int MAX_ADDR_TO_SEND = 1000;
|
2016-01-03 18:54:50 +01:00
|
|
|
/** Maximum length of incoming protocol messages (no message over 4 MB is currently acceptable). */
|
|
|
|
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1000 * 1000;
|
2019-03-23 16:34:40 +01:00
|
|
|
/** Maximum length of the user agent string in `version` message */
|
2015-07-31 18:05:42 +02:00
|
|
|
static const unsigned int MAX_SUBVERSION_LENGTH = 256;
|
2019-03-09 18:55:06 +01:00
|
|
|
/** Maximum number of automatic outgoing nodes over which we'll relay everything (blocks, tx, addrs, etc) */
|
|
|
|
static const int MAX_OUTBOUND_FULL_RELAY_CONNECTIONS = 8;
|
2016-12-11 05:39:26 +01:00
|
|
|
/** Maximum number of addnode outgoing nodes */
|
|
|
|
static const int MAX_ADDNODE_CONNECTIONS = 8;
|
2019-03-09 18:55:06 +01:00
|
|
|
/** Maximum number of block-relay-only outgoing connections */
|
|
|
|
static const int MAX_BLOCKS_ONLY_CONNECTIONS = 2;
|
2014-05-29 13:02:22 +02:00
|
|
|
/** -listen default */
|
|
|
|
static const bool DEFAULT_LISTEN = true;
|
2014-05-05 21:06:14 +02:00
|
|
|
/** -upnp default */
|
|
|
|
#ifdef USE_UPNP
|
|
|
|
static const bool DEFAULT_UPNP = USE_UPNP;
|
|
|
|
#else
|
|
|
|
static const bool DEFAULT_UPNP = false;
|
|
|
|
#endif
|
2015-08-01 19:41:21 +02:00
|
|
|
/** The maximum number of peer connections to maintain. */
|
|
|
|
static const unsigned int DEFAULT_MAX_PEER_CONNECTIONS = 125;
|
2015-11-06 00:05:06 +01:00
|
|
|
/** The default for -maxuploadtarget. 0 = Unlimited */
|
|
|
|
static const uint64_t DEFAULT_MAX_UPLOAD_TARGET = 0;
|
2016-09-12 21:04:20 +02:00
|
|
|
/** The default timeframe for -maxuploadtarget. 1 day. */
|
|
|
|
static const uint64_t MAX_UPLOAD_TIMEFRAME = 60 * 60 * 24;
|
2015-11-14 13:47:53 +01:00
|
|
|
/** Default for blocks only*/
|
|
|
|
static const bool DEFAULT_BLOCKSONLY = false;
|
2018-11-16 00:30:26 +01:00
|
|
|
/** -peertimeout default */
|
|
|
|
static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2015-06-27 21:21:41 +02:00
|
|
|
static const bool DEFAULT_FORCEDNSSEED = false;
|
|
|
|
static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
|
|
|
|
static const size_t DEFAULT_MAXSENDBUFFER = 1 * 1000;
|
|
|
|
|
2017-04-10 21:00:23 +02:00
|
|
|
typedef int64_t NodeId;
|
2016-05-06 20:50:24 +02:00
|
|
|
|
2016-04-17 00:12:58 +02:00
|
|
|
struct AddedNodeInfo
|
|
|
|
{
|
|
|
|
std::string strAddedNode;
|
|
|
|
CService resolvedAddress;
|
|
|
|
bool fConnected;
|
|
|
|
bool fInbound;
|
|
|
|
};
|
|
|
|
|
2016-04-17 00:30:03 +02:00
|
|
|
class CNodeStats;
|
2016-05-26 03:26:46 +02:00
|
|
|
class CClientUIInterface;
|
|
|
|
|
2016-11-10 23:05:23 +01:00
|
|
|
struct CSerializedNetMsg
|
|
|
|
{
|
|
|
|
CSerializedNetMsg() = default;
|
|
|
|
CSerializedNetMsg(CSerializedNetMsg&&) = default;
|
|
|
|
CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default;
|
|
|
|
// No copying, only moves.
|
|
|
|
CSerializedNetMsg(const CSerializedNetMsg& msg) = delete;
|
|
|
|
CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete;
|
|
|
|
|
|
|
|
std::vector<unsigned char> data;
|
|
|
|
std::string command;
|
|
|
|
};
|
|
|
|
|
2017-10-05 19:10:58 +02:00
|
|
|
|
2017-07-06 19:40:09 +02:00
|
|
|
class NetEventsInterface;
|
2016-04-16 20:47:18 +02:00
|
|
|
class CConnman
|
|
|
|
{
|
|
|
|
public:
|
2016-04-17 00:30:03 +02:00
|
|
|
|
|
|
|
enum NumConnections {
|
|
|
|
CONNECTIONS_NONE = 0,
|
|
|
|
CONNECTIONS_IN = (1U << 0),
|
|
|
|
CONNECTIONS_OUT = (1U << 1),
|
|
|
|
CONNECTIONS_ALL = (CONNECTIONS_IN | CONNECTIONS_OUT),
|
|
|
|
};
|
|
|
|
|
2016-05-27 05:53:08 +02:00
|
|
|
struct Options
|
|
|
|
{
|
|
|
|
ServiceFlags nLocalServices = NODE_NONE;
|
|
|
|
int nMaxConnections = 0;
|
2019-03-09 18:55:06 +01:00
|
|
|
int m_max_outbound_full_relay = 0;
|
|
|
|
int m_max_outbound_block_relay = 0;
|
2016-12-11 05:39:26 +01:00
|
|
|
int nMaxAddnode = 0;
|
2016-08-31 19:17:28 +02:00
|
|
|
int nMaxFeeler = 0;
|
2016-05-27 05:53:08 +02:00
|
|
|
int nBestHeight = 0;
|
|
|
|
CClientUIInterface* uiInterface = nullptr;
|
2017-07-06 19:40:09 +02:00
|
|
|
NetEventsInterface* m_msgproc = nullptr;
|
2017-10-05 19:10:58 +02:00
|
|
|
BanMan* m_banman = nullptr;
|
2016-05-27 06:00:02 +02:00
|
|
|
unsigned int nSendBufferMaxSize = 0;
|
|
|
|
unsigned int nReceiveFloodSize = 0;
|
2016-09-12 21:04:20 +02:00
|
|
|
uint64_t nMaxOutboundTimeframe = 0;
|
|
|
|
uint64_t nMaxOutboundLimit = 0;
|
2018-11-16 00:30:26 +01:00
|
|
|
int64_t m_peer_connect_timeout = DEFAULT_PEER_CONNECT_TIMEOUT;
|
2017-05-27 12:00:37 +02:00
|
|
|
std::vector<std::string> vSeedNodes;
|
2019-06-20 11:37:51 +02:00
|
|
|
std::vector<NetWhitelistPermissions> vWhitelistedRange;
|
|
|
|
std::vector<NetWhitebindPermissions> vWhiteBinds;
|
|
|
|
std::vector<CService> vBinds;
|
2017-06-15 09:39:07 +02:00
|
|
|
bool m_use_addrman_outgoing = true;
|
|
|
|
std::vector<std::string> m_specified_outgoing;
|
2017-09-11 16:13:46 +02:00
|
|
|
std::vector<std::string> m_added_nodes;
|
2019-12-24 19:18:44 +01:00
|
|
|
std::vector<bool> m_asmap;
|
2016-05-27 05:53:08 +02:00
|
|
|
};
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
|
|
|
|
void Init(const Options& connOptions) {
|
|
|
|
nLocalServices = connOptions.nLocalServices;
|
|
|
|
nMaxConnections = connOptions.nMaxConnections;
|
2019-03-09 18:55:06 +01:00
|
|
|
m_max_outbound_full_relay = std::min(connOptions.m_max_outbound_full_relay, connOptions.nMaxConnections);
|
|
|
|
m_max_outbound_block_relay = connOptions.m_max_outbound_block_relay;
|
2018-08-23 01:29:01 +02:00
|
|
|
m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
nMaxAddnode = connOptions.nMaxAddnode;
|
|
|
|
nMaxFeeler = connOptions.nMaxFeeler;
|
2019-03-09 18:55:06 +01:00
|
|
|
m_max_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + nMaxFeeler;
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
nBestHeight = connOptions.nBestHeight;
|
|
|
|
clientInterface = connOptions.uiInterface;
|
2017-10-05 19:10:58 +02:00
|
|
|
m_banman = connOptions.m_banman;
|
2017-07-06 19:40:09 +02:00
|
|
|
m_msgproc = connOptions.m_msgproc;
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
|
|
|
|
nReceiveFloodSize = connOptions.nReceiveFloodSize;
|
2018-11-16 00:30:26 +01:00
|
|
|
m_peer_connect_timeout = connOptions.m_peer_connect_timeout;
|
2017-11-21 18:02:57 +01:00
|
|
|
{
|
|
|
|
LOCK(cs_totalBytesSent);
|
|
|
|
nMaxOutboundTimeframe = connOptions.nMaxOutboundTimeframe;
|
|
|
|
nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
|
|
|
|
}
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
vWhitelistedRange = connOptions.vWhitelistedRange;
|
2017-11-21 18:02:57 +01:00
|
|
|
{
|
|
|
|
LOCK(cs_vAddedNodes);
|
|
|
|
vAddedNodes = connOptions.m_added_nodes;
|
|
|
|
}
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
}
|
|
|
|
|
2016-09-09 12:48:10 +02:00
|
|
|
CConnman(uint64_t seed0, uint64_t seed1);
|
2016-04-16 20:47:18 +02:00
|
|
|
~CConnman();
|
[net] Fix use of uninitialized value in getnetworkinfo(const JSONRPCRequest& request)
When running test_bitcoin under Valgrind I found the following issue:
```
$ valgrind src/test/test_bitcoin
...
==10465== Use of uninitialised value of size 8
==10465== at 0x6D09B61: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B1BB: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<unsigned long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D0B36C: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, unsigned long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x6D17699: std::ostream& std::ostream::_M_insert<unsigned long>(unsigned long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21)
==10465== by 0x4CAAD7: operator<< (ostream:171)
==10465== by 0x4CAAD7: formatValue<ServiceFlags> (tinyformat.h:345)
==10465== by 0x4CAAD7: void tinyformat::detail::FormatArg::formatImpl<ServiceFlags>(std::ostream&, char const*, char const*, int, void const*) (tinyformat.h:523)
==10465== by 0x1924D4: format (tinyformat.h:510)
==10465== by 0x1924D4: tinyformat::detail::formatImpl(std::ostream&, char const*, tinyformat::detail::FormatArg const*, int) (tinyformat.h:803)
==10465== by 0x553A55: vformat (tinyformat.h:947)
==10465== by 0x553A55: format<ServiceFlags> (tinyformat.h:957)
==10465== by 0x553A55: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > tinyformat::format<ServiceFlags>(char const*, ServiceFlags const&) (tinyformat.h:966)
==10465== by 0x54C952: getnetworkinfo(JSONRPCRequest const&) (net.cpp:462)
==10465== by 0x28EDB5: CallRPC(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) (rpc_tests.cpp:31)
==10465== by 0x293947: rpc_tests::rpc_togglenetwork::test_method() (rpc_tests.cpp:88)
==10465== by 0x2950E5: rpc_tests::rpc_togglenetwork_invoker() (rpc_tests.cpp:84)
==10465== by 0x182496: invoke<void (*)()> (callback.hpp:56)
==10465== by 0x182496: boost::unit_test::ut_detail::callback0_impl_t<boost::unit_test::ut_detail::unused, void (*)()>::invoke() (callback.hpp:89)
...
```
The read of the uninitialized variable nLocalServices is triggered by g_connman->GetLocalServices()
in getnetworkinfo(const JSONRPCRequest& request) (net.cpp:462):
```c++
UniValue getnetworkinfo(const JSONRPCRequest& request)
{
...
if(g_connman)
obj.push_back(Pair("localservices", strprintf("%016x", g_connman->GetLocalServices())));
...
}
```
The reason for the uninitialized nLocalServices is that CConnman::Start(...) is not called
by the tests, and hence the initialization normally performed by CConnman::Start(...) is
not done.
This commit adds a method Init(const Options& connOptions) which is called by both the
constructor and CConnman::Start(...). This method initializes nLocalServices and the other
relevant values from the supplied Options object.
2017-08-02 14:02:36 +02:00
|
|
|
bool Start(CScheduler& scheduler, const Options& options);
|
2019-01-19 14:49:29 +01:00
|
|
|
|
|
|
|
// TODO: Remove NO_THREAD_SAFETY_ANALYSIS. Lock cs_vNodes before reading the variable vNodes.
|
|
|
|
//
|
|
|
|
// When removing NO_THREAD_SAFETY_ANALYSIS be aware of the following lock order requirements:
|
|
|
|
// * CheckForStaleTipAndEvictPeers locks cs_main before indirectly calling GetExtraOutboundCount
|
|
|
|
// which locks cs_vNodes.
|
|
|
|
// * ProcessMessage locks cs_main and g_cs_orphans before indirectly calling ForEachNode which
|
|
|
|
// locks cs_vNodes.
|
|
|
|
//
|
|
|
|
// Thus the implicit locking order requirement is: (1) cs_main, (2) g_cs_orphans, (3) cs_vNodes.
|
|
|
|
void Stop() NO_THREAD_SAFETY_ANALYSIS;
|
|
|
|
|
2016-12-27 23:12:44 +01:00
|
|
|
void Interrupt();
|
2013-03-26 02:38:24 +01:00
|
|
|
bool GetNetworkActive() const { return fNetworkActive; };
|
2018-08-23 01:29:01 +02:00
|
|
|
bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
|
2013-03-26 02:33:25 +01:00
|
|
|
void SetNetworkActive(bool active);
|
2019-03-09 18:55:06 +01:00
|
|
|
void OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant *grantOutbound = nullptr, const char *strDest = nullptr, bool fOneShot = false, bool fFeeler = false, bool manual_connection = false, bool block_relay_only = false);
|
2016-04-18 02:21:58 +02:00
|
|
|
bool CheckIncomingNonce(uint64_t nonce);
|
2016-04-16 21:46:00 +02:00
|
|
|
|
2016-04-17 01:13:12 +02:00
|
|
|
bool ForNode(NodeId id, std::function<bool(CNode* pnode)> func);
|
2016-06-20 03:42:15 +02:00
|
|
|
|
2016-11-11 02:17:30 +01:00
|
|
|
void PushMessage(CNode* pnode, CSerializedNetMsg&& msg);
|
2016-09-13 02:00:33 +02:00
|
|
|
|
2016-06-20 03:42:15 +02:00
|
|
|
template<typename Callable>
|
|
|
|
void ForEachNode(Callable&& func)
|
|
|
|
{
|
|
|
|
LOCK(cs_vNodes);
|
2017-01-21 02:34:57 +01:00
|
|
|
for (auto&& node : vNodes) {
|
|
|
|
if (NodeFullyConnected(node))
|
|
|
|
func(node);
|
|
|
|
}
|
2016-06-20 03:42:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
template<typename Callable>
|
|
|
|
void ForEachNode(Callable&& func) const
|
|
|
|
{
|
|
|
|
LOCK(cs_vNodes);
|
2017-01-21 02:34:57 +01:00
|
|
|
for (auto&& node : vNodes) {
|
|
|
|
if (NodeFullyConnected(node))
|
|
|
|
func(node);
|
|
|
|
}
|
2016-06-20 03:42:15 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
template<typename Callable, typename CallableAfter>
|
|
|
|
void ForEachNodeThen(Callable&& pre, CallableAfter&& post)
|
|
|
|
{
|
|
|
|
LOCK(cs_vNodes);
|
2017-01-21 02:34:57 +01:00
|
|
|
for (auto&& node : vNodes) {
|
|
|
|
if (NodeFullyConnected(node))
|
|
|
|
pre(node);
|
|
|
|
}
|
2016-06-20 03:42:15 +02:00
|
|
|
post();
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename Callable, typename CallableAfter>
|
|
|
|
void ForEachNodeThen(Callable&& pre, CallableAfter&& post) const
|
|
|
|
{
|
|
|
|
LOCK(cs_vNodes);
|
2017-01-21 02:34:57 +01:00
|
|
|
for (auto&& node : vNodes) {
|
|
|
|
if (NodeFullyConnected(node))
|
|
|
|
pre(node);
|
|
|
|
}
|
2016-06-20 03:42:15 +02:00
|
|
|
post();
|
|
|
|
};
|
2016-04-17 01:13:12 +02:00
|
|
|
|
2016-04-16 23:43:11 +02:00
|
|
|
// Addrman functions
|
|
|
|
size_t GetAddressCount() const;
|
|
|
|
void SetServices(const CService &addr, ServiceFlags nServices);
|
|
|
|
void MarkAddressGood(const CAddress& addr);
|
|
|
|
void AddNewAddresses(const std::vector<CAddress>& vAddr, const CAddress& addrFrom, int64_t nTimePenalty = 0);
|
|
|
|
std::vector<CAddress> GetAddresses();
|
|
|
|
|
2019-03-09 18:55:06 +01:00
|
|
|
// This allows temporarily exceeding m_max_outbound_full_relay, with the goal of finding
|
2017-10-23 19:36:15 +02:00
|
|
|
// a peer that is better than all our current peers.
|
|
|
|
void SetTryNewOutboundPeer(bool flag);
|
|
|
|
bool GetTryNewOutboundPeer();
|
|
|
|
|
|
|
|
// Return the number of outbound peers we have in excess of our target (eg,
|
|
|
|
// if we previously called SetTryNewOutboundPeer(true), and have since set
|
|
|
|
// to false, we may have extra peers that we wish to disconnect). This may
|
|
|
|
// return a value less than (num_outbound_connections - num_outbound_slots)
|
|
|
|
// in cases where some outbound connections are not yet fully connected, or
|
|
|
|
// not yet fully disconnected.
|
|
|
|
int GetExtraOutboundCount();
|
|
|
|
|
2016-04-17 00:12:58 +02:00
|
|
|
bool AddNode(const std::string& node);
|
|
|
|
bool RemoveAddedNode(const std::string& node);
|
|
|
|
std::vector<AddedNodeInfo> GetAddedNodeInfo();
|
|
|
|
|
2016-04-17 00:30:03 +02:00
|
|
|
size_t GetNodeCount(NumConnections num);
|
|
|
|
void GetNodeStats(std::vector<CNodeStats>& vstats);
|
|
|
|
bool DisconnectNode(const std::string& node);
|
2017-10-05 00:25:34 +02:00
|
|
|
bool DisconnectNode(const CSubNet& subnet);
|
|
|
|
bool DisconnectNode(const CNetAddr& addr);
|
2016-04-17 00:30:03 +02:00
|
|
|
bool DisconnectNode(NodeId id);
|
|
|
|
|
2019-09-10 19:09:12 +02:00
|
|
|
//! Used to convey which local services we are offering peers during node
|
|
|
|
//! connection.
|
|
|
|
//!
|
|
|
|
//! The data returned by this is used in CNode construction,
|
|
|
|
//! which is used to advertise which services we are offering
|
|
|
|
//! that peer during `net_processing.cpp:PushNodeVersion()`.
|
2016-04-19 06:04:58 +02:00
|
|
|
ServiceFlags GetLocalServices() const;
|
|
|
|
|
2016-04-19 03:44:42 +02:00
|
|
|
//!set the max outbound target in bytes
|
|
|
|
void SetMaxOutboundTarget(uint64_t limit);
|
|
|
|
uint64_t GetMaxOutboundTarget();
|
|
|
|
|
|
|
|
//!set the timeframe for the max outbound target
|
|
|
|
void SetMaxOutboundTimeframe(uint64_t timeframe);
|
|
|
|
uint64_t GetMaxOutboundTimeframe();
|
|
|
|
|
2019-01-25 04:44:54 +01:00
|
|
|
//! check if the outbound target is reached
|
|
|
|
//! if param historicalBlockServingLimit is set true, the function will
|
|
|
|
//! response true if the limit for serving historical blocks has been reached
|
2016-04-19 03:44:42 +02:00
|
|
|
bool OutboundTargetReached(bool historicalBlockServingLimit);
|
|
|
|
|
2019-01-25 04:44:54 +01:00
|
|
|
//! response the bytes left in the current max outbound cycle
|
|
|
|
//! in case of no limit, it will always response 0
|
2016-04-19 03:44:42 +02:00
|
|
|
uint64_t GetOutboundTargetBytesLeft();
|
|
|
|
|
2019-01-25 04:44:54 +01:00
|
|
|
//! response the time in second left in the current max outbound cycle
|
|
|
|
//! in case of no limit, it will always response 0
|
2016-04-19 03:44:42 +02:00
|
|
|
uint64_t GetMaxOutboundTimeLeftInCycle();
|
|
|
|
|
|
|
|
uint64_t GetTotalBytesRecv();
|
|
|
|
uint64_t GetTotalBytesSent();
|
|
|
|
|
2016-05-24 22:42:17 +02:00
|
|
|
void SetBestHeight(int height);
|
|
|
|
int GetBestHeight() const;
|
|
|
|
|
2016-09-09 12:48:10 +02:00
|
|
|
/** Get a unique deterministic randomizer. */
|
2017-01-24 02:32:52 +01:00
|
|
|
CSipHasher GetDeterministicRandomizer(uint64_t id) const;
|
2016-05-24 22:42:17 +02:00
|
|
|
|
2016-12-31 08:05:09 +01:00
|
|
|
unsigned int GetReceiveFloodSize() const;
|
2017-01-15 01:00:00 +01:00
|
|
|
|
|
|
|
void WakeMessageHandler();
|
2018-05-21 21:02:40 +02:00
|
|
|
|
|
|
|
/** Attempts to obfuscate tx time through exponentially distributed emitting.
|
|
|
|
Works assuming that a single interval is used.
|
|
|
|
Variable intervals will result in privacy decrease.
|
|
|
|
*/
|
|
|
|
int64_t PoissonNextSendInbound(int64_t now, int average_interval_seconds);
|
|
|
|
|
2020-01-29 22:55:40 +01:00
|
|
|
void SetAsmap(std::vector<bool> asmap) { addrman.m_asmap = std::move(asmap); }
|
2019-12-24 19:18:44 +01:00
|
|
|
|
2016-04-16 20:47:18 +02:00
|
|
|
private:
|
2016-04-16 21:46:00 +02:00
|
|
|
struct ListenSocket {
|
2019-06-20 11:37:51 +02:00
|
|
|
public:
|
2016-04-16 21:46:00 +02:00
|
|
|
SOCKET socket;
|
2019-06-20 11:37:51 +02:00
|
|
|
inline void AddSocketPermissionFlags(NetPermissionFlags& flags) const { NetPermissions::AddFlag(flags, m_permissions); }
|
|
|
|
ListenSocket(SOCKET socket_, NetPermissionFlags permissions_) : socket(socket_), m_permissions(permissions_) {}
|
|
|
|
private:
|
|
|
|
NetPermissionFlags m_permissions;
|
2016-04-16 21:46:00 +02:00
|
|
|
};
|
|
|
|
|
2019-06-20 11:37:51 +02:00
|
|
|
bool BindListenPort(const CService& bindAddr, std::string& strError, NetPermissionFlags permissions);
|
|
|
|
bool Bind(const CService& addr, unsigned int flags, NetPermissionFlags permissions);
|
|
|
|
bool InitBinds(const std::vector<CService>& binds, const std::vector<NetWhitebindPermissions>& whiteBinds);
|
2016-04-16 20:47:18 +02:00
|
|
|
void ThreadOpenAddedConnections();
|
2017-05-27 12:00:37 +02:00
|
|
|
void AddOneShot(const std::string& strDest);
|
2016-04-16 20:47:18 +02:00
|
|
|
void ProcessOneShot();
|
2017-06-15 09:39:07 +02:00
|
|
|
void ThreadOpenConnections(std::vector<std::string> connect);
|
2016-04-16 20:47:18 +02:00
|
|
|
void ThreadMessageHandler();
|
|
|
|
void AcceptConnection(const ListenSocket& hListenSocket);
|
2018-09-24 22:36:58 +02:00
|
|
|
void DisconnectNodes();
|
2018-09-24 22:30:53 +02:00
|
|
|
void NotifyNumConnectionsChanged();
|
2018-09-24 22:43:00 +02:00
|
|
|
void InactivityCheck(CNode *pnode);
|
2018-09-25 21:32:07 +02:00
|
|
|
bool GenerateSelectSet(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set);
|
2018-09-27 03:51:46 +02:00
|
|
|
void SocketEvents(std::set<SOCKET> &recv_set, std::set<SOCKET> &send_set, std::set<SOCKET> &error_set);
|
2018-09-24 23:03:17 +02:00
|
|
|
void SocketHandler();
|
2016-04-16 20:47:18 +02:00
|
|
|
void ThreadSocketHandler();
|
|
|
|
void ThreadDNSAddressSeed();
|
2016-04-16 21:46:00 +02:00
|
|
|
|
2017-01-24 02:32:52 +01:00
|
|
|
uint64_t CalculateKeyedNetGroup(const CAddress& ad) const;
|
2016-09-09 12:48:10 +02:00
|
|
|
|
2016-04-17 01:13:12 +02:00
|
|
|
CNode* FindNode(const CNetAddr& ip);
|
|
|
|
CNode* FindNode(const CSubNet& subNet);
|
|
|
|
CNode* FindNode(const std::string& addrName);
|
|
|
|
CNode* FindNode(const CService& addr);
|
|
|
|
|
|
|
|
bool AttemptToEvictConnection();
|
2019-03-09 18:55:06 +01:00
|
|
|
CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, bool manual_connection, bool block_relay_only);
|
2019-06-20 11:37:51 +02:00
|
|
|
void AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr) const;
|
2016-04-18 00:34:32 +02:00
|
|
|
|
2016-05-25 00:59:16 +02:00
|
|
|
void DeleteNode(CNode* pnode);
|
2016-04-18 02:20:34 +02:00
|
|
|
|
|
|
|
NodeId GetNewNodeId();
|
|
|
|
|
2017-01-24 02:32:52 +01:00
|
|
|
size_t SocketSendData(CNode *pnode) const;
|
2016-04-16 23:43:11 +02:00
|
|
|
void DumpAddresses();
|
2016-04-16 21:59:10 +02:00
|
|
|
|
2016-04-19 03:44:42 +02:00
|
|
|
// Network stats
|
|
|
|
void RecordBytesRecv(uint64_t bytes);
|
|
|
|
void RecordBytesSent(uint64_t bytes);
|
|
|
|
|
2017-01-21 02:34:57 +01:00
|
|
|
// Whether the node should be passed out in ForEach* callbacks
|
|
|
|
static bool NodeFullyConnected(const CNode* pnode);
|
|
|
|
|
2016-04-19 03:44:42 +02:00
|
|
|
// Network usage totals
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_totalBytesRecv;
|
|
|
|
RecursiveMutex cs_totalBytesSent;
|
2020-01-10 20:55:10 +01:00
|
|
|
uint64_t nTotalBytesRecv GUARDED_BY(cs_totalBytesRecv) {0};
|
|
|
|
uint64_t nTotalBytesSent GUARDED_BY(cs_totalBytesSent) {0};
|
2016-04-19 03:44:42 +02:00
|
|
|
|
|
|
|
// outbound limit & stats
|
2017-11-23 07:55:45 +01:00
|
|
|
uint64_t nMaxOutboundTotalBytesSentInCycle GUARDED_BY(cs_totalBytesSent);
|
|
|
|
uint64_t nMaxOutboundCycleStartTime GUARDED_BY(cs_totalBytesSent);
|
|
|
|
uint64_t nMaxOutboundLimit GUARDED_BY(cs_totalBytesSent);
|
|
|
|
uint64_t nMaxOutboundTimeframe GUARDED_BY(cs_totalBytesSent);
|
2016-04-19 03:44:42 +02:00
|
|
|
|
2018-11-16 00:30:26 +01:00
|
|
|
// P2P timeout in seconds
|
|
|
|
int64_t m_peer_connect_timeout;
|
|
|
|
|
2016-04-18 00:34:32 +02:00
|
|
|
// Whitelisted ranges. Any node connecting from these is automatically
|
|
|
|
// whitelisted (as well as those connecting to whitelisted binds).
|
2019-06-20 11:37:51 +02:00
|
|
|
std::vector<NetWhitelistPermissions> vWhitelistedRange;
|
2016-04-18 00:34:32 +02:00
|
|
|
|
2019-01-05 12:02:12 +01:00
|
|
|
unsigned int nSendBufferMaxSize{0};
|
|
|
|
unsigned int nReceiveFloodSize{0};
|
2016-04-19 06:01:19 +02:00
|
|
|
|
2016-04-16 21:46:00 +02:00
|
|
|
std::vector<ListenSocket> vhListenSocket;
|
2019-01-05 12:02:12 +01:00
|
|
|
std::atomic<bool> fNetworkActive{true};
|
|
|
|
bool fAddressesInitialized{false};
|
2016-04-16 23:43:11 +02:00
|
|
|
CAddrMan addrman;
|
2018-10-08 15:34:39 +02:00
|
|
|
std::deque<std::string> vOneShots GUARDED_BY(cs_vOneShots);
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_vOneShots;
|
2017-11-23 07:55:45 +01:00
|
|
|
std::vector<std::string> vAddedNodes GUARDED_BY(cs_vAddedNodes);
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_vAddedNodes;
|
2019-01-19 14:49:29 +01:00
|
|
|
std::vector<CNode*> vNodes GUARDED_BY(cs_vNodes);
|
2016-05-27 07:00:01 +02:00
|
|
|
std::list<CNode*> vNodesDisconnected;
|
2020-01-07 17:14:15 +01:00
|
|
|
mutable RecursiveMutex cs_vNodes;
|
2019-01-05 12:02:12 +01:00
|
|
|
std::atomic<NodeId> nLastNodeId{0};
|
|
|
|
unsigned int nPrevNodeCount{0};
|
2016-04-19 06:04:58 +02:00
|
|
|
|
2019-09-10 19:09:12 +02:00
|
|
|
/**
|
|
|
|
* Services this instance offers.
|
|
|
|
*
|
|
|
|
* This data is replicated in each CNode instance we create during peer
|
|
|
|
* connection (in ConnectNode()) under a member also called
|
|
|
|
* nLocalServices.
|
|
|
|
*
|
|
|
|
* This data is not marked const, but after being set it should not
|
|
|
|
* change. See the note in CNode::nLocalServices documentation.
|
|
|
|
*
|
|
|
|
* \sa CNode::nLocalServices
|
|
|
|
*/
|
2016-04-19 06:04:58 +02:00
|
|
|
ServiceFlags nLocalServices;
|
|
|
|
|
2017-08-09 16:07:22 +02:00
|
|
|
std::unique_ptr<CSemaphore> semOutbound;
|
|
|
|
std::unique_ptr<CSemaphore> semAddnode;
|
2016-05-22 09:52:03 +02:00
|
|
|
int nMaxConnections;
|
2019-03-09 18:55:06 +01:00
|
|
|
|
|
|
|
// How many full-relay (tx, block, addr) outbound peers we want
|
|
|
|
int m_max_outbound_full_relay;
|
|
|
|
|
|
|
|
// How many block-relay only outbound peers we want
|
|
|
|
// We do not relay tx or addr messages with these peers
|
|
|
|
int m_max_outbound_block_relay;
|
|
|
|
|
2016-12-11 05:39:26 +01:00
|
|
|
int nMaxAddnode;
|
2016-08-31 19:17:28 +02:00
|
|
|
int nMaxFeeler;
|
2019-03-09 18:55:06 +01:00
|
|
|
int m_max_outbound;
|
2018-08-23 01:29:01 +02:00
|
|
|
bool m_use_addrman_outgoing;
|
2016-05-24 22:42:17 +02:00
|
|
|
std::atomic<int> nBestHeight;
|
2016-05-26 03:26:46 +02:00
|
|
|
CClientUIInterface* clientInterface;
|
2017-07-06 19:40:09 +02:00
|
|
|
NetEventsInterface* m_msgproc;
|
2017-10-05 19:10:58 +02:00
|
|
|
BanMan* m_banman;
|
2016-09-09 12:48:10 +02:00
|
|
|
|
|
|
|
/** SipHasher seeds for deterministic randomness */
|
|
|
|
const uint64_t nSeed0, nSeed1;
|
2016-12-27 23:12:44 +01:00
|
|
|
|
2016-12-31 08:05:26 +01:00
|
|
|
/** flag for waking the message processor. */
|
|
|
|
bool fMsgProcWake;
|
|
|
|
|
2016-12-27 23:12:44 +01:00
|
|
|
std::condition_variable condMsgProc;
|
2017-11-03 12:49:16 +01:00
|
|
|
Mutex mutexMsgProc;
|
2019-01-05 12:02:12 +01:00
|
|
|
std::atomic<bool> flagInterruptMsgProc{false};
|
2016-12-27 23:12:44 +01:00
|
|
|
|
|
|
|
CThreadInterrupt interruptNet;
|
|
|
|
|
|
|
|
std::thread threadDNSAddressSeed;
|
|
|
|
std::thread threadSocketHandler;
|
|
|
|
std::thread threadOpenAddedConnections;
|
|
|
|
std::thread threadOpenConnections;
|
|
|
|
std::thread threadMessageHandler;
|
2017-10-23 19:36:15 +02:00
|
|
|
|
|
|
|
/** flag for deciding to connect to an extra outbound peer,
|
2019-03-09 18:55:06 +01:00
|
|
|
* in excess of m_max_outbound_full_relay
|
2017-10-23 19:36:15 +02:00
|
|
|
* This takes the place of a feeler connection */
|
|
|
|
std::atomic_bool m_try_another_outbound_peer;
|
2017-10-24 10:26:05 +02:00
|
|
|
|
2018-07-16 23:07:52 +02:00
|
|
|
std::atomic<int64_t> m_next_send_inv_to_incoming{0};
|
2018-05-21 21:02:40 +02:00
|
|
|
|
2017-10-24 10:26:05 +02:00
|
|
|
friend struct CConnmanTest;
|
2016-04-16 20:47:18 +02:00
|
|
|
};
|
2018-02-07 23:42:39 +01:00
|
|
|
void Discover();
|
2018-02-07 23:20:16 +01:00
|
|
|
void StartMapPort();
|
|
|
|
void InterruptMapPort();
|
|
|
|
void StopMapPort();
|
2012-05-13 01:26:14 +02:00
|
|
|
unsigned short GetListenPort();
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2015-03-05 13:01:01 +01:00
|
|
|
struct CombinerAll
|
|
|
|
{
|
|
|
|
typedef bool result_type;
|
|
|
|
|
|
|
|
template<typename I>
|
|
|
|
bool operator()(I first, I last) const
|
|
|
|
{
|
|
|
|
while (first != last) {
|
|
|
|
if (!(*first)) return false;
|
|
|
|
++first;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-07-06 19:40:09 +02:00
|
|
|
/**
|
|
|
|
* Interface for message handling
|
|
|
|
*/
|
|
|
|
class NetEventsInterface
|
2013-06-06 05:21:41 +02:00
|
|
|
{
|
2017-07-06 19:40:09 +02:00
|
|
|
public:
|
2017-07-06 20:08:23 +02:00
|
|
|
virtual bool ProcessMessages(CNode* pnode, std::atomic<bool>& interrupt) = 0;
|
2018-07-02 04:26:47 +02:00
|
|
|
virtual bool SendMessages(CNode* pnode) = 0;
|
2017-07-06 20:08:23 +02:00
|
|
|
virtual void InitializeNode(CNode* pnode) = 0;
|
2017-07-06 19:40:09 +02:00
|
|
|
virtual void FinalizeNode(NodeId id, bool& update_connection_time) = 0;
|
2018-03-14 06:04:42 +01:00
|
|
|
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Protected destructor so that instances can only be deleted by derived classes.
|
|
|
|
* If that restriction is no longer desired, this should be made public and virtual.
|
|
|
|
*/
|
|
|
|
~NetEventsInterface() = default;
|
2013-06-06 05:21:41 +02:00
|
|
|
};
|
|
|
|
|
2012-02-12 13:45:24 +01:00
|
|
|
enum
|
|
|
|
{
|
2012-05-10 20:35:13 +02:00
|
|
|
LOCAL_NONE, // unknown
|
|
|
|
LOCAL_IF, // address a local interface listens on
|
2012-05-11 15:28:59 +02:00
|
|
|
LOCAL_BIND, // address explicit bound to
|
2012-05-10 20:35:13 +02:00
|
|
|
LOCAL_UPNP, // address reported by UPnP
|
|
|
|
LOCAL_MANUAL, // address explicitly specified (-externalip=)
|
2012-02-19 20:44:35 +01:00
|
|
|
|
|
|
|
LOCAL_MAX
|
2012-02-12 13:45:24 +01:00
|
|
|
};
|
|
|
|
|
2014-07-21 08:32:25 +02:00
|
|
|
bool IsPeerAddrLocalGood(CNode *pnode);
|
2016-02-12 19:35:32 +01:00
|
|
|
void AdvertiseLocal(CNode *pnode);
|
2019-01-10 01:41:37 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Mark a network as reachable or unreachable (no automatic connects to it)
|
|
|
|
* @note Networks are reachable by default
|
|
|
|
*/
|
|
|
|
void SetReachable(enum Network net, bool reachable);
|
|
|
|
/** @returns true if the network is reachable, false otherwise */
|
|
|
|
bool IsReachable(enum Network net);
|
|
|
|
/** @returns true if the address is in a reachable network, false otherwise */
|
|
|
|
bool IsReachable(const CNetAddr& addr);
|
|
|
|
|
2012-05-10 20:35:13 +02:00
|
|
|
bool AddLocal(const CService& addr, int nScore = LOCAL_NONE);
|
2012-05-13 01:26:14 +02:00
|
|
|
bool AddLocal(const CNetAddr& addr, int nScore = LOCAL_NONE);
|
2018-07-27 08:22:42 +02:00
|
|
|
void RemoveLocal(const CService& addr);
|
2012-05-10 20:35:13 +02:00
|
|
|
bool SeenLocal(const CService& addr);
|
|
|
|
bool IsLocal(const CService& addr);
|
2017-08-07 07:36:37 +02:00
|
|
|
bool GetLocal(CService &addr, const CNetAddr *paddrPeer = nullptr);
|
2016-04-19 06:04:58 +02:00
|
|
|
CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalServices);
|
2012-02-12 13:45:24 +01:00
|
|
|
|
2012-04-10 20:22:04 +02:00
|
|
|
|
2012-05-24 19:02:21 +02:00
|
|
|
extern bool fDiscover;
|
2014-05-29 12:33:17 +02:00
|
|
|
extern bool fListen;
|
2019-05-09 15:16:29 +02:00
|
|
|
extern bool g_relay_txes;
|
2014-11-16 12:19:23 +01:00
|
|
|
|
2015-07-31 18:05:42 +02:00
|
|
|
/** Subversion as sent to the P2P network in `version` messages */
|
|
|
|
extern std::string strSubVersion;
|
|
|
|
|
2014-05-05 13:22:28 +02:00
|
|
|
struct LocalServiceInfo {
|
|
|
|
int nScore;
|
|
|
|
int nPort;
|
|
|
|
};
|
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
extern RecursiveMutex cs_mapLocalHost;
|
2018-10-08 15:34:39 +02:00
|
|
|
extern std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(cs_mapLocalHost);
|
2019-01-02 13:13:50 +01:00
|
|
|
|
|
|
|
extern const std::string NET_MESSAGE_COMMAND_OTHER;
|
2015-08-25 16:30:31 +02:00
|
|
|
typedef std::map<std::string, uint64_t> mapMsgCmdSize; //command, total bytes
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2012-06-29 23:24:53 +02:00
|
|
|
class CNodeStats
|
|
|
|
{
|
|
|
|
public:
|
2013-11-18 01:25:17 +01:00
|
|
|
NodeId nodeid;
|
2016-06-08 19:12:22 +02:00
|
|
|
ServiceFlags nServices;
|
2015-11-21 00:51:44 +01:00
|
|
|
bool fRelayTxes;
|
2013-04-13 07:13:08 +02:00
|
|
|
int64_t nLastSend;
|
|
|
|
int64_t nLastRecv;
|
|
|
|
int64_t nTimeConnected;
|
2014-12-15 11:06:15 +01:00
|
|
|
int64_t nTimeOffset;
|
2012-06-29 23:24:53 +02:00
|
|
|
std::string addrName;
|
|
|
|
int nVersion;
|
2013-11-26 12:52:21 +01:00
|
|
|
std::string cleanSubVer;
|
2012-06-29 23:24:53 +02:00
|
|
|
bool fInbound;
|
2017-10-05 17:49:16 +02:00
|
|
|
bool m_manual_connection;
|
2012-06-29 23:24:53 +02:00
|
|
|
int nStartingHeight;
|
2013-04-13 07:13:08 +02:00
|
|
|
uint64_t nSendBytes;
|
2015-08-25 16:30:31 +02:00
|
|
|
mapMsgCmdSize mapSendBytesPerMsgCmd;
|
2013-04-13 07:13:08 +02:00
|
|
|
uint64_t nRecvBytes;
|
2015-08-25 16:30:31 +02:00
|
|
|
mapMsgCmdSize mapRecvBytesPerMsgCmd;
|
2019-06-20 11:37:51 +02:00
|
|
|
NetPermissionFlags m_permissionFlags;
|
2019-06-21 04:42:04 +02:00
|
|
|
bool m_legacyWhitelisted;
|
2013-08-22 13:34:33 +02:00
|
|
|
double dPingTime;
|
|
|
|
double dPingWait;
|
2016-10-14 16:11:38 +02:00
|
|
|
double dMinPing;
|
2018-06-22 10:53:39 +02:00
|
|
|
CAmount minFeeFilter;
|
2017-05-30 11:59:42 +02:00
|
|
|
// Our address, as reported by the peer
|
2013-08-22 07:50:19 +02:00
|
|
|
std::string addrLocal;
|
2017-05-30 11:59:42 +02:00
|
|
|
// Address of this peer
|
2016-10-05 01:27:11 +02:00
|
|
|
CAddress addr;
|
2017-05-30 11:59:42 +02:00
|
|
|
// Bind address of our side of the connection
|
|
|
|
CAddress addrBind;
|
2019-12-24 19:26:46 +01:00
|
|
|
uint32_t m_mapped_as;
|
2012-06-29 23:24:53 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-06-13 10:39:44 +02:00
|
|
|
/** Transport protocol agnostic message container.
|
|
|
|
* Ideally it should only contain receive time, payload,
|
|
|
|
* command and size.
|
|
|
|
*/
|
2012-11-16 01:41:12 +01:00
|
|
|
class CNetMessage {
|
2019-06-13 10:39:44 +02:00
|
|
|
public:
|
|
|
|
CDataStream m_recv; // received message data
|
|
|
|
int64_t m_time = 0; // time (in microseconds) of message receipt.
|
|
|
|
bool m_valid_netmagic = false;
|
|
|
|
bool m_valid_header = false;
|
|
|
|
bool m_valid_checksum = false;
|
|
|
|
uint32_t m_message_size = 0; // size of the payload
|
2019-06-13 11:07:50 +02:00
|
|
|
uint32_t m_raw_message_size = 0; // used wire size of the message (including header/checksum)
|
2019-06-13 10:39:44 +02:00
|
|
|
std::string m_command;
|
|
|
|
|
2019-10-22 15:28:32 +02:00
|
|
|
CNetMessage(CDataStream&& recv_in) : m_recv(std::move(recv_in)) {}
|
2019-06-13 10:39:44 +02:00
|
|
|
|
|
|
|
void SetVersion(int nVersionIn)
|
|
|
|
{
|
|
|
|
m_recv.SetVersion(nVersionIn);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/** The TransportDeserializer takes care of holding and deserializing the
|
|
|
|
* network receive buffer. It can deserialize the network buffer into a
|
|
|
|
* transport protocol agnostic CNetMessage (command & payload)
|
|
|
|
*/
|
|
|
|
class TransportDeserializer {
|
2019-06-13 11:25:54 +02:00
|
|
|
public:
|
|
|
|
// returns true if the current deserialization is complete
|
|
|
|
virtual bool Complete() const = 0;
|
|
|
|
// set the serialization context version
|
|
|
|
virtual void SetVersion(int version) = 0;
|
|
|
|
// read and deserialize data
|
|
|
|
virtual int Read(const char *data, unsigned int bytes) = 0;
|
|
|
|
// decomposes a message from the context
|
|
|
|
virtual CNetMessage GetMessage(const CMessageHeader::MessageStartChars& message_start, int64_t time) = 0;
|
|
|
|
virtual ~TransportDeserializer() {}
|
|
|
|
};
|
|
|
|
|
2019-10-18 21:09:48 +02:00
|
|
|
class V1TransportDeserializer final : public TransportDeserializer
|
2019-06-13 11:25:54 +02:00
|
|
|
{
|
2016-10-30 23:02:16 +01:00
|
|
|
private:
|
|
|
|
mutable CHash256 hasher;
|
|
|
|
mutable uint256 data_hash;
|
2012-11-16 01:41:12 +01:00
|
|
|
bool in_data; // parsing header (false) or data (true)
|
|
|
|
CDataStream hdrbuf; // partially received header
|
|
|
|
CMessageHeader hdr; // complete header
|
|
|
|
CDataStream vRecv; // received message data
|
2019-06-13 11:25:54 +02:00
|
|
|
unsigned int nHdrPos;
|
2012-11-16 01:41:12 +01:00
|
|
|
unsigned int nDataPos;
|
|
|
|
|
2019-06-13 11:25:54 +02:00
|
|
|
const uint256& GetMessageHash() const;
|
|
|
|
int readHeader(const char *pch, unsigned int nBytes);
|
|
|
|
int readData(const char *pch, unsigned int nBytes);
|
2014-07-06 16:06:46 +02:00
|
|
|
|
2019-06-13 10:39:44 +02:00
|
|
|
void Reset() {
|
|
|
|
vRecv.clear();
|
|
|
|
hdrbuf.clear();
|
2012-11-16 01:41:12 +01:00
|
|
|
hdrbuf.resize(24);
|
|
|
|
in_data = false;
|
|
|
|
nHdrPos = 0;
|
|
|
|
nDataPos = 0;
|
2019-06-13 10:39:44 +02:00
|
|
|
data_hash.SetNull();
|
|
|
|
hasher.Reset();
|
2012-11-16 01:41:12 +01:00
|
|
|
}
|
2019-10-18 21:03:13 +02:00
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
V1TransportDeserializer(const CMessageHeader::MessageStartChars& pchMessageStartIn, int nTypeIn, int nVersionIn) : hdrbuf(nTypeIn, nVersionIn), hdr(pchMessageStartIn), vRecv(nTypeIn, nVersionIn) {
|
|
|
|
Reset();
|
|
|
|
}
|
|
|
|
|
2019-10-18 21:09:48 +02:00
|
|
|
bool Complete() const override
|
2012-11-16 01:41:12 +01:00
|
|
|
{
|
|
|
|
if (!in_data)
|
|
|
|
return false;
|
|
|
|
return (hdr.nMessageSize == nDataPos);
|
|
|
|
}
|
2019-10-18 21:09:48 +02:00
|
|
|
void SetVersion(int nVersionIn) override
|
2012-11-16 01:41:12 +01:00
|
|
|
{
|
|
|
|
hdrbuf.SetVersion(nVersionIn);
|
|
|
|
vRecv.SetVersion(nVersionIn);
|
|
|
|
}
|
2019-10-18 21:09:48 +02:00
|
|
|
int Read(const char *pch, unsigned int nBytes) override {
|
2019-10-18 21:03:13 +02:00
|
|
|
int ret = in_data ? readData(pch, nBytes) : readHeader(pch, nBytes);
|
|
|
|
if (ret < 0) Reset();
|
|
|
|
return ret;
|
2019-06-13 11:25:54 +02:00
|
|
|
}
|
2019-10-18 21:09:48 +02:00
|
|
|
CNetMessage GetMessage(const CMessageHeader::MessageStartChars& message_start, int64_t time) override;
|
2019-06-13 10:39:44 +02:00
|
|
|
};
|
2012-11-16 01:41:12 +01:00
|
|
|
|
2012-03-26 16:48:23 +02:00
|
|
|
/** Information about a peer */
|
2010-08-29 18:58:15 +02:00
|
|
|
class CNode
|
|
|
|
{
|
2016-09-13 02:00:33 +02:00
|
|
|
friend class CConnman;
|
2010-08-29 18:58:15 +02:00
|
|
|
public:
|
2019-06-13 10:39:44 +02:00
|
|
|
std::unique_ptr<TransportDeserializer> m_deserializer;
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
// socket
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<ServiceFlags> nServices{NODE_NONE};
|
2018-10-08 15:34:39 +02:00
|
|
|
SOCKET hSocket GUARDED_BY(cs_hSocket);
|
2019-01-05 12:11:04 +01:00
|
|
|
size_t nSendSize{0}; // total size of all vSendMsg entries
|
|
|
|
size_t nSendOffset{0}; // offset inside the first vSendMsg already sent
|
|
|
|
uint64_t nSendBytes GUARDED_BY(cs_vSend){0};
|
2018-10-08 15:34:39 +02:00
|
|
|
std::deque<std::vector<unsigned char>> vSendMsg GUARDED_BY(cs_vSend);
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_vSend;
|
|
|
|
RecursiveMutex cs_hSocket;
|
|
|
|
RecursiveMutex cs_vRecv;
|
2012-11-16 01:41:12 +01:00
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_vProcessMsg;
|
2018-10-08 15:34:39 +02:00
|
|
|
std::list<CNetMessage> vProcessMsg GUARDED_BY(cs_vProcessMsg);
|
2019-01-05 12:11:04 +01:00
|
|
|
size_t nProcessQueueSize{0};
|
2016-12-31 08:05:28 +01:00
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_sendProcessing;
|
2016-12-24 20:34:20 +01:00
|
|
|
|
2013-03-29 23:49:38 +01:00
|
|
|
std::deque<CInv> vRecvGetData;
|
2019-01-05 12:11:04 +01:00
|
|
|
uint64_t nRecvBytes GUARDED_BY(cs_vRecv){0};
|
|
|
|
std::atomic<int> nRecvVersion{INIT_PROTO_VERSION};
|
2012-11-16 01:41:12 +01:00
|
|
|
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nLastSend{0};
|
|
|
|
std::atomic<int64_t> nLastRecv{0};
|
2017-02-06 17:42:49 +01:00
|
|
|
const int64_t nTimeConnected;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nTimeOffset{0};
|
2017-05-30 11:59:42 +02:00
|
|
|
// Address of this peer
|
2016-05-25 15:38:32 +02:00
|
|
|
const CAddress addr;
|
2017-05-30 11:59:42 +02:00
|
|
|
// Bind address of our side of the connection
|
|
|
|
const CAddress addrBind;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int> nVersion{0};
|
2019-03-23 16:34:40 +01:00
|
|
|
RecursiveMutex cs_SubVer;
|
|
|
|
/**
|
|
|
|
* cleanSubVer is a sanitized string of the user agent byte array we read
|
|
|
|
* from the wire. This cleaned string can safely be logged or displayed.
|
|
|
|
*/
|
|
|
|
std::string cleanSubVer GUARDED_BY(cs_SubVer){};
|
2018-12-11 22:07:36 +01:00
|
|
|
bool m_prefer_evict{false}; // This peer is preferred for eviction.
|
2019-06-20 11:37:51 +02:00
|
|
|
bool HasPermission(NetPermissionFlags permission) const {
|
|
|
|
return NetPermissions::HasFlag(m_permissionFlags, permission);
|
|
|
|
}
|
2019-06-21 04:42:04 +02:00
|
|
|
// This boolean is unusued in actual processing, only present for backward compatibility at RPC/QT level
|
|
|
|
bool m_legacyWhitelisted{false};
|
2019-01-05 12:11:04 +01:00
|
|
|
bool fFeeler{false}; // If true this node is being used as a short lived feeler.
|
|
|
|
bool fOneShot{false};
|
|
|
|
bool m_manual_connection{false};
|
|
|
|
bool fClient{false}; // set by version message
|
|
|
|
bool m_limited_node{false}; //after BIP159, set by version message
|
2016-10-31 22:06:15 +01:00
|
|
|
const bool fInbound;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic_bool fSuccessfullyConnected{false};
|
2019-01-18 00:27:13 +01:00
|
|
|
// Setting fDisconnect to true will cause the node to be disconnected the
|
|
|
|
// next time DisconnectNodes() runs
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic_bool fDisconnect{false};
|
|
|
|
bool fSentAddr{false};
|
2012-05-10 18:44:07 +02:00
|
|
|
CSemaphoreGrant grantOutbound;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int> nRefCount{0};
|
2016-05-23 09:21:05 +02:00
|
|
|
|
2016-05-25 15:38:32 +02:00
|
|
|
const uint64_t nKeyedNetGroup;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic_bool fPauseRecv{false};
|
|
|
|
std::atomic_bool fPauseSend{false};
|
2011-09-06 22:09:04 +02:00
|
|
|
|
2019-01-02 13:13:50 +01:00
|
|
|
protected:
|
2015-08-25 16:30:31 +02:00
|
|
|
mapMsgCmdSize mapSendBytesPerMsgCmd;
|
2018-10-08 15:34:39 +02:00
|
|
|
mapMsgCmdSize mapRecvBytesPerMsgCmd GUARDED_BY(cs_vRecv);
|
2015-08-25 16:30:31 +02:00
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
public:
|
|
|
|
uint256 hashContinue;
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int> nStartingHeight{-1};
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
// flood relay
|
2011-05-15 09:11:04 +02:00
|
|
|
std::vector<CAddress> vAddrToSend;
|
2019-10-31 18:42:02 +01:00
|
|
|
const std::unique_ptr<CRollingBloomFilter> m_addr_known;
|
2019-01-05 12:11:04 +01:00
|
|
|
bool fGetAddr{false};
|
|
|
|
int64_t nNextAddrSend GUARDED_BY(cs_sendProcessing){0};
|
|
|
|
int64_t nNextLocalAddrSend GUARDED_BY(cs_sendProcessing){0};
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2019-10-31 18:42:02 +01:00
|
|
|
bool IsAddrRelayPeer() const { return m_addr_known != nullptr; }
|
2019-04-05 19:35:15 +02:00
|
|
|
|
2016-04-07 13:57:36 +02:00
|
|
|
// List of block ids we still have announce.
|
|
|
|
// There is no final sorting before sending, as they are always sent immediately
|
|
|
|
// and in the order requested.
|
2018-10-08 15:34:39 +02:00
|
|
|
std::vector<uint256> vInventoryBlockToSend GUARDED_BY(cs_inventory);
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_inventory;
|
2019-03-08 20:26:36 +01:00
|
|
|
|
|
|
|
struct TxRelay {
|
|
|
|
TxRelay() { pfilter = MakeUnique<CBloomFilter>(); }
|
2020-01-07 17:14:15 +01:00
|
|
|
mutable RecursiveMutex cs_filter;
|
2019-03-08 20:26:36 +01:00
|
|
|
// We use fRelayTxes for two purposes -
|
|
|
|
// a) it allows us to not relay tx invs before receiving the peer's version message
|
|
|
|
// b) the peer may tell us in its version message that we should not relay tx invs
|
|
|
|
// unless it loads a bloom filter.
|
|
|
|
bool fRelayTxes GUARDED_BY(cs_filter){false};
|
|
|
|
std::unique_ptr<CBloomFilter> pfilter PT_GUARDED_BY(cs_filter) GUARDED_BY(cs_filter);
|
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
mutable RecursiveMutex cs_tx_inventory;
|
2019-03-08 20:26:36 +01:00
|
|
|
CRollingBloomFilter filterInventoryKnown GUARDED_BY(cs_tx_inventory){50000, 0.000001};
|
|
|
|
// Set of transaction ids we still have to announce.
|
|
|
|
// They are sorted by the mempool before relay, so the order is not important.
|
|
|
|
std::set<uint256> setInventoryTxToSend;
|
|
|
|
// Used for BIP35 mempool sending
|
|
|
|
bool fSendMempool GUARDED_BY(cs_tx_inventory){false};
|
|
|
|
// Last time a "MEMPOOL" request was serviced.
|
2019-09-18 19:31:59 +02:00
|
|
|
std::atomic<std::chrono::seconds> m_last_mempool_req{std::chrono::seconds{0}};
|
2019-10-30 23:37:35 +01:00
|
|
|
std::chrono::microseconds nNextInvSend{0};
|
2019-03-08 20:26:36 +01:00
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
RecursiveMutex cs_feeFilter;
|
2019-03-08 20:26:36 +01:00
|
|
|
// Minimum fee rate with which to filter inv's to this node
|
|
|
|
CAmount minFeeFilter GUARDED_BY(cs_feeFilter){0};
|
|
|
|
CAmount lastSentFeeFilter{0};
|
|
|
|
int64_t nextSendTimeFeeFilter{0};
|
|
|
|
};
|
|
|
|
|
2019-03-08 22:04:55 +01:00
|
|
|
// m_tx_relay == nullptr if we're not relaying transactions with this peer
|
2019-03-08 21:30:36 +01:00
|
|
|
std::unique_ptr<TxRelay> m_tx_relay;
|
2019-04-05 19:35:15 +02:00
|
|
|
|
2014-11-18 22:16:32 +01:00
|
|
|
// Used for headers announcements - unfiltered blocks to relay
|
2018-02-03 00:11:01 +01:00
|
|
|
std::vector<uint256> vBlockHashesToAnnounce GUARDED_BY(cs_inventory);
|
2016-05-22 07:55:15 +02:00
|
|
|
|
|
|
|
// Block and TXN accept times
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nLastBlockTime{0};
|
|
|
|
std::atomic<int64_t> nLastTXTime{0};
|
2016-05-22 07:55:15 +02:00
|
|
|
|
2013-10-15 00:34:20 +02:00
|
|
|
// Ping time measurement:
|
|
|
|
// The pong reply we're expecting, or 0 if no pong expected.
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<uint64_t> nPingNonceSent{0};
|
2013-10-15 00:34:20 +02:00
|
|
|
// Time (in usec) the last ping was sent, or 0 if no ping was ever sent.
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nPingUsecStart{0};
|
2013-10-15 00:34:20 +02:00
|
|
|
// Last measured round-trip time.
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nPingUsecTime{0};
|
2015-08-13 11:31:46 +02:00
|
|
|
// Best measured round-trip time.
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<int64_t> nMinPingUsecTime{std::numeric_limits<int64_t>::max()};
|
2013-10-15 00:34:20 +02:00
|
|
|
// Whether a ping is requested.
|
2019-01-05 12:11:04 +01:00
|
|
|
std::atomic<bool> fPingQueued{false};
|
2014-01-11 18:14:29 +01:00
|
|
|
|
2019-03-20 23:26:21 +01:00
|
|
|
std::set<uint256> orphan_work_set;
|
|
|
|
|
2019-03-09 18:55:06 +01:00
|
|
|
CNode(NodeId id, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn, SOCKET hSocketIn, const CAddress &addrIn, uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn, const CAddress &addrBindIn, const std::string &addrNameIn = "", bool fInboundIn = false, bool block_relay_only = false);
|
2014-08-21 05:17:21 +02:00
|
|
|
~CNode();
|
2017-09-16 12:06:05 +02:00
|
|
|
CNode(const CNode&) = delete;
|
|
|
|
CNode& operator=(const CNode&) = delete;
|
2010-08-29 18:58:15 +02:00
|
|
|
|
|
|
|
private:
|
2017-04-11 18:11:27 +02:00
|
|
|
const NodeId id;
|
2016-10-26 21:10:15 +02:00
|
|
|
const uint64_t nLocalHostNonce;
|
2019-09-10 19:09:12 +02:00
|
|
|
|
|
|
|
//! Services offered to this peer.
|
|
|
|
//!
|
|
|
|
//! This is supplied by the parent CConnman during peer connection
|
|
|
|
//! (CConnman::ConnectNode()) from its attribute of the same name.
|
|
|
|
//!
|
|
|
|
//! This is const because there is no protocol defined for renegotiating
|
|
|
|
//! services initially offered to a peer. The set of local services we
|
|
|
|
//! offer should not change after initialization.
|
|
|
|
//!
|
|
|
|
//! An interesting example of this is NODE_NETWORK and initial block
|
|
|
|
//! download: a node which starts up from scratch doesn't have any blocks
|
|
|
|
//! to serve, but still advertises NODE_NETWORK because it will eventually
|
|
|
|
//! fulfill this role after IBD completes. P2P code is written in such a
|
|
|
|
//! way that it can gracefully handle peers who don't make good on their
|
|
|
|
//! service advertisements.
|
2016-10-31 22:06:15 +01:00
|
|
|
const ServiceFlags nLocalServices;
|
2019-09-10 19:09:12 +02:00
|
|
|
|
2016-10-31 22:06:15 +01:00
|
|
|
const int nMyStartingHeight;
|
2019-01-05 12:11:04 +01:00
|
|
|
int nSendVersion{0};
|
2019-06-20 11:37:51 +02:00
|
|
|
NetPermissionFlags m_permissionFlags{ PF_NONE };
|
2016-12-31 08:05:36 +01:00
|
|
|
std::list<CNetMessage> vRecvMsg; // Used only by SocketHandler thread
|
2017-02-06 18:04:34 +01:00
|
|
|
|
2020-01-07 17:14:15 +01:00
|
|
|
mutable RecursiveMutex cs_addrName;
|
2018-10-08 15:34:39 +02:00
|
|
|
std::string addrName GUARDED_BY(cs_addrName);
|
2017-02-06 18:18:51 +01:00
|
|
|
|
2017-05-30 11:59:42 +02:00
|
|
|
// Our address, as reported by the peer
|
2018-10-08 15:34:39 +02:00
|
|
|
CService addrLocal GUARDED_BY(cs_addrLocal);
|
2020-01-07 17:14:15 +01:00
|
|
|
mutable RecursiveMutex cs_addrLocal;
|
2010-08-29 18:58:15 +02:00
|
|
|
public:
|
|
|
|
|
2013-11-18 01:25:17 +01:00
|
|
|
NodeId GetId() const {
|
2017-03-06 17:54:08 +01:00
|
|
|
return id;
|
2013-11-18 01:25:17 +01:00
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
|
2016-04-18 02:21:58 +02:00
|
|
|
uint64_t GetLocalNonce() const {
|
2017-03-06 17:54:08 +01:00
|
|
|
return nLocalHostNonce;
|
2016-04-18 02:21:58 +02:00
|
|
|
}
|
|
|
|
|
2016-10-27 00:08:11 +02:00
|
|
|
int GetMyStartingHeight() const {
|
2017-03-06 17:54:08 +01:00
|
|
|
return nMyStartingHeight;
|
2016-10-27 00:08:11 +02:00
|
|
|
}
|
|
|
|
|
2017-06-01 17:21:03 +02:00
|
|
|
int GetRefCount() const
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2013-03-29 00:43:31 +01:00
|
|
|
assert(nRefCount >= 0);
|
|
|
|
return nRefCount;
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
2016-04-19 03:33:54 +02:00
|
|
|
bool ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete);
|
2012-11-16 01:41:12 +01:00
|
|
|
|
|
|
|
void SetRecvVersion(int nVersionIn)
|
|
|
|
{
|
|
|
|
nRecvVersion = nVersionIn;
|
2016-12-31 08:05:15 +01:00
|
|
|
}
|
2017-06-01 17:21:03 +02:00
|
|
|
int GetRecvVersion() const
|
2016-12-31 08:05:15 +01:00
|
|
|
{
|
|
|
|
return nRecvVersion;
|
2012-11-16 01:41:12 +01:00
|
|
|
}
|
2017-02-02 20:33:41 +01:00
|
|
|
void SetSendVersion(int nVersionIn);
|
|
|
|
int GetSendVersion() const;
|
2012-11-16 01:41:12 +01:00
|
|
|
|
2017-02-06 18:18:51 +01:00
|
|
|
CService GetAddrLocal() const;
|
|
|
|
//! May not be called more than once
|
|
|
|
void SetAddrLocal(const CService& addrLocalIn);
|
|
|
|
|
2013-03-29 00:43:31 +01:00
|
|
|
CNode* AddRef()
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2013-03-29 00:43:31 +01:00
|
|
|
nRefCount++;
|
2010-08-29 18:58:15 +02:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Release()
|
|
|
|
{
|
|
|
|
nRefCount--;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-08-15 14:10:07 +02:00
|
|
|
void AddAddressKnown(const CAddress& _addr)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
2019-10-25 22:28:14 +02:00
|
|
|
assert(m_addr_known);
|
2019-10-16 23:06:20 +02:00
|
|
|
m_addr_known->insert(_addr.GetKey());
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
2016-10-13 16:19:20 +02:00
|
|
|
void PushAddress(const CAddress& _addr, FastRandomContext &insecure_rand)
|
2010-08-29 18:58:15 +02:00
|
|
|
{
|
|
|
|
// Known checking here is only to save space from duplicates.
|
|
|
|
// SendMessages will filter it again for knowns that were added
|
|
|
|
// after addresses were pushed.
|
2019-10-25 22:28:14 +02:00
|
|
|
assert(m_addr_known);
|
2019-10-16 23:06:20 +02:00
|
|
|
if (_addr.IsValid() && !m_addr_known->contains(_addr.GetKey())) {
|
2014-11-21 12:22:11 +01:00
|
|
|
if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {
|
2017-02-25 21:16:58 +01:00
|
|
|
vAddrToSend[insecure_rand.randrange(vAddrToSend.size())] = _addr;
|
2014-11-21 12:22:11 +01:00
|
|
|
} else {
|
2016-08-15 14:10:07 +02:00
|
|
|
vAddrToSend.push_back(_addr);
|
2014-11-21 12:22:11 +01:00
|
|
|
}
|
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void AddInventoryKnown(const CInv& inv)
|
|
|
|
{
|
2019-03-08 21:48:41 +01:00
|
|
|
if (m_tx_relay != nullptr) {
|
2019-03-08 21:30:36 +01:00
|
|
|
LOCK(m_tx_relay->cs_tx_inventory);
|
|
|
|
m_tx_relay->filterInventoryKnown.insert(inv.hash);
|
2012-04-06 18:39:12 +02:00
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void PushInventory(const CInv& inv)
|
|
|
|
{
|
2019-03-08 21:48:41 +01:00
|
|
|
if (inv.type == MSG_TX && m_tx_relay != nullptr) {
|
2019-03-08 21:30:36 +01:00
|
|
|
LOCK(m_tx_relay->cs_tx_inventory);
|
|
|
|
if (!m_tx_relay->filterInventoryKnown.contains(inv.hash)) {
|
|
|
|
m_tx_relay->setInventoryTxToSend.insert(inv.hash);
|
2016-04-07 13:57:36 +02:00
|
|
|
}
|
|
|
|
} else if (inv.type == MSG_BLOCK) {
|
2019-03-08 20:26:36 +01:00
|
|
|
LOCK(cs_inventory);
|
2016-04-07 13:57:36 +02:00
|
|
|
vInventoryBlockToSend.push_back(inv.hash);
|
2012-04-06 18:39:12 +02:00
|
|
|
}
|
2010-08-29 18:58:15 +02:00
|
|
|
}
|
|
|
|
|
2014-11-18 22:16:32 +01:00
|
|
|
void PushBlockHash(const uint256 &hash)
|
|
|
|
{
|
|
|
|
LOCK(cs_inventory);
|
|
|
|
vBlockHashesToAnnounce.push_back(hash);
|
|
|
|
}
|
|
|
|
|
2010-08-29 18:58:15 +02:00
|
|
|
void CloseSocketDisconnect();
|
2011-09-06 22:09:04 +02:00
|
|
|
|
2019-12-24 19:26:46 +01:00
|
|
|
void copyStats(CNodeStats &stats, std::vector<bool> &m_asmap);
|
2016-04-19 06:04:58 +02:00
|
|
|
|
|
|
|
ServiceFlags GetLocalServices() const
|
|
|
|
{
|
|
|
|
return nLocalServices;
|
|
|
|
}
|
2017-02-06 18:04:34 +01:00
|
|
|
|
|
|
|
std::string GetAddrName() const;
|
|
|
|
//! Sets the addrName only if it was not previously set
|
|
|
|
void MaybeSetAddrName(const std::string& addrNameIn);
|
2010-08-29 18:58:15 +02:00
|
|
|
};
|
|
|
|
|
2015-04-08 20:20:00 +02:00
|
|
|
/** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
|
2018-05-21 21:02:40 +02:00
|
|
|
int64_t PoissonNextSend(int64_t now, int average_interval_seconds);
|
2015-04-08 20:20:00 +02:00
|
|
|
|
2019-11-05 11:06:53 +01:00
|
|
|
/** Wrapper to return mockable type */
|
|
|
|
inline std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval)
|
|
|
|
{
|
|
|
|
return std::chrono::microseconds{PoissonNextSend(now.count(), average_interval.count())};
|
|
|
|
}
|
|
|
|
|
2014-08-28 22:21:03 +02:00
|
|
|
#endif // BITCOIN_NET_H
|