Bitcoin Core  27.99.0
P2P Digital Currency
net.h
Go to the documentation of this file.
1 // Copyright (c) 2020-2022 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #ifndef BITCOIN_TEST_UTIL_NET_H
6 #define BITCOIN_TEST_UTIL_NET_H
7 
8 #include <compat/compat.h>
9 #include <net.h>
10 #include <net_permissions.h>
11 #include <net_processing.h>
12 #include <netaddress.h>
13 #include <node/connection_types.h>
14 #include <node/eviction.h>
15 #include <sync.h>
16 #include <util/sock.h>
17 
18 #include <algorithm>
19 #include <array>
20 #include <cassert>
21 #include <chrono>
22 #include <cstdint>
23 #include <cstring>
24 #include <memory>
25 #include <string>
26 #include <unordered_map>
27 #include <vector>
28 
29 class FastRandomContext;
30 
31 template <typename C>
32 class Span;
33 
34 struct ConnmanTestMsg : public CConnman {
35  using CConnman::CConnman;
36 
37  void SetPeerConnectTimeout(std::chrono::seconds timeout)
38  {
39  m_peer_connect_timeout = timeout;
40  }
41 
42  std::vector<CNode*> TestNodes()
43  {
45  return m_nodes;
46  }
47 
49  {
51  m_nodes.push_back(&node);
52 
53  if (node.IsManualOrFullOutboundConn()) ++m_network_conn_counts[node.addr.GetNetwork()];
54  }
55 
57  {
59  for (CNode* node : m_nodes) {
60  delete node;
61  }
62  m_nodes.clear();
63  }
64 
65  void Handshake(CNode& node,
66  bool successfully_connected,
67  ServiceFlags remote_services,
68  ServiceFlags local_services,
69  int32_t version,
70  bool relay_txs)
72 
74  {
75  return m_msgproc->ProcessMessages(&node, flagInterruptMsgProc);
76  }
77 
78  void NodeReceiveMsgBytes(CNode& node, Span<const uint8_t> msg_bytes, bool& complete) const;
79 
80  bool ReceiveMsgFrom(CNode& node, CSerializedNetMsg&& ser_msg) const;
81  void FlushSendBuffer(CNode& node) const;
82 
83  bool AlreadyConnectedPublic(const CAddress& addr) { return AlreadyConnectedToAddress(addr); };
84 
85  CNode* ConnectNodePublic(PeerManager& peerman, const char* pszDest, ConnectionType conn_type)
87 };
88 
90  NODE_NONE,
92  NODE_BLOOM,
97 };
98 
110 };
111 
119 };
120 
121 constexpr auto ALL_NETWORKS = std::array{
129 };
130 
136 class StaticContentsSock : public Sock
137 {
138 public:
139  explicit StaticContentsSock(const std::string& contents)
140  : Sock{INVALID_SOCKET},
141  m_contents{contents}
142  {
143  }
144 
146 
147  StaticContentsSock& operator=(Sock&& other) override
148  {
149  assert(false && "Move of Sock into MockSock not allowed.");
150  return *this;
151  }
152 
153  ssize_t Send(const void*, size_t len, int) const override { return len; }
154 
155  ssize_t Recv(void* buf, size_t len, int flags) const override
156  {
157  const size_t consume_bytes{std::min(len, m_contents.size() - m_consumed)};
158  std::memcpy(buf, m_contents.data() + m_consumed, consume_bytes);
159  if ((flags & MSG_PEEK) == 0) {
160  m_consumed += consume_bytes;
161  }
162  return consume_bytes;
163  }
164 
165  int Connect(const sockaddr*, socklen_t) const override { return 0; }
166 
167  int Bind(const sockaddr*, socklen_t) const override { return 0; }
168 
169  int Listen(int) const override { return 0; }
170 
171  std::unique_ptr<Sock> Accept(sockaddr* addr, socklen_t* addr_len) const override
172  {
173  if (addr != nullptr) {
174  // Pretend all connections come from 5.5.5.5:6789
175  memset(addr, 0x00, *addr_len);
176  const socklen_t write_len = static_cast<socklen_t>(sizeof(sockaddr_in));
177  if (*addr_len >= write_len) {
178  *addr_len = write_len;
179  sockaddr_in* addr_in = reinterpret_cast<sockaddr_in*>(addr);
180  addr_in->sin_family = AF_INET;
181  memset(&addr_in->sin_addr, 0x05, sizeof(addr_in->sin_addr));
182  addr_in->sin_port = htons(6789);
183  }
184  }
185  return std::make_unique<StaticContentsSock>("");
186  };
187 
188  int GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const override
189  {
190  std::memset(opt_val, 0x0, *opt_len);
191  return 0;
192  }
193 
194  int SetSockOpt(int, int, const void*, socklen_t) const override { return 0; }
195 
196  int GetSockName(sockaddr* name, socklen_t* name_len) const override
197  {
198  std::memset(name, 0x0, *name_len);
199  return 0;
200  }
201 
202  bool SetNonBlocking() const override { return true; }
203 
204  bool IsSelectable() const override { return true; }
205 
206  bool Wait(std::chrono::milliseconds timeout,
207  Event requested,
208  Event* occurred = nullptr) const override
209  {
210  if (occurred != nullptr) {
211  *occurred = requested;
212  }
213  return true;
214  }
215 
216  bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const override
217  {
218  for (auto& [sock, events] : events_per_sock) {
219  (void)sock;
220  events.occurred = events.requested;
221  }
222  return true;
223  }
224 
225  bool IsConnected(std::string&) const override
226  {
227  return true;
228  }
229 
230 private:
231  const std::string m_contents;
232  mutable size_t m_consumed{0};
233 };
234 
235 std::vector<NodeEvictionCandidate> GetRandomNodeEvictionCandidates(int n_candidates, FastRandomContext& random_context);
236 
237 #endif // BITCOIN_TEST_UTIL_NET_H
int flags
Definition: bitcoin-tx.cpp:533
A CService with information about it as peer.
Definition: protocol.h:367
Definition: net.h:1033
bool AlreadyConnectedToAddress(const CAddress &addr)
Determine whether we're already connected to a given address, in order to avoid initiating duplicate ...
Definition: net.cpp:357
CConnman(uint64_t seed0, uint64_t seed1, AddrMan &addrman, const NetGroupManager &netgroupman, const CChainParams &params, bool network_active=true)
Definition: net.cpp:3149
std::atomic< bool > flagInterruptMsgProc
Definition: net.h:1515
m_peer_connect_timeout
Definition: net.h:1080
RecursiveMutex m_nodes_mutex
Definition: net.h:1422
m_msgproc
Definition: net.h:1077
Mutex m_unused_i2p_sessions_mutex
Mutex protecting m_i2p_sam_sessions.
Definition: net.h:1571
Information about a peer.
Definition: net.h:670
Fast randomness source.
Definition: random.h:145
static Mutex g_msgproc_mutex
Mutex for anything that is only accessed via the msg processing thread.
Definition: net.h:992
RAII helper class that manages a socket and closes it automatically when it goes out of scope.
Definition: sock.h:27
SOCKET m_socket
Contained socket.
Definition: sock.h:275
uint8_t Event
Definition: sock.h:138
std::unordered_map< std::shared_ptr< const Sock >, Events, HashSharedPtrSock, EqualSharedPtrSock > EventsPerSock
On which socket to wait for what events in WaitMany().
Definition: sock.h:208
A Span is an object that can refer to a contiguous sequence of objects.
Definition: span.h:98
A mocked Sock alternative that returns a statically contained data upon read and succeeds and ignores...
Definition: net.h:137
int SetSockOpt(int, int, const void *, socklen_t) const override
setsockopt(2) wrapper.
Definition: net.h:194
bool IsSelectable() const override
Check if the underlying socket can be used for select(2) (or the Wait() method).
Definition: net.h:204
bool IsConnected(std::string &) const override
Check if still connected.
Definition: net.h:225
bool SetNonBlocking() const override
Set the non-blocking option on the socket.
Definition: net.h:202
bool Wait(std::chrono::milliseconds timeout, Event requested, Event *occurred=nullptr) const override
Wait for readiness for input (recv) or output (send).
Definition: net.h:206
int GetSockOpt(int level, int opt_name, void *opt_val, socklen_t *opt_len) const override
getsockopt(2) wrapper.
Definition: net.h:188
int Connect(const sockaddr *, socklen_t) const override
connect(2) wrapper.
Definition: net.h:165
bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock &events_per_sock) const override
Same as Wait(), but wait on many sockets within the same timeout.
Definition: net.h:216
size_t m_consumed
Definition: net.h:232
const std::string m_contents
Definition: net.h:231
ssize_t Send(const void *, size_t len, int) const override
send(2) wrapper.
Definition: net.h:153
int Bind(const sockaddr *, socklen_t) const override
bind(2) wrapper.
Definition: net.h:167
int GetSockName(sockaddr *name, socklen_t *name_len) const override
getsockname(2) wrapper.
Definition: net.h:196
int Listen(int) const override
listen(2) wrapper.
Definition: net.h:169
StaticContentsSock & operator=(Sock &&other) override
Move assignment operator, grab the socket from another object and close ours (if set).
Definition: net.h:147
~StaticContentsSock() override
Definition: net.h:145
StaticContentsSock(const std::string &contents)
Definition: net.h:139
ssize_t Recv(void *buf, size_t len, int flags) const override
recv(2) wrapper.
Definition: net.h:155
std::unique_ptr< Sock > Accept(sockaddr *addr, socklen_t *addr_len) const override
accept(2) wrapper.
Definition: net.h:171
#define INVALID_SOCKET
Definition: compat.h:56
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.
Definition: messages.h:20
NetPermissionFlags
@ NET_I2P
I2P.
Definition: netaddress.h:46
@ NET_CJDNS
CJDNS.
Definition: netaddress.h:49
@ NET_ONION
TOR (v2 or v3)
Definition: netaddress.h:43
@ NET_IPV6
IPv6.
Definition: netaddress.h:40
@ NET_IPV4
IPv4.
Definition: netaddress.h:37
@ NET_UNROUTABLE
Addresses from these networks are not publicly routable on the global Internet.
Definition: netaddress.h:34
@ NET_INTERNAL
A set of addresses that represent the hash of a string or FQDN.
Definition: netaddress.h:53
ServiceFlags
nServices flags
Definition: protocol.h:309
@ NODE_NONE
Definition: protocol.h:312
@ NODE_P2P_V2
Definition: protocol.h:330
@ NODE_WITNESS
Definition: protocol.h:320
@ NODE_NETWORK_LIMITED
Definition: protocol.h:327
@ NODE_BLOOM
Definition: protocol.h:317
@ NODE_NETWORK
Definition: protocol.h:315
@ NODE_COMPACT_FILTERS
Definition: protocol.h:323
const char * name
Definition: rest.cpp:49
bool ReceiveMsgFrom(CNode &node, CSerializedNetMsg &&ser_msg) const
Definition: net.cpp:90
CNode * ConnectNodePublic(PeerManager &peerman, const char *pszDest, ConnectionType conn_type) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex)
Definition: net.cpp:104
void ClearTestNodes()
Definition: net.h:56
bool AlreadyConnectedPublic(const CAddress &addr)
Definition: net.h:83
void NodeReceiveMsgBytes(CNode &node, Span< const uint8_t > msg_bytes, bool &complete) const
Definition: net.cpp:70
std::vector< CNode * > TestNodes()
Definition: net.h:42
void AddTestNode(CNode &node)
Definition: net.h:48
void Handshake(CNode &node, bool successfully_connected, ServiceFlags remote_services, ServiceFlags local_services, int32_t version, bool relay_txs) EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface bool ProcessMessagesOnce(CNode &node) EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface
Definition: net.h:73
void FlushSendBuffer(CNode &node) const
Definition: net.cpp:78
void SetPeerConnectTimeout(std::chrono::seconds timeout)
Definition: net.h:37
#define LOCK(cs)
Definition: sync.h:257
constexpr ServiceFlags ALL_SERVICE_FLAGS[]
Definition: net.h:89
constexpr ConnectionType ALL_CONNECTION_TYPES[]
Definition: net.h:112
constexpr auto ALL_NETWORKS
Definition: net.h:121
constexpr NetPermissionFlags ALL_NET_PERMISSION_FLAGS[]
Definition: net.h:99
std::vector< NodeEvictionCandidate > GetRandomNodeEvictionCandidates(int n_candidates, FastRandomContext &random_context)
Definition: net.cpp:115
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
assert(!tx.IsCoinBase())