X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.cpp;h=f76cd30e21f1efeb101a76aca523fadbd8db3351;hp=24ce12594cd7c6f3e50a045dd44e6a25c1e1425f;hb=39328183a6a87c6eb10a9dbbffcd5d65bf154a1f;hpb=921e54680da16fcf2adb7a90506875aceb6633a4 diff --git a/src/common/network.cpp b/src/common/network.cpp index 24ce1259..f76cd30e 100644 --- a/src/common/network.cpp +++ b/src/common/network.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2015 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 * @@ -18,21 +18,24 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ +#include + #include #include "network.h" +#include "peer.h" -QTextCodec *Network::_defaultCodecForServer = 0; -QTextCodec *Network::_defaultCodecForEncoding = 0; -QTextCodec *Network::_defaultCodecForDecoding = 0; +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()), @@ -50,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())); @@ -77,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; @@ -100,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; } @@ -126,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); } @@ -147,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 @@ -212,6 +280,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()); @@ -250,7 +340,7 @@ IrcUser *Network::ircUser(QString nickname) const if (_ircUsers.contains(nickname)) return _ircUsers[nickname]; else - return 0; + return nullptr; } @@ -261,7 +351,7 @@ void Network::removeIrcUser(IrcUser *ircuser) return; _ircUsers.remove(nick); - disconnect(ircuser, 0, this, 0); + disconnect(ircuser, nullptr, this, nullptr); ircuser->deleteLater(); } @@ -273,7 +363,7 @@ void Network::removeIrcChannel(IrcChannel *channel) return; _ircChannels.remove(chanName); - disconnect(channel, 0, this, 0); + disconnect(channel, nullptr, this, nullptr); channel->deleteLater(); } @@ -320,7 +410,7 @@ IrcChannel *Network::ircChannel(QString channelname) const if (_ircChannels.contains(channelname)) return _ircChannels[channelname]; else - return 0; + return nullptr; } @@ -664,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 ¶m, const QString &value) { if (!_supports.contains(param)) { @@ -693,6 +841,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 @@ -701,6 +920,8 @@ QVariantMap Network::initSupports() const // (without compression) with a decent amount of IrcUsers. QVariantMap Network::initIrcUsersAndChannels() const { + Q_ASSERT(proxy()); + Q_ASSERT(proxy()->targetPeer()); QVariantMap usersAndChannels; if (_ircUsers.count()) { @@ -708,7 +929,21 @@ QVariantMap Network::initIrcUsersAndChannels() const QHash::const_iterator it = _ircUsers.begin(); QHash::const_iterator end = _ircUsers.end(); while (it != end) { - const QVariantMap &map = it.value()->toVariantMap(); + 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(); @@ -750,6 +985,7 @@ 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 although there already are known users or channels!"; return; @@ -774,6 +1010,22 @@ void Network::initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels) 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 } @@ -808,6 +1060,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()); @@ -897,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 + ; } @@ -948,26 +1199,30 @@ bool NetworkInfo::operator!=(const NetworkInfo &other) const QDataStream &operator<<(QDataStream &out, const NetworkInfo &info) { QVariantMap i; - i["NetworkId"] = QVariant::fromValue(info.networkId); - i["NetworkName"] = info.networkName; - i["Identity"] = QVariant::fromValue(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(info.networkId); + i["Identity"] = QVariant::fromValue(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; } @@ -977,26 +1232,30 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info) { QVariantMap i; in >> i; - info.networkId = i["NetworkId"].value(); - info.networkName = i["NetworkName"].toString(); - info.identity = i["Identity"].value(); - info.codecForServer = i["CodecForServer"].toByteArray(); - info.codecForEncoding = i["CodecForEncoding"].toByteArray(); - info.codecForDecoding = i["CodecForDecoding"].toByteArray(); - info.serverList = fromVariantList(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(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(); + info.identity = i["Identity"].value(); + 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; } @@ -1010,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(); } @@ -1022,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; @@ -1042,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(); @@ -1059,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; @@ -1078,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(); }