/bitcoin/src/netbase.h

Source
// Copyright (c) 2009-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_NETBASE_H
#define BITCOIN_NETBASE_H

#include <compat/compat.h>
#include <netaddress.h>
#include <serialize.h>
#include <util/sock.h>
#include <util/threadinterrupt.h>

#include <functional>
#include <memory>
#include <stdint.h>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>

extern int nConnectTimeout;
extern bool fNameLookup;

//! -timeout default
static const int DEFAULT_CONNECT_TIMEOUT = 5000;
//! -dns default
static const int DEFAULT_NAME_LOOKUP = true;

/** Prefix for unix domain socket addresses (which are local filesystem paths) */
const std::string ADDR_PREFIX_UNIX = "unix:";

enum class ConnectionDirection {
    None = 0,
    In = (1U << 0),
    Out = (1U << 1),
    Both = (In | Out),
};
static inline ConnectionDirection& operator|=(ConnectionDirection& a, ConnectionDirection b) {
    using underlying = std::underlying_type_t<ConnectionDirection>;
    a = ConnectionDirection(underlying(a) | underlying(b));
    return a;
}
static inline bool operator&(ConnectionDirection a, ConnectionDirection b) {
    using underlying = std::underlying_type_t<ConnectionDirection>;
    return (underlying(a) & underlying(b));
}

/**
 * Check if a string is a valid UNIX domain socket path
 *
 * @param      name     The string provided by the user representing a local path
 *
 * @returns Whether the string has proper format, length, and points to an existing file path
 */
bool IsUnixSocketPath(const std::string& name);

class Proxy
{
public:
    Proxy() : m_is_unix_socket(false), m_tor_stream_isolation(false) {}
    explicit Proxy(const CService& _proxy, bool tor_stream_isolation = false) : proxy(_proxy), m_is_unix_socket(false), m_tor_stream_isolation(tor_stream_isolation) {}
    explicit Proxy(const std::string path, bool tor_stream_isolation = false) : m_unix_socket_path(path), m_is_unix_socket(true), m_tor_stream_isolation(tor_stream_isolation) {}

    CService proxy;
    std::string m_unix_socket_path;
    bool m_is_unix_socket;
    bool m_tor_stream_isolation;

    bool IsValid() const
    {
        if (m_is_unix_socket) return IsUnixSocketPath(m_unix_socket_path);
        return proxy.IsValid();
    }

    sa_family_t GetFamily() const
    {
        if (m_is_unix_socket) return AF_UNIX;
        return proxy.GetSAFamily();
    }

    std::string ToString() const
    {
        if (m_is_unix_socket) return m_unix_socket_path;
        return proxy.ToStringAddrPort();
    }

    std::unique_ptr<Sock> Connect() const;
};

/** Credentials for proxy authentication */
struct ProxyCredentials
{
    std::string username;
    std::string password;
};

/**
 * List of reachable networks. Everything is reachable by default.
 */
class ReachableNets {
public:
    void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        LOCK(m_mutex);
        m_reachable.insert(net);
    }

    void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        LOCK(m_mutex);
        m_reachable.erase(net);
    }

    void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        LOCK(m_mutex);
        m_reachable.clear();
    }

    [[nodiscard]] bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        LOCK(m_mutex);
        return m_reachable.count(net) > 0;
    }

    [[nodiscard]] bool Contains(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        return Contains(addr.GetNetwork());
    }

    [[nodiscard]] std::unordered_set<Network> All() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
    {
        AssertLockNotHeld(m_mutex);
        LOCK(m_mutex);
        return m_reachable;
    }

private:
    mutable Mutex m_mutex;

    std::unordered_set<Network> m_reachable GUARDED_BY(m_mutex){
        NET_UNROUTABLE,
        NET_IPV4,
        NET_IPV6,
        NET_ONION,
        NET_I2P,
        NET_CJDNS,
        NET_INTERNAL
    };
};

extern ReachableNets g_reachable_nets;

/**
 * Wrapper for getaddrinfo(3). Do not use directly: call Lookup/LookupHost/LookupNumeric/LookupSubNet.
 */
std::vector<CNetAddr> WrappedGetAddrInfo(const std::string& name, bool allow_lookup);

enum Network ParseNetwork(const std::string& net);
std::string GetNetworkName(enum Network net);
/** Return a vector of publicly routable Network names; optionally append NET_UNROUTABLE. */
std::vector<std::string> GetNetworkNames(bool append_unroutable = false);
bool SetProxy(enum Network net, const Proxy &addrProxy);
bool GetProxy(enum Network net, Proxy &proxyInfoOut);
bool IsProxy(const CNetAddr &addr);
/**
 * Set the name proxy to use for all connections to nodes specified by a
 * hostname. After setting this proxy, connecting to a node specified by a
 * hostname won't result in a local lookup of said hostname, rather, connect to
 * the node by asking the name proxy for a proxy connection to the hostname,
 * effectively delegating the hostname lookup to the specified proxy.
 *
 * This delegation increases privacy for those who set the name proxy as they no
 * longer leak their external hostname queries to their DNS servers.
 *
 * @returns Whether or not the operation succeeded.
 *
 * @note SOCKS5's support for UDP-over-SOCKS5 has been considered, but no SOCK5
 *       server in common use (most notably Tor) actually implements UDP
 *       support, and a DNS resolver is beyond the scope of this project.
 */
bool SetNameProxy(const Proxy &addrProxy);
bool HaveNameProxy();
bool GetNameProxy(Proxy &nameProxyOut);

using DNSLookupFn = std::function<std::vector<CNetAddr>(const std::string&, bool)>;
extern DNSLookupFn g_dns_lookup;

/**
 * Resolve a host string to its corresponding network addresses.
 *
 * @param name    The string representing a host. Could be a name or a numerical
 *                IP address (IPv6 addresses in their bracketed form are
 *                allowed).
 *
 * @returns The resulting network addresses to which the specified host
 *          string resolved.
 *
 * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
 *      for additional parameter descriptions.
 */
std::vector<CNetAddr> LookupHost(const std::string& name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);

/**
 * Resolve a host string to its first corresponding network address.
 *
 * @returns The resulting network address to which the specified host
 *          string resolved or std::nullopt if host does not resolve to an address.
 *
 * @see LookupHost(const std::string&, unsigned int, bool, DNSLookupFn)
 *      for additional parameter descriptions.
 */
std::optional<CNetAddr> LookupHost(const std::string& name, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);

/**
 * Resolve a service string to its corresponding service.
 *
 * @param name    The string representing a service. Could be a name or a
 *                numerical IP address (IPv6 addresses should be in their
 *                disambiguated bracketed form), optionally followed by a uint16_t port
 *                number. (e.g. example.com:8333 or
 *                [2001:db8:85a3:8d3:1319:8a2e:370:7348]:420)
 * @param portDefault The default port for resulting services if not specified
 *                    by the service string.
 * @param fAllowLookup Whether or not hostname lookups are permitted. If yes,
 *                     external queries may be performed.
 * @param nMaxSolutions The maximum number of results we want, specifying 0
 *                      means "as many solutions as we get."
 *
 * @returns The resulting services to which the specified service string
 *          resolved.
 */
std::vector<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function = g_dns_lookup);

/**
 * Resolve a service string to its first corresponding service.
 *
 * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
 *      for additional parameter descriptions.
 */
std::optional<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, DNSLookupFn dns_lookup_function = g_dns_lookup);

/**
 * Resolve a service string with a numeric IP to its first corresponding
 * service.
 *
 * @returns The resulting CService if the resolution was successful, [::]:0 otherwise.
 *
 * @see Lookup(const std::string&, uint16_t, bool, unsigned int, DNSLookupFn)
 *      for additional parameter descriptions.
 */
CService LookupNumeric(const std::string& name, uint16_t portDefault = 0, DNSLookupFn dns_lookup_function = g_dns_lookup);

/**
 * Parse and resolve a specified subnet string into the appropriate internal
 * representation.
 *
 * @param[in]  subnet_str  A string representation of a subnet of the form
 *                         `network address [ "/", ( CIDR-style suffix | netmask ) ]`
 *                         e.g. "2001:db8::/32", "192.0.2.0/255.255.255.0" or "8.8.8.8".
 * @returns a CSubNet object (that may or may not be valid).
 */
CSubNet LookupSubNet(const std::string& subnet_str);

/**
 * Create a real socket from the operating system.
 * @param[in] domain Communications domain, first argument to the socket(2) syscall.
 * @param[in] type Type of the socket, second argument to the socket(2) syscall.
 * @param[in] protocol The particular protocol to be used with the socket, third argument to the socket(2) syscall.
 * @return pointer to the created Sock object or unique_ptr that owns nothing in case of failure
 */
std::unique_ptr<Sock> CreateSockOS(int domain, int type, int protocol);

/**
 * Socket factory. Defaults to `CreateSockOS()`, but can be overridden by unit tests.
 */
extern std::function<std::unique_ptr<Sock>(int, int, int)> CreateSock;

/**
 * Create a socket and try to connect to the specified service.
 *
 * @param[in] dest The service to which to connect.
 * @param[in] manual_connection Whether or not the connection was manually requested (e.g. through the addnode RPC)
 *
 * @returns the connected socket if the operation succeeded, empty unique_ptr otherwise
 */
std::unique_ptr<Sock> ConnectDirectly(const CService& dest, bool manual_connection);

/**
 * Connect to a specified destination service through a SOCKS5 proxy by first
 * connecting to the SOCKS5 proxy.
 *
 * @param[in] proxy The SOCKS5 proxy.
 * @param[in] dest The destination service to which to connect.
 * @param[in] port The destination port.
 * @param[out] proxy_connection_failed Whether or not the connection to the SOCKS5 proxy failed.
 *
 * @returns the connected socket if the operation succeeded. Otherwise an empty unique_ptr.
 */
std::unique_ptr<Sock> ConnectThroughProxy(const Proxy& proxy,
                                          const std::string& dest,
                                          uint16_t port,
                                          bool& proxy_connection_failed);

/**
 * Interrupt SOCKS5 reads or writes.
 */
extern CThreadInterrupt g_socks5_interrupt;

/**
 * Connect to a specified destination service through an already connected
 * SOCKS5 proxy.
 *
 * @param strDest The destination fully-qualified domain name.
 * @param port The destination port.
 * @param auth The credentials with which to authenticate with the specified
 *             SOCKS5 proxy.
 * @param socket The SOCKS5 proxy socket.
 *
 * @returns Whether or not the operation succeeded.
 *
 * @note The specified SOCKS5 proxy socket must already be connected to the
 *       SOCKS5 proxy.
 *
 * @see <a href="https://www.ietf.org/rfc/rfc1928.txt">RFC1928: SOCKS Protocol
 *      Version 5</a>
 */
bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* auth, const Sock& socket);

/**
 * Determine if a port is "bad" from the perspective of attempting to connect
 * to a node on that port.
 * @see doc/p2p-bad-ports.md
 * @param[in] port Port to check.
 * @returns whether the port is bad
 */
bool IsBadPort(uint16_t port);

/**
 * If an IPv6 address belongs to the address range used by the CJDNS network and
 * the CJDNS network is reachable (-cjdnsreachable config is set), then change
 * the type from NET_IPV6 to NET_CJDNS.
 * @param[in] service Address to potentially convert.
 * @return a copy of `service` either unmodified or changed to CJDNS.
 */
CService MaybeFlipIPv6toCJDNS(const CService& service);

#endif // BITCOIN_NETBASE_H

Coverage Report

Created: 2025-06-10 13:21

Line	Count	Source
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	0	using underlying = std::underlying_type_t<ConnectionDirection>;
41	0	a = ConnectionDirection(underlying(a) \| underlying(b));
42	0	return a;
43	0	} Unexecuted instantiation: bitcoind.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: init.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: mapport.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: net.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: net_processing.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: context.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: eviction.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: interfaces.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: peerman_args.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: transaction.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: txdownloadman_impl.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: txreconciliation.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: blockchain.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: mempool.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: mining.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: node.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: server_util.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: torcontrol.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: txorphanage.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: txrequest.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: addrdb.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: headerssync.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: httpserver.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: i2p.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: netif.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: pcp.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: net_permissions.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: net_types.cpp:operator\|=(ConnectionDirection&, ConnectionDirection) Unexecuted instantiation: netbase.cpp:operator\|=(ConnectionDirection&, ConnectionDirection)
44	0	static inline bool operator&(ConnectionDirection a, ConnectionDirection b) {
45	0	using underlying = std::underlying_type_t<ConnectionDirection>;
46	0	return (underlying(a) & underlying(b));
47	0	} Unexecuted instantiation: bitcoind.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: init.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: mapport.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: net.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: net_processing.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: context.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: eviction.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: interfaces.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: peerman_args.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: transaction.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: txdownloadman_impl.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: txreconciliation.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: blockchain.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: mempool.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: mining.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: node.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: server_util.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: torcontrol.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: txorphanage.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: txrequest.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: addrdb.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: headerssync.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: httpserver.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: i2p.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: netif.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: pcp.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: net_permissions.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: net_types.cpp:operator&(ConnectionDirection, ConnectionDirection) Unexecuted instantiation: netbase.cpp:operator&(ConnectionDirection, ConnectionDirection)
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	166k	Proxy() : m_is_unix_socket(false), m_tor_stream_isolation(false) {}
62	0	explicit Proxy(const CService& _proxy, bool tor_stream_isolation = false) : proxy(_proxy), m_is_unix_socket(false), m_tor_stream_isolation(tor_stream_isolation) {}
63	0	explicit Proxy(const std::string path, bool tor_stream_isolation = false) : m_unix_socket_path(path), m_is_unix_socket(true), m_tor_stream_isolation(tor_stream_isolation) {}
64
65		CService proxy;
66		std::string m_unix_socket_path;
67		bool m_is_unix_socket;
68		bool m_tor_stream_isolation;
69
70		bool IsValid() const
71	144k	{
72	144k	if (m_is_unix_socket) return IsUnixSocketPath(m_unix_socket_path); Branch (72:13): [True: 0, False: 144k]
73	144k	return proxy.IsValid();
74	144k	}
75
76		sa_family_t GetFamily() const
77	0	{
78	0	if (m_is_unix_socket) return AF_UNIX;
79	0	return proxy.GetSAFamily();
80	0	}
81
82		std::string ToString() const
83	0	{
84	0	if (m_is_unix_socket) return m_unix_socket_path; Branch (84:13): [True: 0, False: 0]
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		class ReachableNets {
102		public:
103		void Add(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
104	0	{
105	0	AssertLockNotHeld(m_mutex);
106	0	LOCK(m_mutex);
107	0	m_reachable.insert(net);
108	0	}
109
110		void Remove(Network net) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
111	33.2k	{
112	33.2k	AssertLockNotHeld(m_mutex);
113	33.2k	LOCK(m_mutex);
114	33.2k	m_reachable.erase(net);
115	33.2k	}
116
117		void RemoveAll() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
118	0	{
119	0	AssertLockNotHeld(m_mutex);
120	0	LOCK(m_mutex);
121	0	m_reachable.clear();
122	0	}
123
124		[[nodiscard]] bool Contains(Network net) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
125	105k	{
126	105k	AssertLockNotHeld(m_mutex);
127	105k	LOCK(m_mutex);
128	105k	return m_reachable.count(net) > 0;
129	105k	}
130
131		[[nodiscard]] bool Contains(const CNetAddr& addr) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
132	6.32k	{
133	6.32k	AssertLockNotHeld(m_mutex);
134	6.32k	return Contains(addr.GetNetwork());
135	6.32k	}
136
137		[[nodiscard]] std::unordered_set<Network> All() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
138	19.9k	{
139	19.9k	AssertLockNotHeld(m_mutex);
140	19.9k	LOCK(m_mutex);
141	19.9k	return m_reachable;
142	19.9k	}
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 // BITCOIN_NETBASE_H