Network::clearCaps only sync when caps removed

[quassel.git] / src / common / network.cpp

diff --git a/src/common/network.cpp b/src/common/network.cpp
index b60d944..b1e4519 100644 (file)
--- a/src/common/network.cpp
+++ b/src/common/network.cpp
@@ -705,6 +705,77 @@ QVariantMap Network::initSupports() const
     return supports;
 }
 
+void Network::addCap(const QString &capability, const QString &value)
+{
+    // IRCv3 specs all use lowercase capability names
+    QString _capLowercase = capability.toLower();
+    if (!_caps.contains(_capLowercase)) {
+        _caps[_capLowercase] = value;
+        SYNC(ARG(capability), ARG(value))
+        emit capAdded(_capLowercase);
+    }
+}
+
+void Network::acknowledgeCap(const QString &capability)
+{
+    // IRCv3 specs all use lowercase capability names
+    QString _capLowercase = capability.toLower();
+    if (!_capsEnabled.contains(_capLowercase)) {
+        _capsEnabled.append(_capLowercase);
+        SYNC(ARG(capability))
+        emit capAcknowledged(_capLowercase);
+    }
+}
+
+void Network::removeCap(const QString &capability)
+{
+    // IRCv3 specs all use lowercase capability names
+    QString _capLowercase = capability.toLower();
+    if (_caps.contains(_capLowercase)) {
+        // Remove from the list of available capabilities.
+        _caps.remove(_capLowercase);
+        // Remove it from the acknowledged list if it was previously acknowledged.  The SYNC call
+        // ensures this propogates to the other side.
+        // Use removeOne() for speed; no more than one due to contains() check in acknowledgeCap().
+        _capsEnabled.removeOne(_capLowercase);
+        SYNC(ARG(capability))
+        emit capRemoved(_capLowercase);
+    }
+}
+
+void Network::clearCaps()
+{
+    // IRCv3 specs all use lowercase capability names
+    if (_caps.empty() && _capsEnabled.empty()) {
+        // Avoid the sync call if there's nothing to clear (e.g. failed reconnects)
+        return;
+    }
+    // To ease core-side configuration, loop through the list and emit capRemoved for each entry.
+    // If performance issues arise, this can be converted to a more-efficient setup without breaking
+    // protocol (in theory).
+    QString _capLowercase;
+    foreach (const QString &capability, _caps) {
+        _capLowercase = capability.toLower();
+        emit capRemoved(_capLowercase);
+    }
+    // Clear capabilities from the stored list
+    _caps.clear();
+    _capsEnabled.clear();
+
+    SYNC(NO_ARG)
+}
+
+QVariantMap Network::initCaps() const
+{
+    QVariantMap caps;
+    QHashIterator<QString, QString> iter(_caps);
+    while (iter.hasNext()) {
+        iter.next();
+        caps[iter.key()] = iter.value();
+    }
+    return caps;
+}
+
 
 // There's potentially a lot of users and channels, so it makes sense to optimize the format of this.
 // Rather than sending a thousand maps with identical keys, we convert this into one map containing lists
@@ -820,6 +891,16 @@ void Network::initSetSupports(const QVariantMap &supports)
 }
 
 
+void Network::initSetCaps(const QVariantMap &caps)
+{
+    QMapIterator<QString, QVariant> iter(caps);
+    while (iter.hasNext()) {
+        iter.next();
+        addCap(iter.key(), iter.value().toString());
+    }
+}
+
+
 IrcUser *Network::updateNickFromMask(const QString &mask)
 {
     QString nick(nickFromMask(mask).toLower());
@@ -1034,6 +1115,7 @@ QDataStream &operator<<(QDataStream &out, const Network::Server &server)
     serverMap["Port"] = server.port;
     serverMap["Password"] = server.password;
     serverMap["UseSSL"] = server.useSsl;
+    serverMap["sslVerify"] = server.sslVerify;
     serverMap["sslVersion"] = server.sslVersion;
     serverMap["UseProxy"] = server.useProxy;
     serverMap["ProxyType"] = server.proxyType;
@@ -1054,6 +1136,7 @@ QDataStream &operator>>(QDataStream &in, Network::Server &server)
     server.port = serverMap["Port"].toUInt();
     server.password = serverMap["Password"].toString();
     server.useSsl = serverMap["UseSSL"].toBool();
+    server.sslVerify = serverMap["sslVerify"].toBool();
     server.sslVersion = serverMap["sslVersion"].toInt();
     server.useProxy = serverMap["UseProxy"].toBool();
     server.proxyType = serverMap["ProxyType"].toInt();
@@ -1071,6 +1154,7 @@ bool Network::Server::operator==(const Server &other) const
     if (port != other.port) return false;
     if (password != other.password) return false;
     if (useSsl != other.useSsl) return false;
+    if (sslVerify != other.sslVerify) return false;
     if (sslVersion != other.sslVersion) return false;
     if (useProxy != other.useProxy) return false;
     if (proxyType != other.proxyType) return false;
@@ -1090,6 +1174,7 @@ bool Network::Server::operator!=(const Server &other) const
 
 QDebug operator<<(QDebug dbg, const Network::Server &server)
 {
-    dbg.nospace() << "Server(host = " << server.host << ":" << server.port << ", useSsl = " << server.useSsl << ")";
+    dbg.nospace() << "Server(host = " << server.host << ":" << server.port << ", useSsl = " <<
+                     server.useSsl << ", sslVerify = " << server.sslVerify << ")";
     return dbg.space();
 }