Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-09 16:41:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

update DomainServer to new packet receive API

Browse source
This commit is contained in:
Stephen Birarda 2015-07-13 11:11:52 -07:00
parent 1dccc144e7
commit e5d8a39dde
12 changed files with 149 additions and 201 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

287
domain-server/src/DomainServer.cpp
View file

@ -278,7 +278,16 @@ void DomainServer::setupNodeListAndAssignments(const QUuid& sessionUUID) {
connect(nodeList.data(), &LimitedNodeList::nodeAdded, this, &DomainServer::nodeAdded); connect(nodeList.data(), &LimitedNodeList::nodeAdded, this, &DomainServer::nodeAdded);
connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &DomainServer::nodeKilled); 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 // add whatever static assignments that have been parsed to the queue
addStaticAssignmentsToQueue(); addStaticAssignmentsToQueue();
@ -566,17 +575,18 @@ void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet<Ass
const NodeSet STATICALLY_ASSIGNED_NODES = NodeSet() << NodeType::AudioMixer const NodeSet STATICALLY_ASSIGNED_NODES = NodeSet() << NodeType::AudioMixer
<< NodeType::AvatarMixer << NodeType::EntityServer; << NodeType::AvatarMixer << NodeType::EntityServer;
void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSockAddr& senderSockAddr) { void DomainServer::processConnectRequestPacket(QSharedPointer<NLPacket> packet) {
NodeType_t nodeType; NodeType_t nodeType;
HifiSockAddr publicSockAddr, localSockAddr; HifiSockAddr publicSockAddr, localSockAddr;
QDataStream packetStream(packet); QDataStream packetStream(packet.data());
packetStream.skipRawData(numBytesForPacketHeader(packet));
QUuid connectUUID; QUuid connectUUID;
packetStream >> 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 // check if this connect request matches an assignment in the queue
bool isAssignment = _pendingAssignedNodes.contains(connectUUID); bool isAssignment = _pendingAssignedNodes.contains(connectUUID);
@ -715,6 +725,33 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
} }
} }
void DomainServer::processListRequestPacket(QSharedPointer<NLPacket> packet) {
QDataStream packetStream(packet.data());
const QUuid& nodeUUID = packet->getSourceID();
auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
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<NodeType_t> nodeInterestList;
packetStream >> nodeInterestList;
sendDomainListToNode(checkInNode, packet->getSenderSockAddr(), nodeInterestList.toSet());
}
}
unsigned int DomainServer::countConnectedUsers() { unsigned int DomainServer::countConnectedUsers() {
unsigned int result = 0; unsigned int result = 0;
auto nodeList = DependencyManager::get<LimitedNodeList>(); auto nodeList = DependencyManager::get<LimitedNodeList>();
@ -902,9 +939,9 @@ QUrl DomainServer::oauthAuthorizationURL(const QUuid& stateUUID) {
return authorizationURL; return authorizationURL;
} }
int DomainServer::parseNodeDataFromByteArray(QDataStream& packetStream, NodeType_t& nodeType, int DomainServer::parseNodeData(QDataStream& packetStream, NodeType_t& nodeType,
HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr, HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr,
const HifiSockAddr& senderSockAddr) { const HifiSockAddr& senderSockAddr) {
packetStream >> nodeType; packetStream >> nodeType;
packetStream >> publicSockAddr >> localSockAddr; packetStream >> publicSockAddr >> localSockAddr;
@ -1037,97 +1074,68 @@ void DomainServer::broadcastNewNode(const SharedNodePointer& addedNode) {
); );
} }
void DomainServer::readAvailableDatagrams() { void DomainServer::processRequestAssignmentPacket(QSharedPointer<NLPacket> packet) {
auto limitedNodeList = DependencyManager::get<LimitedNodeList>(); // construct the requested assignment from the packet data
Assignment requestAssignment(*packet);
HifiSockAddr senderSockAddr; // Suppress these for Assignment::AgentType to once per 5 seconds
QByteArray receivedPacket; static QElapsedTimer noisyMessageTimer;
static bool wasNoisyTimerStarted = false;
while (limitedNodeList->getNodeSocket().hasPendingDatagrams()) { if (!wasNoisyTimerStarted) {
receivedPacket.resize(limitedNodeList->getNodeSocket().pendingDatagramSize()); noisyMessageTimer.start();
limitedNodeList->getNodeSocket().readDatagram(receivedPacket.data(), receivedPacket.size(), wasNoisyTimerStarted = true;
senderSockAddr.getAddressPointer(), senderSockAddr.getPortPointer()); }
if (packetTypeForPacket(receivedPacket) == PacketType::RequestAssignment
&& limitedNodeList->packetVersionAndHashMatch(receivedPacket)) {
// construct the requested assignment from the packet data const qint64 NOISY_MESSAGE_INTERVAL_MSECS = 5 * 1000;
Assignment requestAssignment(receivedPacket);
// Suppress these for Assignment::AgentType to once per 5 seconds if (requestAssignment.getType() != Assignment::AgentType
static QElapsedTimer noisyMessageTimer; || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) {
static bool wasNoisyTimerStarted = false; 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) { SharedAssignmentPointer assignmentToDeploy = deployableAssignmentForRequest(requestAssignment);
noisyMessageTimer.start();
wasNoisyTimerStarted = true;
}
const qint64 NOISY_MESSAGE_INTERVAL_MSECS = 5 * 1000; if (assignmentToDeploy) {
qDebug() << "Deploying assignment -" << *assignmentToDeploy.data() << "- to" << packet->getSenderSockAddr();
if (requestAssignment.getType() != Assignment::AgentType // give this assignment out, either the type matches or the requestor said they will take any
|| noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) { static std::unique_ptr<NLPacket> assignmentPacket;
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();
}
SharedAssignmentPointer assignmentToDeploy = deployableAssignmentForRequest(requestAssignment); if (!assignmentPacket) {
assignmentPacket = NLPacket::create(PacketType::CreateAssignment);
}
if (assignmentToDeploy) { // setup a copy of this assignment that will have a unique UUID, for packaging purposes
qDebug() << "Deploying assignment -" << *assignmentToDeploy.data() << "- to" << senderSockAddr; Assignment uniqueAssignment(*assignmentToDeploy.data());
uniqueAssignment.setUUID(QUuid::createUuid());
// give this assignment out, either the type matches or the requestor said they will take any // reset the assignmentPacket
static std::unique_ptr<NLPacket> assignmentPacket; assignmentPacket->reset();
if (!assignmentPacket) { QDataStream assignmentStream(assignmentPacket.get());
assignmentPacket = NLPacket::create(PacketType::CreateAssignment);
}
// setup a copy of this assignment that will have a unique UUID, for packaging purposes assignmentStream << uniqueAssignment;
Assignment uniqueAssignment(*assignmentToDeploy.data());
uniqueAssignment.setUUID(QUuid::createUuid());
// reset the assignmentPacket auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
assignmentPacket->reset(); limitedNodeList->sendUnreliablePacket(*assignmentPacket, packet->getSenderSockAddr());
QDataStream assignmentStream(assignmentPacket.get()); // add the information for that deployed assignment to the hash of pending assigned nodes
PendingAssignedNodeData* pendingNodeData = new PendingAssignedNodeData(assignmentToDeploy->getUUID(),
assignmentStream << uniqueAssignment; requestAssignment.getWalletUUID());
_pendingAssignedNodes.insert(uniqueAssignment.getUUID(), pendingNodeData);
limitedNodeList->sendUnreliablePacket(*assignmentPacket, senderSockAddr); } else {
if (requestAssignment.getType() != Assignment::AgentType
// add the information for that deployed assignment to the hash of pending assigned nodes || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) {
PendingAssignedNodeData* pendingNodeData = new PendingAssignedNodeData(assignmentToDeploy->getUUID(), static QString repeatedMessage = LogHandler::getInstance().addOnlyOnceMessageRegex
requestAssignment.getWalletUUID()); ("Unable to fulfill assignment request of type [^ ]+ from [^ ]+");
_pendingAssignedNodes.insert(uniqueAssignment.getUUID(), pendingNodeData); qDebug() << "Unable to fulfill assignment request of type" << requestAssignment.getType()
} else { << "from" << packet->getSenderSockAddr();
if (requestAssignment.getType() != Assignment::AgentType noisyMessageTimer.restart();
|| 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<NLPacket> 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);
} }
} }
} }
@ -1355,11 +1363,10 @@ void DomainServer::handlePeerPingTimeout() {
} }
} }
void DomainServer::processICEPeerInformation(const QByteArray& packet) { void DomainServer::processICEPeerInformationPacket(QSharedPointer<NLPacket> packet) {
// loop through the packet and pull out network peers // loop through the packet and pull out network peers
// any peer we don't have we add to the hash, otherwise we update // any peer we don't have we add to the hash, otherwise we update
QDataStream iceResponseStream(packet); QDataStream iceResponseStream(packet.data());
iceResponseStream.skipRawData(numBytesForPacketHeader(packet));
NetworkPeer* receivedPeer = new NetworkPeer; NetworkPeer* receivedPeer = new NetworkPeer;
iceResponseStream >> *receivedPeer; iceResponseStream >> *receivedPeer;
@ -1384,86 +1391,30 @@ void DomainServer::processICEPeerInformation(const QByteArray& packet) {
} }
} }
void DomainServer::processICEPingReply(const QByteArray& packet, const HifiSockAddr& senderSockAddr) { void DomainServer::processICEPingPacket(QSharedPointer<NLPacket> packet) {
QUuid nodeUUID = uuidFromPacketHeader(packet); auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
auto pingReplyPacket = limitedNodeList->constructICEPingReplyPacket(packet, limitedNodeList->getSessionUUID());
limitedNodeList->sendPacket(std::move(pingReplyPacket), packet->getSenderSockAddr());
}
void DomainServer::processICEPingReplyPacket(QSharedPointer<NLPacket> packet) {
QDataStream packetStream(packet.data());
QUuid nodeUUID;
packetStream >> nodeUUID;
SharedNetworkPeer sendingPeer = _icePeers.value(nodeUUID); SharedNetworkPeer sendingPeer = _icePeers.value(nodeUUID);
if (sendingPeer) { if (sendingPeer) {
// we had this NetworkPeer in our connecting list - add the right sock addr to our connected list // 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) { void DomainServer::processNodeJSONStatsPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode) {
auto nodeList = DependencyManager::get<LimitedNodeList>(); if (sendingNode->getLinkedData()) {
reinterpret_cast<DomainServerNodeData*>(sendingNode->getLinkedData())->processJSONStatsPacket(*packet);
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<NodeType_t> 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<DomainServerNodeData*>(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;
}
} }
} }
@ -2231,19 +2182,17 @@ void DomainServer::addStaticAssignmentsToQueue() {
} }
} }
void DomainServer::respondToPathQuery(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) { void DomainServer::processPathQueryPacket(QSharedPointer<NLPacket> packet) {
// this is a query for the viewpoint resulting from a path // this is a query for the viewpoint resulting from a path
// first pull the query path from the packet // 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 // 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 // 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 // our settings contain paths that start with a leading slash, so make sure this query has that
if (!pathQuery.startsWith("/")) { 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 // 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? // TODO: does this senderSockAddr always work for a punched DS client?
nodeList->sendPacket(std::move(pathResponsePacket), senderSockAddr); nodeList->sendPacket(std::move(pathResponsePacket), packet->getSenderSockAddr());
} }
} }

24
domain-server/src/DomainServer.h
View file

@ -55,11 +55,19 @@ public slots:
void restart(); void restart();
void processRequestAssignmentPacket(QSharedPointer<NLPacket> packet);
void processConnectRequestPacket(QSharedPointer<NLPacket> packet);
void processListRequestPacket(QSharedPointer<NLPacket> packet);
void processNodeJSONStatsPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode);
void processPathQueryPacket(QSharedPointer<NLPacket> packet);
void processICEPingPacket(QSharedPointer<NLPacket> packet);
void processICEPingReplyPacket(QSharedPointer<NLPacket> packet);
void processICEPeerInformationPacket(QSharedPointer<NLPacket> packet);
private slots: private slots:
void aboutToQuit(); void aboutToQuit();
void loginFailed(); void loginFailed();
void readAvailableDatagrams();
void setupPendingAssignmentCredits(); void setupPendingAssignmentCredits();
void sendPendingTransactionsToServer(); void sendPendingTransactionsToServer();
@ -78,14 +86,9 @@ private:
void setupAutomaticNetworking(); void setupAutomaticNetworking();
void sendHeartbeatToDataServer(const QString& networkAddress); void sendHeartbeatToDataServer(const QString& networkAddress);
void processICEPingReply(const QByteArray& packet, const HifiSockAddr& senderSockAddr);
void processICEPeerInformation(const QByteArray& packet);
void pingPunchForConnectingPeer(const SharedNetworkPeer& peer); void pingPunchForConnectingPeer(const SharedNetworkPeer& peer);
void processDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr);
void handleConnectRequest(const QByteArray& packet, const HifiSockAddr& senderSockAddr);
unsigned int countConnectedUsers(); unsigned int countConnectedUsers();
bool verifyUsersKey (const QString& username, const QByteArray& usernameSignature, QString& reasonReturn); bool verifyUsersKey (const QString& username, const QByteArray& usernameSignature, QString& reasonReturn);
bool shouldAllowConnectionFromNode(const QString& username, const QByteArray& usernameSignature, bool shouldAllowConnectionFromNode(const QString& username, const QByteArray& usernameSignature,
@ -94,11 +97,8 @@ private:
void preloadAllowedUserPublicKeys(); void preloadAllowedUserPublicKeys();
void requestUserPublicKey(const QString& username); void requestUserPublicKey(const QString& username);
int parseNodeDataFromByteArray(QDataStream& packetStream, int parseNodeData(QDataStream& packetStream, NodeType_t& nodeType,
NodeType_t& nodeType, HifiSockAddr& publicSockAddr, HifiSockAddr& localSockAddr, const HifiSockAddr& senderSockAddr);
HifiSockAddr& publicSockAddr,
HifiSockAddr& localSockAddr,
const HifiSockAddr& senderSockAddr);
void sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr& senderSockAddr, void sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr& senderSockAddr,
const NodeSet& nodeInterestSet); const NodeSet& nodeInterestSet);
@ -117,8 +117,6 @@ private:
void refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer& assignment); void refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer& assignment);
void addStaticAssignmentsToQueue(); void addStaticAssignmentsToQueue();
void respondToPathQuery(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr);
QUrl oauthRedirectURL(); QUrl oauthRedirectURL();
QUrl oauthAuthorizationURL(const QUuid& stateUUID = QUuid::createUuid()); QUrl oauthAuthorizationURL(const QUuid& stateUUID = QUuid::createUuid());

4
domain-server/src/DomainServerNodeData.cpp
View file

@ -31,8 +31,8 @@ DomainServerNodeData::DomainServerNodeData() :
_paymentIntervalTimer.start(); _paymentIntervalTimer.start();
} }
void DomainServerNodeData::parseJSONStatsPacket(const QByteArray& statsPacket) { void DomainServerNodeData::processJSONStatsPacket(NLPacket& statsPacket) {
QVariantMap packetVariantMap = JSONBreakableMarshal::fromStringBuffer(statsPacket.mid(numBytesForPacketHeader(statsPacket))); QVariantMap packetVariantMap = JSONBreakableMarshal::fromStringBuffer(statsPacket.readAll());
_statsJSONObject = mergeJSONStatsFromNewObject(QJsonObject::fromVariantMap(packetVariantMap), _statsJSONObject); _statsJSONObject = mergeJSONStatsFromNewObject(QJsonObject::fromVariantMap(packetVariantMap), _statsJSONObject);
} }

3
domain-server/src/DomainServerNodeData.h
View file

@ -17,6 +17,7 @@
#include <QtCore/QUuid> #include <QtCore/QUuid>
#include <HifiSockAddr.h> #include <HifiSockAddr.h>
#include <NLPacket.h>
#include <NodeData.h> #include <NodeData.h>
#include <NodeType.h> #include <NodeType.h>
@ -27,7 +28,7 @@ public:
const QJsonObject& getStatsJSONObject() const { return _statsJSONObject; } const QJsonObject& getStatsJSONObject() const { return _statsJSONObject; }
void parseJSONStatsPacket(const QByteArray& statsPacket); void processJSONStatsPacket(NLPacket& packet);
void setAssignmentUUID(const QUuid& assignmentUUID) { _assignmentUUID = assignmentUUID; } void setAssignmentUUID(const QUuid& assignmentUUID) { _assignmentUUID = assignmentUUID; }
const QUuid& getAssignmentUUID() const { return _assignmentUUID; } const QUuid& getAssignmentUUID() const { return _assignmentUUID; }

13
libraries/networking/src/Assignment.cpp
View file

@ -60,28 +60,25 @@ Assignment::Assignment(Assignment::Command command, Assignment::Type type, const
} }
} }
Assignment::Assignment(const QByteArray& packet) : Assignment::Assignment(NLPacket& packet) :
_pool(), _pool(),
_location(GlobalLocation), _location(GlobalLocation),
_payload(), _payload(),
_walletUUID() _walletUUID()
{ {
PacketType::Value packetType = packetTypeForPacket(packet); if (packet.getType() == PacketType::RequestAssignment) {
if (packetType == PacketType::RequestAssignment) {
_command = Assignment::RequestCommand; _command = Assignment::RequestCommand;
} else if (packetType == PacketType::CreateAssignment) { } else if (packet.getType() == PacketType::CreateAssignment) {
_command = Assignment::CreateCommand; _command = Assignment::CreateCommand;
} }
QDataStream packetStream(packet); QDataStream packetStream(&packet);
packetStream.skipRawData(numBytesForPacketHeader(packet));
packetStream >> *this; packetStream >> *this;
} }
#ifdef WIN32 #ifdef WIN32
#pragma warning(default:4351) #pragma warning(default:4351)
#endif #endif

7
libraries/networking/src/Assignment.h
View file

@ -59,10 +59,9 @@ public:
void swap(Assignment& otherAssignment); void swap(Assignment& otherAssignment);
/// Constructs an Assignment from the data in the buffer /// Constructs an Assignment from a network packet
/// \param dataBuffer the source buffer to un-pack the assignment from /// \param packet the packet to un-pack the assignment from
/// \param numBytes the number of bytes left to read in the source buffer Assignment(NLPacket& packet);
Assignment(const QByteArray& packet);
void setUUID(const QUuid& uuid) { _uuid = uuid; } void setUUID(const QUuid& uuid) { _uuid = uuid; }
const QUuid& getUUID() const { return _uuid; } const QUuid& getUUID() const { return _uuid; }

3
libraries/networking/src/LimitedNodeList.cpp
View file

@ -98,6 +98,9 @@ LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short
connect(&_nodeSocket, &QUdpSocket::readyRead, &_packetReceiver, &PacketReceiver::processDatagrams); connect(&_nodeSocket, &QUdpSocket::readyRead, &_packetReceiver, &PacketReceiver::processDatagrams);
_packetStatTimer.start(); _packetStatTimer.start();
// make sure we handle STUN response packets
_packetReceiver.registerPacketListener(PacketType::StunResponse, this, "processSTUNResponse");
} }
void LimitedNodeList::setSessionUUID(const QUuid& sessionUUID) { void LimitedNodeList::setSessionUUID(const QUuid& sessionUUID) {

1
libraries/networking/src/LimitedNodeList.h
View file

@ -243,6 +243,7 @@ public slots:
virtual void sendSTUNRequest(); virtual void sendSTUNRequest();
void killNodeWithUUID(const QUuid& nodeUUID); void killNodeWithUUID(const QUuid& nodeUUID);
signals: signals:
void uuidChanged(const QUuid& ownerUUID, const QUuid& oldUUID); void uuidChanged(const QUuid& ownerUUID, const QUuid& oldUUID);
void nodeAdded(SharedNodePointer); void nodeAdded(SharedNodePointer);

1
libraries/networking/src/NodeList.cpp
View file

@ -101,7 +101,6 @@ NodeList::NodeList(char newOwnerType, unsigned short socketListenPort, unsigned
packetReceiver.registerPacketListener(PacketType::PingReply, this, "processPingReplyPacket"); packetReceiver.registerPacketListener(PacketType::PingReply, this, "processPingReplyPacket");
packetReceiver.registerPacketListener(PacketType::ICEPing, this, "processICEPingPacket"); packetReceiver.registerPacketListener(PacketType::ICEPing, this, "processICEPingPacket");
packetReceiver.registerPacketListener(PacketType::ICEPingReply, this, "processICEPingReplyPacket"); packetReceiver.registerPacketListener(PacketType::ICEPingReply, this, "processICEPingReplyPacket");
packetReceiver.registerPacketListener(PacketType::StunResponse, this, "processSTUNResponse");
} }
qint64 NodeList::sendStats(const QJsonObject& statsObject, const HifiSockAddr& destination) { qint64 NodeList::sendStats(const QJsonObject& statsObject, const HifiSockAddr& destination) {

3
libraries/networking/src/PacketHeaders.cpp
View file

@ -21,6 +21,7 @@ const QSet<PacketType::Value> NON_VERIFIED_PACKETS = QSet<PacketType::Value>()
<< CreateAssignment << RequestAssignment << StunResponse << CreateAssignment << RequestAssignment << StunResponse
<< NodeJsonStats << EntityQuery << NodeJsonStats << EntityQuery
<< OctreeDataNack << EntityEditNack << OctreeDataNack << EntityEditNack
<< DomainListRequest
<< Ping << Ping
<< PingReply << StopNode; << PingReply << StopNode;
@ -28,7 +29,7 @@ const QSet<PacketType::Value> SEQUENCE_NUMBERED_PACKETS = QSet<PacketType::Value
const QSet<PacketType::Value> NON_SOURCED_PACKETS = QSet<PacketType::Value>() const QSet<PacketType::Value> NON_SOURCED_PACKETS = QSet<PacketType::Value>()
<< DomainServerRequireDTLS << DomainConnectRequest << DomainServerRequireDTLS << DomainConnectRequest
<< DomainList << DomainListRequest << DomainConnectionDenied << DomainList << DomainConnectionDenied
<< DomainServerPathQuery << DomainServerPathResponse << DomainServerPathQuery << DomainServerPathResponse
<< DomainServerAddedNode << DomainServerAddedNode
<< ICEServerPeerInformation << ICEServerQuery << ICEServerHeartbeat << ICEServerPeerInformation << ICEServerQuery << ICEServerHeartbeat

2
libraries/networking/src/ThreadedAssignment.cpp
View file

@ -18,7 +18,7 @@
#include "ThreadedAssignment.h" #include "ThreadedAssignment.h"
ThreadedAssignment::ThreadedAssignment(const QByteArray& packet) : ThreadedAssignment::ThreadedAssignment(NLPacket& packet) :
Assignment(packet), Assignment(packet),
_isFinished(false), _isFinished(false),
_datagramProcessingThread(NULL) _datagramProcessingThread(NULL)

2
libraries/networking/src/ThreadedAssignment.h
View file

@ -19,7 +19,7 @@
class ThreadedAssignment : public Assignment { class ThreadedAssignment : public Assignment {
Q_OBJECT Q_OBJECT
public: public:
ThreadedAssignment(const QByteArray& packet); ThreadedAssignment(NLPacket& packet);
~ThreadedAssignment() { stop(); } ~ThreadedAssignment() { stop(); }
void setFinished(bool isFinished); void setFinished(bool isFinished);