feat: add callback for unhandled STUN requests

include/rtc/global.hpp

@@ -34,6 +34,22 @@ RTC_CPP_EXPORT void InitLogger(LogLevel level, LogCallback callback = nullptr);
 RTC_CPP_EXPORT void Preload();
 RTC_CPP_EXPORT std::shared_future<void> Cleanup();
 
+struct UnhandledStunRequest {
+	std::string localUfrag;
+	std::string remoteUfrag;
+	std::string remoteHost;
+	uint16_t remotePort;
+};
+
+RTC_CPP_EXPORT typedef std::function<void(UnhandledStunRequest request, void* userPtr)> UnhandledStunRequestCallback;
+
+struct UnhandledStunRequestHandler {
+	UnhandledStunRequestCallback callback;
+	void *userPtr;
+};
+
+RTC_CPP_EXPORT void OnUnhandledStunRequest(std::string host, int port, UnhandledStunRequestCallback callback = nullptr, void *userPtr = nullptr);
+
 struct SctpSettings {
 	// For the following settings, not set means optimized default
 	optional<size_t> recvBufferSize;                // in bytes

include/rtc/rtc.h

@@ -172,6 +172,20 @@ typedef void(RTC_API *rtcAvailableCallbackFunc)(int id, void *ptr);
 typedef void(RTC_API *rtcPliHandlerCallbackFunc)(int tr, void *ptr);
 typedef void(RTC_API *rtcRembHandlerCallbackFunc)(int tr, unsigned int bitrate, void *ptr);
 
+// Handle STUN requests with unexpected ufrags
+
+typedef struct {
+	const char * ufrag;
+	const char * pwd;
+	uint8_t family;
+	const char * address;
+	uint16_t port;
+} rtcUnhandledStunRequest;
+
+typedef void(RTC_API *rtcUnhandledStunRequestCallbackFunc)(rtcUnhandledStunRequest request);
+
+RTC_C_EXPORT void rtcOnUnhandledStunRequest(const char *host, int port, rtcUnhandledStunRequestCallbackFunc callback);
+
 // Log
 
 // NULL cb on the first call will log to stdout

src/global.cpp

@@ -19,6 +19,11 @@
 #include "impl/init.hpp"
 
 #include <mutex>
+#include <map>
+
+#if !USE_NICE
+#include <juice/juice.h>
+#endif
 
 namespace {
 
@@ -88,6 +93,61 @@ std::shared_future<void> Cleanup() { return impl::Init::Instance().cleanup(); }
 
 void SetSctpSettings(SctpSettings s) { impl::Init::Instance().setSctpSettings(std::move(s)); }
 
+std::map<int, UnhandledStunRequestHandler *> unboundStunCallbacks;
+
+#if !USE_NICE
+
+void InvokeUnhandledStunRequestCallback (const juice_mux_binding_request *info, void *user_ptr) {
+	PLOG_DEBUG << "Invoking unhandled STUN request callback";
+
+	UnhandledStunRequestHandler *handler = (struct UnhandledStunRequestHandler*)user_ptr;
+
+	if (handler->callback) {
+		handler->callback({
+			std::string(info->local_ufrag),
+			std::string(info->remote_ufrag),
+			std::string(info->address),
+			info->port
+		}, handler->userPtr);
+	} else {
+		PLOG_DEBUG << "No unhandled STUN request callback configured for port " << info->port;
+	}
+}
+
+#endif
+
+void OnUnhandledStunRequest ([[maybe_unused]] std::string host, [[maybe_unused]] int port, [[maybe_unused]] UnhandledStunRequestCallback callback, [[maybe_unused]] void *userPtr) {
+	#if USE_NICE
+		PLOG_WARNING << "BindStunListener is not supported with libnice, please use libjuice";
+	#else
+	if (callback == NULL) {
+		PLOG_DEBUG << "Removing unhandled STUN request listener";
+
+		free(unboundStunCallbacks.at(port));
+		unboundStunCallbacks.erase(port);
+
+		// call with NULL callback to unbind
+		if (juice_mux_listen(host.c_str(), port, NULL, NULL) < 0) {
+			throw std::runtime_error("Could not unbind STUN listener");
+		}
+
+		return;
+	}
+
+	PLOG_DEBUG << "Adding listener for unhandled STUN requests";
+
+	UnhandledStunRequestHandler *handler = (UnhandledStunRequestHandler*)calloc(1, sizeof(UnhandledStunRequestHandler));
+	handler->callback = std::move(callback);
+	handler->userPtr = userPtr;
+
+	unboundStunCallbacks[port] = handler;
+
+	if (juice_mux_listen(host.c_str(), port, &InvokeUnhandledStunRequestCallback, handler) < 0) {
+		throw std::invalid_argument("Could not add listener for unhandled STUN requests");
+	}
+	#endif
+}
+
 RTC_CPP_EXPORT std::ostream &operator<<(std::ostream &out, LogLevel level) {
 	switch (level) {
 	case LogLevel::Fatal: