From e5d8a39ddea284ce11ca3bd9158490e4fa1f5f97 Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 13 Jul 2015 11:11:52 -0700 Subject: [PATCH] update DomainServer to new packet receive API --- domain-server/src/DomainServer.cpp | 287 +++++++----------- domain-server/src/DomainServer.h | 24 +- domain-server/src/DomainServerNodeData.cpp | 4 +- domain-server/src/DomainServerNodeData.h | 3 +- libraries/networking/src/Assignment.cpp | 13 +- libraries/networking/src/Assignment.h | 7 +- libraries/networking/src/LimitedNodeList.cpp | 3 + libraries/networking/src/LimitedNodeList.h | 1 + libraries/networking/src/NodeList.cpp | 1 - libraries/networking/src/PacketHeaders.cpp | 3 +- .../networking/src/ThreadedAssignment.cpp | 2 +- libraries/networking/src/ThreadedAssignment.h | 2 +- 12 files changed, 149 insertions(+), 201 deletions(-) diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp index 5e16949688..d6d6956a12 100644 --- a/domain-server/src/DomainServer.cpp +++ b/domain-server/src/DomainServer.cpp @@ -278,7 +278,16 @@ void DomainServer::setupNodeListAndAssignments(const QUuid& sessionUUID) { connect(nodeList.data(), &LimitedNodeList::nodeAdded, this, &DomainServer::nodeAdded); connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &DomainServer::nodeKilled); - connect(&nodeList->getNodeSocket(), SIGNAL(readyRead()), SLOT(readAvailableDatagrams())); + // register as the packet receiver for the types we want + PacketReceiver& packetReceiver = nodeList->getPacketReceiver(); + packetReceiver.registerPacketListener(PacketType::RequestAssignment, this, "processRequestAssignmentPacket"); + packetReceiver.registerPacketListener(PacketType::DomainConnectRequest, this, "processConnectRequestPackets"); + packetReceiver.registerPacketListener(PacketType::DomainListRequest, this, "processListRequestPacket"); + packetReceiver.registerPacketListener(PacketType::DomainServerPathQuery, this, "processPathQueryPacket"); + packetReceiver.registerPacketListener(PacketType::NodeJsonStats, this, "processNodeJSONStatsPacket"); + packetReceiver.registerPacketListener(PacketType::ICEPing, this, "processICEPingPacket"); + packetReceiver.registerPacketListener(PacketType::ICEPingReply, this, "processICEPingReplyPacket"); + packetReceiver.registerPacketListener(PacketType::ICEServerPeerInformation, this, "processICEPeerInformationPacket"); // add whatever static assignments that have been parsed to the queue addStaticAssignmentsToQueue(); @@ -566,17 +575,18 @@ void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet packet) { NodeType_t nodeType; HifiSockAddr publicSockAddr, localSockAddr; - QDataStream packetStream(packet); - packetStream.skipRawData(numBytesForPacketHeader(packet)); + QDataStream packetStream(packet.data()); QUuid connectUUID; packetStream >> connectUUID; - parseNodeDataFromByteArray(packetStream, nodeType, publicSockAddr, localSockAddr, senderSockAddr); + const HifiSockAddr& senderSockAddr = packet->getSenderSockAddr(); + + parseNodeData(packetStream, nodeType, publicSockAddr, localSockAddr, senderSockAddr); // check if this connect request matches an assignment in the queue bool isAssignment = _pendingAssignedNodes.contains(connectUUID); @@ -715,6 +725,33 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock } } +void DomainServer::processListRequestPacket(QSharedPointer packet) { + QDataStream packetStream(packet.data()); + + const QUuid& nodeUUID = packet->getSourceID(); + + auto limitedNodeList = DependencyManager::get(); + + SharedNodePointer checkInNode = limitedNodeList->nodeWithUUID(nodeUUID); + + if (!nodeUUID.isNull() && checkInNode) { + NodeType_t throwawayNodeType; + HifiSockAddr nodePublicAddress, nodeLocalAddress; + + QDataStream packetStream(packet.data()); + + parseNodeData(packetStream, throwawayNodeType, nodePublicAddress, nodeLocalAddress, packet->getSenderSockAddr()); + + checkInNode->setPublicSocket(nodePublicAddress); + checkInNode->setLocalSocket(nodeLocalAddress); + + QList nodeInterestList; + packetStream >> nodeInterestList; + + sendDomainListToNode(checkInNode, packet->getSenderSockAddr(), nodeInterestList.toSet()); + } +} + unsigned int DomainServer::countConnectedUsers() { unsigned int result = 0; auto nodeList = DependencyManager::get(); @@ -902,9 +939,9 @@ QUrl DomainServer::oauthAuthorizationURL(const QUuid& stateUUID) { return authorizationURL; } -int DomainServer::parseNodeDataFromByteArray(QDataStream& packetStream, NodeType_t& nodeType, - HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr, - const HifiSockAddr& senderSockAddr) { +int DomainServer::parseNodeData(QDataStream& packetStream, NodeType_t& nodeType, + HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr, + const HifiSockAddr& senderSockAddr) { packetStream >> nodeType; packetStream >> publicSockAddr >> localSockAddr; @@ -1037,97 +1074,68 @@ void DomainServer::broadcastNewNode(const SharedNodePointer& addedNode) { ); } -void DomainServer::readAvailableDatagrams() { - auto limitedNodeList = DependencyManager::get(); +void DomainServer::processRequestAssignmentPacket(QSharedPointer packet) { + // construct the requested assignment from the packet data + Assignment requestAssignment(*packet); - HifiSockAddr senderSockAddr; - QByteArray receivedPacket; + // Suppress these for Assignment::AgentType to once per 5 seconds + static QElapsedTimer noisyMessageTimer; + static bool wasNoisyTimerStarted = false; - while (limitedNodeList->getNodeSocket().hasPendingDatagrams()) { - receivedPacket.resize(limitedNodeList->getNodeSocket().pendingDatagramSize()); - limitedNodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(), - senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); - if (packetTypeForPacket(receivedPacket) == PacketType::RequestAssignment - && limitedNodeList->packetVersionAndHashMatch(receivedPacket)) { + if (!wasNoisyTimerStarted) { + noisyMessageTimer.start(); + wasNoisyTimerStarted = true; + } - // construct the requested assignment from the packet data - Assignment requestAssignment(receivedPacket); + const qint64 NOISY_MESSAGE_INTERVAL_MSECS = 5 * 1000; - // Suppress these for Assignment::AgentType to once per 5 seconds - static QElapsedTimer noisyMessageTimer; - static bool wasNoisyTimerStarted = false; + if (requestAssignment.getType() != Assignment::AgentType + || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) { + static QString repeatedMessage = LogHandler::getInstance().addOnlyOnceMessageRegex + ("Received a request for assignment type [^ ]+ from [^ ]+"); + qDebug() << "Received a request for assignment type" << requestAssignment.getType() + << "from" << packet->getSenderSockAddr(); + noisyMessageTimer.restart(); + } - if (!wasNoisyTimerStarted) { - noisyMessageTimer.start(); - wasNoisyTimerStarted = true; - } + SharedAssignmentPointer assignmentToDeploy = deployableAssignmentForRequest(requestAssignment); - const qint64 NOISY_MESSAGE_INTERVAL_MSECS = 5 * 1000; + if (assignmentToDeploy) { + qDebug() << "Deploying assignment -" << *assignmentToDeploy.data() << "- to" << packet->getSenderSockAddr(); - if (requestAssignment.getType() != Assignment::AgentType - || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) { - static QString repeatedMessage = LogHandler::getInstance().addOnlyOnceMessageRegex - ("Received a request for assignment type [^ ]+ from [^ ]+"); - qDebug() << "Received a request for assignment type" << requestAssignment.getType() - << "from" << senderSockAddr; - noisyMessageTimer.restart(); - } + // give this assignment out, either the type matches or the requestor said they will take any + static std::unique_ptr assignmentPacket; - SharedAssignmentPointer assignmentToDeploy = deployableAssignmentForRequest(requestAssignment); + if (!assignmentPacket) { + assignmentPacket = NLPacket::create(PacketType::CreateAssignment); + } - if (assignmentToDeploy) { - qDebug() << "Deploying assignment -" << *assignmentToDeploy.data() << "- to" << senderSockAddr; + // setup a copy of this assignment that will have a unique UUID, for packaging purposes + Assignment uniqueAssignment(*assignmentToDeploy.data()); + uniqueAssignment.setUUID(QUuid::createUuid()); - // give this assignment out, either the type matches or the requestor said they will take any - static std::unique_ptr assignmentPacket; + // reset the assignmentPacket + assignmentPacket->reset(); - if (!assignmentPacket) { - assignmentPacket = NLPacket::create(PacketType::CreateAssignment); - } + QDataStream assignmentStream(assignmentPacket.get()); - // setup a copy of this assignment that will have a unique UUID, for packaging purposes - Assignment uniqueAssignment(*assignmentToDeploy.data()); - uniqueAssignment.setUUID(QUuid::createUuid()); + assignmentStream << uniqueAssignment; - // reset the assignmentPacket - assignmentPacket->reset(); + auto limitedNodeList = DependencyManager::get(); + limitedNodeList->sendUnreliablePacket(*assignmentPacket, packet->getSenderSockAddr()); - QDataStream assignmentStream(assignmentPacket.get()); - - assignmentStream << uniqueAssignment; - - limitedNodeList->sendUnreliablePacket(*assignmentPacket, senderSockAddr); - - // add the information for that deployed assignment to the hash of pending assigned nodes - PendingAssignedNodeData* pendingNodeData = new PendingAssignedNodeData(assignmentToDeploy->getUUID(), - requestAssignment.getWalletUUID()); - _pendingAssignedNodes.insert(uniqueAssignment.getUUID(), pendingNodeData); - } else { - if (requestAssignment.getType() != Assignment::AgentType - || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) { - static QString repeatedMessage = LogHandler::getInstance().addOnlyOnceMessageRegex - ("Unable to fulfill assignment request of type [^ ]+ from [^ ]+"); - qDebug() << "Unable to fulfill assignment request of type" << requestAssignment.getType() - << "from" << senderSockAddr; - noisyMessageTimer.restart(); - } - } - } else if (!_isUsingDTLS) { - // not using DTLS, process datagram normally - processDatagram(receivedPacket, senderSockAddr); - } else { - // we're using DTLS, so tell the sender to get back to us using DTLS - static std::unique_ptr dtlsRequiredPacket; - - if (!dtlsRequiredPacket) { - dtlsRequiredPacket = NLPacket::create(PacketType::DomainServerRequireDTLS, sizeof(unsigned short)); - - // pack the port that we accept DTLS traffic on - unsigned short dtlsPort = limitedNodeList->getDTLSSocket().localPort(); - dtlsRequiredPacket->writePrimitive(dtlsPort); - } - - limitedNodeList->sendUnreliablePacket(*dtlsRequiredPacket, senderSockAddr); + // add the information for that deployed assignment to the hash of pending assigned nodes + PendingAssignedNodeData* pendingNodeData = new PendingAssignedNodeData(assignmentToDeploy->getUUID(), + requestAssignment.getWalletUUID()); + _pendingAssignedNodes.insert(uniqueAssignment.getUUID(), pendingNodeData); + } else { + if (requestAssignment.getType() != Assignment::AgentType + || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) { + static QString repeatedMessage = LogHandler::getInstance().addOnlyOnceMessageRegex + ("Unable to fulfill assignment request of type [^ ]+ from [^ ]+"); + qDebug() << "Unable to fulfill assignment request of type" << requestAssignment.getType() + << "from" << packet->getSenderSockAddr(); + noisyMessageTimer.restart(); } } } @@ -1355,11 +1363,10 @@ void DomainServer::handlePeerPingTimeout() { } } -void DomainServer::processICEPeerInformation(const QByteArray& packet) { +void DomainServer::processICEPeerInformationPacket(QSharedPointer packet) { // loop through the packet and pull out network peers // any peer we don't have we add to the hash, otherwise we update - QDataStream iceResponseStream(packet); - iceResponseStream.skipRawData(numBytesForPacketHeader(packet)); + QDataStream iceResponseStream(packet.data()); NetworkPeer* receivedPeer = new NetworkPeer; iceResponseStream >> *receivedPeer; @@ -1384,86 +1391,30 @@ void DomainServer::processICEPeerInformation(const QByteArray& packet) { } } -void DomainServer::processICEPingReply(const QByteArray& packet, const HifiSockAddr& senderSockAddr) { - QUuid nodeUUID = uuidFromPacketHeader(packet); +void DomainServer::processICEPingPacket(QSharedPointer packet) { + auto limitedNodeList = DependencyManager::get(); + auto pingReplyPacket = limitedNodeList->constructICEPingReplyPacket(packet, limitedNodeList->getSessionUUID()); + + limitedNodeList->sendPacket(std::move(pingReplyPacket), packet->getSenderSockAddr()); +} + +void DomainServer::processICEPingReplyPacket(QSharedPointer packet) { + QDataStream packetStream(packet.data()); + + QUuid nodeUUID; + packetStream >> nodeUUID; + SharedNetworkPeer sendingPeer = _icePeers.value(nodeUUID); if (sendingPeer) { // we had this NetworkPeer in our connecting list - add the right sock addr to our connected list - sendingPeer->activateMatchingOrNewSymmetricSocket(senderSockAddr); + sendingPeer->activateMatchingOrNewSymmetricSocket(packet->getSenderSockAddr()); } } -void DomainServer::processDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) { - auto nodeList = DependencyManager::get(); - - if (nodeList->packetVersionAndHashMatch(receivedPacket)) { - PacketType::Value requestType = packetTypeForPacket(receivedPacket); - switch (requestType) { - case PacketType::DomainConnectRequest: - handleConnectRequest(receivedPacket, senderSockAddr); - break; - case PacketType::DomainListRequest: { - QUuid nodeUUID = uuidFromPacketHeader(receivedPacket); - - if (!nodeUUID.isNull() && nodeList->nodeWithUUID(nodeUUID)) { - NodeType_t throwawayNodeType; - HifiSockAddr nodePublicAddress, nodeLocalAddress; - - QDataStream packetStream(receivedPacket); - packetStream.skipRawData(numBytesForPacketHeader(receivedPacket)); - - parseNodeDataFromByteArray(packetStream, throwawayNodeType, nodePublicAddress, nodeLocalAddress, - senderSockAddr); - - SharedNodePointer checkInNode = nodeList->nodeWithUUID(nodeUUID); - checkInNode->setPublicSocket(nodePublicAddress); - checkInNode->setLocalSocket(nodeLocalAddress); - - // update last receive to now - quint64 timeNow = usecTimestampNow(); - checkInNode->setLastHeardMicrostamp(timeNow); - - QList nodeInterestList; - packetStream >> nodeInterestList; - - sendDomainListToNode(checkInNode, senderSockAddr, nodeInterestList.toSet()); - } - - break; - } - case PacketType::DomainServerPathQuery: { - // have our private method attempt to respond to this path query - respondToPathQuery(receivedPacket, senderSockAddr); - break; - } - case PacketType::NodeJsonStats: { - SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket); - if (matchingNode) { - reinterpret_cast(matchingNode->getLinkedData())->parseJSONStatsPacket(receivedPacket); - } - - break; - } - case PacketType::StunResponse: - nodeList->processSTUNResponse(receivedPacket); - break; - case PacketType::ICEPing: { - auto pingReplyPacket = nodeList->constructPingReplyPacket(receivedPacket); - nodeList->sendPacket(std::move(pingReplyPacket), senderSockAddr); - - break; - } - case PacketType::ICEPingReply: { - processICEPingReply(receivedPacket, senderSockAddr); - break; - } - case PacketType::ICEServerPeerInformation: - processICEPeerInformation(receivedPacket); - break; - default: - break; - } +void DomainServer::processNodeJSONStatsPacket(QSharedPointer packet, SharedNodePointer sendingNode) { + if (sendingNode->getLinkedData()) { + reinterpret_cast(sendingNode->getLinkedData())->processJSONStatsPacket(*packet); } } @@ -2231,19 +2182,17 @@ void DomainServer::addStaticAssignmentsToQueue() { } } -void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) { +void DomainServer::processPathQueryPacket(QSharedPointer packet) { // this is a query for the viewpoint resulting from a path // first pull the query path from the packet - int numHeaderBytes = 0; - const char* packetDataStart = receivedPacket.data() + numHeaderBytes; - // figure out how many bytes the sender said this path is - quint16 numPathBytes = *packetDataStart; + quint16 numPathBytes; + packet->readPrimitive(&numPathBytes); - if (numPathBytes <= receivedPacket.size() - numHeaderBytes - sizeof(numPathBytes)) { + if (numPathBytes <= packet->bytesAvailable()) { // the number of path bytes makes sense for the sent packet - pull out the path - QString pathQuery = QString::fromUtf8(packetDataStart + sizeof(numPathBytes), numPathBytes); + QString pathQuery = QString::fromUtf8(packet->getPayload() + packet->pos(), numPathBytes); // our settings contain paths that start with a leading slash, so make sure this query has that if (!pathQuery.startsWith("/")) { @@ -2291,7 +2240,7 @@ void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const Hi // send off the packet - see if we can associate this outbound data to a particular node // TODO: does this senderSockAddr always work for a punched DS client? - nodeList->sendPacket(std::move(pathResponsePacket), senderSockAddr); + nodeList->sendPacket(std::move(pathResponsePacket), packet->getSenderSockAddr()); } } diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h index b46ccf3884..0c287c4c55 100644 --- a/domain-server/src/DomainServer.h +++ b/domain-server/src/DomainServer.h @@ -55,11 +55,19 @@ public slots: void restart(); + void processRequestAssignmentPacket(QSharedPointer packet); + void processConnectRequestPacket(QSharedPointer packet); + void processListRequestPacket(QSharedPointer packet); + void processNodeJSONStatsPacket(QSharedPointer packet, SharedNodePointer sendingNode); + void processPathQueryPacket(QSharedPointer packet); + void processICEPingPacket(QSharedPointer packet); + void processICEPingReplyPacket(QSharedPointer packet); + void processICEPeerInformationPacket(QSharedPointer packet); + private slots: void aboutToQuit(); void loginFailed(); - void readAvailableDatagrams(); void setupPendingAssignmentCredits(); void sendPendingTransactionsToServer(); @@ -78,14 +86,9 @@ private: void setupAutomaticNetworking(); void sendHeartbeatToDataServer(const QString& networkAddress); - void processICEPingReply(const QByteArray& packet, const HifiSockAddr& senderSockAddr); - void processICEPeerInformation(const QByteArray& packet); void pingPunchForConnectingPeer(const SharedNetworkPeer& peer); - void processDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr); - - void handleConnectRequest(const QByteArray& packet, const HifiSockAddr& senderSockAddr); unsigned int countConnectedUsers(); bool verifyUsersKey (const QString& username, const QByteArray& usernameSignature, QString& reasonReturn); bool shouldAllowConnectionFromNode(const QString& username, const QByteArray& usernameSignature, @@ -94,11 +97,8 @@ private: void preloadAllowedUserPublicKeys(); void requestUserPublicKey(const QString& username); - int parseNodeDataFromByteArray(QDataStream& packetStream, - NodeType_t& nodeType, - HifiSockAddr& publicSockAddr, - HifiSockAddr& localSockAddr, - const HifiSockAddr& senderSockAddr); + int parseNodeData(QDataStream& packetStream, NodeType_t& nodeType, + HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr, const HifiSockAddr& senderSockAddr); void sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr& senderSockAddr, const NodeSet& nodeInterestSet); @@ -117,8 +117,6 @@ private: void refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer& assignment); void addStaticAssignmentsToQueue(); - void respondToPathQuery(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr); - QUrl oauthRedirectURL(); QUrl oauthAuthorizationURL(const QUuid& stateUUID = QUuid::createUuid()); diff --git a/domain-server/src/DomainServerNodeData.cpp b/domain-server/src/DomainServerNodeData.cpp index 0d7efa064c..02528cc70e 100644 --- a/domain-server/src/DomainServerNodeData.cpp +++ b/domain-server/src/DomainServerNodeData.cpp @@ -31,8 +31,8 @@ DomainServerNodeData::DomainServerNodeData() : _paymentIntervalTimer.start(); } -void DomainServerNodeData::parseJSONStatsPacket(const QByteArray& statsPacket) { - QVariantMap packetVariantMap = JSONBreakableMarshal::fromStringBuffer(statsPacket.mid(numBytesForPacketHeader(statsPacket))); +void DomainServerNodeData::processJSONStatsPacket(NLPacket& statsPacket) { + QVariantMap packetVariantMap = JSONBreakableMarshal::fromStringBuffer(statsPacket.readAll()); _statsJSONObject = mergeJSONStatsFromNewObject(QJsonObject::fromVariantMap(packetVariantMap), _statsJSONObject); } diff --git a/domain-server/src/DomainServerNodeData.h b/domain-server/src/DomainServerNodeData.h index a91a7e0b9c..d2efced1ef 100644 --- a/domain-server/src/DomainServerNodeData.h +++ b/domain-server/src/DomainServerNodeData.h @@ -17,6 +17,7 @@ #include #include +#include #include #include @@ -27,7 +28,7 @@ public: const QJsonObject& getStatsJSONObject() const { return _statsJSONObject; } - void parseJSONStatsPacket(const QByteArray& statsPacket); + void processJSONStatsPacket(NLPacket& packet); void setAssignmentUUID(const QUuid& assignmentUUID) { _assignmentUUID = assignmentUUID; } const QUuid& getAssignmentUUID() const { return _assignmentUUID; } diff --git a/libraries/networking/src/Assignment.cpp b/libraries/networking/src/Assignment.cpp index 3da1fb9a41..bd28361eb7 100644 --- a/libraries/networking/src/Assignment.cpp +++ b/libraries/networking/src/Assignment.cpp @@ -60,28 +60,25 @@ Assignment::Assignment(Assignment::Command command, Assignment::Type type, const } } -Assignment::Assignment(const QByteArray& packet) : +Assignment::Assignment(NLPacket& packet) : _pool(), _location(GlobalLocation), _payload(), _walletUUID() { - PacketType::Value packetType = packetTypeForPacket(packet); - - if (packetType == PacketType::RequestAssignment) { + if (packet.getType() == PacketType::RequestAssignment) { _command = Assignment::RequestCommand; - } else if (packetType == PacketType::CreateAssignment) { + } else if (packet.getType() == PacketType::CreateAssignment) { _command = Assignment::CreateCommand; } - QDataStream packetStream(packet); - packetStream.skipRawData(numBytesForPacketHeader(packet)); + QDataStream packetStream(&packet); packetStream >> *this; } #ifdef WIN32 -#pragma warning(default:4351) +#pragma warning(default:4351) #endif diff --git a/libraries/networking/src/Assignment.h b/libraries/networking/src/Assignment.h index 26b38914ba..a8338a7b5a 100644 --- a/libraries/networking/src/Assignment.h +++ b/libraries/networking/src/Assignment.h @@ -59,10 +59,9 @@ public: void swap(Assignment& otherAssignment); - /// Constructs an Assignment from the data in the buffer - /// \param dataBuffer the source buffer to un-pack the assignment from - /// \param numBytes the number of bytes left to read in the source buffer - Assignment(const QByteArray& packet); + /// Constructs an Assignment from a network packet + /// \param packet the packet to un-pack the assignment from + Assignment(NLPacket& packet); void setUUID(const QUuid& uuid) { _uuid = uuid; } const QUuid& getUUID() const { return _uuid; } diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp index 764a9eed7e..47a7a4b99b 100644 --- a/libraries/networking/src/LimitedNodeList.cpp +++ b/libraries/networking/src/LimitedNodeList.cpp @@ -98,6 +98,9 @@ LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short connect(&_nodeSocket, &QUdpSocket::readyRead, &_packetReceiver, &PacketReceiver::processDatagrams); _packetStatTimer.start(); + + // make sure we handle STUN response packets + _packetReceiver.registerPacketListener(PacketType::StunResponse, this, "processSTUNResponse"); } void LimitedNodeList::setSessionUUID(const QUuid& sessionUUID) { diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h index f48f2aaa31..2e0bb5b6b7 100644 --- a/libraries/networking/src/LimitedNodeList.h +++ b/libraries/networking/src/LimitedNodeList.h @@ -243,6 +243,7 @@ public slots: virtual void sendSTUNRequest(); void killNodeWithUUID(const QUuid& nodeUUID); + signals: void uuidChanged(const QUuid& ownerUUID, const QUuid& oldUUID); void nodeAdded(SharedNodePointer); diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp index 8d897e82b5..1daf8a1c02 100644 --- a/libraries/networking/src/NodeList.cpp +++ b/libraries/networking/src/NodeList.cpp @@ -101,7 +101,6 @@ NodeList::NodeList(char newOwnerType, unsigned short socketListenPort, unsigned packetReceiver.registerPacketListener(PacketType::PingReply, this, "processPingReplyPacket"); packetReceiver.registerPacketListener(PacketType::ICEPing, this, "processICEPingPacket"); packetReceiver.registerPacketListener(PacketType::ICEPingReply, this, "processICEPingReplyPacket"); - packetReceiver.registerPacketListener(PacketType::StunResponse, this, "processSTUNResponse"); } qint64 NodeList::sendStats(const QJsonObject& statsObject, const HifiSockAddr& destination) { diff --git a/libraries/networking/src/PacketHeaders.cpp b/libraries/networking/src/PacketHeaders.cpp index f6001711c0..6fdd421ea0 100644 --- a/libraries/networking/src/PacketHeaders.cpp +++ b/libraries/networking/src/PacketHeaders.cpp @@ -21,6 +21,7 @@ const QSet NON_VERIFIED_PACKETS = QSet() << CreateAssignment << RequestAssignment << StunResponse << NodeJsonStats << EntityQuery << OctreeDataNack << EntityEditNack + << DomainListRequest << Ping << PingReply << StopNode; @@ -28,7 +29,7 @@ const QSet SEQUENCE_NUMBERED_PACKETS = QSet NON_SOURCED_PACKETS = QSet() << DomainServerRequireDTLS << DomainConnectRequest - << DomainList << DomainListRequest << DomainConnectionDenied + << DomainList << DomainConnectionDenied << DomainServerPathQuery << DomainServerPathResponse << DomainServerAddedNode << ICEServerPeerInformation << ICEServerQuery << ICEServerHeartbeat diff --git a/libraries/networking/src/ThreadedAssignment.cpp b/libraries/networking/src/ThreadedAssignment.cpp index 2406df4602..b1c4bdbc7f 100644 --- a/libraries/networking/src/ThreadedAssignment.cpp +++ b/libraries/networking/src/ThreadedAssignment.cpp @@ -18,7 +18,7 @@ #include "ThreadedAssignment.h" -ThreadedAssignment::ThreadedAssignment(const QByteArray& packet) : +ThreadedAssignment::ThreadedAssignment(NLPacket& packet) : Assignment(packet), _isFinished(false), _datagramProcessingThread(NULL) diff --git a/libraries/networking/src/ThreadedAssignment.h b/libraries/networking/src/ThreadedAssignment.h index daca2cfe00..c4c6127b7b 100644 --- a/libraries/networking/src/ThreadedAssignment.h +++ b/libraries/networking/src/ThreadedAssignment.h @@ -19,7 +19,7 @@ class ThreadedAssignment : public Assignment { Q_OBJECT public: - ThreadedAssignment(const QByteArray& packet); + ThreadedAssignment(NLPacket& packet); ~ThreadedAssignment() { stop(); } void setFinished(bool isFinished);