refactor stream features parsing

6 files changed, 84 insertions, 86 deletions

diff --git a/src/QXmppIncomingClient.cpp b/src/QXmppIncomingClient.cpp
index b3556b62..81ef14de 100644
--- a/src/QXmppIncomingClient.cpp
+++ b/src/QXmppIncomingClient.cpp
@@ -152,11 +152,11 @@ void QXmppIncomingClient::handleStream(const QDomElement &streamElement)
     // send stream features
     QXmppStreamFeatures features;
     if (!socket()->isEncrypted() && !socket()->localCertificate().isNull() && !socket()->privateKey().isNull())
-        features.setSecurityMode(QXmppConfiguration::TLSEnabled);
+        features.setTlsMode(QXmppStreamFeatures::Enabled);
     if (!d->username.isEmpty())
     {
-        features.setBindAvailable(true);
-        features.setSessionAvailable(true);
+        features.setBindMode(QXmppStreamFeatures::Required);
+        features.setSessionMode(QXmppStreamFeatures::Enabled);
     }
     else if (d->passwordChecker)
     {
diff --git a/src/QXmppIncomingServer.cpp b/src/QXmppIncomingServer.cpp
index 853eac8e..c7f2fca8 100644
--- a/src/QXmppIncomingServer.cpp
+++ b/src/QXmppIncomingServer.cpp
@@ -90,7 +90,7 @@ void QXmppIncomingServer::handleStream(const QDomElement &streamElement)
     // send stream features
     QXmppStreamFeatures features;
     if (!socket()->isEncrypted() && !socket()->localCertificate().isNull() && !socket()->privateKey().isNull())
-        features.setSecurityMode(QXmppConfiguration::TLSEnabled);
+        features.setTlsMode(QXmppStreamFeatures::Enabled);
     sendPacket(features);
 }
 
diff --git a/src/QXmppOutgoingClient.cpp b/src/QXmppOutgoingClient.cpp
index 38e06ddb..f7fc8bc3 100644
--- a/src/QXmppOutgoingClient.cpp
+++ b/src/QXmppOutgoingClient.cpp
@@ -237,17 +237,17 @@ void QXmppOutgoingClient::handleStanza(const QDomElement &nodeRecv)
         {
             // determine TLS mode to use
             const QXmppConfiguration::StreamSecurityMode localSecurity = configuration().streamSecurityMode();
-            const QXmppConfiguration::StreamSecurityMode remoteSecurity = features.securityMode();
+            const QXmppStreamFeatures::Mode remoteSecurity = features.tlsMode();
             if (!socket()->supportsSsl() &&
                 (localSecurity == QXmppConfiguration::TLSRequired ||
-                 remoteSecurity == QXmppConfiguration::TLSRequired))
+                 remoteSecurity == QXmppStreamFeatures::Required))
             {
                 warning("Disconnecting as TLS is required, but SSL support is not available");
                 disconnectFromHost();
                 return;
             }
             if (localSecurity == QXmppConfiguration::TLSRequired &&
-                remoteSecurity == QXmppConfiguration::TLSDisabled)
+                remoteSecurity == QXmppStreamFeatures::Disabled)
             {
                 warning("Disconnecting as TLS is required, but not supported by the server");
                 disconnectFromHost();
@@ -255,8 +255,8 @@ void QXmppOutgoingClient::handleStanza(const QDomElement &nodeRecv)
             }
 
             if (socket()->supportsSsl() &&
-                remoteSecurity != QXmppConfiguration::TLSDisabled && 
-                localSecurity != QXmppConfiguration::TLSDisabled)
+                localSecurity != QXmppConfiguration::TLSDisabled &&
+                remoteSecurity != QXmppStreamFeatures::Disabled) 
             {
                 // enable TLS as it is support by both parties
                 sendData("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
@@ -265,7 +265,7 @@ void QXmppOutgoingClient::handleStanza(const QDomElement &nodeRecv)
         }
 
         // handle authentication
-        const bool nonSaslAvailable = features.isNonSaslAuthAvailable();
+        const bool nonSaslAvailable = features.nonSaslAuthMode() != QXmppStreamFeatures::Disabled;
         const bool saslAvailable = !features.authMechanisms().isEmpty();
         const bool useSasl = configuration().useSASLAuthentication();
         if((saslAvailable && nonSaslAvailable && !useSasl) ||
@@ -313,7 +313,7 @@ void QXmppOutgoingClient::handleStanza(const QDomElement &nodeRecv)
         }
 
         // check whether bind is available
-        if (features.isBindAvailable())
+        if (features.bindMode() != QXmppStreamFeatures::Disabled)
         {
             QXmppBindIq bind;
             bind.setType(QXmppIq::Set);
@@ -323,7 +323,7 @@ void QXmppOutgoingClient::handleStanza(const QDomElement &nodeRecv)
         }
 
         // check whether session is available
-        if (features.isSessionAvailable())
+        if (features.sessionMode() != QXmppStreamFeatures::Disabled)
             d->sessionAvailable = true;
     }
     else if(ns == ns_stream && nodeRecv.tagName() == "error")
diff --git a/src/QXmppOutgoingServer.cpp b/src/QXmppOutgoingServer.cpp
index 4e5a05b0..c3790cd0 100644
--- a/src/QXmppOutgoingServer.cpp
+++ b/src/QXmppOutgoingServer.cpp
@@ -83,7 +83,7 @@ void QXmppOutgoingServer::handleStanza(const QDomElement &stanza)
     {
         QXmppStreamFeatures features;
         features.parse(stanza);
-        if (features.securityMode() != QXmppConfiguration::TLSDisabled)
+        if (features.tlsMode() != QXmppStreamFeatures::Disabled)
         {
             // let QXmppOutgoingClient handle TLS
             QXmppOutgoingClient::handleStanza(stanza);
diff --git a/src/QXmppStreamFeatures.cpp b/src/QXmppStreamFeatures.cpp
index a3158ece..cc007840 100644
--- a/src/QXmppStreamFeatures.cpp
+++ b/src/QXmppStreamFeatures.cpp
@@ -27,41 +27,41 @@
 #include "QXmppStreamFeatures.h"
 
 QXmppStreamFeatures::QXmppStreamFeatures()
-    : m_bindAvailable(false),
-    m_sessionAvailable(false),
-    m_nonSaslAuthAvailable(false),
-    m_securityMode(QXmppConfiguration::TLSDisabled)
+    : m_bindMode(Disabled),
+    m_sessionMode(Disabled),
+    m_nonSaslAuthMode(Disabled),
+    m_tlsMode(Disabled)
 {
 }
 
-bool QXmppStreamFeatures::isBindAvailable() const
+QXmppStreamFeatures::Mode QXmppStreamFeatures::bindMode() const
 {
-    return m_bindAvailable;
+    return m_bindMode;
 }
 
-void QXmppStreamFeatures::setBindAvailable(bool available)
+void QXmppStreamFeatures::setBindMode(QXmppStreamFeatures::Mode mode)
 {
-    m_bindAvailable = available;
+    m_bindMode = mode;
 }
 
-bool QXmppStreamFeatures::isSessionAvailable() const
+QXmppStreamFeatures::Mode QXmppStreamFeatures::sessionMode() const
 {
-    return m_sessionAvailable;
+    return m_sessionMode;
 }
 
-void QXmppStreamFeatures::setSessionAvailable(bool available)
+void QXmppStreamFeatures::setSessionMode(Mode mode)
 {
-    m_sessionAvailable = available;
+    m_sessionMode = mode;
 }
 
-bool QXmppStreamFeatures::isNonSaslAuthAvailable() const
+QXmppStreamFeatures::Mode QXmppStreamFeatures::nonSaslAuthMode() const
 {
-    return m_nonSaslAuthAvailable;
+    return m_nonSaslAuthMode;
 }
 
-void QXmppStreamFeatures::setNonSaslAuthAvailable(bool available)
+void QXmppStreamFeatures::setNonSaslAuthMode(QXmppStreamFeatures::Mode mode)
 {
-    m_nonSaslAuthAvailable = available;
+    m_nonSaslAuthMode = mode;
 }
 
 QList<QXmppConfiguration::SASLAuthMechanism> QXmppStreamFeatures::authMechanisms() const
@@ -84,14 +84,14 @@ void QXmppStreamFeatures::setCompressionMethods(QList<QXmppConfiguration::Compre
     m_compressionMethods = methods;
 }
 
-QXmppConfiguration::StreamSecurityMode QXmppStreamFeatures::securityMode() const
+QXmppStreamFeatures::Mode QXmppStreamFeatures::tlsMode() const
 {
-    return m_securityMode;
+    return m_tlsMode;
 }
 
-void QXmppStreamFeatures::setSecurityMode(QXmppConfiguration::StreamSecurityMode mode)
+void QXmppStreamFeatures::setTlsMode(QXmppStreamFeatures::Mode mode)
 {
-    m_securityMode = mode;
+    m_tlsMode = mode;
 }
 
 bool QXmppStreamFeatures::isStreamFeatures(const QDomElement &element)
@@ -100,10 +100,26 @@ bool QXmppStreamFeatures::isStreamFeatures(const QDomElement &element)
            element.tagName() == "features";
 }
 
+static QXmppStreamFeatures::Mode readFeature(const QDomElement &element, const char *tagName, const char *tagNs)
+{
+    QDomElement subElement = element.firstChildElement(tagName);
+    if (subElement.namespaceURI() == tagNs)
+    {
+        if (!subElement.firstChildElement("required").isNull())
+            return QXmppStreamFeatures::Required;
+        else
+            return QXmppStreamFeatures::Enabled;
+    } else {
+        return QXmppStreamFeatures::Disabled;
+    }
+}
+
 void QXmppStreamFeatures::parse(const QDomElement &element)
 {
-    m_bindAvailable = !element.firstChildElement("bind").isNull();
-    m_sessionAvailable = !element.firstChildElement("session").isNull();
+    m_bindMode = readFeature(element, "bind", ns_bind);
+    m_sessionMode = readFeature(element, "session", ns_session);
+    m_nonSaslAuthMode = readFeature(element, "auth", ns_authFeature);
+    m_tlsMode = readFeature(element, "starttls", ns_tls);
 
     // parse advertised compression methods
     QDomElement compression = element.firstChildElement("compression");
@@ -134,39 +150,28 @@ void QXmppStreamFeatures::parse(const QDomElement &element)
             subElement = subElement.nextSiblingElement("mechanism");
         }
     }
+}
 
-    // parse advertised Non-SASL Authentication
-    QDomElement authElement = element.firstChildElement("auth");
-    m_nonSaslAuthAvailable = (authElement.namespaceURI() == ns_authFeature);
-
-    // parse advertised TLS mode
-    QDomElement tlsElement = element.firstChildElement("starttls");
-    if (tlsElement.namespaceURI() == ns_tls)
+static void writeFeature(QXmlStreamWriter *writer, const char *tagName, const char *tagNs, QXmppStreamFeatures::Mode mode)
+{
+    if (mode != QXmppStreamFeatures::Disabled)
     {
-        if (tlsElement.firstChildElement().tagName() == "required")
-            m_securityMode = QXmppConfiguration::TLSRequired;
-        else
-            m_securityMode = QXmppConfiguration::TLSEnabled;
-    } else {
-        m_securityMode = QXmppConfiguration::TLSDisabled;
+        writer->writeStartElement(tagName);
+        writer->writeAttribute("xmlns", tagNs);
+        if (mode == QXmppStreamFeatures::Required)
+            writer->writeEmptyElement("required");
+        writer->writeEndElement();
     }
 }
 
 void QXmppStreamFeatures::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement("stream:features");
-    if (m_bindAvailable)
-    {
-        writer->writeStartElement("bind");
-        writer->writeAttribute("xmlns", ns_bind);
-        writer->writeEndElement();
-    }
-    if (m_sessionAvailable)
-    {
-        writer->writeStartElement("session");
-        writer->writeAttribute("xmlns", ns_session);
-        writer->writeEndElement();
-    }
+    writeFeature(writer, "bind", ns_bind, m_bindMode);
+    writeFeature(writer, "session", ns_session, m_sessionMode);
+    writeFeature(writer, "auth", ns_authFeature, m_nonSaslAuthMode);
+    writeFeature(writer, "starttls", ns_tls, m_tlsMode);
+
     if (!m_compressionMethods.isEmpty())
     {
         writer->writeStartElement("compression");
@@ -207,20 +212,6 @@ void QXmppStreamFeatures::toXml(QXmlStreamWriter *writer) const
         }
         writer->writeEndElement();
     }
-    if (m_nonSaslAuthAvailable)
-    {
-        writer->writeStartElement("auth");
-        writer->writeAttribute("xmlns", ns_authFeature);
-        writer->writeEndElement();
-    }
-    if (m_securityMode != QXmppConfiguration::TLSDisabled)
-    {
-        writer->writeStartElement("starttls");
-        writer->writeAttribute("xmlns", ns_tls);
-        if (m_securityMode == QXmppConfiguration::TLSRequired)
-            writer->writeEmptyElement("required");
-        writer->writeEndElement();
-    }
     writer->writeEndElement();
 }
 
diff --git a/src/QXmppStreamFeatures.h b/src/QXmppStreamFeatures.h
index df2d504f..c47fe06b 100644
--- a/src/QXmppStreamFeatures.h
+++ b/src/QXmppStreamFeatures.h
@@ -32,14 +32,21 @@ class QXmppStreamFeatures : public QXmppStanza
 public:
     QXmppStreamFeatures();
 
-    bool isBindAvailable() const;
-    void setBindAvailable(bool available);
+    enum Mode
+    {
+        Disabled = 0,
+        Enabled,
+        Required
+    };
 
-    bool isSessionAvailable() const;
-    void setSessionAvailable(bool available);
+    Mode bindMode() const;
+    void setBindMode(Mode mode);
 
-    bool isNonSaslAuthAvailable() const;
-    void setNonSaslAuthAvailable(bool available);
+    Mode sessionMode() const;
+    void setSessionMode(Mode mode);
+
+    Mode nonSaslAuthMode() const;
+    void setNonSaslAuthMode(Mode mode);
 
     QList<QXmppConfiguration::SASLAuthMechanism> authMechanisms() const;
     void setAuthMechanisms(QList<QXmppConfiguration::SASLAuthMechanism> &mecanisms);
@@ -47,8 +54,8 @@ public:
     QList<QXmppConfiguration::CompressionMethod> compressionMethods() const;
     void setCompressionMethods(QList<QXmppConfiguration::CompressionMethod> &methods);
 
-    QXmppConfiguration::StreamSecurityMode securityMode() const;
-    void setSecurityMode(QXmppConfiguration::StreamSecurityMode mode);
+    Mode tlsMode() const;
+    void setTlsMode(Mode mode);
 
     /// \cond
     void parse(const QDomElement &element);
@@ -58,12 +65,12 @@ public:
     static bool isStreamFeatures(const QDomElement &element);
 
 private:
-    bool m_bindAvailable;
-    bool m_sessionAvailable;
-    bool m_nonSaslAuthAvailable;
+    Mode m_bindMode;
+    Mode m_sessionMode;
+    Mode m_nonSaslAuthMode;
+    Mode m_tlsMode;
     QList<QXmppConfiguration::SASLAuthMechanism> m_authMechanisms;
     QList<QXmppConfiguration::CompressionMethod> m_compressionMethods;
-    QXmppConfiguration::StreamSecurityMode m_securityMode;
 };
 
 #endif