Bitcoin Core  22.99.0
P2P Digital Currency
mapport.cpp
Go to the documentation of this file.
1 // Copyright (c) 2011-2020 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 #if defined(HAVE_CONFIG_H)
7 #endif
8 
9 #include <mapport.h>
10 
11 #include <clientversion.h>
12 #include <logging.h>
13 #include <net.h>
14 #include <netaddress.h>
15 #include <netbase.h>
16 #include <threadinterrupt.h>
17 #include <util/system.h>
18 #include <util/thread.h>
19 
20 #ifdef USE_NATPMP
21 #include <compat.h>
22 #include <natpmp.h>
23 #endif // USE_NATPMP
24 
25 #ifdef USE_UPNP
26 #include <miniupnpc/miniupnpc.h>
27 #include <miniupnpc/upnpcommands.h>
28 #include <miniupnpc/upnperrors.h>
29 // The minimum supported miniUPnPc API version is set to 10. This keeps compatibility
30 // with Ubuntu 16.04 LTS and Debian 8 libminiupnpc-dev packages.
31 static_assert(MINIUPNPC_API_VERSION >= 10, "miniUPnPc API version >= 10 assumed");
32 #endif // USE_UPNP
33 
34 #include <atomic>
35 #include <cassert>
36 #include <chrono>
37 #include <functional>
38 #include <string>
39 #include <thread>
40 
41 #if defined(USE_NATPMP) || defined(USE_UPNP)
42 static CThreadInterrupt g_mapport_interrupt;
43 static std::thread g_mapport_thread;
44 static std::atomic_uint g_mapport_enabled_protos{MapPortProtoFlag::NONE};
45 static std::atomic<MapPortProtoFlag> g_mapport_current_proto{MapPortProtoFlag::NONE};
46 
47 using namespace std::chrono_literals;
48 static constexpr auto PORT_MAPPING_REANNOUNCE_PERIOD{20min};
49 static constexpr auto PORT_MAPPING_RETRY_PERIOD{5min};
50 
51 #ifdef USE_NATPMP
52 static uint16_t g_mapport_external_port = 0;
53 static bool NatpmpInit(natpmp_t* natpmp)
54 {
55  const int r_init = initnatpmp(natpmp, /* detect gateway automatically */ 0, /* forced gateway - NOT APPLIED*/ 0);
56  if (r_init == 0) return true;
57  LogPrintf("natpmp: initnatpmp() failed with %d error.\n", r_init);
58  return false;
59 }
60 
61 static bool NatpmpDiscover(natpmp_t* natpmp, struct in_addr& external_ipv4_addr)
62 {
63  const int r_send = sendpublicaddressrequest(natpmp);
64  if (r_send == 2 /* OK */) {
65  int r_read;
66  natpmpresp_t response;
67  do {
68  r_read = readnatpmpresponseorretry(natpmp, &response);
69  } while (r_read == NATPMP_TRYAGAIN);
70 
71  if (r_read == 0) {
72  external_ipv4_addr = response.pnu.publicaddress.addr;
73  return true;
74  } else if (r_read == NATPMP_ERR_NOGATEWAYSUPPORT) {
75  LogPrintf("natpmp: The gateway does not support NAT-PMP.\n");
76  } else {
77  LogPrintf("natpmp: readnatpmpresponseorretry() for public address failed with %d error.\n", r_read);
78  }
79  } else {
80  LogPrintf("natpmp: sendpublicaddressrequest() failed with %d error.\n", r_send);
81  }
82 
83  return false;
84 }
85 
86 static bool NatpmpMapping(natpmp_t* natpmp, const struct in_addr& external_ipv4_addr, uint16_t private_port, bool& external_ip_discovered)
87 {
88  const uint16_t suggested_external_port = g_mapport_external_port ? g_mapport_external_port : private_port;
89  const int r_send = sendnewportmappingrequest(natpmp, NATPMP_PROTOCOL_TCP, private_port, suggested_external_port, 3600 /*seconds*/);
90  if (r_send == 12 /* OK */) {
91  int r_read;
92  natpmpresp_t response;
93  do {
94  r_read = readnatpmpresponseorretry(natpmp, &response);
95  } while (r_read == NATPMP_TRYAGAIN);
96 
97  if (r_read == 0) {
98  auto pm = response.pnu.newportmapping;
99  if (private_port == pm.privateport && pm.lifetime > 0) {
100  g_mapport_external_port = pm.mappedpublicport;
101  const CService external{external_ipv4_addr, pm.mappedpublicport};
102  if (!external_ip_discovered && fDiscover) {
103  AddLocal(external, LOCAL_MAPPED);
104  external_ip_discovered = true;
105  }
106  LogPrintf("natpmp: Port mapping successful. External address = %s\n", external.ToString());
107  return true;
108  } else {
109  LogPrintf("natpmp: Port mapping failed.\n");
110  }
111  } else if (r_read == NATPMP_ERR_NOGATEWAYSUPPORT) {
112  LogPrintf("natpmp: The gateway does not support NAT-PMP.\n");
113  } else {
114  LogPrintf("natpmp: readnatpmpresponseorretry() for port mapping failed with %d error.\n", r_read);
115  }
116  } else {
117  LogPrintf("natpmp: sendnewportmappingrequest() failed with %d error.\n", r_send);
118  }
119 
120  return false;
121 }
122 
123 static bool ProcessNatpmp()
124 {
125  bool ret = false;
126  natpmp_t natpmp;
127  struct in_addr external_ipv4_addr;
128  if (NatpmpInit(&natpmp) && NatpmpDiscover(&natpmp, external_ipv4_addr)) {
129  bool external_ip_discovered = false;
130  const uint16_t private_port = GetListenPort();
131  do {
132  ret = NatpmpMapping(&natpmp, external_ipv4_addr, private_port, external_ip_discovered);
133  } while (ret && g_mapport_interrupt.sleep_for(PORT_MAPPING_REANNOUNCE_PERIOD));
134  g_mapport_interrupt.reset();
135 
136  const int r_send = sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_TCP, private_port, g_mapport_external_port, /* remove a port mapping */ 0);
137  g_mapport_external_port = 0;
138  if (r_send == 12 /* OK */) {
139  LogPrintf("natpmp: Port mapping removed successfully.\n");
140  } else {
141  LogPrintf("natpmp: sendnewportmappingrequest(0) failed with %d error.\n", r_send);
142  }
143  }
144 
145  closenatpmp(&natpmp);
146  return ret;
147 }
148 #endif // USE_NATPMP
149 
150 #ifdef USE_UPNP
151 static bool ProcessUpnp()
152 {
153  bool ret = false;
154  std::string port = strprintf("%u", GetListenPort());
155  const char * multicastif = nullptr;
156  const char * minissdpdpath = nullptr;
157  struct UPNPDev * devlist = nullptr;
158  char lanaddr[64];
159 
160  int error = 0;
161 #if MINIUPNPC_API_VERSION < 14
162  devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
163 #else
164  devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, 2, &error);
165 #endif
166 
167  struct UPNPUrls urls;
168  struct IGDdatas data;
169  int r;
170 
171  r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
172  if (r == 1)
173  {
174  if (fDiscover) {
175  char externalIPAddress[40];
176  r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
177  if (r != UPNPCOMMAND_SUCCESS) {
178  LogPrintf("UPnP: GetExternalIPAddress() returned %d\n", r);
179  } else {
180  if (externalIPAddress[0]) {
181  CNetAddr resolved;
182  if (LookupHost(externalIPAddress, resolved, false)) {
183  LogPrintf("UPnP: ExternalIPAddress = %s\n", resolved.ToString());
184  AddLocal(resolved, LOCAL_MAPPED);
185  }
186  } else {
187  LogPrintf("UPnP: GetExternalIPAddress failed.\n");
188  }
189  }
190  }
191 
192  std::string strDesc = PACKAGE_NAME " " + FormatFullVersion();
193 
194  do {
195  r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype, port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
196 
197  if (r != UPNPCOMMAND_SUCCESS) {
198  ret = false;
199  LogPrintf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n", port, port, lanaddr, r, strupnperror(r));
200  break;
201  } else {
202  ret = true;
203  LogPrintf("UPnP Port Mapping successful.\n");
204  }
205  } while (g_mapport_interrupt.sleep_for(PORT_MAPPING_REANNOUNCE_PERIOD));
206  g_mapport_interrupt.reset();
207 
208  r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "TCP", 0);
209  LogPrintf("UPNP_DeletePortMapping() returned: %d\n", r);
210  freeUPNPDevlist(devlist); devlist = nullptr;
211  FreeUPNPUrls(&urls);
212  } else {
213  LogPrintf("No valid UPnP IGDs found\n");
214  freeUPNPDevlist(devlist); devlist = nullptr;
215  if (r != 0)
216  FreeUPNPUrls(&urls);
217  }
218 
219  return ret;
220 }
221 #endif // USE_UPNP
222 
223 static void ThreadMapPort()
224 {
225  bool ok;
226  do {
227  ok = false;
228 
229 #ifdef USE_UPNP
230  // High priority protocol.
231  if (g_mapport_enabled_protos & MapPortProtoFlag::UPNP) {
232  g_mapport_current_proto = MapPortProtoFlag::UPNP;
233  ok = ProcessUpnp();
234  if (ok) continue;
235  }
236 #endif // USE_UPNP
237 
238 #ifdef USE_NATPMP
239  // Low priority protocol.
240  if (g_mapport_enabled_protos & MapPortProtoFlag::NAT_PMP) {
241  g_mapport_current_proto = MapPortProtoFlag::NAT_PMP;
242  ok = ProcessNatpmp();
243  if (ok) continue;
244  }
245 #endif // USE_NATPMP
246 
247  g_mapport_current_proto = MapPortProtoFlag::NONE;
248  if (g_mapport_enabled_protos == MapPortProtoFlag::NONE) {
249  return;
250  }
251 
252  } while (ok || g_mapport_interrupt.sleep_for(PORT_MAPPING_RETRY_PERIOD));
253 }
254 
255 void StartThreadMapPort()
256 {
257  if (!g_mapport_thread.joinable()) {
258  assert(!g_mapport_interrupt);
259  g_mapport_thread = std::thread(&util::TraceThread, "mapport", &ThreadMapPort);
260  }
261 }
262 
263 static void DispatchMapPort()
264 {
265  if (g_mapport_current_proto == MapPortProtoFlag::NONE && g_mapport_enabled_protos == MapPortProtoFlag::NONE) {
266  return;
267  }
268 
269  if (g_mapport_current_proto == MapPortProtoFlag::NONE && g_mapport_enabled_protos != MapPortProtoFlag::NONE) {
270  StartThreadMapPort();
271  return;
272  }
273 
274  if (g_mapport_current_proto != MapPortProtoFlag::NONE && g_mapport_enabled_protos == MapPortProtoFlag::NONE) {
276  StopMapPort();
277  return;
278  }
279 
280  if (g_mapport_enabled_protos & g_mapport_current_proto) {
281  // Enabling another protocol does not cause switching from the currently used one.
282  return;
283  }
284 
285  assert(g_mapport_thread.joinable());
286  assert(!g_mapport_interrupt);
287  // Interrupt a protocol-specific loop in the ThreadUpnp() or in the ThreadNatpmp()
288  // to force trying the next protocol in the ThreadMapPort() loop.
289  g_mapport_interrupt();
290 }
291 
292 static void MapPortProtoSetEnabled(MapPortProtoFlag proto, bool enabled)
293 {
294  if (enabled) {
295  g_mapport_enabled_protos |= proto;
296  } else {
297  g_mapport_enabled_protos &= ~proto;
298  }
299 }
300 
301 void StartMapPort(bool use_upnp, bool use_natpmp)
302 {
303  MapPortProtoSetEnabled(MapPortProtoFlag::UPNP, use_upnp);
304  MapPortProtoSetEnabled(MapPortProtoFlag::NAT_PMP, use_natpmp);
305  DispatchMapPort();
306 }
307 
308 void InterruptMapPort()
309 {
310  g_mapport_enabled_protos = MapPortProtoFlag::NONE;
311  if (g_mapport_thread.joinable()) {
312  g_mapport_interrupt();
313  }
314 }
315 
316 void StopMapPort()
317 {
318  if (g_mapport_thread.joinable()) {
319  g_mapport_thread.join();
320  g_mapport_interrupt.reset();
321  }
322 }
323 
324 #else // #if defined(USE_NATPMP) || defined(USE_UPNP)
325 void StartMapPort(bool use_upnp, bool use_natpmp)
326 {
327  // Intentionally left blank.
328 }
330 {
331  // Intentionally left blank.
332 }
334 {
335  // Intentionally left blank.
336 }
337 #endif // #if defined(USE_NATPMP) || defined(USE_UPNP)
CService
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:539
threadinterrupt.h
LookupHost
bool LookupHost(const std::string &name, std::vector< CNetAddr > &vIP, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
Definition: netbase.cpp:167
StartMapPort
void StartMapPort(bool use_upnp, bool use_natpmp)
Definition: mapport.cpp:325
assert
assert(!tx.IsCoinBase())
InterruptMapPort
void InterruptMapPort()
Definition: mapport.cpp:329
mapport.h
util::TraceThread
void TraceThread(const char *thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
Definition: thread.cpp:13
CThreadInterrupt::sleep_for
bool sleep_for(std::chrono::milliseconds rel_time)
Definition: threadinterrupt.cpp:31
CNetAddr
Network address.
Definition: netaddress.h:118
CNetAddr::ToString
std::string ToString() const
Definition: netaddress.cpp:631
clientversion.h
fDiscover
bool fDiscover
Definition: net.cpp:111
UPNP
@ UPNP
Definition: mapport.h:22
bitcoin-config.h
NAT_PMP
@ NAT_PMP
Definition: mapport.h:23
MapPortProtoFlag
MapPortProtoFlag
Definition: mapport.h:20
LOCAL_MAPPED
@ LOCAL_MAPPED
Definition: net.h:192
PACKAGE_NAME
#define PACKAGE_NAME
Definition: bitcoin-config.h:362
compat.h
netaddress.h
LogPrintf
#define LogPrintf(...)
Definition: logging.h:185
system.h
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
StopMapPort
void StopMapPort()
Definition: mapport.cpp:333
logging.h
CThreadInterrupt::reset
void reset()
Definition: threadinterrupt.cpp:17
netbase.h
FormatFullVersion
std::string FormatFullVersion()
Definition: clientversion.cpp:50
error
bool error(const char *fmt, const Args &... args)
Definition: system.h:49
net.h
GetListenPort
uint16_t GetListenPort()
Definition: net.cpp:124
CThreadInterrupt
Definition: threadinterrupt.h:19
thread.h
BCLog::NONE
@ NONE
Definition: logging.h:37
AddLocal
bool AddLocal(const CService &addr, int nScore)
Definition: net.cpp:233