modernize: Use nullptr
[quassel.git] / src / common / network.cpp
index 4ce07fe..f76cd30 100644 (file)
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2012 by the Quassel Project                        *
+ *   Copyright (C) 2005-2018 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
-#include <QSettings>
+#include <algorithm>
+
 #include <QTextCodec>
 
 #include "network.h"
-#include "quassel.h"
+#include "peer.h"
 
-QTextCodec *Network::_defaultCodecForServer = 0;
-QTextCodec *Network::_defaultCodecForEncoding = 0;
-QTextCodec *Network::_defaultCodecForDecoding = 0;
-QString Network::_networksIniPath = QString();
+QTextCodec *Network::_defaultCodecForServer = nullptr;
+QTextCodec *Network::_defaultCodecForEncoding = nullptr;
+QTextCodec *Network::_defaultCodecForDecoding = nullptr;
 
 // ====================
 //  Public:
 // ====================
-INIT_SYNCABLE_OBJECT(Network)
+
 Network::Network(const NetworkId &networkid, QObject *parent)
     : SyncableObject(parent),
-    _proxy(0),
+    _proxy(nullptr),
     _networkId(networkid),
     _identity(0),
     _myNick(QString()),
@@ -53,9 +53,13 @@ Network::Network(const NetworkId &networkid, QObject *parent)
     _autoReconnectInterval(60),
     _autoReconnectRetries(10),
     _unlimitedReconnectRetries(false),
-    _codecForServer(0),
-    _codecForEncoding(0),
-    _codecForDecoding(0),
+    _useCustomMessageRate(false),
+    _messageRateBurstSize(5),
+    _messageRateDelay(2200),
+    _unlimitedMessageRate(false),
+    _codecForServer(nullptr),
+    _codecForEncoding(nullptr),
+    _codecForDecoding(nullptr),
     _autoAwayActive(false)
 {
     setObjectName(QString::number(networkid.toInt()));
@@ -80,6 +84,18 @@ bool Network::isChannelName(const QString &channelname) const
 }
 
 
+bool Network::isStatusMsg(const QString &target) const
+{
+    if (target.isEmpty())
+        return false;
+
+    if (supports("STATUSMSG"))
+        return support("STATUSMSG").contains(target[0]);
+    else
+        return QString("@+").contains(target[0]);
+}
+
+
 NetworkInfo Network::networkInfo() const
 {
     NetworkInfo info;
@@ -103,6 +119,10 @@ NetworkInfo Network::networkInfo() const
     info.autoReconnectRetries = autoReconnectRetries();
     info.unlimitedReconnectRetries = unlimitedReconnectRetries();
     info.rejoinChannels = rejoinChannels();
+    info.useCustomMessageRate = useCustomMessageRate();
+    info.messageRateBurstSize = messageRateBurstSize();
+    info.messageRateDelay = messageRateDelay();
+    info.unlimitedMessageRate = unlimitedMessageRate();
     return info;
 }
 
@@ -129,6 +149,15 @@ void Network::setNetworkInfo(const NetworkInfo &info)
     if (info.autoReconnectRetries != autoReconnectRetries()) setAutoReconnectRetries(info.autoReconnectRetries);
     if (info.unlimitedReconnectRetries != unlimitedReconnectRetries()) setUnlimitedReconnectRetries(info.unlimitedReconnectRetries);
     if (info.rejoinChannels != rejoinChannels()) setRejoinChannels(info.rejoinChannels);
+    // Custom rate limiting
+    if (info.useCustomMessageRate != useCustomMessageRate())
+        setUseCustomMessageRate(info.useCustomMessageRate);
+    if (info.messageRateBurstSize != messageRateBurstSize())
+        setMessageRateBurstSize(info.messageRateBurstSize);
+    if (info.messageRateDelay != messageRateDelay())
+        setMessageRateDelay(info.messageRateDelay);
+    if (info.unlimitedMessageRate != unlimitedMessageRate())
+        setUnlimitedMessageRate(info.unlimitedMessageRate);
 }
 
 
@@ -150,6 +179,42 @@ QString Network::modeToPrefix(const QString &mode) const
 }
 
 
+QString Network::sortPrefixModes(const QString &modes) const
+{
+    // If modes is empty or we don't have any modes, nothing can be sorted, bail out early
+    if (modes.isEmpty() || prefixModes().isEmpty()) {
+        return modes;
+    }
+
+    // Store a copy of the modes for modification
+    // QString should be efficient and not copy memory if nothing changes, but if mistaken,
+    // std::is_sorted could be called first.
+    QString sortedModes = QString(modes);
+
+    // Sort modes as if a QChar array
+    // See https://en.cppreference.com/w/cpp/algorithm/sort
+    // Defining lambda with [&] implicitly captures variables by reference
+    std::sort(sortedModes.begin(), sortedModes.end(), [&](const QChar &lmode, const QChar &rmode) {
+        // Compare characters according to prefix modes
+        // Return true if lmode comes before rmode (is "less than")
+
+        // Check for unknown modes...
+        if (!prefixModes().contains(lmode)) {
+            // Left mode not in prefix list, send to end
+            return false;
+        } else if (!prefixModes().contains(rmode)) {
+            // Right mode not in prefix list, send to end
+            return true;
+        } else {
+            // Both characters known, sort according to index in prefixModes()
+            return (prefixModes().indexOf(lmode) < prefixModes().indexOf(rmode));
+        }
+    });
+
+    return sortedModes;
+}
+
+
 QStringList Network::nicks() const
 {
     // we don't use _ircUsers.keys() since the keys may be
@@ -215,6 +280,28 @@ QString Network::support(const QString &param) const
 }
 
 
+bool Network::saslMaybeSupports(const QString &saslMechanism) const
+{
+    if (!capAvailable(IrcCap::SASL)) {
+        // If SASL's not advertised at all, it's likely the mechanism isn't supported, as per specs.
+        // Unfortunately, we don't know for sure, but Quassel won't request SASL without it being
+        // advertised, anyways.
+        // This may also occur if the network's disconnected or negotiation hasn't yet happened.
+        return false;
+    }
+
+    // Get the SASL capability value
+    QString saslCapValue = capValue(IrcCap::SASL);
+    // SASL mechanisms are only specified in capability values as part of SASL 3.2.  In SASL 3.1,
+    // it's handled differently.  If we don't know via capability value, assume it's supported to
+    // reduce the risk of breaking existing setups.
+    // See: http://ircv3.net/specs/extensions/sasl-3.1.html
+    // And: http://ircv3.net/specs/extensions/sasl-3.2.html
+    return (saslCapValue.length() == 0)
+            || (saslCapValue.contains(saslMechanism, Qt::CaseInsensitive));
+}
+
+
 IrcUser *Network::newIrcUser(const QString &hostmask, const QVariantMap &initData)
 {
     QString nick(nickFromMask(hostmask).toLower());
@@ -234,8 +321,12 @@ IrcUser *Network::newIrcUser(const QString &hostmask, const QVariantMap &initDat
 
         _ircUsers[nick] = ircuser;
 
-        SYNC_OTHER(addIrcUser, ARG(hostmask))
-        // emit ircUserAdded(hostmask);
+        // This method will be called with a nick instead of hostmask by setInitIrcUsersAndChannels().
+        // Not a problem because initData contains all we need; however, making sure here to get the real
+        // hostmask out of the IrcUser afterwards.
+        QString mask = ircuser->hostmask();
+        SYNC_OTHER(addIrcUser, ARG(mask));
+        // emit ircUserAdded(mask);
         emit ircUserAdded(ircuser);
     }
 
@@ -249,7 +340,7 @@ IrcUser *Network::ircUser(QString nickname) const
     if (_ircUsers.contains(nickname))
         return _ircUsers[nickname];
     else
-        return 0;
+        return nullptr;
 }
 
 
@@ -260,7 +351,7 @@ void Network::removeIrcUser(IrcUser *ircuser)
         return;
 
     _ircUsers.remove(nick);
-    disconnect(ircuser, 0, this, 0);
+    disconnect(ircuser, nullptr, this, nullptr);
     ircuser->deleteLater();
 }
 
@@ -272,7 +363,7 @@ void Network::removeIrcChannel(IrcChannel *channel)
         return;
 
     _ircChannels.remove(chanName);
-    disconnect(channel, 0, this, 0);
+    disconnect(channel, nullptr, this, nullptr);
     channel->deleteLater();
 }
 
@@ -284,20 +375,6 @@ void Network::removeChansAndUsers()
     QList<IrcChannel *> channels = ircChannels();
     _ircChannels.clear();
 
-    foreach(IrcChannel *channel, channels) {
-        proxy()->detachObject(channel);
-        disconnect(channel, 0, this, 0);
-    }
-    foreach(IrcUser *user, users) {
-        proxy()->detachObject(user);
-        disconnect(user, 0, this, 0);
-    }
-
-    // the second loop is needed because quit can have sideffects
-    foreach(IrcUser *user, users) {
-        user->quit();
-    }
-
     qDeleteAll(users);
     qDeleteAll(channels);
 }
@@ -333,7 +410,7 @@ IrcChannel *Network::ircChannel(QString channelname) const
     if (_ircChannels.contains(channelname))
         return _ircChannels[channelname];
     else
-        return 0;
+        return nullptr;
 }
 
 
@@ -465,7 +542,7 @@ QByteArray Network::encodeString(const QString &string) const
     if (_defaultCodecForEncoding) {
         return _defaultCodecForEncoding->fromUnicode(string);
     }
-    return string.toAscii();
+    return string.toLatin1();
 }
 
 
@@ -486,74 +563,7 @@ QByteArray Network::encodeServerString(const QString &string) const
     if (_defaultCodecForServer) {
         return _defaultCodecForServer->fromUnicode(string);
     }
-    return string.toAscii();
-}
-
-
-/*** Handle networks.ini ***/
-
-QStringList Network::presetNetworks(bool onlyDefault)
-{
-    // lazily find the file, make sure to not call one of the other preset functions first (they'll fail else)
-    if (_networksIniPath.isNull()) {
-        _networksIniPath = Quassel::findDataFilePath("networks.ini");
-        if (_networksIniPath.isNull()) {
-            _networksIniPath = ""; // now we won't check again, as it's not null anymore
-            return QStringList();
-        }
-    }
-    if (!_networksIniPath.isEmpty()) {
-        QSettings s(_networksIniPath, QSettings::IniFormat);
-        QStringList networks = s.childGroups();
-        if (!networks.isEmpty()) {
-            // we sort the list case-insensitive
-            QMap<QString, QString> sorted;
-            foreach(QString net, networks) {
-                if (onlyDefault && !s.value(QString("%1/Default").arg(net)).toBool())
-                    continue;
-                sorted[net.toLower()] = net;
-            }
-            return sorted.values();
-        }
-    }
-    return QStringList();
-}
-
-
-QStringList Network::presetDefaultChannels(const QString &networkName)
-{
-    if (_networksIniPath.isEmpty()) // be sure to have called presetNetworks() first, else this always fails
-        return QStringList();
-    QSettings s(_networksIniPath, QSettings::IniFormat);
-    return s.value(QString("%1/DefaultChannels").arg(networkName)).toStringList();
-}
-
-
-NetworkInfo Network::networkInfoFromPreset(const QString &networkName)
-{
-    NetworkInfo info;
-    if (!_networksIniPath.isEmpty()) {
-        info.networkName = networkName;
-        QSettings s(_networksIniPath, QSettings::IniFormat);
-        s.beginGroup(info.networkName);
-        foreach(QString server, s.value("Servers").toStringList()) {
-            bool ssl = false;
-            QStringList splitserver = server.split(':', QString::SkipEmptyParts);
-            if (splitserver.count() != 2) {
-                qWarning() << "Invalid server entry in networks.conf:" << server;
-                continue;
-            }
-            if (splitserver[1].at(0) == '+')
-                ssl = true;
-            uint port = splitserver[1].toUInt();
-            if (!port) {
-                qWarning() << "Invalid port entry in networks.conf:" << server;
-                continue;
-            }
-            info.serverList << Network::Server(splitserver[0].trimmed(), port, QString(), ssl);
-        }
-    }
-    return info;
+    return string.toLatin1();
 }
 
 
@@ -744,6 +754,64 @@ void Network::setRejoinChannels(bool rejoin)
 }
 
 
+void Network::setUseCustomMessageRate(bool useCustomRate)
+{
+    if (_useCustomMessageRate != useCustomRate) {
+        _useCustomMessageRate = useCustomRate;
+        SYNC(ARG(useCustomRate))
+        emit configChanged();
+        emit useCustomMessageRateSet(_useCustomMessageRate);
+    }
+}
+
+
+void Network::setMessageRateBurstSize(quint32 burstSize)
+{
+    if (burstSize < 1) {
+        // Can't go slower than one message at a time.  Also blocks old clients from trying to set
+        // this to 0.
+        qDebug() << "Received invalid setMessageRateBurstSize data - message burst size must be "
+                    "non-zero positive, given" << burstSize;
+        return;
+    }
+    if (_messageRateBurstSize != burstSize) {
+        _messageRateBurstSize = burstSize;
+        SYNC(ARG(burstSize))
+        emit configChanged();
+        emit messageRateBurstSizeSet(_messageRateBurstSize);
+    }
+}
+
+
+void Network::setMessageRateDelay(quint32 messageDelay)
+{
+    if (messageDelay == 0) {
+        // Nonsensical to have no delay - just check the Unlimited box instead.  Also blocks old
+        // clients from trying to set this to 0.
+        qDebug() << "Received invalid setMessageRateDelay data - message delay must be non-zero "
+                    "positive, given" << messageDelay;
+        return;
+    }
+    if (_messageRateDelay != messageDelay) {
+        _messageRateDelay = messageDelay;
+        SYNC(ARG(messageDelay))
+        emit configChanged();
+        emit messageRateDelaySet(_messageRateDelay);
+    }
+}
+
+
+void Network::setUnlimitedMessageRate(bool unlimitedRate)
+{
+    if (_unlimitedMessageRate != unlimitedRate) {
+        _unlimitedMessageRate = unlimitedRate;
+        SYNC(ARG(unlimitedRate))
+        emit configChanged();
+        emit unlimitedMessageRateSet(_unlimitedMessageRate);
+    }
+}
+
+
 void Network::addSupport(const QString &param, const QString &value)
 {
     if (!_supports.contains(param)) {
@@ -773,28 +841,142 @@ 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
+// where each list index corresponds to a particular IrcUser. This saves sending the key names a thousand times.
+// Benchmarks have shown space savings of around 56%, resulting in saving several MBs worth of data on sync
+// (without compression) with a decent amount of IrcUsers.
 QVariantMap Network::initIrcUsersAndChannels() const
 {
+    Q_ASSERT(proxy());
+    Q_ASSERT(proxy()->targetPeer());
     QVariantMap usersAndChannels;
-    QVariantMap users;
-    QVariantMap channels;
-
-    QHash<QString, IrcUser *>::const_iterator userIter = _ircUsers.constBegin();
-    QHash<QString, IrcUser *>::const_iterator userIterEnd = _ircUsers.constEnd();
-    while (userIter != userIterEnd) {
-        users[userIter.value()->hostmask()] = userIter.value()->toVariantMap();
-        userIter++;
+
+    if (_ircUsers.count()) {
+        QHash<QString, QVariantList> users;
+        QHash<QString, IrcUser *>::const_iterator it = _ircUsers.begin();
+        QHash<QString, IrcUser *>::const_iterator end = _ircUsers.end();
+        while (it != end) {
+            QVariantMap map = it.value()->toVariantMap();
+            // If the peer doesn't support LongTime, replace the lastAwayMessageTime field
+            // with the 32-bit numerical seconds value (lastAwayMessage) used in older versions
+            if (!proxy()->targetPeer()->hasFeature(Quassel::Feature::LongTime)) {
+#if QT_VERSION >= 0x050800
+                int lastAwayMessage = it.value()->lastAwayMessageTime().toSecsSinceEpoch();
+#else
+                // toSecsSinceEpoch() was added in Qt 5.8.  Manually downconvert to seconds for now.
+                // See https://doc.qt.io/qt-5/qdatetime.html#toMSecsSinceEpoch
+                int lastAwayMessage = it.value()->lastAwayMessageTime().toMSecsSinceEpoch() / 1000;
+#endif
+                map.remove("lastAwayMessageTime");
+                map["lastAwayMessage"] = lastAwayMessage;
+            }
+
+            QVariantMap::const_iterator mapiter = map.begin();
+            while (mapiter != map.end()) {
+                users[mapiter.key()] << mapiter.value();
+                ++mapiter;
+            }
+            ++it;
+        }
+        // Can't have a container with a value type != QVariant in a QVariant :(
+        // However, working directly on a QVariantMap is awkward for appending, thus the detour via the hash above.
+        QVariantMap userMap;
+        foreach(const QString &key, users.keys())
+            userMap[key] = users[key];
+        usersAndChannels["Users"] = userMap;
     }
-    usersAndChannels["users"] = users;
 
-    QHash<QString, IrcChannel *>::const_iterator channelIter = _ircChannels.constBegin();
-    QHash<QString, IrcChannel *>::const_iterator channelIterEnd = _ircChannels.constEnd();
-    while (channelIter != channelIterEnd) {
-        channels[channelIter.value()->name()] = channelIter.value()->toVariantMap();
-        channelIter++;
+    if (_ircChannels.count()) {
+        QHash<QString, QVariantList> channels;
+        QHash<QString, IrcChannel *>::const_iterator it = _ircChannels.begin();
+        QHash<QString, IrcChannel *>::const_iterator end = _ircChannels.end();
+        while (it != end) {
+            const QVariantMap &map = it.value()->toVariantMap();
+            QVariantMap::const_iterator mapiter = map.begin();
+            while (mapiter != map.end()) {
+                channels[mapiter.key()] << mapiter.value();
+                ++mapiter;
+            }
+            ++it;
+        }
+        QVariantMap channelMap;
+        foreach(const QString &key, channels.keys())
+            channelMap[key] = channels[key];
+        usersAndChannels["Channels"] = channelMap;
     }
-    usersAndChannels["channels"] = channels;
 
     return usersAndChannels;
 }
@@ -803,25 +985,67 @@ QVariantMap Network::initIrcUsersAndChannels() const
 void Network::initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels)
 {
     Q_ASSERT(proxy());
+    Q_ASSERT(proxy()->sourcePeer());
     if (isInitialized()) {
-        qWarning() << "Network" << networkId() << "received init data for users and channels allthough there allready are known users or channels!";
+        qWarning() << "Network" << networkId() << "received init data for users and channels although there already are known users or channels!";
         return;
     }
 
-    QVariantMap users = usersAndChannels.value("users").toMap();
-    QVariantMap::const_iterator userIter = users.constBegin();
-    QVariantMap::const_iterator userIterEnd = users.constEnd();
-    while (userIter != userIterEnd) {
-        newIrcUser(userIter.key(), userIter.value().toMap());
-        userIter++;
+    // toMap() and toList() are cheap, so we can avoid copying to lists...
+    // However, we really have to make sure to never accidentally detach from the shared data!
+
+    const QVariantMap &users = usersAndChannels["Users"].toMap();
+
+    // sanity check
+    int count = users["nick"].toList().count();
+    foreach(const QString &key, users.keys()) {
+        if (users[key].toList().count() != count) {
+            qWarning() << "Received invalid usersAndChannels init data, sizes of attribute lists don't match!";
+            return;
+        }
     }
 
-    QVariantMap channels = usersAndChannels.value("channels").toMap();
-    QVariantMap::const_iterator channelIter = channels.constBegin();
-    QVariantMap::const_iterator channelIterEnd = channels.constEnd();
-    while (channelIter != channelIterEnd) {
-        newIrcChannel(channelIter.key(), channelIter.value().toMap());
-        channelIter++;
+    // now create the individual IrcUsers
+    for(int i = 0; i < count; i++) {
+        QVariantMap map;
+        foreach(const QString &key, users.keys())
+            map[key] = users[key].toList().at(i);
+
+        // If the peer doesn't support LongTime, upconvert the lastAwayMessageTime field
+        // from the 32-bit numerical seconds value used in older versions to QDateTime
+        if (!proxy()->sourcePeer()->hasFeature(Quassel::Feature::LongTime)) {
+            QDateTime lastAwayMessageTime = QDateTime();
+            lastAwayMessageTime.setTimeSpec(Qt::UTC);
+#if QT_VERSION >= 0x050800
+            lastAwayMessageTime.fromSecsSinceEpoch(map.take("lastAwayMessage").toInt());
+#else
+            // toSecsSinceEpoch() was added in Qt 5.8.  Manually downconvert to seconds for now.
+            // See https://doc.qt.io/qt-5/qdatetime.html#toMSecsSinceEpoch
+            lastAwayMessageTime.fromMSecsSinceEpoch(map.take("lastAwayMessage").toInt() * 1000);
+#endif
+            map["lastAwayMessageTime"] = lastAwayMessageTime;
+        }
+
+        newIrcUser(map["nick"].toString(), map); // newIrcUser() properly handles the hostmask being just the nick
+    }
+
+    // same thing for IrcChannels
+    const QVariantMap &channels = usersAndChannels["Channels"].toMap();
+
+    // sanity check
+    count = channels["name"].toList().count();
+    foreach(const QString &key, channels.keys()) {
+        if (channels[key].toList().count() != count) {
+            qWarning() << "Received invalid usersAndChannels init data, sizes of attribute lists don't match!";
+            return;
+        }
+    }
+    // now create the individual IrcChannels
+    for(int i = 0; i < count; i++) {
+        QVariantMap map;
+        foreach(const QString &key, channels.keys())
+            map[key] = channels[key].toList().at(i);
+        newIrcChannel(map["name"].toString(), map);
     }
 }
 
@@ -836,6 +1060,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());
@@ -925,45 +1159,34 @@ void Network::determinePrefixes() const
  * NetworkInfo
  ************************************************************************/
 
-NetworkInfo::NetworkInfo()
-    : networkId(0),
-    identity(1),
-    useRandomServer(false),
-    useAutoIdentify(false),
-    autoIdentifyService("NickServ"),
-    useSasl(false),
-    useAutoReconnect(true),
-    autoReconnectInterval(60),
-    autoReconnectRetries(20),
-    unlimitedReconnectRetries(false),
-    rejoinChannels(true)
-{
-}
-
 
 bool NetworkInfo::operator==(const NetworkInfo &other) const
 {
-    if (networkId != other.networkId) return false;
-    if (networkName != other.networkName) return false;
-    if (identity != other.identity) return false;
-    if (codecForServer != other.codecForServer) return false;
-    if (codecForEncoding != other.codecForEncoding) return false;
-    if (codecForDecoding != other.codecForDecoding) return false;
-    if (serverList != other.serverList) return false;
-    if (useRandomServer != other.useRandomServer) return false;
-    if (perform != other.perform) return false;
-    if (useAutoIdentify != other.useAutoIdentify) return false;
-    if (autoIdentifyService != other.autoIdentifyService) return false;
-    if (autoIdentifyPassword != other.autoIdentifyPassword) return false;
-    if (useSasl != other.useSasl) return false;
-    if (saslAccount != other.saslAccount) return false;
-    if (saslPassword != other.saslPassword) return false;
-    if (useAutoReconnect != other.useAutoReconnect) return false;
-    if (autoReconnectInterval != other.autoReconnectInterval) return false;
-    if (autoReconnectRetries != other.autoReconnectRetries) return false;
-    if (unlimitedReconnectRetries != other.unlimitedReconnectRetries) return false;
-    if (rejoinChannels != other.rejoinChannels) return false;
-    return true;
+    return     networkName               == other.networkName
+            && serverList                == other.serverList
+            && perform                   == other.perform
+            && autoIdentifyService       == other.autoIdentifyService
+            && autoIdentifyPassword      == other.autoIdentifyPassword
+            && saslAccount               == other.saslAccount
+            && saslPassword              == other.saslPassword
+            && codecForServer            == other.codecForServer
+            && codecForEncoding          == other.codecForEncoding
+            && codecForDecoding          == other.codecForDecoding
+            && networkId                 == other.networkId
+            && identity                  == other.identity
+            && messageRateBurstSize      == other.messageRateBurstSize
+            && messageRateDelay          == other.messageRateDelay
+            && autoReconnectInterval     == other.autoReconnectInterval
+            && autoReconnectRetries      == other.autoReconnectRetries
+            && rejoinChannels            == other.rejoinChannels
+            && useRandomServer           == other.useRandomServer
+            && useAutoIdentify           == other.useAutoIdentify
+            && useSasl                   == other.useSasl
+            && useAutoReconnect          == other.useAutoReconnect
+            && unlimitedReconnectRetries == other.unlimitedReconnectRetries
+            && useCustomMessageRate      == other.useCustomMessageRate
+            && unlimitedMessageRate      == other.unlimitedMessageRate
+        ;
 }
 
 
@@ -976,26 +1199,30 @@ bool NetworkInfo::operator!=(const NetworkInfo &other) const
 QDataStream &operator<<(QDataStream &out, const NetworkInfo &info)
 {
     QVariantMap i;
-    i["NetworkId"] = QVariant::fromValue<NetworkId>(info.networkId);
-    i["NetworkName"] = info.networkName;
-    i["Identity"] = QVariant::fromValue<IdentityId>(info.identity);
-    i["CodecForServer"] = info.codecForServer;
-    i["CodecForEncoding"] = info.codecForEncoding;
-    i["CodecForDecoding"] = info.codecForDecoding;
-    i["ServerList"] = toVariantList(info.serverList);
-    i["UseRandomServer"] = info.useRandomServer;
-    i["Perform"] = info.perform;
-    i["UseAutoIdentify"] = info.useAutoIdentify;
-    i["AutoIdentifyService"] = info.autoIdentifyService;
-    i["AutoIdentifyPassword"] = info.autoIdentifyPassword;
-    i["UseSasl"] = info.useSasl;
-    i["SaslAccount"] = info.saslAccount;
-    i["SaslPassword"] = info.saslPassword;
-    i["UseAutoReconnect"] = info.useAutoReconnect;
-    i["AutoReconnectInterval"] = info.autoReconnectInterval;
-    i["AutoReconnectRetries"] = info.autoReconnectRetries;
+    i["NetworkName"]               = info.networkName;
+    i["ServerList"]                = toVariantList(info.serverList);
+    i["Perform"]                   = info.perform;
+    i["AutoIdentifyService"]       = info.autoIdentifyService;
+    i["AutoIdentifyPassword"]      = info.autoIdentifyPassword;
+    i["SaslAccount"]               = info.saslAccount;
+    i["SaslPassword"]              = info.saslPassword;
+    i["CodecForServer"]            = info.codecForServer;
+    i["CodecForEncoding"]          = info.codecForEncoding;
+    i["CodecForDecoding"]          = info.codecForDecoding;
+    i["NetworkId"]                 = QVariant::fromValue<NetworkId>(info.networkId);
+    i["Identity"]                  = QVariant::fromValue<IdentityId>(info.identity);
+    i["MessageRateBurstSize"]      = info.messageRateBurstSize;
+    i["MessageRateDelay"]          = info.messageRateDelay;
+    i["AutoReconnectInterval"]     = info.autoReconnectInterval;
+    i["AutoReconnectRetries"]      = info.autoReconnectRetries;
+    i["RejoinChannels"]            = info.rejoinChannels;
+    i["UseRandomServer"]           = info.useRandomServer;
+    i["UseAutoIdentify"]           = info.useAutoIdentify;
+    i["UseSasl"]                   = info.useSasl;
+    i["UseAutoReconnect"]          = info.useAutoReconnect;
     i["UnlimitedReconnectRetries"] = info.unlimitedReconnectRetries;
-    i["RejoinChannels"] = info.rejoinChannels;
+    i["UseCustomMessageRate"]      = info.useCustomMessageRate;
+    i["UnlimitedMessageRate"]      = info.unlimitedMessageRate;
     out << i;
     return out;
 }
@@ -1005,26 +1232,30 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info)
 {
     QVariantMap i;
     in >> i;
-    info.networkId = i["NetworkId"].value<NetworkId>();
-    info.networkName = i["NetworkName"].toString();
-    info.identity = i["Identity"].value<IdentityId>();
-    info.codecForServer = i["CodecForServer"].toByteArray();
-    info.codecForEncoding = i["CodecForEncoding"].toByteArray();
-    info.codecForDecoding = i["CodecForDecoding"].toByteArray();
-    info.serverList = fromVariantList<Network::Server>(i["ServerList"].toList());
-    info.useRandomServer = i["UseRandomServer"].toBool();
-    info.perform = i["Perform"].toStringList();
-    info.useAutoIdentify = i["UseAutoIdentify"].toBool();
-    info.autoIdentifyService = i["AutoIdentifyService"].toString();
-    info.autoIdentifyPassword = i["AutoIdentifyPassword"].toString();
-    info.useSasl = i["UseSasl"].toBool();
-    info.saslAccount = i["SaslAccount"].toString();
-    info.saslPassword = i["SaslPassword"].toString();
-    info.useAutoReconnect = i["UseAutoReconnect"].toBool();
-    info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt();
-    info.autoReconnectRetries = i["AutoReconnectRetries"].toInt();
+    info.networkName               = i["NetworkName"].toString();
+    info.serverList                = fromVariantList<Network::Server>(i["ServerList"].toList());
+    info.perform                   = i["Perform"].toStringList();
+    info.autoIdentifyService       = i["AutoIdentifyService"].toString();
+    info.autoIdentifyPassword      = i["AutoIdentifyPassword"].toString();
+    info.saslAccount               = i["SaslAccount"].toString();
+    info.saslPassword              = i["SaslPassword"].toString();
+    info.codecForServer            = i["CodecForServer"].toByteArray();
+    info.codecForEncoding          = i["CodecForEncoding"].toByteArray();
+    info.codecForDecoding          = i["CodecForDecoding"].toByteArray();
+    info.networkId                 = i["NetworkId"].value<NetworkId>();
+    info.identity                  = i["Identity"].value<IdentityId>();
+    info.messageRateBurstSize      = i["MessageRateBurstSize"].toUInt();
+    info.messageRateDelay          = i["MessageRateDelay"].toUInt();
+    info.autoReconnectInterval     = i["AutoReconnectInterval"].toUInt();
+    info.autoReconnectRetries      = i["AutoReconnectRetries"].toInt();
+    info.rejoinChannels            = i["RejoinChannels"].toBool();
+    info.useRandomServer           = i["UseRandomServer"].toBool();
+    info.useAutoIdentify           = i["UseAutoIdentify"].toBool();
+    info.useSasl                   = i["UseSasl"].toBool();
+    info.useAutoReconnect          = i["UseAutoReconnect"].toBool();
     info.unlimitedReconnectRetries = i["UnlimitedReconnectRetries"].toBool();
-    info.rejoinChannels = i["RejoinChannels"].toBool();
+    info.useCustomMessageRate      = i["UseCustomMessageRate"].toBool();
+    info.unlimitedMessageRate      = i["UnlimitedMessageRate"].toBool();
     return in;
 }
 
@@ -1038,7 +1269,12 @@ QDebug operator<<(QDebug dbg, const NetworkInfo &i)
     << " useSasl = " << i.useSasl << " saslAccount = " << i.saslAccount << " saslPassword = " << i.saslPassword
     << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval
     << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries
-    << " rejoinChannels = " << i.rejoinChannels << ")";
+    << " rejoinChannels = " << i.rejoinChannels
+    << " useCustomMessageRate = " << i.useCustomMessageRate
+    << " messageRateBurstSize = " << i.messageRateBurstSize
+    << " messageRateDelay = " << i.messageRateDelay
+    << " unlimitedMessageRate = " << i.unlimitedMessageRate
+    << ")";
     return dbg.space();
 }
 
@@ -1050,6 +1286,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;
@@ -1070,6 +1307,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();
@@ -1087,6 +1325,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;
@@ -1106,6 +1345,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();
 }