Add UPnP support via miniupnpc

Author: Fulgen301

CMakeLists.txt

@@ -95,6 +95,8 @@ CMAKE_DEPENDENT_OPTION(WITH_DEVELOPER_MODE "Use GTK for the developer mode" OFF
 	"NOT USE_CONSOLE" OFF)
 # USE_LIBNOTIFY
 CMAKE_DEPENDENT_OPTION(USE_LIBNOTIFY "Use libnotify for desktop notifications" ON "WITH_DEVELOPER_MODE AND NOT USE_CONSOLE AND NOT WIN32" OFF)
+# USE_MINIUPNPC
+option(USE_MINIUPNPC "Use miniupnpc for UPnP support" ON)
 # USE_WINDOWS_RUNTIME
 CMAKE_DEPENDENT_OPTION(USE_WINDOWS_RUNTIME "Use Windows Runtime features" ON "WIN32" OFF)
 
@@ -242,6 +244,10 @@ if (USE_LIBNOTIFY)
 		src/C4ToastLibNotify.cpp src/C4ToastLibNotify.h)
 endif ()
 
+if (USE_MINIUPNPC)
+	list(APPEND CLONK_SOURCES src/C4Network2UPnPMiniUPnPc.cpp)
+endif ()
+
 if (USE_WINDOWS_RUNTIME)
 	list(APPEND CLONK_SOURCES
 		src/C4ToastWinRT.cpp src/C4ToastWinRT.h)
@@ -426,6 +432,12 @@ if (USE_LIBNOTIFY)
 	target_link_libraries(clonk PkgConfig::libnotify)
 endif ()
 
+# Link miniupnpc
+if (USE_MINIUPNPC)
+	find_package(miniupnpc CONFIG REQUIRED)
+	target_link_libraries(clonk miniupnpc::miniupnpc)
+endif ()
+
 # Link Windows libraries
 if (WIN32)
 	target_link_libraries(clonk dbghelp dwmapi iphlpapi winmm ws2_32)

cmake/filelists/Engine.txt

@@ -196,6 +196,7 @@ src/C4Network2Res.h
 src/C4Network2ResDlg.cpp
 src/C4Network2Stats.cpp
 src/C4Network2Stats.h
+src/C4Network2UPnP.h
 src/C4NumberParsing.h
 src/C4Object.cpp
 src/C4Object.h

src/C4Network2IO.cpp

@@ -20,6 +20,7 @@
 #include <C4Network2Reference.h>
 
 #include <C4Network2Discover.h>
+#include "C4Network2UPnP.h"
 #include <C4Application.h>
 #include <C4UserMessages.h>
 #include <C4Log.h>
@@ -106,18 +107,23 @@ bool C4Network2IO::Init(std::shared_ptr<spdlog::logger> logger, const std::uint1
 	Thread.SetCallback(Ev_Net_Disconn, this);
 	Thread.SetCallback(Ev_Net_Packet, this);
 
+	// initialize UPnP
+	UPnP = std::make_unique<C4Network2UPnP>();
+
 	// initialize net i/o classes: TCP first
 	pNetIO_TCP = CreateNetIO(this->logger, "TCP I/O", new C4NetIOTCP{}, iPortTCP, Thread);
 	if (pNetIO_TCP)
 	{
 		pNetIO_TCP->SetCallback(this);
+		UPnP->AddMapping(P_TCP, iPortTCP, 0);
 	}
 
 	// then UDP
 	pNetIO_UDP = CreateNetIO(this->logger, "UDP I/O", new C4NetIOUDP{}, iPortUDP, Thread);
 	if (pNetIO_UDP)
 	{
 		pNetIO_UDP->SetCallback(this);
+		UPnP->AddMapping(P_UDP, iPortUDP, 0);
 	}
 
 	// no protocols?
@@ -177,6 +183,8 @@ void C4Network2IO::Clear() // by main thread
 	if (pNetIO_TCP)     { Thread.RemoveProc(pNetIO_TCP);     delete pNetIO_TCP;     pNetIO_TCP     = nullptr; }
 	if (pNetIO_UDP)     { Thread.RemoveProc(pNetIO_UDP);     delete pNetIO_UDP;     pNetIO_UDP     = nullptr; }
 	if (pRefServer)     { Thread.RemoveProc(pRefServer);     delete pRefServer;     pRefServer     = nullptr; }
+	// clear UPnP
+	UPnP.reset();
 	// remove auto-accepts
 	ClearAutoAccept();
 	// reset flags

src/C4Network2IO.h

@@ -56,6 +56,9 @@ class C4Network2IO
 	// discovery net i/o
 	class C4Network2IODiscover *pNetIODiscover;
 
+	// UPnP
+	std::unique_ptr<class C4Network2UPnP> UPnP;
+
 	// reference server
 	class C4Network2RefServer *pRefServer;
 

src/C4Network2UPnP.h

@@ -0,0 +1,37 @@
+/*
+ * LegacyClonk
+ *
+ * Copyright (c) 2022, The LegacyClonk Team and contributors
+ *
+ * Distributed under the terms of the ISC license; see accompanying file
+ * "COPYING" for details.
+ *
+ * "Clonk" is a registered trademark of Matthes Bender, used with permission.
+ * See accompanying file "TRADEMARK" for details.
+ *
+ * To redistribute this file separately, substitute the full license texts
+ * for the above references.
+ */
+
+#pragma once
+
+#include "C4Network2IO.h"
+
+#include <memory>
+
+class C4Network2UPnP
+{
+private:
+	struct Impl;
+
+public:
+	C4Network2UPnP();
+	~C4Network2UPnP() noexcept;
+
+public:
+	void AddMapping(C4Network2IOProtocol protocol, std::uint16_t internalPort, std::uint16_t externalPort);
+	void ClearMappings();
+
+private:
+	const std::unique_ptr<Impl> impl;
+};

src/C4Network2UPnPMiniUPnPc.cpp

@@ -0,0 +1,243 @@
+/*
+ * LegacyClonk
+ *
+ * Copyright (c) 2022, The LegacyClonk Team and contributors
+ *
+ * Distributed under the terms of the ISC license; see accompanying file
+ * "COPYING" for details.
+ *
+ * "Clonk" is a registered trademark of Matthes Bender, used with permission.
+ * See accompanying file "TRADEMARK" for details.
+ *
+ * To redistribute this file separately, substitute the full license texts
+ * for the above references.
+ */
+
+#include "C4Application.h"
+#include "C4Network2UPnP.h"
+#include "C4Strings.h"
+
+#include <array>
+#include <future>
+#include <limits>
+
+#include "miniupnpc/miniupnpc.h"
+#include "miniupnpc/upnpcommands.h"
+#include "miniupnpc/upnperrors.h"
+
+struct C4Network2UPnP::Impl
+{
+private:
+	struct PortMapping
+	{
+		std::array<char, 4> Protocol;
+		std::array<char, C4Strings::NumberOfCharactersForDigits<std::uint16_t> + 1> InternalPort;
+		std::array<char, C4Strings::NumberOfCharactersForDigits<std::uint16_t> + 1> ExternalPort;
+
+		PortMapping(const C4Network2IOProtocol protocol, const std::uint16_t internalPort, const std::uint16_t externalPort)
+		{
+			if (protocol == P_TCP)
+			{
+				Protocol = {"TCP"};
+			}
+			else
+			{
+				Protocol = {"UDP"};
+			}
+
+			*std::to_chars(InternalPort.data(), InternalPort.data() + InternalPort.size() - 1, internalPort).ptr = '\0';
+			*std::to_chars(ExternalPort.data(), ExternalPort.data() + ExternalPort.size() - 1, externalPort).ptr = '\0';
+		}
+	};
+
+public:
+	Impl() : logger{CreateLogger("C4Network2UPnP", {.ShowLoggerNameInGui = true})}
+	{
+		action = std::async([this]
+		{
+			logger->debug("Discovering devices");
+			int error;
+			const C4DeleterFunctionUniquePtr<&freeUPNPDevlist> deviceList{upnpDiscover(DiscoveryDelay, nullptr, nullptr, UPNP_LOCAL_PORT_ANY, 0, 2, &error)};
+
+			if (!deviceList)
+			{
+				logger->error("Failed to get device list: {}", ([error]
+					{
+						switch (error)
+						{
+						case UPNPDISCOVER_SUCCESS:
+							return "Success";
+
+						case UPNPDISCOVER_UNKNOWN_ERROR:
+							return "Unknown error";
+
+						case UPNPDISCOVER_SOCKET_ERROR:
+							return "Socket error";
+
+						case UPNPDISCOVER_MEMORY_ERROR:
+							return "Memory error";
+
+						default:
+							return "Invalid error";
+						}
+					})());
+
+				return;
+			}
+
+			if (const int status{UPNP_GetValidIGD(deviceList.get(), &urls, &igdData, lanAddress.data(), lanAddress.size())}; !status)
+			{
+				logger->error("Could not find valid IGD");
+			}
+		});
+	}
+
+	~Impl()
+	{
+		if (urls.controlURL)
+		{
+			FreeUPNPUrls(&urls);
+		}
+	}
+
+	void AddMapping(const C4Network2IOProtocol protocol, std::uint16_t internalPort, std::uint16_t externalPort)
+	{
+		action = std::async([=,this, action = std::move(action)]
+		{
+			action.wait();
+
+			if (!IsInitialized())
+			{
+				return;
+			}
+
+			PortMapping mapping{protocol, internalPort, externalPort > 0 ? externalPort : internalPort};
+
+			decltype(mapping.ExternalPort) externalPortBuffer{mapping.ExternalPort};
+
+			const std::tuple arguments{
+				urls.controlURL,
+				igdData.first.servicetype,
+				externalPortBuffer.data(),
+				mapping.InternalPort.data(),
+				lanAddress.data(),
+				STD_PRODUCT,
+				mapping.Protocol.data(),
+				nullptr,
+				nullptr
+			};
+
+			const int result{externalPort == 0
+						? std::apply(&UPNP_AddAnyPortMapping, std::tuple_cat(arguments, std::make_tuple(mapping.ExternalPort.data())))
+						: std::apply(&UPNP_AddPortMapping, arguments)};
+
+			if (result == UPNPCOMMAND_SUCCESS)
+			{
+				logger->info(
+							"Added port mapping {} {} -> {}:{}",
+							mapping.Protocol.data(),
+							mapping.ExternalPort.data(),
+							lanAddress.data(),
+							mapping.InternalPort.data()
+							);
+
+				mapping.ExternalPort = std::move(externalPortBuffer);
+				mappings.emplace_back(std::move(mapping));
+			}
+			else
+			{
+				logger->error(
+							"Failed to add port mapping {} {} -> {}:{}: {}",
+							mapping.Protocol.data(),
+							mapping.ExternalPort.data(),
+							lanAddress.data(),
+							mapping.InternalPort.data(),
+							strupnperror(result)
+							);
+			}
+		});
+	}
+
+	void ClearMappings()
+	{
+		action = std::async([this, action = std::move(action)]
+		{
+			action.wait();
+
+			if (!IsInitialized())
+			{
+				return;
+			}
+
+			for (const auto &mapping : mappings)
+			{
+				const int result{UPNP_DeletePortMapping(
+								urls.controlURL,
+								igdData.first.servicetype,
+								mapping.ExternalPort.data(),
+								mapping.Protocol.data(),
+								nullptr
+								)};
+				if (result == UPNPCOMMAND_SUCCESS)
+				{
+					logger->info("Removed port mapping {} {} -> {}:{}",
+								mapping.Protocol.data(),
+								mapping.ExternalPort.data(),
+								lanAddress.data(),
+								mapping.InternalPort.data()
+								);
+
+					mappings.emplace_back(std::move(mapping));
+				}
+				else
+				{
+					logger->error("Failed to remove port mapping {} {} -> {}:{}: {}",
+								mapping.Protocol.data(),
+								mapping.ExternalPort.data(),
+								lanAddress.data(),
+								mapping.InternalPort.data(),
+								strupnperror(result)
+								);
+				}
+			}
+
+			mappings.clear();
+		});
+	}
+
+	bool IsInitialized() const
+	{
+		return urls.controlURL;
+	}
+
+private:
+	std::shared_ptr<spdlog::logger> logger;
+	std::future<void> action;
+	UPNPUrls urls{};
+	IGDdatas igdData;
+	std::array<char, 64> lanAddress;
+
+	std::vector<PortMapping> mappings;
+
+	static constexpr auto DiscoveryDelay = 2000;
+};
+
+C4Network2UPnP::C4Network2UPnP()
+	: impl{std::make_unique<Impl>()}
+{
+}
+
+C4Network2UPnP::~C4Network2UPnP() noexcept
+{
+	ClearMappings();
+}
+
+void C4Network2UPnP::AddMapping(const C4Network2IOProtocol protocol, const std::uint16_t internalPort, const std::uint16_t externalPort)
+{
+	impl->AddMapping(protocol, internalPort, externalPort);
+}
+
+void C4Network2UPnP::ClearMappings()
+{
+	impl->ClearMappings();
+}

src/C4ResStrTable.txt

@@ -757,6 +757,7 @@ IDS_MSG_TOPICIN=2
 IDS_MSG_TRYLEAGUESIGNUP=2
 IDS_MSG_UPDATEFAILED=0
 IDS_MSG_UPDATENOTAVAILABLE=0
+IDS_MSG_UPNPHINT=0
 IDS_MSG_USINGPLR=1
 IDS_MSG_USINGPLR_DESC=0
 IDS_MSG_WASKICKEDFROMTHECHANNEL=2