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