/***************************************************************************
- * 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 *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include "network.h"
-
-#include <QDebug>
+#include <QSettings>
#include <QTextCodec>
-#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:
// ====================
+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("<not initialized>")),
_currentServer(QString()),
_connected(false),
_prefixModes(QString()),
_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()));
}
bool Network::isChannelName(const QString &channelname) const {
if(channelname.isEmpty())
return false;
-
+
if(supports("CHANTYPES"))
return support("CHANTYPES").contains(channelname[0]);
else
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();
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.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);
QString Network::prefixes() {
if(_prefixes.isNull())
determinePrefixes();
-
+
return _prefixes;
}
return _prefixModes;
}
-// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG
+// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG
Network::ChannelModeType Network::channelModeType(const QString &mode) {
if(mode.isEmpty())
return NOT_A_CHANMODE;
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);
+ 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()));
- connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
+
_ircUsers[nick] = ircuser;
- emit ircUserAdded(hostmask);
+
+ SYNC_OTHER(addIrcUser, ARG(hostmask))
+ // emit ircUserAdded(hostmask);
emit ircUserAdded(ircuser);
}
+
return _ircUsers[nick];
}
-void Network::ircUserDestroyed() {
- IrcUser *ircUser = static_cast<IrcUser *>(sender());
- if(!ircUser)
- return;
-
- QHash<QString, IrcUser *>::iterator ircUserIter = _ircUsers.begin();
- while(ircUserIter != _ircUsers.end()) {
- if(ircUser == *ircUserIter) {
- ircUserIter = _ircUsers.erase(ircUserIter);
- break;
- }
- ircUserIter++;
- }
+IrcUser *Network::ircUser(QString nickname) const {
+ nickname = nickname.toLower();
+ if(_ircUsers.contains(nickname))
+ return _ircUsers[nickname];
+ else
+ return 0;
}
void Network::removeIrcUser(IrcUser *ircuser) {
_ircUsers.remove(nick);
disconnect(ircuser, 0, this, 0);
- emit ircUserRemoved(nick);
- emit ircUserRemoved(ircuser);
ircuser->deleteLater();
}
-void Network::removeIrcUser(const 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;
+
+ _ircChannels.remove(chanName);
+ disconnect(channel, 0, this, 0);
+ channel->deleteLater();
}
void Network::removeChansAndUsers() {
QList<IrcUser *> users = ircUsers();
- foreach(IrcUser *user, users) {
- removeIrcUser(user);
- }
+ _ircUsers.clear();
QList<IrcChannel *> channels = ircChannels();
+ _ircChannels.clear();
+
foreach(IrcChannel *channel, channels) {
- removeIrcChannel(channel);
+ proxy()->detachObject(channel);
+ disconnect(channel, 0, this, 0);
+ }
+ foreach(IrcUser *user, users) {
+ proxy()->detachObject(user);
+ disconnect(user, 0, this, 0);
}
-}
-IrcUser *Network::ircUser(QString nickname) const {
- nickname = nickname.toLower();
- if(_ircUsers.contains(nickname))
- return _ircUsers[nickname];
- else
- return 0;
+ // the second loop is needed because quit can have sideffects
+ foreach(IrcUser *user, users) {
+ user->quit();
+ }
+
+ 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);
+ 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()];
void Network::setCodecForServer(QTextCodec *codec) {
_codecForServer = codec;
- emit codecForServerSet(codecForServer());
+ QByteArray codecName = codecForServer();
+ SYNC_OTHER(setCodecForServer, ARG(codecName))
+ emit configChanged();
}
QByteArray Network::codecForEncoding() const {
void Network::setCodecForEncoding(QTextCodec *codec) {
_codecForEncoding = codec;
- emit codecForEncodingSet(codecForEncoding());
+ QByteArray codecName = codecForEncoding();
+ SYNC_OTHER(setCodecForEncoding, ARG(codecName))
+ emit configChanged();
}
QByteArray Network::codecForDecoding() const {
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
return string.toAscii();
}
+/*** Handle networks.ini ***/
+
+QStringList Network::presetNetworks(bool onlyDefault) {
+ // lazily find the file, make sure to not call one of the other preset functions first (they'll fail else)
+ if(_networksIniPath.isNull()) {
+ _networksIniPath = Quassel::findDataFilePath("networks.ini");
+ if(_networksIniPath.isNull()) {
+ _networksIniPath = ""; // now we won't check again, as it's not null anymore
+ return QStringList();
+ }
+ }
+ if(!_networksIniPath.isEmpty()) {
+ QSettings s(_networksIniPath, QSettings::IniFormat);
+ QStringList networks = s.childGroups();
+ if(!networks.isEmpty()) {
+ // we sort the list case-insensitive
+ QMap<QString, QString> sorted;
+ foreach(QString net, networks) {
+ if(onlyDefault && !s.value(QString("%1/Default").arg(net)).toBool())
+ continue;
+ sorted[net.toLower()] = net;
+ }
+ return sorted.values();
+ }
+ }
+ return QStringList();
+}
+
+QStringList Network::presetDefaultChannels(const QString &networkName) {
+ if(_networksIniPath.isEmpty()) // be sure to have called presetNetworks() first, else this always fails
+ return QStringList();
+ QSettings s(_networksIniPath, QSettings::IniFormat);
+ return s.value(QString("%1/DefaultChannels").arg(networkName)).toStringList();
+}
+
+NetworkInfo Network::networkInfoFromPreset(const QString &networkName) {
+ NetworkInfo info;
+ if(!_networksIniPath.isEmpty()) {
+ info.networkName = networkName;
+ QSettings s(_networksIniPath, QSettings::IniFormat);
+ s.beginGroup(info.networkName);
+ foreach(QString server, s.value("Servers").toStringList()) {
+ bool ssl = false;
+ QStringList splitserver = server.split(':', QString::SkipEmptyParts);
+ if(splitserver.count() != 2) {
+ qWarning() << "Invalid server entry in networks.conf:" << server;
+ continue;
+ }
+ if(splitserver[1].at(0) == '+')
+ ssl = true;
+ uint port = splitserver[1].toUInt();
+ if(!port) {
+ qWarning() << "Invalid port entry in networks.conf:" << server;
+ continue;
+ }
+ info.serverList << Network::Server(splitserver[0].trimmed(), port, QString(), ssl);
+ }
+ }
+ return info;
+}
+
+
// ====================
// 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);
}
void Network::setConnectionState(int state) {
_connectionState = (ConnectionState)state;
//qDebug() << "netstate" << networkId() << networkName() << state;
- emit connectionStateSet(state);
+ SYNC(ARG(state))
emit connectionStateSet(_connectionState);
}
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<Server>(serverList);
+ SYNC(ARG(serverList))
+ emit configChanged();
}
void Network::setUseRandomServer(bool use) {
_useRandomServer = use;
- emit useRandomServerSet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setPerform(const QStringList &perform) {
_perform = perform;
- emit performSet(perform);
+ SYNC(ARG(perform))
+ emit configChanged();
}
void Network::setUseAutoIdentify(bool use) {
_useAutoIdentify = use;
- emit useAutoIdentifySet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setAutoIdentifyService(const QString &service) {
_autoIdentifyService = service;
- emit autoIdentifyServiceSet(service);
+ SYNC(ARG(service))
+ emit configChanged();
}
void Network::setAutoIdentifyPassword(const QString &password) {
_autoIdentifyPassword = password;
- emit autoIdentifyPasswordSet(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;
- emit useAutoReconnectSet(use);
+ SYNC(ARG(use))
+ emit configChanged();
}
void Network::setAutoReconnectInterval(quint32 interval) {
_autoReconnectInterval = interval;
- emit autoReconnectIntervalSet(interval);
+ SYNC(ARG(interval))
+ emit configChanged();
}
void Network::setAutoReconnectRetries(quint16 retries) {
_autoReconnectRetries = retries;
- emit autoReconnectRetriesSet(retries);
+ SYNC(ARG(retries))
+ emit configChanged();
}
void Network::setUnlimitedReconnectRetries(bool unlimited) {
_unlimitedReconnectRetries = unlimited;
- emit unlimitedReconnectRetriesSet(unlimited);
+ SYNC(ARG(unlimited))
+ emit configChanged();
}
void Network::setRejoinChannels(bool rejoin) {
_rejoinChannels = rejoin;
- emit rejoinChannelsSet(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))
}
}
QHash<QString, IrcChannel *>::const_iterator channelIter = _ircChannels.constBegin();
QHash<QString, IrcChannel *>::const_iterator channelIterEnd = _ircChannels.constEnd();
while(channelIter != channelIterEnd) {
- channels[channelIter.key()] = channelIter.value()->toVariantMap();
+ channels[channelIter.value()->name()] = channelIter.value()->toVariantMap();
channelIter++;
}
usersAndChannels["channels"] = channels;
void Network::initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels) {
Q_ASSERT(proxy());
- if(!_ircUsers.isEmpty() || !_ircChannels.isEmpty()) {
+ 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 users = usersAndChannels.value("users").toMap();
QVariantMap::const_iterator userIter = users.constBegin();
QVariantMap::const_iterator userIterEnd = users.constEnd();
- IrcUser *ircUser = 0;
- QString hostmask;
while(userIter != userIterEnd) {
- hostmask = userIter.key();
- ircUser = new IrcUser(hostmask, this);
- ircUser->fromVariantMap(userIter.value().toMap());
- ircUser->setInitialized();
- proxy()->synchronize(ircUser);
-
- connect(ircUser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
- connect(ircUser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
-
- _ircUsers[nickFromMask(hostmask).toLower()] = ircUser;
-
- emit ircUserAdded(hostmask);
- emit ircUserAdded(ircUser);
- emit ircUserInitDone(ircUser);
-
+ 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();
- IrcChannel *ircChannel = 0;
- QString channelName;
-
while(channelIter != channelIterEnd) {
- channelName = channelIter.key();
- ircChannel = new IrcChannel(channelName, this);
- ircChannel->fromVariantMap(channelIter.value().toMap());
- ircChannel->setInitialized();
- proxy()->synchronize(ircChannel);
-
- connect(ircChannel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
- _ircChannels[channelName.toLower()] = ircChannel;
-
- emit ircChannelAdded(channelName);
- emit ircChannelAdded(ircChannel);
- emit ircChannelInitDone(ircChannel);
-
+ newIrcChannel(channelIter.key(), channelIter.value().toMap());
channelIter++;
}
-
}
void Network::initSetSupports(const QVariantMap &supports) {
IrcUser *Network::updateNickFromMask(const QString &mask) {
QString nick(nickFromMask(mask).toLower());
IrcUser *ircuser;
-
+
if(_ircUsers.contains(nick)) {
ircuser = _ircUsers[nick];
ircuser->updateHostmask(mask);
setMyNick(newnick);
}
-void Network::ircUserInitDone() {
- IrcUser *ircuser = static_cast<IrcUser *>(sender());
- Q_ASSERT(ircuser);
- connect(ircuser, SIGNAL(initDone()), this, SLOT(ircUserInitDone()));
- emit ircUserInitDone(ircuser);
-}
-
-void Network::ircChannelInitDone() {
- IrcChannel *ircChannel = static_cast<IrcChannel *>(sender());
- Q_ASSERT(ircChannel);
- disconnect(ircChannel, SIGNAL(initDone()), this, SLOT(ircChannelInitDone()));
- emit ircChannelInitDone(ircChannel);
-}
-
-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();
-}
-
-void Network::removeIrcChannel(const QString &channel) {
- IrcChannel *chan;
- if((chan = ircChannel(channel)) != 0)
- removeIrcChannel(chan);
-}
-
-void Network::channelDestroyed() {
- IrcChannel *channel = static_cast<IrcChannel *>(sender());
- Q_ASSERT(channel);
- _ircChannels.remove(_ircChannels.key(channel));
- emit ircChannelRemoved(channel);
-}
-
void Network::emitConnectionError(const QString &errorMsg) {
emit connectionError(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()) {
+ 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];
}
// 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];
}
* 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(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;
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;
info.codecForServer = i["CodecForServer"].toByteArray();
info.codecForEncoding = i["CodecForEncoding"].toByteArray();
info.codecForDecoding = i["CodecForDecoding"].toByteArray();
- info.serverList = i["ServerList"].toList();
+ info.serverList = fromVariantList<Network::Server>(i["ServerList"].toList());
info.useRandomServer = i["UseRandomServer"].toBool();
info.perform = i["Perform"].toStringList();
info.useAutoIdentify = i["UseAutoIdentify"].toBool();
info.autoIdentifyService = i["AutoIdentifyService"].toString();
info.autoIdentifyPassword = i["AutoIdentifyPassword"].toString();
+ info.useSasl = i["UseSasl"].toBool();
+ info.saslAccount = i["SaslAccount"].toString();
+ info.saslPassword = i["SaslPassword"].toString();
info.useAutoReconnect = i["UseAutoReconnect"].toBool();
info.autoReconnectInterval = i["AutoReconnectInterval"].toUInt();
info.autoReconnectRetries = i["AutoReconnectRetries"].toInt();
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 << ")";
+ << " 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();
}
projects / quassel.git / blobdiff