X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.cpp;h=ed8b35a62d3738b6f47161378694b97c3ea60d13;hp=cfcda7de71bcdcaf7e24847fbecbc7f5d85e1a6b;hb=f0013829ab979864e1cbf23c0195485c5d7ccb72;hpb=83e369bbb28a21f21dc939cce93189f98ca8502b

diff --git a/src/common/network.cpp b/src/common/network.cpp
index cfcda7de..ed8b35a6 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-2010 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -17,25 +17,28 @@
  *   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),
@@ -44,13 +47,15 @@ Network::Network(const NetworkId &networkid, QObject *parent)
     _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()));
 }
@@ -62,7 +67,7 @@ Network::~Network() {
 bool Network::isChannelName(const QString &channelname) const {
   if(channelname.isEmpty())
     return false;
-  
+
   if(supports("CHANTYPES"))
     return support("CHANTYPES").contains(channelname[0]);
   else
@@ -83,6 +88,9 @@ NetworkInfo Network::networkInfo() const {
   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();
@@ -98,12 +106,15 @@ void Network::setNetworkInfo(const NetworkInfo &info) {
   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);
@@ -138,7 +149,7 @@ QStringList Network::nicks() const {
 QString Network::prefixes() {
   if(_prefixes.isNull())
     determinePrefixes();
-  
+
   return _prefixes;
 }
 
@@ -149,7 +160,7 @@ QString Network::prefixModes() {
   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;
@@ -180,39 +191,38 @@ QString Network::support(const QString &param) 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);
+    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, 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) {
@@ -222,49 +232,60 @@ 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()];
@@ -320,7 +341,9 @@ void Network::setCodecForServer(const QByteArray &name) {
 
 void Network::setCodecForServer(QTextCodec *codec) {
   _codecForServer = codec;
-  emit codecForServerSet(codecForServer());
+  QByteArray codecName = codecForServer();
+  SYNC_OTHER(setCodecForServer, ARG(codecName))
+  emit configChanged();
 }
 
 QByteArray Network::codecForEncoding() const {
@@ -335,7 +358,9 @@ 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 {
@@ -350,7 +375,9 @@ 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
@@ -387,29 +414,94 @@ QByteArray Network::encodeServerString(const QString &string) const {
   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 &currentServer) {
   _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);
 }
 
@@ -417,7 +509,7 @@ 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);
 }
 
@@ -426,80 +518,119 @@ void Network::setMyNick(const QString &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<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 &param, const QString &value) {
   if(!_supports.contains(param)) {
     _supports[param] = value;
-    emit supportAdded(param, value);
+    SYNC(ARG(param), ARG(value))
   }
 }
 
 void Network::removeSupport(const QString &param) {
   if(_supports.contains(param)) {
     _supports.remove(param);
-    emit supportRemoved(param);
+    SYNC(ARG(param))
   }
 }
 
@@ -513,22 +644,52 @@ QVariantMap Network::initSupports() const {
   return supports;
 }
 
-QStringList Network::initIrcUsers() const {
-  QStringList hostmasks;
-  foreach(IrcUser *ircuser, ircUsers()) {
-    hostmasks << ircuser->hostmask();
+QVariantMap Network::initIrcUsersAndChannels() const {
+  QVariantMap usersAndChannels;
+  QVariantMap users;
+  QVariantMap channels;
+
+  QHash<QString, IrcUser *>::const_iterator userIter = _ircUsers.constBegin();
+  QHash<QString, IrcUser *>::const_iterator userIterEnd = _ircUsers.constEnd();
+  while(userIter != userIterEnd) {
+    users[userIter.value()->hostmask()] = userIter.value()->toVariantMap();
+    userIter++;
   }
-  return hostmasks;
+  usersAndChannels["users"] = users;
+
+  QHash<QString, IrcChannel *>::const_iterator channelIter = _ircChannels.constBegin();
+  QHash<QString, IrcChannel *>::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 {
-  QStringList channels;
-  QHash<QString, IrcChannel *>::const_iterator iter = _ircChannels.constBegin();
-  while(iter != _ircChannels.constEnd()) {
-    channels << iter.value()->name();
-    iter++;
+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++;
   }
-  return channels;
 }
 
 void Network::initSetSupports(const QVariantMap &supports) {
@@ -539,25 +700,10 @@ void Network::initSetSupports(const QVariantMap &supports) {
   }
 }
 
-void Network::initSetIrcUsers(const QStringList &hostmasks) {
-  if(!_ircUsers.empty())
-    return;
-  foreach(QString hostmask, hostmasks) {
-    newIrcUser(hostmask);
-  }
-}
-
-void Network::initSetIrcChannels(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);
@@ -579,43 +725,6 @@ void Network::ircUserNickChanged(QString newnick) {
     setMyNick(newnick);
 }
 
-void Network::ircUserInitDone() {
-  IrcUser *ircuser = static_cast<IrcUser *>(sender());
-  Q_ASSERT(ircuser);
-  emit ircUserInitDone(ircuser);
-}
-
-void Network::ircChannelInitDone() {
-  IrcChannel *ircchannel = static_cast<IrcChannel *>(sender());
-  Q_ASSERT(ircchannel);
-  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);
 }
@@ -625,32 +734,41 @@ 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;
+    }
+    // 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];
+      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];
+      if(prefix.contains(defaultPrefixModes[i])) {
+        _prefixes += defaultPrefixes[i];
+        _prefixModes += defaultPrefixModes[i];
       }
     }
     // now we've done all we've could...
@@ -661,6 +779,22 @@ 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;
@@ -674,6 +808,9 @@ bool NetworkInfo::operator==(const NetworkInfo &other) const {
   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;
@@ -694,12 +831,15 @@ QDataStream &operator<<(QDataStream &out, const NetworkInfo &info) {
   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;
@@ -718,12 +858,15 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info) {
   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();
@@ -734,11 +877,71 @@ QDataStream &operator>>(QDataStream &in, NetworkInfo &info) {
 
 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();
 }