X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.cpp;h=3b1fe1d8bf15c70f86cef5e4d8aaefadddcd605f;hp=1aa907d83509761c3599e4b82a12377a092da14c;hb=2e8eab59dd72e37a740d16d9484502d077aef64d;hpb=40601ae070413b727a68e35e5b8c619176c661b1 diff --git a/src/common/network.cpp b/src/common/network.cpp index 1aa907d8..3b1fe1d8 100644 --- a/src/common/network.cpp +++ b/src/common/network.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2014 by the Quassel Project * + * Copyright (C) 2005-2016 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -18,16 +18,13 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ -#include #include #include "network.h" -#include "quassel.h" QTextCodec *Network::_defaultCodecForServer = 0; QTextCodec *Network::_defaultCodecForEncoding = 0; QTextCodec *Network::_defaultCodecForDecoding = 0; -QString Network::_networksIniPath = QString(); // ==================== // Public: @@ -53,6 +50,10 @@ Network::Network(const NetworkId &networkid, QObject *parent) _autoReconnectInterval(60), _autoReconnectRetries(10), _unlimitedReconnectRetries(false), + _useCustomMessageRate(false), + _messageRateBurstSize(5), + _messageRateDelay(2200), + _unlimitedMessageRate(false), _codecForServer(0), _codecForEncoding(0), _codecForDecoding(0), @@ -80,6 +81,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 +116,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 +146,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); } @@ -215,6 +241,28 @@ QString Network::support(const QString ¶m) 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()); @@ -480,73 +528,6 @@ QByteArray Network::encodeServerString(const QString &string) const } -/*** 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 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; -} - - // ==================== // Public Slots: // ==================== @@ -734,6 +715,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 ¶m, const QString &value) { if (!_supports.contains(param)) { @@ -763,6 +802,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 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 @@ -878,6 +988,16 @@ void Network::initSetSupports(const QVariantMap &supports) } +void Network::initSetCaps(const QVariantMap &caps) +{ + QMapIterator iter(caps); + while (iter.hasNext()) { + iter.next(); + addCap(iter.key(), iter.value().toString()); + } +} + + IrcUser *Network::updateNickFromMask(const QString &mask) { QString nick(nickFromMask(mask).toLower()); @@ -978,7 +1098,11 @@ NetworkInfo::NetworkInfo() autoReconnectInterval(60), autoReconnectRetries(20), unlimitedReconnectRetries(false), - rejoinChannels(true) + rejoinChannels(true), + useCustomMessageRate(false), + messageRateBurstSize(5), + messageRateDelay(2200), + unlimitedMessageRate(false) { } @@ -1005,6 +1129,11 @@ bool NetworkInfo::operator==(const NetworkInfo &other) const if (autoReconnectRetries != other.autoReconnectRetries) return false; if (unlimitedReconnectRetries != other.unlimitedReconnectRetries) return false; if (rejoinChannels != other.rejoinChannels) return false; + // Custom rate limiting + if (useCustomMessageRate != other.useCustomMessageRate) return false; + if (messageRateBurstSize != other.messageRateBurstSize) return false; + if (messageRateDelay != other.messageRateDelay) return false; + if (unlimitedMessageRate != other.unlimitedMessageRate) return false; return true; } @@ -1038,6 +1167,11 @@ QDataStream &operator<<(QDataStream &out, const NetworkInfo &info) i["AutoReconnectRetries"] = info.autoReconnectRetries; i["UnlimitedReconnectRetries"] = info.unlimitedReconnectRetries; i["RejoinChannels"] = info.rejoinChannels; + // Custom rate limiting + i["UseCustomMessageRate"] = info.useCustomMessageRate; + i["MessageRateBurstSize"] = info.messageRateBurstSize; + i["MessageRateDelay"] = info.messageRateDelay; + i["UnlimitedMessageRate"] = info.unlimitedMessageRate; out << i; return out; } @@ -1067,6 +1201,11 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info) info.autoReconnectRetries = i["AutoReconnectRetries"].toInt(); info.unlimitedReconnectRetries = i["UnlimitedReconnectRetries"].toBool(); info.rejoinChannels = i["RejoinChannels"].toBool(); + // Custom rate limiting + info.useCustomMessageRate = i["UseCustomMessageRate"].toBool(); + info.messageRateBurstSize = i["MessageRateBurstSize"].toUInt(); + info.messageRateDelay = i["MessageRateDelay"].toUInt(); + info.unlimitedMessageRate = i["UnlimitedMessageRate"].toBool(); return in; } @@ -1080,7 +1219,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(); } @@ -1092,6 +1236,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; @@ -1112,6 +1257,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(); @@ -1129,6 +1275,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; @@ -1148,6 +1295,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(); }