[WPE][GTK][WebRTC] Support for UDP ports range configuration

https://bugs.webkit.org/show_bug.cgi?id=280330

Reviewed by Xabier Rodriguez-Calvar.

In some constrained environments where a firewall blocks UDP network traffic excepted on a
specific port range, this settings can be used to give hints to the WebRTC backend regarding
which ports to allocate. The format is min-port:max-port, so for instance 20000:30000. The
default value is 0:0 which means the OS will use no hints from the WebRTC backend.

* Source/WTF/Scripts/Preferences/UnifiedWebPreferences.yaml:
* Source/WebCore/platform/mediastream/WebRTCProvider.cpp:
(WebCore::WebRTCProvider::setPortAllocatorRange):
* Source/WebCore/platform/mediastream/WebRTCProvider.h:
* Source/WebCore/platform/mediastream/libwebrtc/LibWebRTCProvider.cpp:
(WebCore::LibWebRTCProvider::createPeerConnection):
* Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp:
(_WebKitSettingsPrivate::_WebKitSettingsPrivate):
(webKitSettingsSetProperty):
(webKitSettingsGetProperty):
(webkit_settings_class_init):
(webkit_settings_get_webrtc_udp_ports_range):
(webkit_settings_set_webrtc_udp_ports_range):
* Source/WebKit/UIProcess/API/glib/WebKitSettings.h.in:
* Source/WebKit/WebProcess/Network/webrtc/LibWebRTCProvider.cpp:
(WebKit::LibWebRTCProvider::LibWebRTCProvider):
* Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp:
(testWebKitSettings):

Canonical link: https://commits.webkit.org/285190@main

Author: philn

Source/WTF/Scripts/Preferences/WebPreferences.yaml

@@ -2588,6 +2588,21 @@ WebMParserEnabled:
     WebKit:
       default: true
 
+WebRTCUDPPortRange:
+  type: String
+  status: embedder
+  category: media
+  humanReadableName: "WebRTC UDP Port Range"
+  humanReadableDescription: "Set a UDP port range for WebRTC. If set to 0:0, the port range is determined by the OS"
+  condition: ENABLE(WEB_RTC)
+  defaultValue:
+    WebKitLegacy:
+      default: '"0:0"_str'
+    WebKit:
+      default: '"0:0"_str'
+    WebCore:
+      default: '"0:0"_str'
+
 WebSecurityEnabled:
   type: bool
   inspectorOverride: true

Source/WebCore/platform/mediastream/WebRTCProvider.cpp

@@ -34,6 +34,7 @@
 
 #include <wtf/Function.h>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/text/StringToIntegerConversion.h>
 
 namespace WebCore {
 
@@ -307,4 +308,29 @@ std::optional<MediaCapabilitiesEncodingInfo> WebRTCProvider::videoEncodingCapabi
     return { };
 }
 
+void WebRTCProvider::setPortAllocatorRange(StringView range)
+{
+    auto components = range.toStringWithoutCopying().split(':');
+    if (UNLIKELY(components.size() != 2)) {
+        WTFLogAlways("Invalid format for UDP port range. Should be \"min-port:max-port\"");
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    auto minPort = WTF::parseInteger<int>(components[0]).value_or(0);
+    auto maxPort = WTF::parseInteger<int>(components[1]).value_or(0);
+    if (!minPort || !maxPort) {
+        WTFLogAlways("Invalid format for UDP port range. Should be \"min-port:max-port\"");
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    m_portAllocatorRange = { { minPort, maxPort } };
+}
+
+std::optional<std::pair<int, int>> WebRTCProvider::portAllocatorRange() const
+{
+    return m_portAllocatorRange;
+}
+
 } // namespace WebCore

Source/WebCore/platform/mediastream/WebRTCProvider.h

@@ -81,6 +81,9 @@ class WEBCORE_EXPORT WebRTCProvider {
     virtual void setLoggingLevel(WTFLogLevel);
     virtual void clearFactory();
 
+    void setPortAllocatorRange(StringView);
+    std::optional<std::pair<int, int>> portAllocatorRange() const;
+
 protected:
 #if ENABLE(WEB_RTC)
     std::optional<RTCRtpCapabilities>& audioDecodingCapabilities();
@@ -107,6 +110,8 @@ class WEBCORE_EXPORT WebRTCProvider {
     bool m_supportsVP9Profile2 { false };
     bool m_supportsMDNS { false };
 
+    std::optional<std::pair<int, int>> m_portAllocatorRange;
+
 private:
     virtual void initializeAudioDecodingCapabilities();
     virtual void initializeVideoDecodingCapabilities();

Source/WebCore/platform/mediastream/libwebrtc/LibWebRTCProvider.cpp

@@ -399,6 +399,9 @@ rtc::scoped_refptr<webrtc::PeerConnectionInterface> LibWebRTCProvider::createPee
     if (!factory)
         return nullptr;
 
+    if (auto portRange = portAllocatorRange())
+        portAllocator->SetPortRange(portRange->first, portRange->second);
+
     webrtc::PeerConnectionDependencies dependencies { &observer };
     dependencies.allocator = WTFMove(portAllocator);
     dependencies.async_resolver_factory = WTFMove(asyncResolveFactory);

Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp

@@ -67,6 +67,9 @@ struct _WebKitSettingsPrivate {
         fantasyFontFamily = preferences->fantasyFontFamily().utf8();
         pictographFontFamily = preferences->pictographFontFamily().utf8();
         defaultCharset = preferences->defaultTextEncodingName().utf8();
+#if ENABLE(WEB_RTC)
+        webrtcUDPPortsRange = preferences->webRTCUDPPortRange().utf8();
+#endif
     }
 
     RefPtr<WebPreferences> preferences;
@@ -80,6 +83,9 @@ struct _WebKitSettingsPrivate {
     CString defaultCharset;
     CString userAgent;
     CString mediaContentTypesRequiringHardwareSupport;
+#if ENABLE(WEB_RTC)
+    CString webrtcUDPPortsRange;
+#endif
     bool allowModalDialogs { false };
     bool zoomTextOnly { false };
 #if PLATFORM(GTK)
@@ -181,6 +187,7 @@ enum {
     PROP_ENABLE_DIRECTORY_UPLOAD,
     PROP_ENABLE_SERVICE_WORKER,
     PROP_ENABLE_ICE_CANDIDATE_FILTERING,
+    PROP_WEBRTC_UDP_PORTS_RANGE,
     N_PROPERTIES,
 };
 
@@ -438,6 +445,9 @@ ALLOW_DEPRECATED_DECLARATIONS_END
     case PROP_ENABLE_ICE_CANDIDATE_FILTERING:
         webkit_settings_set_enable_ice_candidate_filtering(settings, g_value_get_boolean(value));
         break;
+    case PROP_WEBRTC_UDP_PORTS_RANGE:
+        webkit_settings_set_webrtc_udp_ports_range(settings, g_value_get_string(value));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
         break;
@@ -666,6 +676,9 @@ ALLOW_DEPRECATED_DECLARATIONS_END
     case PROP_ENABLE_ICE_CANDIDATE_FILTERING:
         g_value_set_boolean(value, webkit_settings_get_enable_ice_candidate_filtering(settings));
         break;
+    case PROP_WEBRTC_UDP_PORTS_RANGE:
+        g_value_set_string(value, webkit_settings_get_webrtc_udp_ports_range(settings));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
         break;
@@ -1774,6 +1787,25 @@ static void webkit_settings_class_init(WebKitSettingsClass* klass)
         TRUE,
         readWriteConstructParamFlags);
 
+    /**
+     * WebKitSettings:webrtc-udp-ports-range:
+     *
+     * Allow customization of the WebRTC UDP ports range.
+     *
+     * In some constrained environments where a firewall blocks UDP network traffic excepted on a
+     * specific port range, this settings can be used to give hints to the WebRTC backend regarding
+     * which ports to allocate. The format is min-port:max-port, so for instance 20000:30000. The
+     * default value is 0:0 which means the OS will use no hints from the WebRTC backend.
+     *
+     * Since: 2.48
+     */
+    sObjProperties[PROP_WEBRTC_UDP_PORTS_RANGE] = g_param_spec_string(
+        "webrtc-udp-ports-range",
+        _("WebRTC UDP ports range"),
+        _("WebRTC UDP ports range, the format is min-port:max-port"),
+        nullptr, // A null string forces the default value.
+        readWriteConstructParamFlags);
+
     g_object_class_install_properties(gObjectClass, N_PROPERTIES, sObjProperties);
 }
 
@@ -4466,3 +4498,51 @@ void webkit_settings_set_enable_ice_candidate_filtering(WebKitSettings* settings
     priv->preferences->setICECandidateFilteringEnabled(enabled);
     g_object_notify(G_OBJECT(settings), "enable-ice-candidate-filtering");
 }
+
+/**
+ * webkit_settings_get_webrtc_udp_ports_range:
+ * @settings: a #WebKitSettings
+ *
+ * Get the [property@Settings:webrtc-udp-ports-range] property.
+ *
+ * Returns: The WebRTC UDP ports range, or %NULL if un-set.
+ *
+ * Since: 2.48
+ */
+const gchar*
+webkit_settings_get_webrtc_udp_ports_range(WebKitSettings* settings)
+{
+    g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
+#if ENABLE(WEB_RTC)
+    return settings->priv->webrtcUDPPortsRange.data();
+#else
+    return nullptr;
+#endif
+}
+
+/**
+ * webkit_settings_set_webrtc_udp_ports_range:
+ * @settings: a #WebKitSettings
+ * @udp_port_range: Value to be set
+ *
+ * Set the [property@Settings:webrtc-udp-ports-range] property.
+ *
+ * Since: 2.48
+ */
+void
+webkit_settings_set_webrtc_udp_ports_range(WebKitSettings* settings, const gchar* udpPortsRange)
+{
+    g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
+#if ENABLE(WEB_RTC)
+    WebKitSettingsPrivate* priv = settings->priv;
+    if (!g_strcmp0(priv->webrtcUDPPortsRange.data(), udpPortsRange))
+        return;
+
+    auto portRange = String::fromLatin1(udpPortsRange);
+    priv->preferences->setWebRTCUDPPortRange(portRange);
+    priv->webrtcUDPPortsRange = portRange.utf8();
+    g_object_notify_by_pspec(G_OBJECT(settings), sObjProperties[PROP_WEBRTC_UDP_PORTS_RANGE]);
+#else
+    UNUSED_PARAM(udpPortsRange);
+#endif
+}

Source/WebKit/UIProcess/API/gtk/WebKitSettings.h

@@ -522,6 +522,20 @@ WEBKIT_API void
 webkit_settings_set_enable_webrtc                              (WebKitSettings *settings,
                                                                 gboolean enabled);
 
+WEBKIT_API gboolean
+webkit_settings_get_disable_web_security                       (WebKitSettings *settings);
+
+WEBKIT_API void
+webkit_settings_set_disable_web_security                       (WebKitSettings *settings,
+                                                                gboolean        disabled);
+
+WEBKIT_API const gchar*
+webkit_settings_get_webrtc_udp_ports_range                     (WebKitSettings *settings);
+
+WEBKIT_API void
+webkit_settings_set_webrtc_udp_ports_range                     (WebKitSettings *settings,
+                                                                const gchar    *udp_port_range);
+
 G_END_DECLS
 
 #endif /* WebKitSettings_h */

Source/WebKit/UIProcess/API/wpe/WebKitSettings.h

@@ -540,6 +540,13 @@ WEBKIT_API void
 webkit_settings_set_enable_ice_candidate_filtering             (WebKitSettings *settings,
                                                                 gboolean        enabled);
 
+WEBKIT_API const gchar*
+webkit_settings_get_webrtc_udp_ports_range                     (WebKitSettings *settings);
+
+WEBKIT_API void
+webkit_settings_set_webrtc_udp_ports_range                     (WebKitSettings *settings,
+                                                                const gchar    *udp_port_range);
+
 G_END_DECLS
 
 #endif /* WebKitSettings_h */

Source/WebKit/WebProcess/Network/webrtc/LibWebRTCProvider.cpp

@@ -73,6 +73,12 @@ LibWebRTCProvider::LibWebRTCProvider(WebPage& webPage)
 #else
     m_supportsMDNS = true;
 #endif
+
+    auto* page = webPage.corePage();
+    if (!page || !page->settings().webRTCUDPPortRange())
+        return;
+
+    setPortAllocatorRange(page->settings().webRTCUDPPortRange());
 }
 
 rtc::scoped_refptr<webrtc::PeerConnectionInterface> LibWebRTCProvider::createPeerConnection(ScriptExecutionContextIdentifier identifier, webrtc::PeerConnectionObserver& observer, rtc::PacketSocketFactory* socketFactory, webrtc::PeerConnectionInterface::RTCConfiguration&& configuration)

Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp

@@ -383,6 +383,12 @@ ALLOW_DEPRECATED_DECLARATIONS_END
     webkit_settings_set_disable_web_security(settings, TRUE);
     g_assert_true(webkit_settings_get_disable_web_security(settings));
 
+#if ENABLE(WEB_RTC)
+    g_assert_cmpstr("", ==, webkit_settings_get_webrtc_udp_ports_range(settings));
+    webkit_settings_set_webrtc_udp_ports_range(settings, "20000:30000");
+    g_assert_cmpstr("20000:30000", ==, webkit_settings_get_webrtc_udp_ports_range(settings));
+#endif
+
     g_object_unref(G_OBJECT(settings));
 }