Branch data Line data Source code
1 : : // Copyright (c) 2009-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_NETBASE_H
6 : : #define BITCOIN_NETBASE_H
7 : :
8 : : #include <compat/compat.h>
9 : : #include <netaddress.h>
10 : : #include <serialize.h>
11 : : #include <util/sock.h>
12 : : #include <util/threadinterrupt.h>
13 : :
14 : : #include <functional>
15 : : #include <memory>
16 : : #include <stdint.h>
17 : : #include <string>
18 : : #include <type_traits>
19 : : #include <unordered_set>
20 : : #include <vector>
21 : :
22 : : extern int nConnectTimeout;
23 : : extern bool fNameLookup;
24 : :
25 : : //! -timeout default
26 : : static const int DEFAULT_CONNECT_TIMEOUT = 5000;
27 : : //! -dns default
28 : : static const int DEFAULT_NAME_LOOKUP = true;
29 : :
30 : : /** Prefix for unix domain socket addresses (which are local filesystem paths) */
31 : : const std::string ADDR_PREFIX_UNIX = "unix:";
32 : :
33 : : enum class ConnectionDirection {
34 : : None = 0,
35 : : In = (1U << 0),
36 : : Out = (1U << 1),
37 : : Both = (In | Out),
38 : : };
39 : 0 : static inline ConnectionDirection& operator|=(ConnectionDirection& a, ConnectionDirection b) {
40 : : using underlying = typename std::underlying_type<ConnectionDirection>::type;
41 : 0 : a = ConnectionDirection(underlying(a) | underlying(b));
42 : 0 : return a;
43 : : }
44 : 0 : static inline bool operator&(ConnectionDirection a, ConnectionDirection b) {
45 : : using underlying = typename std::underlying_type<ConnectionDirection>::type;
46 : 0 : return (underlying(a) & underlying(b));
47 : : }
48 : :
49 : : /**
50 : : * Check if a string is a valid UNIX domain socket path
51 : : *
52 : : * @param name The string provided by the user representing a local path
53 : : *
54 : : * @returns Whether the string has proper format, length, and points to an existing file path
55 : : */
56 : : bool IsUnixSocketPath(const std::string& name);
57 : :
58 : 0 : class Proxy
59 : : {
60 : : public:
61 : 24 : Proxy() : m_is_unix_socket(false), m_randomize_credentials(false) {}
62 : 0 : explicit Proxy(const CService& _proxy, bool _randomize_credentials = false) : proxy(_proxy), m_is_unix_socket(false), m_randomize_credentials(_randomize_credentials) {}
63 [ # # ]: 0 : explicit Proxy(const std::string path, bool _randomize_credentials = false) : m_unix_socket_path(path), m_is_unix_socket(true), m_randomize_credentials(_randomize_credentials) {}
64 : :
65 : : CService proxy;
66 : : std::string m_unix_socket_path;
67 : : bool m_is_unix_socket;
68 : : bool m_randomize_credentials;
69 : :
70 : 0 : bool IsValid() const
71 : : {
72 [ # # ]: 0 : if (m_is_unix_socket) return IsUnixSocketPath(m_unix_socket_path);
73 : 0 : return proxy.IsValid();
74 : 0 : }
75 : :
76 : : sa_family_t GetFamily() const
77 : : {
78 : : if (m_is_unix_socket) return AF_UNIX;
79 : : return proxy.GetSAFamily();
80 : : }
81 : :
82 : 0 : std::string ToString() const
83 : : {
84 [ # # ]: 0 : if (m_is_unix_socket) return m_unix_socket_path;
85 : 0 : return proxy.ToStringAddrPort();
86 : 0 : }
87 : :
88 : : std::unique_ptr<Sock> Connect() const;
89 : : };
90 : :
91 : : /** Credentials for proxy authentication */
92 : : struct ProxyCredentials
93 : : {
94 : : std::string username;
95 : : std::string password;
96 : : };
97 : :
98 : : /**
99 : : * List of reachable networks. Everything is reachable by default.
100 : : */
101 : 3 : class ReachableNets {
102 : : public:
103 : 0 : void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
104 : : {
105 : 0 : AssertLockNotHeld(m_mutex);
106 : 0 : LOCK(m_mutex);
107 [ # # ]: 0 : m_reachable.insert(net);
108 : 0 : }
109 : :
110 : 0 : void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
111 : : {
112 : 0 : AssertLockNotHeld(m_mutex);
113 : 0 : LOCK(m_mutex);
114 [ # # ]: 0 : m_reachable.erase(net);
115 : 0 : }
116 : :
117 : 0 : void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
118 : : {
119 : 0 : AssertLockNotHeld(m_mutex);
120 : 0 : LOCK(m_mutex);
121 : 0 : m_reachable.clear();
122 : 0 : }
123 : :
124 : 58814 : [[nodiscard]] bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
125 : : {
126 : 58814 : AssertLockNotHeld(m_mutex);
127 : 58814 : LOCK(m_mutex);
128 [ + - ]: 58814 : return m_reachable.count(net) > 0;
129 : 58814 : }
130 : :
131 : 58814 : [[nodiscard]] bool Contains(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
132 : : {
133 : 58814 : AssertLockNotHeld(m_mutex);
134 : 58814 : return Contains(addr.GetNetwork());
135 : : }
136 : :
137 : : private:
138 : : mutable Mutex m_mutex;
139 : :
140 [ + - ]: 3 : std::unordered_set<Network> m_reachable GUARDED_BY(m_mutex){
141 : : NET_UNROUTABLE,
142 : : NET_IPV4,
143 : : NET_IPV6,
144 : : NET_ONION,
145 : : NET_I2P,
146 : : NET_CJDNS,
147 : : NET_INTERNAL
148 : : };
149 : : };
150 : :
151 : : extern ReachableNets g_reachable_nets;
152 : :
153 : : /**
154 : : * Wrapper for getaddrinfo(3). Do not use directly: call Lookup/LookupHost/LookupNumeric/LookupSubNet.
155 : : */
156 : : std::vector<CNetAddr> WrappedGetAddrInfo(const std::string& name, bool allow_lookup);
157 : :
158 : : enum Network ParseNetwork(const std::string& net);
159 : : std::string GetNetworkName(enum Network net);
160 : : /** Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE. */
161 : : std::vector<std::string> GetNetworkNames(bool append_unroutable = false);
162 : : bool SetProxy(enum Network net, const Proxy &addrProxy);
163 : : bool GetProxy(enum Network net, Proxy &proxyInfoOut);
164 : : bool IsProxy(const CNetAddr &addr);
165 : : /**
166 : : * Set the name proxy to use for all connections to nodes specified by a
167 : : * hostname. After setting this proxy, connecting to a node specified by a
168 : : * hostname won't result in a local lookup of said hostname, rather, connect to
169 : : * the node by asking the name proxy for a proxy connection to the hostname,
170 : : * effectively delegating the hostname lookup to the specified proxy.
171 : : *
172 : : * This delegation increases privacy for those who set the name proxy as they no
173 : : * longer leak their external hostname queries to their DNS servers.
174 : : *
175 : : * @returns Whether or not the operation succeeded.
176 : : *
177 : : * @note SOCKS5's support for UDP-over-SOCKS5 has been considered, but no SOCK5
178 : : * server in common use (most notably Tor) actually implements UDP
179 : : * support, and a DNS resolver is beyond the scope of this project.
180 : : */
181 : : bool SetNameProxy(const Proxy &addrProxy);
182 : : bool HaveNameProxy();
183 : : bool GetNameProxy(Proxy &nameProxyOut);
184 : :
185 : : using DNSLookupFn = std::function<std::vector<CNetAddr>(const std::string&, bool)>;
186 : : extern DNSLookupFn g_dns_lookup;
187 : :
188 : : /**
189 : : * Resolve a host string to its corresponding network addresses.
190 : : *
191 : : * @param name The string representing a host. Could be a name or a numerical
192 : : * IP address (IPv6 addresses in their bracketed form are
193 : : * allowed).
194 : : *
195 : : * @returns The resulting network addresses to which the specified host
196 : : * string resolved.
197 : : *
198 : : * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
199 : : * for additional parameter descriptions.
200 : : */
201 : : std::vector<CNetAddr> LookupHost(const std::string& name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);
202 : :
203 : : /**
204 : : * Resolve a host string to its first corresponding network address.
205 : : *
206 : : * @returns The resulting network address to which the specified host
207 : : * string resolved or std::nullopt if host does not resolve to an address.
208 : : *
209 : : * @see LookupHost(const std::string&, unsigned int, bool, DNSLookupFn)
210 : : * for additional parameter descriptions.
211 : : */
212 : : std::optional<CNetAddr> LookupHost(const std::string& name, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);
213 : :
214 : : /**
215 : : * Resolve a service string to its corresponding service.
216 : : *
217 : : * @param name The string representing a service. Could be a name or a
218 : : * numerical IP address (IPv6 addresses should be in their
219 : : * disambiguated bracketed form), optionally followed by a uint16_t port
220 : : * number. (e.g. example.com:8333 or
221 : : * [2001:db8:85a3:8d3:1319:8a2e:370:7348]:420)
222 : : * @param portDefault The default port for resulting services if not specified
223 : : * by the service string.
224 : : * @param fAllowLookup Whether or not hostname lookups are permitted. If yes,
225 : : * external queries may be performed.
226 : : * @param nMaxSolutions The maximum number of results we want, specifying 0
227 : : * means "as many solutions as we get."
228 : : *
229 : : * @returns The resulting services to which the specified service string
230 : : * resolved.
231 : : */
232 : : std::vector<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function = g_dns_lookup);
233 : :
234 : : /**
235 : : * Resolve a service string to its first corresponding service.
236 : : *
237 : : * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
238 : : * for additional parameter descriptions.
239 : : */
240 : : std::optional<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);
241 : :
242 : : /**
243 : : * Resolve a service string with a numeric IP to its first corresponding
244 : : * service.
245 : : *
246 : : * @returns The resulting CService if the resolution was successful, [::]:0 otherwise.
247 : : *
248 : : * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
249 : : * for additional parameter descriptions.
250 : : */
251 : : CService LookupNumeric(const std::string& name, uint16_t portDefault = 0, DNSLookupFn dns_lookup_function = g_dns_lookup);
252 : :
253 : : /**
254 : : * Parse and resolve a specified subnet string into the appropriate internal
255 : : * representation.
256 : : *
257 : : * @param[in] subnet_str A string representation of a subnet of the form
258 : : * `network address [ "/", ( CIDR-style suffix | netmask ) ]`
259 : : * e.g. "2001:db8::/32", "192.0.2.0/255.255.255.0" or "8.8.8.8".
260 : : * @returns a CSubNet object (that may or may not be valid).
261 : : */
262 : : CSubNet LookupSubNet(const std::string& subnet_str);
263 : :
264 : : /**
265 : : * Create a TCP or UNIX socket in the given address family.
266 : : * @param[in] address_family to use for the socket.
267 : : * @return pointer to the created Sock object or unique_ptr that owns nothing in case of failure
268 : : */
269 : : std::unique_ptr<Sock> CreateSockOS(sa_family_t address_family);
270 : :
271 : : /**
272 : : * Socket factory. Defaults to `CreateSockOS()`, but can be overridden by unit tests.
273 : : */
274 : : extern std::function<std::unique_ptr<Sock>(const sa_family_t&)> CreateSock;
275 : :
276 : : /**
277 : : * Create a socket and try to connect to the specified service.
278 : : *
279 : : * @param[in] dest The service to which to connect.
280 : : * @param[in] manual_connection Whether or not the connection was manually requested (e.g. through the addnode RPC)
281 : : *
282 : : * @returns the connected socket if the operation succeeded, empty unique_ptr otherwise
283 : : */
284 : : std::unique_ptr<Sock> ConnectDirectly(const CService& dest, bool manual_connection);
285 : :
286 : : /**
287 : : * Connect to a specified destination service through a SOCKS5 proxy by first
288 : : * connecting to the SOCKS5 proxy.
289 : : *
290 : : * @param[in] proxy The SOCKS5 proxy.
291 : : * @param[in] dest The destination service to which to connect.
292 : : * @param[in] port The destination port.
293 : : * @param[out] proxy_connection_failed Whether or not the connection to the SOCKS5 proxy failed.
294 : : *
295 : : * @returns the connected socket if the operation succeeded. Otherwise an empty unique_ptr.
296 : : */
297 : : std::unique_ptr<Sock> ConnectThroughProxy(const Proxy& proxy,
298 : : const std::string& dest,
299 : : uint16_t port,
300 : : bool& proxy_connection_failed);
301 : :
302 : : /**
303 : : * Interrupt SOCKS5 reads or writes.
304 : : */
305 : : extern CThreadInterrupt g_socks5_interrupt;
306 : :
307 : : /**
308 : : * Connect to a specified destination service through an already connected
309 : : * SOCKS5 proxy.
310 : : *
311 : : * @param strDest The destination fully-qualified domain name.
312 : : * @param port The destination port.
313 : : * @param auth The credentials with which to authenticate with the specified
314 : : * SOCKS5 proxy.
315 : : * @param socket The SOCKS5 proxy socket.
316 : : *
317 : : * @returns Whether or not the operation succeeded.
318 : : *
319 : : * @note The specified SOCKS5 proxy socket must already be connected to the
320 : : * SOCKS5 proxy.
321 : : *
322 : : * @see <a href="https://www.ietf.org/rfc/rfc1928.txt">RFC1928: SOCKS Protocol
323 : : * Version 5</a>
324 : : */
325 : : bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* auth, const Sock& socket);
326 : :
327 : : /**
328 : : * Determine if a port is "bad" from the perspective of attempting to connect
329 : : * to a node on that port.
330 : : * @see doc/p2p-bad-ports.md
331 : : * @param[in] port Port to check.
332 : : * @returns whether the port is bad
333 : : */
334 : : bool IsBadPort(uint16_t port);
335 : :
336 : : /**
337 : : * If an IPv6 address belongs to the address range used by the CJDNS network and
338 : : * the CJDNS network is reachable (-cjdnsreachable config is set), then change
339 : : * the type from NET_IPV6 to NET_CJDNS.
340 : : * @param[in] service Address to potentially convert.
341 : : * @return a copy of `service` either unmodified or changed to CJDNS.
342 : : */
343 : : CService MaybeFlipIPv6toCJDNS(const CService& service);
344 : :
345 : : #endif // BITCOIN_NETBASE_H
|
