Move WebRTCSignalingServer into Domain Server

domain-server/src/DomainServer.cpp

@@ -167,6 +167,10 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     _gatekeeper(this),
     _httpManager(QHostAddress::AnyIPv4, DOMAIN_SERVER_HTTP_PORT,
         QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this)
+#if defined(WEBRTC_DATA_CHANNELS)
+    ,
+    _webrtcSignalingServer(this)
+#endif
 {
     if (_parentPID != -1) {
         watchParentProcess(_parentPID);
@@ -248,6 +252,10 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     updateDownstreamNodes();
     updateUpstreamNodes();
 
+#if defined(WEBRTC_DATA_CHANNELS)
+    setUpWebRTCSignalingServer();
+#endif
+
     if (_type != NonMetaverse) {
         // if we have a metaverse domain, we'll use an access token for API calls
         resetAccountManagerAccessToken();
@@ -846,6 +854,38 @@ void DomainServer::setupNodeListAndAssignments() {
     addStaticAssignmentsToQueue();
 }
 
+
+#if defined(WEBRTC_DATA_CHANNELS)
+
+void DomainServer::setUpWebRTCSignalingServer() {
+    // Bind the WebRTC signaling server's WebSocket to its port.
+    bool isBound = _webrtcSignalingServer.bind(QHostAddress::AnyIPv4, DEFAULT_DOMAIN_SERVER_WS_PORT);
+    if (!isBound) {
+        qWarning() << "WebRTC signaling server not bound to port. WebRTC connections are not supported.";
+        return;
+    }
+
+    auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
+
+    // Route inbound WebRTC signaling messages received from user clients.
+    connect(&_webrtcSignalingServer, &WebRTCSignalingServer::messageReceived, 
+        this, &DomainServer::routeWebRTCSignalingMessage);
+
+    // Route domain server signaling messages.
+    auto webrtcSocket = limitedNodeList->getWebRTCSocket();
+    connect(this, &DomainServer::webrtcSignalingMessageForDomainServer, webrtcSocket, &WebRTCSocket::onSignalingMessage);
+    connect(webrtcSocket, &WebRTCSocket::sendSignalingMessage, &_webrtcSignalingServer, &WebRTCSignalingServer::sendMessage);
+}
+
+void DomainServer::routeWebRTCSignalingMessage(const QJsonObject& json) {
+    if (json.value("to").toString() == NodeType::DomainServer) {
+        emit webrtcSignalingMessageForDomainServer(json);
+    }
+}
+
+#endif
+
+
 bool DomainServer::resetAccountManagerAccessToken() {
     if (!_oauthProviderURL.isEmpty()) {
         // check for an access-token in our settings, can optionally be overidden by env value

domain-server/src/DomainServer.h

@@ -27,6 +27,8 @@
 #include <Assignment.h>
 #include <HTTPSConnection.h>
 #include <LimitedNodeList.h>
+#include <shared/WebRTC.h>
+#include <webrtc/WebRTCSignalingServer.h>
 
 #include "AssetsBackupHandler.h"
 #include "DomainGatekeeper.h"
@@ -155,6 +157,11 @@ signals:
     void userConnected();
     void userDisconnected();
 
+#if defined(WEBRTC_DATA_CHANNELS)
+    void webrtcSignalingMessageForDomainServer(const QJsonObject& json);
+#endif
+
+
 private:
     QUuid getID();
 
@@ -235,6 +242,11 @@ private:
                                     std::initializer_list<QString> optionalData = { },
                                     bool requireAccessToken = true);
 
+#if defined(WEBRTC_DATA_CHANNELS)
+    void setUpWebRTCSignalingServer();
+    void routeWebRTCSignalingMessage(const QJsonObject& json);
+#endif
+
     QString operationToString(const QNetworkAccessManager::Operation &op);
 
     SubnetList _acSubnetWhitelist;
@@ -312,6 +324,10 @@ private:
     std::unordered_map<int, std::unique_ptr<QTemporaryFile>> _pendingContentFiles;
 
     QThread _assetClientThread;
+
+#if defined(WEBRTC_DATA_CHANNELS)
+    WebRTCSignalingServer _webrtcSignalingServer;
+#endif
 };
 
 

ice-server/src/IceServer.cpp

@@ -16,6 +16,7 @@
 
 #include <QtCore/QDataStream>
 #include <QtCore/QJsonDocument>
+#include <QtCore/QJsonObject>
 #include <QtCore/QTimer>
 #include <QtNetwork/QNetworkReply>
 #include <QtNetwork/QNetworkRequest>

libraries/networking/src/BaseAssetScriptingInterface.cpp

@@ -9,8 +9,9 @@
 
 #include "BaseAssetScriptingInterface.h"
 
-#include <QJsonDocument>
 #include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
 #include <QMimeDatabase>
 #include <QThread>
 

libraries/networking/src/LimitedNodeList.cpp

@@ -74,7 +74,7 @@ LimitedNodeList::LimitedNodeList(char ownerType, int socketListenPort, int dtlsL
         qCDebug(networking) << "NodeList DTLS socket is listening on" << _dtlsSocket->localPort();
     }
 
-    _nodeSocket.bind(SocketType::WebRTC, QHostAddress::AnyIPv4, DEFAULT_DOMAIN_SERVER_WS_PORT);
+    _nodeSocket.bind(SocketType::WebRTC, QHostAddress::AnyIPv4);
 
     // check for local socket updates every so often
     const int LOCAL_SOCKET_UPDATE_INTERVAL_MSECS = 5 * 1000;
@@ -241,6 +241,12 @@ QUdpSocket& LimitedNodeList::getDTLSSocket() {
     return *_dtlsSocket;
 }
 
+#if defined(WEBRTC_DATA_CHANNELS)
+const WebRTCSocket* LimitedNodeList::getWebRTCSocket() {
+    return _nodeSocket.getWebRTCSocket();
+}
+#endif
+
 bool LimitedNodeList::isPacketVerifiedWithSource(const udt::Packet& packet, Node* sourceNode) {
     // We track bandwidth when doing packet verification to avoid needing to do a node lookup
     // later when we already do it in packetSourceAndHashMatchAndTrackBandwidth. A node lookup

libraries/networking/src/LimitedNodeList.h

@@ -37,7 +37,6 @@
 #include <DependencyManager.h>
 #include <SharedUtil.h>
 
-#include "DomainHandler.h"
 #include "NetworkingConstants.h"
 #include "Node.h"
 #include "NLPacket.h"
@@ -139,6 +138,10 @@ public:
     Q_INVOKABLE void setSocketLocalPort(SocketType socketType, quint16 socketLocalPort);
 
     QUdpSocket& getDTLSSocket();
+#if defined(WEBRTC_DATA_CHANNELS)
+    const WebRTCSocket* getWebRTCSocket();
+#endif
+
 
     PacketReceiver& getPacketReceiver() { return *_packetReceiver; }
 

libraries/networking/src/udt/NetworkSocket.cpp

@@ -267,6 +267,13 @@ QString NetworkSocket::errorString(SocketType socketType) const {
 }
 
 
+#if defined(WEBRTC_DATA_CHANNELS)
+const WebRTCSocket* NetworkSocket::getWebRTCSocket() {
+    return &_webrtcSocket;
+}
+#endif
+
+
 void NetworkSocket::onUDPStateChanged(QAbstractSocket::SocketState socketState) {
     emit stateChanged(SocketType::UDP, socketState);
 }

libraries/networking/src/udt/NetworkSocket.h

@@ -91,7 +91,7 @@ public:
     bool hasPendingDatagrams() const;
     
     /// @brief Gets the size of the next pending datagram, alternating between socket types if both have datagrams to read.
-    /// @return The size of the next pendign datagram.
+    /// @return The size of the next pending datagram.
     qint64 pendingDatagramSize();
     
     /// @brief Reads the next datagram per the most recent pendingDatagramSize call if made, otherwise alternating between
@@ -111,7 +111,7 @@ public:
 
     /// @brief Gets the type of error that last occurred.
     /// @param socketType The type of socket for which to get the last error.
-    /// @return The type of error that last occurred
+    /// @return The type of error that last occurred.
     QAbstractSocket::SocketError error(SocketType socketType) const;
 
     /// @brief Gets the description of the error that last occurred.
@@ -119,6 +119,13 @@ public:
     /// @return The description of the error that last occurred.
     QString errorString(SocketType socketType) const;
 
+
+#if defined(WEBRTC_DATA_CHANNELS)
+    /// @brief  @brief Gets a pointer to the WebRTC socket object.
+    /// @return A pointer to the WebRTC socket object.
+    const WebRTCSocket* getWebRTCSocket();
+#endif
+
 signals:
 
     /// @brief Emitted each time new data becomes available for reading.

libraries/networking/src/udt/Socket.cpp

@@ -91,6 +91,12 @@ void Socket::rebind(SocketType socketType, quint16 localPort) {
     bind(socketType, QHostAddress::AnyIPv4, localPort);
 }
 
+#if defined(WEBRTC_DATA_CHANNELS)
+const WebRTCSocket* Socket::getWebRTCSocket() {
+    return _networkSocket.getWebRTCSocket();
+}
+#endif
+
 void Socket::setSystemBufferSizes(SocketType socketType) {
     for (int i = 0; i < 2; i++) {
         QAbstractSocket::SocketOption bufferOpt;

libraries/networking/src/udt/Socket.h

@@ -90,6 +90,10 @@ public:
     
     StatsVector sampleStatsForAllConnections();
 
+#if defined(WEBRTC_DATA_CHANNELS)
+    const WebRTCSocket* getWebRTCSocket();
+#endif
+
 #if (PR_BUILD || DEV_BUILD)
     void sendFakedHandshakeRequest(const SockAddr& sockAddr);
 #endif

libraries/networking/src/webrtc/WebRTCSocket.cpp

@@ -10,20 +10,19 @@
 
 #if defined(WEBRTC_DATA_CHANNELS)
 
+#include <QHostAddress>
+
 #include "../NetworkLogging.h"
 #include "../udt/Constants.h"
 
 
 WebRTCSocket::WebRTCSocket(QObject* parent, NodeType_t nodeType) :
     QObject(parent),
-    _signalingServer(this /*, QHostAddress::AnyIPv4, DEFAULT_DOMAIN_SERVER_WS_PORT*/),
     _dataChannels(this, nodeType)
 {
-    // Connect WebRTC signaling server and data channels.
-    connect(&_signalingServer, &WebRTCSignalingServer::messageReceived,
-        &_dataChannels, &WebRTCDataChannels::onSignalingMessage);
-    connect(&_dataChannels, &WebRTCDataChannels::signalingMessage,
-        &_signalingServer, &WebRTCSignalingServer::sendMessage);
+    // Route signaling messages.
+    connect(this, &WebRTCSocket::onSignalingMessage, &_dataChannels, &WebRTCDataChannels::onSignalingMessage);
+    connect(&_dataChannels, &WebRTCDataChannels::signalingMessage, this, &WebRTCSocket::sendSignalingMessage);
 
     // Route received data channel messages.
     connect(&_dataChannels, &WebRTCDataChannels::dataMessage, this, &WebRTCSocket::onDataChannelReceivedMessage);
@@ -63,7 +62,7 @@ QVariant WebRTCSocket::socketOption(QAbstractSocket::SocketOption option) {
 bool WebRTCSocket::bind(const QHostAddress& address, quint16 port, QAbstractSocket::BindMode mode) {
     // WebRTC data channels aren't bound to ports so just treat this as a successful operation.
     auto wasBound = _isBound;
-    _isBound = _signalingServer.bind(address, port);
+    _isBound = true;
     if (_isBound != wasBound) {
         emit stateChanged(_isBound ? QAbstractSocket::BoundState : QAbstractSocket::UnconnectedState);
     }

libraries/networking/src/webrtc/WebRTCSocket.h

@@ -18,7 +18,6 @@
 #include <QQueue>
 
 #include "WebRTCDataChannels.h"
-#include "WebRTCSignalingServer.h"
 
 /// @addtogroup Networking
 /// @{
@@ -52,13 +51,14 @@ public:
     /// @return The value of the socket option.
     QVariant socketOption(QAbstractSocket::SocketOption option);
 
-    /// @brief Binds the WebRTC socket's signaling server to an address and port.
-    /// @details Note: WebRTC data connections aren't bound to an address or port. Their ports are negotiated as part of the
+    /// @brief Nominally binds the WebRTC socket to an address and port.
+    /// @details WebRTC data connections aren't actually bound to an address or port. Their ports are negotiated as part of the
     /// WebRTC peer connection process.
-    /// @param address The address to use for the signaling server.
-    /// @param port The port to use for the signaling server.
-    /// @param mode The bind mode. (Not used: included for compatibility with the QUdpSocket interface.)
-    /// @return <code>true</code> if the signaling server was successfully bound, <code>false</code> if it wasn't.
+    /// Included for compatibility with the QUdpSocket interface.
+    /// @param address The address.
+    /// @param port The port.
+    /// @param mode The bind mode.
+    /// @return <code>true</code>.
     bool bind(const QHostAddress& address, quint16 port = 0, QAbstractSocket::BindMode mode
         = QAbstractSocket::DefaultForPlatform);
 
@@ -132,17 +132,26 @@ public slots:
 signals:
 
     /// @brief Emitted when the state of the socket changes.
+    /// @param socketState The new state of the socket.
     void stateChanged(QAbstractSocket::SocketState socketState);
 
     /// @brief Emitted each time new data becomes available for reading.
     void readyRead();
 
+    /// @brief Emitted when a WebRTC signaling message has been received from the signaling server for this WebRTCSocket.
+    /// @param json The signaling message.
+    void onSignalingMessage(const QJsonObject& json);
+
+    /// @brief Emitted when there's a WebRTC signaling message to send via the signaling server.
+    /// @param json The signaling message.
+    void sendSignalingMessage(const QJsonObject& message);
+
+
 private:
 
     void setError(QAbstractSocket::SocketError errorType, QString errorString);
     void clearError();
 
-    WebRTCSignalingServer _signalingServer;
     WebRTCDataChannels _dataChannels;
 
     bool _isBound { false };