X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.cpp;h=67ebe91512527493e0adb0160f198496d24730ce;hp=17db37d97ea29a457648b29c648aa320345ba88d;hb=e4972a0ebce0d555d752ab2f34ffd6a6dcdef1dd;hpb=4aca5963302eb2f6dfc41b723df4b362704f1b2b diff --git a/src/common/network.cpp b/src/common/network.cpp index 17db37d9..67ebe915 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-09 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -17,97 +17,85 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#include "network.h" - -#include "signalproxy.h" -#include "ircuser.h" -#include "ircchannel.h" - -#include +#include #include -#include "util.h" +#include "network.h" +#include "quassel.h" + +QTextCodec *Network::_defaultCodecForServer = 0; +QTextCodec *Network::_defaultCodecForEncoding = 0; +QTextCodec *Network::_defaultCodecForDecoding = 0; +QString Network::_networksIniPath = QString(); // ==================== // Public: // ==================== -Network::Network(const NetworkId &networkid, QObject *parent) : SyncableObject(parent), +INIT_SYNCABLE_OBJECT(Network) +Network::Network(const NetworkId &networkid, QObject *parent) + : SyncableObject(parent), + _proxy(0), _networkId(networkid), _identity(0), _myNick(QString()), + _latency(0), _networkName(QString("")), _currentServer(QString()), _connected(false), _connectionState(Disconnected), _prefixes(QString()), _prefixModes(QString()), - _proxy(0), + _useRandomServer(false), + _useAutoIdentify(false), + _useSasl(false), + _useAutoReconnect(false), + _autoReconnectInterval(60), + _autoReconnectRetries(10), + _unlimitedReconnectRetries(false), + _codecForServer(0), _codecForEncoding(0), - _codecForDecoding(0) + _codecForDecoding(0), + _autoAwayActive(false) { setObjectName(QString::number(networkid.toInt())); } -// I think this is unnecessary since IrcUsers have us as their daddy :) - Network::~Network() { -// 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()); -} - -bool Network::isMe(IrcUser *ircuser) const { - return (ircuser->nick().toLower() == myNick().toLower()); + 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::isConnected() const { - return _connected; -} - -//Network::ConnectionState Network::connectionState() const { -int Network::connectionState() const { - return _connectionState; -} - 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(); return info; } @@ -115,11 +103,23 @@ 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.codecForEncoding.isEmpty() && info.codecForEncoding != codecForEncoding()) - setCodecForEncoding(QTextCodec::codecForName(info.codecForEncoding)); - if(!info.codecForDecoding.isEmpty() && info.codecForDecoding != codecForDecoding()) - setCodecForDecoding(QTextCodec::codecForName(info.codecForDecoding)); - if(info.serverList.count()) setServerList(info.serverList); // FIXME compare components + 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); } QString Network::prefixToMode(const QString &prefix) { @@ -129,10 +129,6 @@ QString Network::prefixToMode(const QString &prefix) { return QString(); } -QString Network::prefixToMode(const QCharRef &prefix) { - return prefixToMode(QString(prefix)); -} - QString Network::modeToPrefix(const QString &mode) { if(prefixModes().contains(mode)) return QString(prefixes()[prefixModes().indexOf(mode)]); @@ -140,26 +136,6 @@ QString Network::modeToPrefix(const QString &mode) { return QString(); } -QString Network::modeToPrefix(const QCharRef &mode) { - return modeToPrefix(QString(mode)); -} - -QString Network::networkName() const { - return _networkName; -} - -QString Network::currentServer() const { - return _currentServer; -} - -QString Network::myNick() const { - return _myNick; -} - -IdentityId Network::identity() const { - return _identity; -} - QStringList Network::nicks() const { // we don't use _ircUsers.keys() since the keys may be // not up to date after a nick change @@ -170,18 +146,10 @@ QStringList Network::nicks() const { return nicks; } -QStringList Network::channels() const { - return _ircChannels.keys(); -} - -QVariantList Network::serverList() const { - return _serverList; -} - QString Network::prefixes() { if(_prefixes.isNull()) determinePrefixes(); - + return _prefixes; } @@ -192,8 +160,27 @@ QString Network::prefixModes() { return _prefixModes; } -bool Network::supports(const QString ¶m) const { - return _supports.contains(param); +// 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; } QString Network::support(const QString ¶m) const { @@ -204,29 +191,38 @@ QString Network::support(const QString ¶m) const { return QString(); } -IrcUser *Network::newIrcUser(const QString &hostmask) { +IrcUser *Network::newIrcUser(const QString &hostmask, const QVariantMap &initData) { QString nick(nickFromMask(hostmask).toLower()); if(!_ircUsers.contains(nick)) { IrcUser *ircuser = new IrcUser(hostmask, this); - // mark IrcUser as already initialized to keep the SignalProxy from requesting initData - //if(isInitialized()) - // ircuser->setInitialized(); + 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, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString))); - connect(ircuser, SIGNAL(initDone()), this, SLOT(ircUserInitDone())); + _ircUsers[nick] = ircuser; - emit ircUserAdded(hostmask); + + SYNC_OTHER(addIrcUser, ARG(hostmask)) + // emit ircUserAdded(hostmask); emit ircUserAdded(ircuser); } + return _ircUsers[nick]; } -IrcUser *Network::newIrcUser(const QByteArray &hostmask) { - return newIrcUser(decodeString(hostmask)); +IrcUser *Network::ircUser(QString nickname) const { + nickname = nickname.toLower(); + if(_ircUsers.contains(nickname)) + return _ircUsers[nickname]; + else + return 0; } void Network::removeIrcUser(IrcUser *ircuser) { @@ -236,62 +232,65 @@ void Network::removeIrcUser(IrcUser *ircuser) { _ircUsers.remove(nick); disconnect(ircuser, 0, this, 0); - emit ircUserRemoved(nick); - emit ircUserRemoved(ircuser); ircuser->deleteLater(); } -void Network::removeIrcUser(QString nick) { - IrcUser *ircuser; - if((ircuser = ircUser(nick)) != 0) - removeIrcUser(ircuser); -} +void Network::removeIrcChannel(IrcChannel *channel) { + QString chanName = _ircChannels.key(channel); + if(chanName.isNull()) + return; -IrcUser *Network::ircUser(QString nickname) const { - nickname = nickname.toLower(); - if(_ircUsers.contains(nickname)) - return _ircUsers[nickname]; - else - return 0; + _ircChannels.remove(chanName); + disconnect(channel, 0, this, 0); + channel->deleteLater(); } -IrcUser *Network::ircUser(const QByteArray &nickname) const { - return ircUser(decodeString(nickname)); -} +void Network::removeChansAndUsers() { + QList users = ircUsers(); + _ircUsers.clear(); + QList channels = ircChannels(); + _ircChannels.clear(); -QList Network::ircUsers() const { - return _ircUsers.values(); -} + foreach(IrcChannel *channel, channels) { + proxy()->detachObject(channel); + disconnect(channel, 0, this, 0); + } + foreach(IrcUser *user, users) { + proxy()->detachObject(user); + disconnect(user, 0, this, 0); + } + + // the second loop is needed because quit can have sideffects + foreach(IrcUser *user, users) { + user->quit(); + } -quint32 Network::ircUserCount() const { - return _ircUsers.count(); + qDeleteAll(users); + qDeleteAll(channels); } -IrcChannel *Network::newIrcChannel(const QString &channelname) { +IrcChannel *Network::newIrcChannel(const QString &channelname, const QVariantMap &initData) { if(!_ircChannels.contains(channelname.toLower())) { - IrcChannel *channel = new IrcChannel(channelname, this); - // mark IrcUser as already initialized to keep the SignalProxy from requesting initData - //if(isInitialized()) - // channel->setInitialized(); + 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 *)?"; - connect(channel, SIGNAL(initDone()), this, SLOT(ircChannelInitDone())); - connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed())); _ircChannels[channelname.toLower()] = channel; - emit ircChannelAdded(channelname); + + SYNC_OTHER(addIrcChannel, ARG(channelname)) + // emit ircChannelAdded(channelname); emit ircChannelAdded(channel); } return _ircChannels[channelname.toLower()]; } -IrcChannel *Network::newIrcChannel(const QByteArray &channelname) { - return newIrcChannel(decodeString(channelname)); -} - IrcChannel *Network::ircChannel(QString channelname) const { channelname = channelname.toLower(); if(_ircChannels.contains(channelname)) @@ -300,21 +299,56 @@ IrcChannel *Network::ircChannel(QString channelname) const { return 0; } -IrcChannel *Network::ircChannel(const QByteArray &channelname) const { - return ircChannel(decodeString(channelname)); +QByteArray Network::defaultCodecForServer() { + if(_defaultCodecForServer) + return _defaultCodecForServer->name(); + return QByteArray(); } +void Network::setDefaultCodecForServer(const QByteArray &name) { + _defaultCodecForServer = QTextCodec::codecForName(name); +} -QList Network::ircChannels() const { - return _ircChannels.values(); +QByteArray Network::defaultCodecForEncoding() { + if(_defaultCodecForEncoding) + return _defaultCodecForEncoding->name(); + return QByteArray(); } -quint32 Network::ircChannelCount() const { - return _ircChannels.count(); +void Network::setDefaultCodecForEncoding(const QByteArray &name) { + _defaultCodecForEncoding = QTextCodec::codecForName(name); +} + +QByteArray Network::defaultCodecForDecoding() { + if(_defaultCodecForDecoding) + return _defaultCodecForDecoding->name(); + return QByteArray(); +} + +void Network::setDefaultCodecForDecoding(const QByteArray &name) { + _defaultCodecForDecoding = QTextCodec::codecForName(name); +} + +QByteArray Network::codecForServer() const { + if(_codecForServer) + return _codecForServer->name(); + return QByteArray(); +} + +void Network::setCodecForServer(const QByteArray &name) { + setCodecForServer(QTextCodec::codecForName(name)); +} + +void Network::setCodecForServer(QTextCodec *codec) { + _codecForServer = codec; + QByteArray codecName = codecForServer(); + SYNC_OTHER(setCodecForServer, ARG(codecName)) + emit configChanged(); } QByteArray Network::codecForEncoding() const { - if(_codecForEncoding) return _codecForEncoding->name(); + if(_codecForEncoding) + return _codecForEncoding->name(); return QByteArray(); } @@ -324,11 +358,14 @@ void Network::setCodecForEncoding(const QByteArray &name) { void Network::setCodecForEncoding(QTextCodec *codec) { _codecForEncoding = codec; - emit codecForEncodingSet(codecForEncoding()); + QByteArray codecName = codecForEncoding(); + SYNC_OTHER(setCodecForEncoding, ARG(codecName)) + emit configChanged(); } QByteArray Network::codecForDecoding() const { - if(_codecForDecoding) return _codecForDecoding->name(); + if(_codecForDecoding) + return _codecForDecoding->name(); else return QByteArray(); } @@ -338,35 +375,134 @@ void Network::setCodecForDecoding(const QByteArray &name) { void Network::setCodecForDecoding(QTextCodec *codec) { _codecForDecoding = codec; - emit codecForDecodingSet(codecForDecoding()); + QByteArray codecName = codecForDecoding(); + SYNC_OTHER(setCodecForDecoding, ARG(codecName)) + emit configChanged(); } +// FIXME use server encoding if appropriate QString Network::decodeString(const QByteArray &text) const { - return ::decodeString(text, _codecForDecoding); + if(_codecForDecoding) + return ::decodeString(text, _codecForDecoding); + else return ::decodeString(text, _defaultCodecForDecoding); } -QByteArray Network::encodeString(const QString string) const { +QByteArray Network::encodeString(const QString &string) const { if(_codecForEncoding) { return _codecForEncoding->fromUnicode(string); } + if(_defaultCodecForEncoding) { + return _defaultCodecForEncoding->fromUnicode(string); + } + return string.toAscii(); +} + +QString Network::decodeServerString(const QByteArray &text) const { + if(_codecForServer) + return ::decodeString(text, _codecForServer); + else + return ::decodeString(text, _defaultCodecForServer); +} + +QByteArray Network::encodeServerString(const QString &string) const { + if(_codecForServer) { + return _codecForServer->fromUnicode(string); + } + if(_defaultCodecForServer) { + return _defaultCodecForServer->fromUnicode(string); + } return string.toAscii(); } +/*** Handle networks.ini ***/ + +QStringList Network::presetNetworks(bool onlyDefault) { + // lazily find the file, make sure to not call one of the other preset functions first (they'll fail else) + if(_networksIniPath.isNull()) { + _networksIniPath = Quassel::findDataFilePath("networks.ini"); + if(_networksIniPath.isNull()) { + _networksIniPath = ""; // now we won't check again, as it's not null anymore + return QStringList(); + } + } + if(!_networksIniPath.isEmpty()) { + QSettings s(_networksIniPath, QSettings::IniFormat); + QStringList networks = s.childGroups(); + if(!networks.isEmpty()) { + // we sort the list case-insensitive + QMap 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: // ==================== void Network::setNetworkName(const QString &networkName) { _networkName = networkName; + SYNC(ARG(networkName)) emit networkNameSet(networkName); + emit configChanged(); } void Network::setCurrentServer(const QString ¤tServer) { _currentServer = currentServer; + SYNC(ARG(currentServer)) emit currentServerSet(currentServer); } void Network::setConnected(bool connected) { + if(_connected == connected) + return; + _connected = connected; + if(!connected) { + setMyNick(QString()); + setCurrentServer(QString()); + removeChansAndUsers(); + } + SYNC(ARG(connected)) emit connectedSet(connected); } @@ -374,36 +510,128 @@ void Network::setConnected(bool connected) { void Network::setConnectionState(int state) { _connectionState = (ConnectionState)state; //qDebug() << "netstate" << networkId() << networkName() << state; - emit connectionStateSet(state); + SYNC(ARG(state)) emit connectionStateSet(_connectionState); } void Network::setMyNick(const QString &nickname) { _myNick = nickname; + if(!_myNick.isEmpty() && !ircUser(myNick())) { + newIrcUser(myNick()); + } + SYNC(ARG(nickname)) emit myNickSet(nickname); } +void Network::setLatency(int latency) { + if(_latency == latency) + return; + _latency = latency; + SYNC(ARG(latency)) +} + void Network::setIdentity(IdentityId id) { _identity = id; + SYNC(ARG(id)) emit identitySet(id); + emit configChanged(); } void Network::setServerList(const QVariantList &serverList) { - _serverList = serverList; - emit serverListSet(serverList); + _serverList = fromVariantList(serverList); + SYNC(ARG(serverList)) + emit configChanged(); +} + +void Network::setUseRandomServer(bool use) { + _useRandomServer = use; + SYNC(ARG(use)) + emit configChanged(); +} + +void Network::setPerform(const QStringList &perform) { + _perform = perform; + SYNC(ARG(perform)) + emit configChanged(); +} + +void Network::setUseAutoIdentify(bool use) { + _useAutoIdentify = use; + SYNC(ARG(use)) + emit configChanged(); +} + +void Network::setAutoIdentifyService(const QString &service) { + _autoIdentifyService = service; + SYNC(ARG(service)) + emit configChanged(); +} + +void Network::setAutoIdentifyPassword(const QString &password) { + _autoIdentifyPassword = password; + SYNC(ARG(password)) + emit configChanged(); +} + +void Network::setUseSasl(bool use) { + _useSasl = use; + SYNC(ARG(use)) + emit configChanged(); +} + +void Network::setSaslAccount(const QString &account) { + _saslAccount = account; + SYNC(ARG(account)) + emit configChanged(); +} + +void Network::setSaslPassword(const QString &password) { + _saslPassword = password; + SYNC(ARG(password)) + emit configChanged(); +} + +void Network::setUseAutoReconnect(bool use) { + _useAutoReconnect = use; + SYNC(ARG(use)) + emit configChanged(); +} + +void Network::setAutoReconnectInterval(quint32 interval) { + _autoReconnectInterval = interval; + SYNC(ARG(interval)) + emit configChanged(); +} + +void Network::setAutoReconnectRetries(quint16 retries) { + _autoReconnectRetries = retries; + SYNC(ARG(retries)) + emit configChanged(); +} + +void Network::setUnlimitedReconnectRetries(bool unlimited) { + _unlimitedReconnectRetries = unlimited; + SYNC(ARG(unlimited)) + emit configChanged(); +} + +void Network::setRejoinChannels(bool rejoin) { + _rejoinChannels = rejoin; + SYNC(ARG(rejoin)) + emit configChanged(); } void Network::addSupport(const QString ¶m, const QString &value) { if(!_supports.contains(param)) { _supports[param] = value; - emit supportAdded(param, value); + SYNC(ARG(param), ARG(value)) } } void Network::removeSupport(const QString ¶m) { if(_supports.contains(param)) { _supports.remove(param); - emit supportRemoved(param); + SYNC(ARG(param)) } } @@ -417,20 +645,52 @@ QVariantMap Network::initSupports() const { return supports; } -QVariantList Network::initServerList() const { - return serverList(); -} +QVariantMap Network::initIrcUsersAndChannels() const { + QVariantMap usersAndChannels; + QVariantMap users; + QVariantMap channels; -QStringList Network::initIrcUsers() const { - QStringList hostmasks; - foreach(IrcUser *ircuser, ircUsers()) { - hostmasks << ircuser->hostmask(); + QHash::const_iterator userIter = _ircUsers.constBegin(); + QHash::const_iterator userIterEnd = _ircUsers.constEnd(); + while(userIter != userIterEnd) { + users[userIter.value()->hostmask()] = userIter.value()->toVariantMap(); + userIter++; } - return hostmasks; + usersAndChannels["users"] = users; + + QHash::const_iterator channelIter = _ircChannels.constBegin(); + QHash::const_iterator channelIterEnd = _ircChannels.constEnd(); + while(channelIter != channelIterEnd) { + channels[channelIter.value()->name()] = channelIter.value()->toVariantMap(); + channelIter++; + } + usersAndChannels["channels"] = channels; + + return usersAndChannels; } -QStringList Network::initIrcChannels() const { - return _ircChannels.keys(); +void Network::initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels) { + Q_ASSERT(proxy()); + if(isInitialized()) { + qWarning() << "Network" << networkId() << "received init data for users and channels allthough there allready are known users or channels!"; + return; + } + + QVariantMap users = usersAndChannels.value("users").toMap(); + QVariantMap::const_iterator userIter = users.constBegin(); + QVariantMap::const_iterator userIterEnd = users.constEnd(); + while(userIter != userIterEnd) { + newIrcUser(userIter.key(), userIter.value().toMap()); + userIter++; + } + + QVariantMap channels = usersAndChannels.value("channels").toMap(); + QVariantMap::const_iterator channelIter = channels.constBegin(); + QVariantMap::const_iterator channelIterEnd = channels.constEnd(); + while(channelIter != channelIterEnd) { + newIrcChannel(channelIter.key(), channelIter.value().toMap()); + channelIter++; + } } void Network::initSetSupports(const QVariantMap &supports) { @@ -441,29 +701,10 @@ void Network::initSetSupports(const QVariantMap &supports) { } } -void Network::initSetServerList(const QVariantList & serverList) { - setServerList(serverList); -} - -void Network::initSetIrcUsers(const QStringList &hostmasks) { - if(!_ircUsers.empty()) - return; - foreach(QString hostmask, hostmasks) { - newIrcUser(hostmask); - } -} - -void Network::initSetChannels(const QStringList &channels) { - if(!_ircChannels.empty()) - return; - foreach(QString channel, channels) - newIrcChannel(channel); -} - IrcUser *Network::updateNickFromMask(const QString &mask) { QString nick(nickFromMask(mask).toLower()); IrcUser *ircuser; - + if(_ircUsers.contains(nick)) { ircuser = _ircUsers[nick]; ircuser->updateHostmask(mask); @@ -485,49 +726,6 @@ void Network::ircUserNickChanged(QString newnick) { setMyNick(newnick); } -void Network::ircUserInitDone() { - IrcUser *ircuser = static_cast(sender()); - Q_ASSERT(ircuser); - emit ircUserInitDone(ircuser); -} - -void Network::ircChannelInitDone() { - IrcChannel *ircchannel = static_cast(sender()); - Q_ASSERT(ircchannel); - emit ircChannelInitDone(ircchannel); -} - -void Network::channelDestroyed() { - IrcChannel *channel = static_cast(sender()); - Q_ASSERT(channel); - _ircChannels.remove(_ircChannels.key(channel)); - emit ircChannelRemoved(channel); -} - -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 not being disconnected!"; - return; - } - emit connectRequested(networkId()); // and this is for CoreSession :) - } -} - -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 :) - } -} - void Network::emitConnectionError(const QString &errorMsg) { emit connectionError(errorMsg); } @@ -537,18 +735,24 @@ void Network::emitConnectionError(const QString &errorMsg) { // ==================== 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); + 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; + } + // we just assume that in PREFIX are only prefix chars stored for(int i = 0; i < defaultPrefixes.size(); i++) { - if(PREFIX.contains(defaultPrefixes[i])) { + if(prefix.contains(defaultPrefixes[i])) { _prefixes += defaultPrefixes[i]; _prefixModes += defaultPrefixModes[i]; } @@ -556,11 +760,11 @@ void Network::determinePrefixes() { // 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])) { + if(prefix.contains(defaultPrefixModes[i])) { _prefixes += defaultPrefixes[i]; _prefixModes += defaultPrefixModes[i]; } @@ -573,13 +777,43 @@ void Network::determinePrefixes() { * 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; } @@ -592,9 +826,23 @@ QDataStream &operator<<(QDataStream &out, const NetworkInfo &info) { 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["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["UnlimitedReconnectRetries"] = info.unlimitedReconnectRetries; + i["RejoinChannels"] = info.rejoinChannels; out << i; return out; } @@ -605,8 +853,93 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info) { 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.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.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 + << " useSasl = " << i.useSasl << " saslAccount = " << i.saslAccount << " saslPassword = " << i.saslPassword + << " useAutoReconnect = " << i.useAutoReconnect << " autoReconnectInterval = " << i.autoReconnectInterval + << " autoReconnectRetries = " << i.autoReconnectRetries << " unlimitedReconnectRetries = " << i.unlimitedReconnectRetries + << " rejoinChannels = " << i.rejoinChannels << ")"; + 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["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.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(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 << ")"; + return dbg.space(); +}