1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <netbase.h>
9
10#include <compat/compat.h>
11#include <sync.h>
12#include <tinyformat.h>
13#include <util/log.h>
14#include <util/sock.h>
15#include <util/strencodings.h>
16#include <util/string.h>
17#include <util/time.h>
18
19#include <atomic>
20#include <chrono>
21#include <cstdint>
22#include <functional>
23#include <limits>
24#include <memory>
25
26#ifdef HAVE_SOCKADDR_UN
27#include <sys/un.h>
28#endif
29
30using util::ContainsNUL;
31
32// Settings
33static GlobalMutex g_proxyinfo_mutex;
34static Proxy proxyInfo[NET_MAX] GUARDED_BY(g_proxyinfo_mutex);
35static Proxy nameProxy GUARDED_BY(g_proxyinfo_mutex);
36int nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
37bool fNameLookup = DEFAULT_NAME_LOOKUP;
38
39// Need ample time for negotiation for very slow proxies such as Tor
40std::chrono::milliseconds g_socks5_recv_timeout = 20s;
41CThreadInterrupt g_socks5_interrupt;
42
43ReachableNets g_reachable_nets;
44
45std::vector<CNetAddr> WrappedGetAddrInfo(const std::string& name, bool allow_lookup)
46{
47    addrinfo ai_hint{};
48    // We want a TCP port, which is a streaming socket type
49    ai_hint.ai_socktype = SOCK_STREAM;
50    ai_hint.ai_protocol = IPPROTO_TCP;
51    // We don't care which address family (IPv4 or IPv6) is returned
52    ai_hint.ai_family = AF_UNSPEC;
53
54    // If we allow lookups of hostnames, use the AI_ADDRCONFIG flag to only
55    // return addresses whose family we have an address configured for.
56    //
57    // If we don't allow lookups, then use the AI_NUMERICHOST flag for
58    // getaddrinfo to only decode numerical network addresses and suppress
59    // hostname lookups.
60    ai_hint.ai_flags = allow_lookup ? AI_ADDRCONFIG : AI_NUMERICHOST;
61
62    addrinfo* ai_res{nullptr};
63    const int n_err{getaddrinfo(name.c_str(), nullptr, &ai_hint, &ai_res)};
64    if (n_err != 0) {
65        if ((ai_hint.ai_flags & AI_ADDRCONFIG) == AI_ADDRCONFIG) {
66            // AI_ADDRCONFIG on some systems may exclude loopback-only addresses
67            // If first lookup failed we perform a second lookup without AI_ADDRCONFIG
68            ai_hint.ai_flags = (ai_hint.ai_flags & ~AI_ADDRCONFIG);
69            const int n_err_retry{getaddrinfo(name.c_str(), nullptr, &ai_hint, &ai_res)};
70            if (n_err_retry != 0) {
71                return {};
72            }
73        } else {
74            return {};
75        }
76    }
77
78    // Traverse the linked list starting with ai_trav.
79    addrinfo* ai_trav{ai_res};
80    std::vector<CNetAddr> resolved_addresses;
81    while (ai_trav != nullptr) {
82        if (ai_trav->ai_family == AF_INET) {
83            assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in));
84            resolved_addresses.emplace_back(reinterpret_cast<sockaddr_in*>(ai_trav->ai_addr)->sin_addr);
85        }
86        if (ai_trav->ai_family == AF_INET6) {
87            assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in6));
88            const sockaddr_in6* s6{reinterpret_cast<sockaddr_in6*>(ai_trav->ai_addr)};
89            resolved_addresses.emplace_back(s6->sin6_addr, s6->sin6_scope_id);
90        }
91        ai_trav = ai_trav->ai_next;
92    }
93    freeaddrinfo(ai_res);
94
95    return resolved_addresses;
96}
97
98DNSLookupFn g_dns_lookup{WrappedGetAddrInfo};
99
100enum Network ParseNetwork(const std::string& net_in) {
101    std::string net = ToLower(net_in);
102    if (net == "ipv4") return NET_IPV4;
103    if (net == "ipv6") return NET_IPV6;
104    if (net == "onion") return NET_ONION;
105    if (net == "i2p") {
106        return NET_I2P;
107    }
108    if (net == "cjdns") {
109        return NET_CJDNS;
110    }
111    return NET_UNROUTABLE;
112}
113
114std::string GetNetworkName(enum Network net)
115{
116    switch (net) {
117    case NET_UNROUTABLE: return "not_publicly_routable";
118    case NET_IPV4: return "ipv4";
119    case NET_IPV6: return "ipv6";
120    case NET_ONION: return "onion";
121    case NET_I2P: return "i2p";
122    case NET_CJDNS: return "cjdns";
123    case NET_INTERNAL: return "internal";
124    case NET_MAX: assert(false);
125    } // no default case, so the compiler can warn about missing cases
126
127    assert(false);
128}
129
130std::vector<std::string> GetNetworkNames(bool append_unroutable)
131{
132    std::vector<std::string> names;
133    for (int n = 0; n < NET_MAX; ++n) {
134        const enum Network network{static_cast<Network>(n)};
135        if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;
136        names.emplace_back(GetNetworkName(network));
137    }
138    if (append_unroutable) {
139        names.emplace_back(GetNetworkName(NET_UNROUTABLE));
140    }
141    return names;
142}
143
144static std::vector<CNetAddr> LookupIntern(const std::string& name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
145{
146    if (ContainsNUL(name)) return {};
147    {
148        CNetAddr addr;
149        // From our perspective, onion addresses are not hostnames but rather
150        // direct encodings of CNetAddr much like IPv4 dotted-decimal notation
151        // or IPv6 colon-separated hextet notation. Since we can't use
152        // getaddrinfo to decode them and it wouldn't make sense to resolve
153        // them, we return a network address representing it instead. See
154        // CNetAddr::SetSpecial(const std::string&) for more details.
155        if (addr.SetSpecial(name)) return {addr};
156    }
157
158    std::vector<CNetAddr> addresses;
159
160    for (const CNetAddr& resolved : dns_lookup_function(name, fAllowLookup)) {
161        if (nMaxSolutions > 0 && addresses.size() >= nMaxSolutions) {
162            break;
163        }
164        /* Never allow resolving to an internal address. Consider any such result invalid */
165        if (!resolved.IsInternal()) {
166            addresses.push_back(resolved);
167        }
168    }
169
170    return addresses;
171}
172
173std::vector<CNetAddr> LookupHost(const std::string& name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
174{
175    if (ContainsNUL(name)) return {};
176    std::string strHost = name;
177    if (strHost.empty()) return {};
178    if (strHost.front() == '[' && strHost.back() == ']') {
179        strHost = strHost.substr(1, strHost.size() - 2);
180    }
181
182    return LookupIntern(strHost, nMaxSolutions, fAllowLookup, dns_lookup_function);
183}
184
185std::optional<CNetAddr> LookupHost(const std::string& name, bool fAllowLookup, DNSLookupFn dns_lookup_function)
186{
187    const std::vector<CNetAddr> addresses{LookupHost(name, 1, fAllowLookup, dns_lookup_function)};
188    return addresses.empty() ? std::nullopt : std::make_optional(addresses.front());
189}
190
191std::vector<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, unsigned int nMaxSolutions, DNSLookupFn dns_lookup_function)
192{
193    if (name.empty() || ContainsNUL(name)) {
194        return {};
195    }
196    uint16_t port{portDefault};
197    std::string hostname;
198    SplitHostPort(name, port, hostname);
199
200    const std::vector<CNetAddr> addresses{LookupIntern(hostname, nMaxSolutions, fAllowLookup, dns_lookup_function)};
201    if (addresses.empty()) return {};
202    std::vector<CService> services;
203    services.reserve(addresses.size());
204    for (const auto& addr : addresses)
205        services.emplace_back(addr, port);
206    return services;
207}
208
209std::optional<CService> Lookup(const std::string& name, uint16_t portDefault, bool fAllowLookup, DNSLookupFn dns_lookup_function)
210{
211    const std::vector<CService> services{Lookup(name, portDefault, fAllowLookup, 1, dns_lookup_function)};
212
213    return services.empty() ? std::nullopt : std::make_optional(services.front());
214}
215
216CService LookupNumeric(const std::string& name, uint16_t portDefault, DNSLookupFn dns_lookup_function)
217{
218    if (ContainsNUL(name)) {
219        return {};
220    }
221    // "1.2:345" will fail to resolve the ip, but will still set the port.
222    // If the ip fails to resolve, re-init the result.
223    return Lookup(name, portDefault, /*fAllowLookup=*/false, dns_lookup_function).value_or(CService{});
224}
225
226bool IsUnixSocketPath(const std::string& name)
227{
228#ifdef HAVE_SOCKADDR_UN
229    if (!name.starts_with(ADDR_PREFIX_UNIX)) return false;
230
231    // Split off "unix:" prefix
232    std::string str{name.substr(ADDR_PREFIX_UNIX.length())};
233
234    // Path size limit is platform-dependent
235    // see https://manpages.ubuntu.com/manpages/xenial/en/man7/unix.7.html
236    if (str.size() + 1 > sizeof(((sockaddr_un*)nullptr)->sun_path)) return false;
237
238    return true;
239#else
240    return false;
241#endif
242}
243
244/** SOCKS version */
245enum SOCKSVersion: uint8_t {
246    SOCKS4 = 0x04,
247    SOCKS5 = 0x05
248};
249
250/** Values defined for METHOD in RFC1928 */