check point with protocol refusal working

domain-server/src/DomainGatekeeper.cpp

@@ -548,12 +548,27 @@ void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const H
     quint16 payloadSize = utfString.size();
     
     // setup the DomainConnectionDenied packet
-    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied, payloadSize + sizeof(payloadSize));
+    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied); // , payloadSize + sizeof(payloadSize)
     
     // pack in the reason the connection was denied (the client displays this)
     if (payloadSize > 0) {
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write reasonCode:" << (int)reasonCode;
+        uint8_t reasonCodeWire = (uint8_t)reasonCode;
+        qDebug() << __FUNCTION__ << "about to write reasonCodeWire:" << (int)reasonCodeWire;
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        connectionDeniedPacket->writePrimitive(reasonCodeWire);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write payloadSize:" << payloadSize;
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->writePrimitive(payloadSize);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write utfString:" << utfString;
+        qDebug() << __FUNCTION__ << "about to write utfString.size():" << utfString.size();
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->write(utfString);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+
     }
     
     // send the packet off

interface/src/Application.cpp

@@ -630,8 +630,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(&domainHandler, SIGNAL(connectedToDomain(const QString&)), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(clearDomainOctreeDetails()));
-    
     connect(&domainHandler, &DomainHandler::resetting, nodeList.data(), &NodeList::resetDomainServerCheckInVersion);
+    connect(&domainHandler, &DomainHandler::domainConnectionRefused, this, &Application::domainConnectionRefused);
 
     // update our location every 5 seconds in the metaverse server, assuming that we are authenticated with one
     const qint64 DATA_SERVER_LOCATION_CHANGE_UPDATE_MSECS = 5 * MSECS_PER_SECOND;
@@ -1068,6 +1068,17 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     firstRun.set(false);
 }
 
+void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCode) {
+    qDebug() << __FUNCTION__ << "message:" << reasonMessage << "code:" << reasonCode;
+    qDebug() << __FUNCTION__ << "DomainHandler::ConnectionRefusedReason::ProtocolMismatch:" << (int)DomainHandler::ConnectionRefusedReason::ProtocolMismatch;
+
+    if (static_cast<DomainHandler::ConnectionRefusedReason>(reasonCode) == DomainHandler::ConnectionRefusedReason::ProtocolMismatch) {
+        qDebug() << __FUNCTION__ << " PROTOCOL MISMATCH!!!";
+        notifyPacketVersionMismatch();
+    }
+}
+
+
 QString Application::getUserAgent() {
     if (QThread::currentThread() != thread()) {
         QString userAgent;

interface/src/Application.h

@@ -330,6 +330,7 @@ private slots:
     static void packetSent(quint64 length);
     void updateDisplayMode();
     void updateInputModes();
+    void domainConnectionRefused(const QString& reasonMessage, int reason);
 
 private:
     static void initDisplay();

interface/src/scripting/WindowScriptingInterface.h

@@ -47,7 +47,7 @@ public slots:
 signals:
     void domainChanged(const QString& domainHostname);
     void svoImportRequested(const QString& url);
-    void domainConnectionRefused(const QString& reasonMessage, DomainHandler::ConnectionRefusedReason reason = DomainHandler::ConnectionRefusedReason::Unknown);
+    void domainConnectionRefused(const QString& reasonMessage, int reason);
 
 private slots:
     WebWindowClass* doCreateWebWindow(const QString& title, const QString& url, int width, int height);

libraries/networking/src/DomainHandler.cpp

@@ -103,7 +103,9 @@ void DomainHandler::hardReset() {
     _sockAddr.clear();
 
     _hasCheckedForAccessToken = false;
-    _domainConnectionRefusals.clear();
+
+    //qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
+    //_domainConnectionRefusals.clear();
 
     // clear any pending path we may have wanted to ask the previous DS about
     _pendingPath.clear();
@@ -142,6 +144,10 @@ void DomainHandler::setSocketAndID(const QString& hostname, quint16 port, const
             // set the new hostname
             _hostname = hostname;
 
+            // FIXME - is this the right place???
+            qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
+            _domainConnectionRefusals.clear();
+
             qCDebug(networking) << "Updated domain hostname to" << _hostname;
 
             // re-set the sock addr to null and fire off a lookup of the IP address for this domain-server's hostname
@@ -366,25 +372,50 @@ bool DomainHandler::reasonSuggestsLogin(ConnectionRefusedReason reasonCode) {
 
 void DomainHandler::processDomainServerConnectionDeniedPacket(QSharedPointer<ReceivedMessage> message) {
     // Read deny reason from packet
-    ConnectionRefusedReason reasonCode = DomainHandler::ConnectionRefusedReason::Unknown;
+    uint8_t reasonCodeWire;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+    message->readPrimitive(&reasonCodeWire);
+    qDebug() << __FUNCTION__ << "reasonCodeWire:" << reasonCodeWire;
+    ConnectionRefusedReason reasonCode = static_cast<ConnectionRefusedReason>(reasonCodeWire);
+    qDebug() << __FUNCTION__ << "reasonCode:" << (int)reasonCode;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+
     quint16 reasonSize;
     message->readPrimitive(&reasonSize);
-    QString reasonMessage = QString::fromUtf8(message->readWithoutCopy(reasonSize));
+    qDebug() << __FUNCTION__ << "reasonSize:" << reasonSize;
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+    auto reasonText = message->readWithoutCopy(reasonSize);
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonText:" << reasonText;
+    QString reasonMessage = QString::fromUtf8(reasonText);
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonMessage:" << reasonMessage;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
 
     // output to the log so the user knows they got a denied connection request
     // and check and signal for an access token so that we can make sure they are logged in
     qCWarning(networking) << "The domain-server denied a connection request: " << reasonMessage;
-    qCWarning(networking) << "Make sure you are logged in.";
+
+    qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
 
     if (!_domainConnectionRefusals.contains(reasonMessage)) {
+        qDebug(networking) << "about to call _domainConnectionRefusals.append(reasonMessage);";
         _domainConnectionRefusals.append(reasonMessage);
-        emit domainConnectionRefused(reasonMessage, reasonCode);
+        qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
+
+
+        emit domainConnectionRefused(reasonMessage, (int)reasonCode);
+    } else {
+        qDebug(networking) << "ALREADY EMITTED domainConnectionRefused() ----------------------------";
     }
 
     auto accountManager = DependencyManager::get<AccountManager>();
 
     // Some connection refusal reasons imply that a login is required. If so, suggest a new login
     if (reasonSuggestsLogin(reasonCode)) {
+        qCWarning(networking) << "Make sure you are logged in.";
+
         if (!_hasCheckedForAccessToken) {
             accountManager->checkAndSignalForAccessToken();
             _hasCheckedForAccessToken = true;

libraries/networking/src/DomainHandler.h

@@ -124,7 +124,7 @@ signals:
     void settingsReceived(const QJsonObject& domainSettingsObject);
     void settingsReceiveFail();
 
-    void domainConnectionRefused(QString reasonMessage, ConnectionRefusedReason reason = ConnectionRefusedReason::Unknown);
+    void domainConnectionRefused(QString reasonMessage, int reason);
 
 private:
     bool reasonSuggestsLogin(ConnectionRefusedReason reasonCode);

libraries/networking/src/PacketReceiver.cpp

@@ -310,7 +310,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
 
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
 
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
@@ -318,19 +318,19 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
 
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
 
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                     }
                 } else {
                     listenerIsDead = true;
                 }
             } else {
-                qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
+                //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
 
                 // qDebug() << "Got verified unsourced packet list: " << QString(nlPacketList->getMessage());
                 emit dataReceived(NodeType::Unassigned, receivedMessage->getSize());
@@ -340,7 +340,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                     success = listener.method.invoke(listener.object,
                                                      Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
 
-                    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                    //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                 } else {
                     listenerIsDead = true;
                 }