X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.cpp;h=bb9b6bf9b3aa2f2ba065ab4a78366e9b6c7242ff;hp=a3b97729f032c8d89e334b39e08dab30be859f94;hb=1f21c1f9613031ae263eeed0c4883bfcd5488343;hpb=c2b60983d1a144088cb9e0be9c5ae001621925c3 diff --git a/src/common/network.cpp b/src/common/network.cpp index a3b97729..bb9b6bf9 100644 --- a/src/common/network.cpp +++ b/src/common/network.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel Project * + * Copyright (C) 2005-2019 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -15,873 +15,1287 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ + #include "network.h" -#include "signalproxy.h" -#include "ircuser.h" -#include "ircchannel.h" +#include -#include #include -#include "util.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: // ==================== -Network::Network(const NetworkId &networkid, QObject *parent) : SyncableObject(parent), - _proxy(0), - _networkId(networkid), - _identity(0), - _myNick(QString()), - _networkName(QString("")), - _currentServer(QString()), - _connected(false), - _connectionState(Disconnected), - _prefixes(QString()), - _prefixModes(QString()), - _useRandomServer(false), - _useAutoIdentify(false), - _useAutoReconnect(false), - _autoReconnectInterval(60), - _autoReconnectRetries(10), - _unlimitedReconnectRetries(false), - _codecForServer(0), - _codecForEncoding(0), - _codecForDecoding(0) -{ - setObjectName(QString::number(networkid.toInt())); -} - -// I think this is unnecessary since IrcUsers have us as their daddy :) - -Network::~Network() { - emit aboutToBeDestroyed(); -// QHashIterator ircuser(_ircUsers); -// while (ircuser.hasNext()) { -// ircuser.next(); -// delete ircuser.value(); -// } -// qDebug() << "Destroying net" << networkName() << networkId(); -} - - -NetworkId Network::networkId() const { - return _networkId; -} - -SignalProxy *Network::proxy() const { - return _proxy; -} - -void Network::setProxy(SignalProxy *proxy) { - _proxy = proxy; - //proxy->synchronize(this); // we should to this explicitly from the outside! -} -bool Network::isMyNick(const QString &nick) const { - return (myNick().toLower() == nick.toLower()); +Network::Network(const NetworkId& networkid, QObject* parent) + : SyncableObject(parent) + , _proxy(nullptr) + , _networkId(networkid) + , _identity(0) + , _myNick(QString()) + , _latency(0) + , _networkName(QString("")) + , _currentServer(QString()) + , _connected(false) + , _connectionState(Disconnected) + , _prefixes(QString()) + , _prefixModes(QString()) + , _useRandomServer(false) + , _useAutoIdentify(false) + , _useSasl(false) + , _useAutoReconnect(false) + , _autoReconnectInterval(60) + , _autoReconnectRetries(10) + , _unlimitedReconnectRetries(false) + , _useCustomMessageRate(false) + , _messageRateBurstSize(5) + , _messageRateDelay(2200) + , _unlimitedMessageRate(false) + , _codecForServer(nullptr) + , _codecForEncoding(nullptr) + , _codecForDecoding(nullptr) + , _autoAwayActive(false) +{ + setObjectName(QString::number(networkid.toInt())); } -bool Network::isMe(IrcUser *ircuser) const { - return (ircuser->nick().toLower() == myNick().toLower()); +Network::~Network() +{ + emit aboutToBeDestroyed(); } -bool Network::isChannelName(const QString &channelname) const { - if(channelname.isEmpty()) - return false; - - if(supports("CHANTYPES")) - return support("CHANTYPES").contains(channelname[0]); - else - return QString("#&!+").contains(channelname[0]); -} +bool Network::isChannelName(const QString& channelname) const +{ + if (channelname.isEmpty()) + return false; -bool Network::isConnected() const { - return _connected; + if (supports("CHANTYPES")) + return support("CHANTYPES").contains(channelname[0]); + else + return QString("#&!+").contains(channelname[0]); } -//Network::ConnectionState Network::connectionState() const { -int Network::connectionState() const { - return _connectionState; -} +bool Network::isStatusMsg(const QString& target) const +{ + if (target.isEmpty()) + return false; -NetworkInfo Network::networkInfo() const { - NetworkInfo info; - info.networkName = networkName(); - info.networkId = networkId(); - info.identity = identity(); - info.codecForServer = codecForServer(); - info.codecForEncoding = codecForEncoding(); - info.codecForDecoding = codecForDecoding(); - info.serverList = serverList(); - info.useRandomServer = useRandomServer(); - info.perform = perform(); - info.useAutoIdentify = useAutoIdentify(); - info.autoIdentifyService = autoIdentifyService(); - info.autoIdentifyPassword = autoIdentifyPassword(); - info.useAutoReconnect = useAutoReconnect(); - info.autoReconnectInterval = autoReconnectInterval(); - info.autoReconnectRetries = autoReconnectRetries(); - info.unlimitedReconnectRetries = unlimitedReconnectRetries(); - info.rejoinChannels = rejoinChannels(); - return info; + if (supports("STATUSMSG")) + return support("STATUSMSG").contains(target[0]); + else + return QString("@+").contains(target[0]); } -void Network::setNetworkInfo(const NetworkInfo &info) { - // we don't set our ID! - if(!info.networkName.isEmpty() && info.networkName != networkName()) setNetworkName(info.networkName); - if(info.identity > 0 && info.identity != identity()) setIdentity(info.identity); - if(info.codecForServer != codecForServer()) setCodecForServer(QTextCodec::codecForName(info.codecForServer)); - if(info.codecForEncoding != codecForEncoding()) setCodecForEncoding(QTextCodec::codecForName(info.codecForEncoding)); - if(info.codecForDecoding != codecForDecoding()) setCodecForDecoding(QTextCodec::codecForName(info.codecForDecoding)); - if(info.serverList.count()) setServerList(info.serverList); // FIXME compare components - if(info.useRandomServer != useRandomServer()) setUseRandomServer(info.useRandomServer); - if(info.perform != perform()) setPerform(info.perform); - if(info.useAutoIdentify != useAutoIdentify()) setUseAutoIdentify(info.useAutoIdentify); - if(info.autoIdentifyService != autoIdentifyService()) setAutoIdentifyService(info.autoIdentifyService); - if(info.autoIdentifyPassword != autoIdentifyPassword()) setAutoIdentifyPassword(info.autoIdentifyPassword); - if(info.useAutoReconnect != useAutoReconnect()) setUseAutoReconnect(info.useAutoReconnect); - if(info.autoReconnectInterval != autoReconnectInterval()) setAutoReconnectInterval(info.autoReconnectInterval); - if(info.autoReconnectRetries != autoReconnectRetries()) setAutoReconnectRetries(info.autoReconnectRetries); - if(info.unlimitedReconnectRetries != unlimitedReconnectRetries()) setUnlimitedReconnectRetries(info.unlimitedReconnectRetries); - if(info.rejoinChannels != rejoinChannels()) setRejoinChannels(info.rejoinChannels); +NetworkInfo Network::networkInfo() const +{ + NetworkInfo info; + info.networkName = networkName(); + info.networkId = networkId(); + info.identity = identity(); + info.codecForServer = codecForServer(); + info.codecForEncoding = codecForEncoding(); + info.codecForDecoding = codecForDecoding(); + info.serverList = serverList(); + info.useRandomServer = useRandomServer(); + info.perform = perform(); + info.useAutoIdentify = useAutoIdentify(); + info.autoIdentifyService = autoIdentifyService(); + info.autoIdentifyPassword = autoIdentifyPassword(); + info.useSasl = useSasl(); + info.saslAccount = saslAccount(); + info.saslPassword = saslPassword(); + info.useAutoReconnect = useAutoReconnect(); + info.autoReconnectInterval = autoReconnectInterval(); + info.autoReconnectRetries = autoReconnectRetries(); + info.unlimitedReconnectRetries = unlimitedReconnectRetries(); + info.rejoinChannels = rejoinChannels(); + info.useCustomMessageRate = useCustomMessageRate(); + info.messageRateBurstSize = messageRateBurstSize(); + info.messageRateDelay = messageRateDelay(); + info.unlimitedMessageRate = unlimitedMessageRate(); + return info; +} + +void Network::setNetworkInfo(const NetworkInfo& info) +{ + // we don't set our ID! + if (!info.networkName.isEmpty() && info.networkName != networkName()) + setNetworkName(info.networkName); + if (info.identity > 0 && info.identity != identity()) + setIdentity(info.identity); + if (info.codecForServer != codecForServer()) + setCodecForServer(QTextCodec::codecForName(info.codecForServer)); + if (info.codecForEncoding != codecForEncoding()) + setCodecForEncoding(QTextCodec::codecForName(info.codecForEncoding)); + if (info.codecForDecoding != codecForDecoding()) + setCodecForDecoding(QTextCodec::codecForName(info.codecForDecoding)); + if (info.serverList.count()) + setServerList(toVariantList(info.serverList)); // FIXME compare components + if (info.useRandomServer != useRandomServer()) + setUseRandomServer(info.useRandomServer); + if (info.perform != perform()) + setPerform(info.perform); + if (info.useAutoIdentify != useAutoIdentify()) + setUseAutoIdentify(info.useAutoIdentify); + if (info.autoIdentifyService != autoIdentifyService()) + setAutoIdentifyService(info.autoIdentifyService); + if (info.autoIdentifyPassword != autoIdentifyPassword()) + setAutoIdentifyPassword(info.autoIdentifyPassword); + if (info.useSasl != useSasl()) + setUseSasl(info.useSasl); + if (info.saslAccount != saslAccount()) + setSaslAccount(info.saslAccount); + if (info.saslPassword != saslPassword()) + setSaslPassword(info.saslPassword); + if (info.useAutoReconnect != useAutoReconnect()) + setUseAutoReconnect(info.useAutoReconnect); + if (info.autoReconnectInterval != autoReconnectInterval()) + setAutoReconnectInterval(info.autoReconnectInterval); + 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); +} + +QString Network::prefixToMode(const QString& prefix) const +{ + if (prefixes().contains(prefix)) + return QString(prefixModes()[prefixes().indexOf(prefix)]); + else + return QString(); } -QString Network::prefixToMode(const QString &prefix) { - if(prefixes().contains(prefix)) - return QString(prefixModes()[prefixes().indexOf(prefix)]); - else - return QString(); +QString Network::modeToPrefix(const QString& mode) const +{ + if (prefixModes().contains(mode)) + return QString(prefixes()[prefixModes().indexOf(mode)]); + else + return QString(); } -QString Network::prefixToMode(const QCharRef &prefix) { - return prefixToMode(QString(prefix)); -} +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; + } -QString Network::modeToPrefix(const QString &mode) { - if(prefixModes().contains(mode)) - return QString(prefixes()[prefixModes().indexOf(mode)]); - else - return QString(); + // 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 + // not up to date after a nick change + QStringList nicks; + foreach (IrcUser* ircuser, _ircUsers.values()) { + nicks << ircuser->nick(); + } + return nicks; } -QString Network::modeToPrefix(const QCharRef &mode) { - return modeToPrefix(QString(mode)); -} - -QString Network::networkName() const { - return _networkName; -} +QString Network::prefixes() const +{ + if (_prefixes.isNull()) + determinePrefixes(); -QString Network::currentServer() const { - return _currentServer; + return _prefixes; } -QString Network::myNick() const { - return _myNick; -} +QString Network::prefixModes() const +{ + if (_prefixModes.isNull()) + determinePrefixes(); -IdentityId Network::identity() const { - return _identity; + return _prefixModes; } -QStringList Network::nicks() const { - // we don't use _ircUsers.keys() since the keys may be - // not up to date after a nick change - QStringList nicks; - foreach(IrcUser *ircuser, _ircUsers.values()) { - nicks << ircuser->nick(); - } - return nicks; +// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG +Network::ChannelModeType Network::channelModeType(const QString& mode) +{ + if (mode.isEmpty()) + return NOT_A_CHANMODE; + + QString chanmodes = support("CHANMODES"); + if (chanmodes.isEmpty()) + return NOT_A_CHANMODE; + + ChannelModeType modeType = A_CHANMODE; + for (int i = 0; i < chanmodes.count(); i++) { + if (chanmodes[i] == mode[0]) + break; + else if (chanmodes[i] == ',') + modeType = (ChannelModeType)(modeType << 1); + } + if (modeType > D_CHANMODE) { + qWarning() << "Network" << networkId() << "supplied invalid CHANMODES:" << chanmodes; + modeType = NOT_A_CHANMODE; + } + return modeType; } -QStringList Network::channels() const { - return _ircChannels.keys(); +QString Network::support(const QString& param) const +{ + QString support_ = param.toUpper(); + if (_supports.contains(support_)) + return _supports[support_]; + else + return QString(); } -QVariantList Network::serverList() const { - return _serverList; -} +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; + } -bool Network::useRandomServer() const { - return _useRandomServer; + // 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)); } -QStringList Network::perform() const { - return _perform; -} +IrcUser* Network::newIrcUser(const QString& hostmask, const QVariantMap& initData) +{ + QString nick(nickFromMask(hostmask).toLower()); + if (!_ircUsers.contains(nick)) { + IrcUser* ircuser = ircUserFactory(hostmask); + if (!initData.isEmpty()) { + ircuser->fromVariantMap(initData); + ircuser->setInitialized(); + } + + if (proxy()) + proxy()->synchronize(ircuser); + else + qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call Network::setProxy(SignalProxy *)?"; + + connect(ircuser, &IrcUser::nickSet, this, &Network::ircUserNickChanged); + + _ircUsers[nick] = ircuser; + + // 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); + } -bool Network::useAutoIdentify() const { - return _useAutoIdentify; + return _ircUsers[nick]; } -QString Network::autoIdentifyService() const { - return _autoIdentifyService; +IrcUser* Network::ircUser(QString nickname) const +{ + nickname = nickname.toLower(); + if (_ircUsers.contains(nickname)) + return _ircUsers[nickname]; + else + return nullptr; } -QString Network::autoIdentifyPassword() const { - return _autoIdentifyPassword; -} +void Network::removeIrcUser(IrcUser* ircuser) +{ + QString nick = _ircUsers.key(ircuser); + if (nick.isNull()) + return; -bool Network::useAutoReconnect() const { - return _useAutoReconnect; + _ircUsers.remove(nick); + disconnect(ircuser, nullptr, this, nullptr); + ircuser->deleteLater(); } -quint32 Network::autoReconnectInterval() const { - return _autoReconnectInterval; -} +void Network::removeIrcChannel(IrcChannel* channel) +{ + QString chanName = _ircChannels.key(channel); + if (chanName.isNull()) + return; -quint16 Network::autoReconnectRetries() const { - return _autoReconnectRetries; + _ircChannels.remove(chanName); + disconnect(channel, nullptr, this, nullptr); + channel->deleteLater(); } -bool Network::unlimitedReconnectRetries() const { - return _unlimitedReconnectRetries; -} +void Network::removeChansAndUsers() +{ + QList users = ircUsers(); + _ircUsers.clear(); + QList channels = ircChannels(); + _ircChannels.clear(); -bool Network::rejoinChannels() const { - return _rejoinChannels; + qDeleteAll(users); + qDeleteAll(channels); } -QString Network::prefixes() { - if(_prefixes.isNull()) - determinePrefixes(); - - return _prefixes; +IrcChannel* Network::newIrcChannel(const QString& channelname, const QVariantMap& initData) +{ + if (!_ircChannels.contains(channelname.toLower())) { + IrcChannel* channel = ircChannelFactory(channelname); + if (!initData.isEmpty()) { + channel->fromVariantMap(initData); + channel->setInitialized(); + } + + if (proxy()) + proxy()->synchronize(channel); + else + qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call Network::setProxy(SignalProxy *)?"; + + _ircChannels[channelname.toLower()] = channel; + + SYNC_OTHER(addIrcChannel, ARG(channelname)) + // emit ircChannelAdded(channelname); + emit ircChannelAdded(channel); + } + return _ircChannels[channelname.toLower()]; } -QString Network::prefixModes() { - if(_prefixModes.isNull()) - determinePrefixes(); - - return _prefixModes; +IrcChannel* Network::ircChannel(QString channelname) const +{ + channelname = channelname.toLower(); + if (_ircChannels.contains(channelname)) + return _ircChannels[channelname]; + else + return nullptr; } -bool Network::supports(const QString ¶m) const { - return _supports.contains(param); +QByteArray Network::defaultCodecForServer() +{ + if (_defaultCodecForServer) + return _defaultCodecForServer->name(); + return QByteArray(); } -QString Network::support(const QString ¶m) const { - QString support_ = param.toUpper(); - if(_supports.contains(support_)) - return _supports[support_]; - else - return QString(); +void Network::setDefaultCodecForServer(const QByteArray& name) +{ + _defaultCodecForServer = QTextCodec::codecForName(name); } -IrcUser *Network::newIrcUser(const QString &hostmask) { - QString nick(nickFromMask(hostmask).toLower()); - if(!_ircUsers.contains(nick)) { - IrcUser *ircuser = new IrcUser(hostmask, this); - - if(proxy()) - proxy()->synchronize(ircuser); - else - qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call Network::setProxy(SignalProxy *)?"; - - connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString))); - connect(ircuser, SIGNAL(initDone()), this, SLOT(ircUserInitDone())); - connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed())); - _ircUsers[nick] = ircuser; - emit ircUserAdded(hostmask); - emit ircUserAdded(ircuser); - } - return _ircUsers[nick]; +QByteArray Network::defaultCodecForEncoding() +{ + if (_defaultCodecForEncoding) + return _defaultCodecForEncoding->name(); + return QByteArray(); } -IrcUser *Network::newIrcUser(const QByteArray &hostmask) { - return newIrcUser(decodeServerString(hostmask)); +void Network::setDefaultCodecForEncoding(const QByteArray& name) +{ + _defaultCodecForEncoding = QTextCodec::codecForName(name); } -void Network::ircUserDestroyed() { - IrcUser *ircUser = static_cast(sender()); - if(!ircUser) - return; - - QHash::iterator ircUserIter = _ircUsers.begin(); - while(ircUserIter != _ircUsers.end()) { - if(ircUser == *ircUserIter) { - ircUserIter = _ircUsers.erase(ircUserIter); - break; - } - ircUserIter++; - } +QByteArray Network::defaultCodecForDecoding() +{ + if (_defaultCodecForDecoding) + return _defaultCodecForDecoding->name(); + return QByteArray(); } -void Network::removeIrcUser(IrcUser *ircuser) { - QString nick = _ircUsers.key(ircuser); - if(nick.isNull()) - return; - - _ircUsers.remove(nick); - disconnect(ircuser, 0, this, 0); - emit ircUserRemoved(nick); - emit ircUserRemoved(ircuser); - ircuser->deleteLater(); +void Network::setDefaultCodecForDecoding(const QByteArray& name) +{ + _defaultCodecForDecoding = QTextCodec::codecForName(name); } -void Network::removeIrcUser(const QString &nick) { - IrcUser *ircuser; - if((ircuser = ircUser(nick)) != 0) - removeIrcUser(ircuser); +QByteArray Network::codecForServer() const +{ + if (_codecForServer) + return _codecForServer->name(); + return QByteArray(); } -void Network::removeChansAndUsers() { - QList users = ircUsers(); - foreach(IrcUser *user, users) { - removeIrcUser(user); - } - QList channels = ircChannels(); - foreach(IrcChannel *channel, channels) { - removeIrcChannel(channel); - } +void Network::setCodecForServer(const QByteArray& name) +{ + setCodecForServer(QTextCodec::codecForName(name)); } -IrcUser *Network::ircUser(QString nickname) const { - nickname = nickname.toLower(); - if(_ircUsers.contains(nickname)) - return _ircUsers[nickname]; - else - return 0; +void Network::setCodecForServer(QTextCodec* codec) +{ + _codecForServer = codec; + QByteArray codecName = codecForServer(); + SYNC_OTHER(setCodecForServer, ARG(codecName)) + emit configChanged(); } -IrcUser *Network::ircUser(const QByteArray &nickname) const { - return ircUser(decodeServerString(nickname)); +QByteArray Network::codecForEncoding() const +{ + if (_codecForEncoding) + return _codecForEncoding->name(); + return QByteArray(); } -QList Network::ircUsers() const { - return _ircUsers.values(); +void Network::setCodecForEncoding(const QByteArray& name) +{ + setCodecForEncoding(QTextCodec::codecForName(name)); } -quint32 Network::ircUserCount() const { - return _ircUsers.count(); +void Network::setCodecForEncoding(QTextCodec* codec) +{ + _codecForEncoding = codec; + QByteArray codecName = codecForEncoding(); + SYNC_OTHER(setCodecForEncoding, ARG(codecName)) + emit configChanged(); } -IrcChannel *Network::newIrcChannel(const QString &channelname) { - if(!_ircChannels.contains(channelname.toLower())) { - IrcChannel *channel = new IrcChannel(channelname, this); - - if(proxy()) - proxy()->synchronize(channel); +QByteArray Network::codecForDecoding() const +{ + if (_codecForDecoding) + return _codecForDecoding->name(); else - qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call Network::setProxy(SignalProxy *)?"; - - connect(channel, SIGNAL(initDone()), this, SLOT(ircChannelInitDone())); - connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed())); - _ircChannels[channelname.toLower()] = channel; - emit ircChannelAdded(channelname); - emit ircChannelAdded(channel); - } - return _ircChannels[channelname.toLower()]; -} - -IrcChannel *Network::newIrcChannel(const QByteArray &channelname) { - return newIrcChannel(decodeServerString(channelname)); -} - -IrcChannel *Network::ircChannel(QString channelname) const { - channelname = channelname.toLower(); - if(_ircChannels.contains(channelname)) - return _ircChannels[channelname]; - else - return 0; + return QByteArray(); } -IrcChannel *Network::ircChannel(const QByteArray &channelname) const { - return ircChannel(decodeServerString(channelname)); +void Network::setCodecForDecoding(const QByteArray& name) +{ + setCodecForDecoding(QTextCodec::codecForName(name)); } - -QList Network::ircChannels() const { - return _ircChannels.values(); +void Network::setCodecForDecoding(QTextCodec* codec) +{ + _codecForDecoding = codec; + QByteArray codecName = codecForDecoding(); + SYNC_OTHER(setCodecForDecoding, ARG(codecName)) + emit configChanged(); } -quint32 Network::ircChannelCount() const { - return _ircChannels.count(); +// FIXME use server encoding if appropriate +QString Network::decodeString(const QByteArray& text) const +{ + if (_codecForDecoding) + return ::decodeString(text, _codecForDecoding); + else + return ::decodeString(text, _defaultCodecForDecoding); } -QByteArray Network::defaultCodecForServer() { - if(_defaultCodecForServer) return _defaultCodecForServer->name(); - return QByteArray(); +QByteArray Network::encodeString(const QString& string) const +{ + if (_codecForEncoding) { + return _codecForEncoding->fromUnicode(string); + } + if (_defaultCodecForEncoding) { + return _defaultCodecForEncoding->fromUnicode(string); + } + return string.toLatin1(); } -void Network::setDefaultCodecForServer(const QByteArray &name) { - _defaultCodecForServer = QTextCodec::codecForName(name); +QString Network::decodeServerString(const QByteArray& text) const +{ + if (_codecForServer) + return ::decodeString(text, _codecForServer); + else + return ::decodeString(text, _defaultCodecForServer); } -QByteArray Network::defaultCodecForEncoding() { - if(_defaultCodecForEncoding) return _defaultCodecForEncoding->name(); - return QByteArray(); +QByteArray Network::encodeServerString(const QString& string) const +{ + if (_codecForServer) { + return _codecForServer->fromUnicode(string); + } + if (_defaultCodecForServer) { + return _defaultCodecForServer->fromUnicode(string); + } + return string.toLatin1(); } -void Network::setDefaultCodecForEncoding(const QByteArray &name) { - _defaultCodecForEncoding = QTextCodec::codecForName(name); +// ==================== +// Public Slots: +// ==================== +void Network::setNetworkName(const QString& networkName) +{ + _networkName = networkName; + SYNC(ARG(networkName)) + emit networkNameSet(networkName); + emit configChanged(); } -QByteArray Network::defaultCodecForDecoding() { - if(_defaultCodecForDecoding) return _defaultCodecForDecoding->name(); - return QByteArray(); +void Network::setCurrentServer(const QString& currentServer) +{ + _currentServer = currentServer; + SYNC(ARG(currentServer)) + emit currentServerSet(currentServer); } -void Network::setDefaultCodecForDecoding(const QByteArray &name) { - _defaultCodecForDecoding = QTextCodec::codecForName(name); +void Network::setConnected(bool connected) +{ + if (_connected == connected) + return; + + _connected = connected; + if (!connected) { + setMyNick(QString()); + setCurrentServer(QString()); + removeChansAndUsers(); + } + SYNC(ARG(connected)) + emit connectedSet(connected); } -QByteArray Network::codecForServer() const { - if(_codecForServer) return _codecForServer->name(); - return QByteArray(); +// void Network::setConnectionState(ConnectionState state) { +void Network::setConnectionState(int state) +{ + _connectionState = (ConnectionState)state; + // qDebug() << "netstate" << networkId() << networkName() << state; + SYNC(ARG(state)) + emit connectionStateSet(_connectionState); } -void Network::setCodecForServer(const QByteArray &name) { - setCodecForServer(QTextCodec::codecForName(name)); +void Network::setMyNick(const QString& nickname) +{ + _myNick = nickname; + if (!_myNick.isEmpty() && !ircUser(myNick())) { + newIrcUser(myNick()); + } + SYNC(ARG(nickname)) + emit myNickSet(nickname); } -void Network::setCodecForServer(QTextCodec *codec) { - _codecForServer = codec; - emit codecForServerSet(codecForServer()); +void Network::setLatency(int latency) +{ + if (_latency == latency) + return; + _latency = latency; + SYNC(ARG(latency)) } -QByteArray Network::codecForEncoding() const { - if(_codecForEncoding) return _codecForEncoding->name(); - return QByteArray(); +void Network::setIdentity(IdentityId id) +{ + _identity = id; + SYNC(ARG(id)) + emit identitySet(id); + emit configChanged(); } -void Network::setCodecForEncoding(const QByteArray &name) { - setCodecForEncoding(QTextCodec::codecForName(name)); +void Network::setServerList(const QVariantList& serverList) +{ + _serverList = fromVariantList(serverList); + SYNC(ARG(serverList)) + emit configChanged(); } -void Network::setCodecForEncoding(QTextCodec *codec) { - _codecForEncoding = codec; - emit codecForEncodingSet(codecForEncoding()); +void Network::setUseRandomServer(bool use) +{ + _useRandomServer = use; + SYNC(ARG(use)) + emit configChanged(); } -QByteArray Network::codecForDecoding() const { - if(_codecForDecoding) return _codecForDecoding->name(); - else return QByteArray(); +void Network::setPerform(const QStringList& perform) +{ + _perform = perform; + SYNC(ARG(perform)) + emit configChanged(); } -void Network::setCodecForDecoding(const QByteArray &name) { - setCodecForDecoding(QTextCodec::codecForName(name)); +void Network::setUseAutoIdentify(bool use) +{ + _useAutoIdentify = use; + SYNC(ARG(use)) + emit configChanged(); } -void Network::setCodecForDecoding(QTextCodec *codec) { - _codecForDecoding = codec; - emit codecForDecodingSet(codecForDecoding()); +void Network::setAutoIdentifyService(const QString& service) +{ + _autoIdentifyService = service; + SYNC(ARG(service)) + emit configChanged(); } -// FIXME use server encoding if appropriate -QString Network::decodeString(const QByteArray &text) const { - if(_codecForDecoding) return ::decodeString(text, _codecForDecoding); - else return ::decodeString(text, _defaultCodecForDecoding); +void Network::setAutoIdentifyPassword(const QString& password) +{ + _autoIdentifyPassword = password; + SYNC(ARG(password)) + emit configChanged(); } -QByteArray Network::encodeString(const QString &string) const { - if(_codecForEncoding) { - return _codecForEncoding->fromUnicode(string); - } - if(_defaultCodecForEncoding) { - return _defaultCodecForEncoding->fromUnicode(string); - } - return string.toAscii(); +void Network::setUseSasl(bool use) +{ + _useSasl = use; + SYNC(ARG(use)) + emit configChanged(); } -QString Network::decodeServerString(const QByteArray &text) const { - if(_codecForServer) return ::decodeString(text, _codecForServer); - else return ::decodeString(text, _defaultCodecForServer); +void Network::setSaslAccount(const QString& account) +{ + _saslAccount = account; + SYNC(ARG(account)) + emit configChanged(); } -QByteArray Network::encodeServerString(const QString &string) const { - if(_codecForServer) { - return _codecForServer->fromUnicode(string); - } - if(_defaultCodecForServer) { - return _defaultCodecForServer->fromUnicode(string); - } - return string.toAscii(); +void Network::setSaslPassword(const QString& password) +{ + _saslPassword = password; + SYNC(ARG(password)) + emit configChanged(); } -// ==================== -// Public Slots: -// ==================== -void Network::setNetworkName(const QString &networkName) { - _networkName = networkName; - emit networkNameSet(networkName); +void Network::setUseAutoReconnect(bool use) +{ + _useAutoReconnect = use; + SYNC(ARG(use)) + emit configChanged(); } -void Network::setCurrentServer(const QString ¤tServer) { - _currentServer = currentServer; - emit currentServerSet(currentServer); +void Network::setAutoReconnectInterval(quint32 interval) +{ + _autoReconnectInterval = interval; + SYNC(ARG(interval)) + emit configChanged(); } -void Network::setConnected(bool connected) { - _connected = connected; - if(!connected) { - removeChansAndUsers(); - setCurrentServer(QString()); - } - emit connectedSet(connected); +void Network::setAutoReconnectRetries(quint16 retries) +{ + _autoReconnectRetries = retries; + SYNC(ARG(retries)) + emit configChanged(); } -//void Network::setConnectionState(ConnectionState state) { -void Network::setConnectionState(int state) { - _connectionState = (ConnectionState)state; - //qDebug() << "netstate" << networkId() << networkName() << state; - emit connectionStateSet(state); - emit connectionStateSet(_connectionState); +void Network::setUnlimitedReconnectRetries(bool unlimited) +{ + _unlimitedReconnectRetries = unlimited; + SYNC(ARG(unlimited)) + emit configChanged(); } -void Network::setMyNick(const QString &nickname) { - _myNick = nickname; - emit myNickSet(nickname); +void Network::setRejoinChannels(bool rejoin) +{ + _rejoinChannels = rejoin; + SYNC(ARG(rejoin)) + emit configChanged(); } -void Network::setIdentity(IdentityId id) { - _identity = id; - emit identitySet(id); +void Network::setUseCustomMessageRate(bool useCustomRate) +{ + if (_useCustomMessageRate != useCustomRate) { + _useCustomMessageRate = useCustomRate; + SYNC(ARG(useCustomRate)) + emit configChanged(); + emit useCustomMessageRateSet(_useCustomMessageRate); + } } -void Network::setServerList(const QVariantList &serverList) { - _serverList = serverList; - emit serverListSet(serverList); +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::setUseRandomServer(bool use) { - _useRandomServer = use; - emit useRandomServerSet(use); +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::setPerform(const QStringList &perform) { - _perform = perform; - emit performSet(perform); +void Network::setUnlimitedMessageRate(bool unlimitedRate) +{ + if (_unlimitedMessageRate != unlimitedRate) { + _unlimitedMessageRate = unlimitedRate; + SYNC(ARG(unlimitedRate)) + emit configChanged(); + emit unlimitedMessageRateSet(_unlimitedMessageRate); + } } -void Network::setUseAutoIdentify(bool use) { - _useAutoIdentify = use; - emit useAutoIdentifySet(use); +void Network::addSupport(const QString& param, const QString& value) +{ + if (!_supports.contains(param)) { + _supports[param] = value; + SYNC(ARG(param), ARG(value)) + } } -void Network::setAutoIdentifyService(const QString &service) { - _autoIdentifyService = service; - emit autoIdentifyServiceSet(service); +void Network::removeSupport(const QString& param) +{ + if (_supports.contains(param)) { + _supports.remove(param); + SYNC(ARG(param)) + } } -void Network::setAutoIdentifyPassword(const QString &password) { - _autoIdentifyPassword = password; - emit autoIdentifyPasswordSet(password); +QVariantMap Network::initSupports() const +{ + QVariantMap supports; + QHashIterator iter(_supports); + while (iter.hasNext()) { + iter.next(); + supports[iter.key()] = iter.value(); + } + return supports; } -void Network::setUseAutoReconnect(bool use) { - _useAutoReconnect = use; - emit useAutoReconnectSet(use); +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::setAutoReconnectInterval(quint32 interval) { - _autoReconnectInterval = interval; - emit autoReconnectIntervalSet(interval); +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::setAutoReconnectRetries(quint16 retries) { - _autoReconnectRetries = retries; - emit autoReconnectRetriesSet(retries); +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::setUnlimitedReconnectRetries(bool unlimited) { - _unlimitedReconnectRetries = unlimited; - emit unlimitedReconnectRetriesSet(unlimited); -} +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(); -void Network::setRejoinChannels(bool rejoin) { - _rejoinChannels = rejoin; - emit rejoinChannelsSet(rejoin); + SYNC(NO_ARG) } -void Network::addSupport(const QString ¶m, const QString &value) { - if(!_supports.contains(param)) { - _supports[param] = value; - emit supportAdded(param, value); - } +QVariantMap Network::initCaps() const +{ + QVariantMap caps; + QHashIterator iter(_caps); + while (iter.hasNext()) { + iter.next(); + caps[iter.key()] = iter.value(); + } + return caps; } -void Network::removeSupport(const QString ¶m) { - if(_supports.contains(param)) { - _supports.remove(param); - emit supportRemoved(param); - } -} +// 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; + + if (_ircUsers.count()) { + QHash users; + QHash::const_iterator it = _ircUsers.begin(); + QHash::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; + } -QVariantMap Network::initSupports() const { - QVariantMap supports; - QHashIterator iter(_supports); - while(iter.hasNext()) { - iter.next(); - supports[iter.key()] = iter.value(); - } - return supports; -} + if (_ircChannels.count()) { + QHash channels; + QHash::const_iterator it = _ircChannels.begin(); + QHash::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; + } -QVariantList Network::initServerList() const { - return serverList(); + return usersAndChannels; } -QStringList Network::initIrcUsers() const { - QStringList hostmasks; - foreach(IrcUser *ircuser, ircUsers()) { - hostmasks << ircuser->hostmask(); - } - return hostmasks; -} +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; + } -QStringList Network::initIrcChannels() const { - return _ircChannels.keys(); -} + // 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! -void Network::initSetSupports(const QVariantMap &supports) { - QMapIterator iter(supports); - while(iter.hasNext()) { - iter.next(); - addSupport(iter.key(), iter.value().toString()); - } -} + const QVariantMap& users = usersAndChannels["Users"].toMap(); -void Network::initSetServerList(const QVariantList & serverList) { - setServerList(serverList); -} + // 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; + } + } -void Network::initSetIrcUsers(const QStringList &hostmasks) { - if(!_ircUsers.empty()) - return; - foreach(QString hostmask, hostmasks) { - newIrcUser(hostmask); - } -} + // 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 + } -void Network::initSetIrcChannels(const QStringList &channels) { - if(!_ircChannels.empty()) - return; - foreach(QString channel, channels) - newIrcChannel(channel); -} + // same thing for IrcChannels + const QVariantMap& channels = usersAndChannels["Channels"].toMap(); -IrcUser *Network::updateNickFromMask(const QString &mask) { - QString nick(nickFromMask(mask).toLower()); - IrcUser *ircuser; - - if(_ircUsers.contains(nick)) { - ircuser = _ircUsers[nick]; - ircuser->updateHostmask(mask); - } else { - ircuser = newIrcUser(mask); - } - return ircuser; + // 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); + } } -void Network::ircUserNickChanged(QString newnick) { - QString oldnick = _ircUsers.key(qobject_cast(sender())); - - if(oldnick.isNull()) - return; - - if(newnick.toLower() != oldnick) _ircUsers[newnick.toLower()] = _ircUsers.take(oldnick); - - if(myNick().toLower() == oldnick) - setMyNick(newnick); +void Network::initSetSupports(const QVariantMap& supports) +{ + QMapIterator iter(supports); + while (iter.hasNext()) { + iter.next(); + addSupport(iter.key(), iter.value().toString()); + } } -void Network::ircUserInitDone() { - IrcUser *ircuser = static_cast(sender()); - Q_ASSERT(ircuser); - emit ircUserInitDone(ircuser); +void Network::initSetCaps(const QVariantMap& caps) +{ + QMapIterator iter(caps); + while (iter.hasNext()) { + iter.next(); + addCap(iter.key(), iter.value().toString()); + } } -void Network::ircChannelInitDone() { - IrcChannel *ircchannel = static_cast(sender()); - Q_ASSERT(ircchannel); - emit ircChannelInitDone(ircchannel); -} +IrcUser* Network::updateNickFromMask(const QString& mask) +{ + QString nick(nickFromMask(mask).toLower()); + IrcUser* ircuser; -void Network::removeIrcChannel(IrcChannel *channel) { - QString chanName = _ircChannels.key(channel); - if(chanName.isNull()) - return; - - _ircChannels.remove(chanName); - disconnect(channel, 0, this, 0); - emit ircChannelRemoved(chanName); - emit ircChannelRemoved(channel); - channel->deleteLater(); + if (_ircUsers.contains(nick)) { + ircuser = _ircUsers[nick]; + ircuser->updateHostmask(mask); + } + else { + ircuser = newIrcUser(mask); + } + return ircuser; } -void Network::removeIrcChannel(const QString &channel) { - IrcChannel *chan; - if((chan = ircChannel(channel)) != 0) - removeIrcChannel(chan); -} +void Network::ircUserNickChanged(QString newnick) +{ + QString oldnick = _ircUsers.key(qobject_cast(sender())); -void Network::channelDestroyed() { - IrcChannel *channel = static_cast(sender()); - Q_ASSERT(channel); - _ircChannels.remove(_ircChannels.key(channel)); - emit ircChannelRemoved(channel); -} + if (oldnick.isNull()) + return; -void Network::requestConnect() const { - if(!proxy()) return; - if(proxy()->proxyMode() == SignalProxy::Client) emit connectRequested(); // on the client this triggers calling this slot on the core - else { - if(connectionState() != Disconnected) { - qWarning() << "Requesting connect while already being connected!"; - return; - } - emit connectRequested(networkId()); // and this is for CoreSession :) - } -} + if (newnick.toLower() != oldnick) + _ircUsers[newnick.toLower()] = _ircUsers.take(oldnick); -void Network::requestDisconnect() const { - if(!proxy()) return; - if(proxy()->proxyMode() == SignalProxy::Client) emit disconnectRequested(); // on the client this triggers calling this slot on the core - else { - if(connectionState() == Disconnected) { - qWarning() << "Requesting disconnect while not being connected!"; - return; - } - emit disconnectRequested(networkId()); // and this is for CoreSession :) - } + if (myNick().toLower() == oldnick) + setMyNick(newnick); } -void Network::emitConnectionError(const QString &errorMsg) { - emit connectionError(errorMsg); +void Network::emitConnectionError(const QString& errorMsg) +{ + emit connectionError(errorMsg); } // ==================== // Private: // ==================== -void Network::determinePrefixes() { - // seems like we have to construct them first - QString PREFIX = support("PREFIX"); - - if(PREFIX.startsWith("(") && PREFIX.contains(")")) { - _prefixes = PREFIX.section(")", 1); - _prefixModes = PREFIX.mid(1).section(")", 0, 0); - } else { - QString defaultPrefixes("~&@%+"); - QString defaultPrefixModes("qaohv"); - - // we just assume that in PREFIX are only prefix chars stored - for(int i = 0; i < defaultPrefixes.size(); i++) { - if(PREFIX.contains(defaultPrefixes[i])) { - _prefixes += defaultPrefixes[i]; - _prefixModes += defaultPrefixModes[i]; - } - } - // check for success - if(!_prefixes.isNull()) - return; - - // well... our assumption was obviously wrong... - // check if it's only prefix modes - for(int i = 0; i < defaultPrefixes.size(); i++) { - if(PREFIX.contains(defaultPrefixModes[i])) { - _prefixes += defaultPrefixes[i]; - _prefixModes += defaultPrefixModes[i]; - } - } - // now we've done all we've could... - } +void Network::determinePrefixes() const +{ + // seems like we have to construct them first + QString prefix = support("PREFIX"); + + if (prefix.startsWith("(") && prefix.contains(")")) { + _prefixes = prefix.section(")", 1); + _prefixModes = prefix.mid(1).section(")", 0, 0); + } + else { + QString defaultPrefixes("~&@%+"); + QString defaultPrefixModes("qaohv"); + + if (prefix.isEmpty()) { + _prefixes = defaultPrefixes; + _prefixModes = defaultPrefixModes; + return; + } + // clear the existing modes, just in case we're run multiple times + _prefixes = QString(); + _prefixModes = QString(); + + // we just assume that in PREFIX are only prefix chars stored + for (int i = 0; i < defaultPrefixes.size(); i++) { + if (prefix.contains(defaultPrefixes[i])) { + _prefixes += defaultPrefixes[i]; + _prefixModes += defaultPrefixModes[i]; + } + } + // check for success + if (!_prefixes.isNull()) + return; + + // well... our assumption was obviously wrong... + // check if it's only prefix modes + for (int i = 0; i < defaultPrefixes.size(); i++) { + if (prefix.contains(defaultPrefixModes[i])) { + _prefixes += defaultPrefixes[i]; + _prefixModes += defaultPrefixModes[i]; + } + } + // now we've done all we've could... + } } /************************************************************************ * NetworkInfo ************************************************************************/ -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(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; -} - -bool NetworkInfo::operator!=(const NetworkInfo &other) const { - return !(*this == other); -} - -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"] = info.serverList; - i["UseRandomServer"] = info.useRandomServer; - i["Perform"] = info.perform; - i["UseAutoIdentify"] = info.useAutoIdentify; - i["AutoIdentifyService"] = info.autoIdentifyService; - i["AutoIdentifyPassword"] = info.autoIdentifyPassword; - i["UseAutoReconnect"] = info.useAutoReconnect; - i["AutoReconnectInterval"] = info.autoReconnectInterval; - i["AutoReconnectRetries"] = info.autoReconnectRetries; - i["UnlimitedReconnectRetries"] = info.unlimitedReconnectRetries; - i["RejoinChannels"] = info.rejoinChannels; - out << i; - return out; -} - -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 = 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.useAutoReconnect = i["UseAutoReconnect"].toBool(); - info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt(); - info.autoReconnectRetries = i["AutoReconnectRetries"].toInt(); - info.unlimitedReconnectRetries = i["UnlimitedReconnectRetries"].toBool(); - info.rejoinChannels = i["RejoinChannels"].toBool(); - return in; -} - -QDebug operator<<(QDebug dbg, const NetworkInfo &i) { - dbg.nospace() << "(id = " << i.networkId << " name = " << i.networkName << " identity = " << i.identity - << " codecForServer = " << i.codecForServer << " codecForEncoding = " << i.codecForEncoding << " codecForDecoding = " << i.codecForDecoding - << " serverList = " << i.serverList << " useRandomServer = " << i.useRandomServer << " perform = " << i.perform - << " useAutoIdentify = " << i.useAutoIdentify << " autoIdentifyService = " << i.autoIdentifyService << " autoIdentifyPassword = " << i.autoIdentifyPassword - << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval - << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries - << " rejoinChannels = " << i.rejoinChannels << ")"; - return dbg.space(); +bool NetworkInfo::operator==(const NetworkInfo& other) const +{ + 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 + ; +} + +bool NetworkInfo::operator!=(const NetworkInfo& other) const +{ + return !(*this == other); } +QDataStream& operator<<(QDataStream& out, const NetworkInfo& info) +{ + QVariantMap i; + 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["UseCustomMessageRate"] = info.useCustomMessageRate; + i["UnlimitedMessageRate"] = info.unlimitedMessageRate; + out << i; + return out; +} + +QDataStream& operator>>(QDataStream& in, NetworkInfo& info) +{ + QVariantMap i; + in >> i; + 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.useCustomMessageRate = i["UseCustomMessageRate"].toBool(); + info.unlimitedMessageRate = i["UnlimitedMessageRate"].toBool(); + return in; +} + +QDebug operator<<(QDebug dbg, const NetworkInfo& i) +{ + dbg.nospace() << "(id = " << i.networkId << " name = " << i.networkName << " identity = " << i.identity + << " codecForServer = " << i.codecForServer << " codecForEncoding = " << i.codecForEncoding + << " codecForDecoding = " << i.codecForDecoding << " serverList = " << i.serverList + << " useRandomServer = " << i.useRandomServer << " perform = " << i.perform << " useAutoIdentify = " << i.useAutoIdentify + << " autoIdentifyService = " << i.autoIdentifyService << " autoIdentifyPassword = " << i.autoIdentifyPassword + << " useSasl = " << i.useSasl << " saslAccount = " << i.saslAccount << " saslPassword = " << i.saslPassword + << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval + << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries + << " rejoinChannels = " << i.rejoinChannels << " useCustomMessageRate = " << i.useCustomMessageRate + << " messageRateBurstSize = " << i.messageRateBurstSize << " messageRateDelay = " << i.messageRateDelay + << " unlimitedMessageRate = " << i.unlimitedMessageRate << ")"; + return dbg.space(); +} + +QDataStream& operator<<(QDataStream& out, const Network::Server& server) +{ + QVariantMap serverMap; + serverMap["Host"] = server.host; + 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; + serverMap["ProxyHost"] = server.proxyHost; + serverMap["ProxyPort"] = server.proxyPort; + serverMap["ProxyUser"] = server.proxyUser; + serverMap["ProxyPass"] = server.proxyPass; + out << serverMap; + return out; +} + +QDataStream& operator>>(QDataStream& in, Network::Server& server) +{ + QVariantMap serverMap; + in >> serverMap; + server.host = serverMap["Host"].toString(); + 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(); + server.proxyHost = serverMap["ProxyHost"].toString(); + server.proxyPort = serverMap["ProxyPort"].toUInt(); + server.proxyUser = serverMap["ProxyUser"].toString(); + server.proxyPass = serverMap["ProxyPass"].toString(); + return in; +} + +bool Network::Server::operator==(const Server& other) const +{ + if (host != other.host) + return false; + 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; + if (proxyHost != other.proxyHost) + return false; + if (proxyPort != other.proxyPort) + return false; + if (proxyUser != other.proxyUser) + return false; + if (proxyPass != other.proxyPass) + return false; + return true; +} + +bool Network::Server::operator!=(const Server& other) const +{ + return !(*this == other); +} - - +QDebug operator<<(QDebug dbg, const Network::Server& server) +{ + dbg.nospace() << "Server(host = " << server.host << ":" << server.port << ", useSsl = " << server.useSsl + << ", sslVerify = " << server.sslVerify << ")"; + return dbg.space(); +}