src/core/coresession.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2012 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "coresession.h"
  22
  23 #include <QtScript>
  24
  25 #include "core.h"
  26 #include "coreuserinputhandler.h"
  27 #include "corebuffersyncer.h"
  28 #include "corebacklogmanager.h"
  29 #include "corebufferviewmanager.h"
  30 #include "coreeventmanager.h"
  31 #include "coreidentity.h"
  32 #include "coreignorelistmanager.h"
  33 #include "coreirclisthelper.h"
  34 #include "corenetwork.h"
  35 #include "corenetworkconfig.h"
  36 #include "coresessioneventprocessor.h"
  37 #include "coreusersettings.h"
  38 #include "ctcpparser.h"
  39 #include "eventstringifier.h"
  40 #include "ircchannel.h"
  41 #include "ircparser.h"
  42 #include "ircuser.h"
  43 #include "logger.h"
  44 #include "messageevent.h"
  45 #include "signalproxy.h"
  46 #include "storage.h"
  47 #include "util.h"
  48
  49 class ProcessMessagesEvent : public QEvent
  50 {
  51 public:
  52     ProcessMessagesEvent() : QEvent(QEvent::User) {}
  53 };
  54
  55
  56 CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
  57     : QObject(parent),
  58     _user(uid),
  59     _signalProxy(new SignalProxy(SignalProxy::Server, 0, this)),
  60     _aliasManager(this),
  61     _bufferSyncer(new CoreBufferSyncer(this)),
  62     _backlogManager(new CoreBacklogManager(this)),
  63     _bufferViewManager(new CoreBufferViewManager(_signalProxy, this)),
  64     _ircListHelper(new CoreIrcListHelper(this)),
  65     _networkConfig(new CoreNetworkConfig("GlobalNetworkConfig", this)),
  66     _coreInfo(this),
  67     _eventManager(new CoreEventManager(this)),
  68     _eventStringifier(new EventStringifier(this)),
  69     _sessionEventProcessor(new CoreSessionEventProcessor(this)),
  70     _ctcpParser(new CtcpParser(this)),
  71     _ircParser(new IrcParser(this)),
  72     scriptEngine(new QScriptEngine(this)),
  73     _processMessages(false),
  74     _ignoreListManager(this)
  75 {
  76     SignalProxy *p = signalProxy();
  77     p->setHeartBeatInterval(30);
  78     p->setMaxHeartBeatCount(60); // 30 mins until we throw a dead socket out
  79
  80     connect(p, SIGNAL(peerRemoved(QIODevice *)), this, SLOT(removeClient(QIODevice *)));
  81
  82     connect(p, SIGNAL(connected()), this, SLOT(clientsConnected()));
  83     connect(p, SIGNAL(disconnected()), this, SLOT(clientsDisconnected()));
  84
  85     p->attachSlot(SIGNAL(sendInput(BufferInfo, QString)), this, SLOT(msgFromClient(BufferInfo, QString)));
  86     p->attachSignal(this, SIGNAL(displayMsg(Message)));
  87     p->attachSignal(this, SIGNAL(displayStatusMsg(QString, QString)));
  88
  89     p->attachSignal(this, SIGNAL(identityCreated(const Identity &)));
  90     p->attachSignal(this, SIGNAL(identityRemoved(IdentityId)));
  91     p->attachSlot(SIGNAL(createIdentity(const Identity &, const QVariantMap &)), this, SLOT(createIdentity(const Identity &, const QVariantMap &)));
  92     p->attachSlot(SIGNAL(removeIdentity(IdentityId)), this, SLOT(removeIdentity(IdentityId)));
  93
  94     p->attachSignal(this, SIGNAL(networkCreated(NetworkId)));
  95     p->attachSignal(this, SIGNAL(networkRemoved(NetworkId)));
  96     p->attachSlot(SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)), this, SLOT(createNetwork(const NetworkInfo &, const QStringList &)));
  97     p->attachSlot(SIGNAL(removeNetwork(NetworkId)), this, SLOT(removeNetwork(NetworkId)));
  98
  99     loadSettings();
 100     initScriptEngine();
 101
 102     eventManager()->registerObject(ircParser(), EventManager::NormalPriority);
 103     eventManager()->registerObject(sessionEventProcessor(), EventManager::HighPriority); // needs to process events *before* the stringifier!
 104     eventManager()->registerObject(ctcpParser(), EventManager::NormalPriority);
 105     eventManager()->registerObject(eventStringifier(), EventManager::NormalPriority);
 106     eventManager()->registerObject(this, EventManager::LowPriority); // for sending MessageEvents to the client
 107     // some events need to be handled after msg generation
 108     eventManager()->registerObject(sessionEventProcessor(), EventManager::LowPriority, "lateProcess");
 109     eventManager()->registerObject(ctcpParser(), EventManager::LowPriority, "send");
 110
 111     // periodically save our session state
 112     connect(&(Core::instance()->syncTimer()), SIGNAL(timeout()), this, SLOT(saveSessionState()));
 113
 114     p->synchronize(_bufferSyncer);
 115     p->synchronize(&aliasManager());
 116     p->synchronize(_backlogManager);
 117     p->synchronize(ircListHelper());
 118     p->synchronize(networkConfig());
 119     p->synchronize(&_coreInfo);
 120     p->synchronize(&_ignoreListManager);
 121     // Restore session state
 122     if (restoreState)
 123         restoreSessionState();
 124
 125     emit initialized();
 126 }
 127
 128
 129 CoreSession::~CoreSession()
 130 {
 131     saveSessionState();
 132     foreach(CoreNetwork *net, _networks.values()) {
 133         delete net;
 134     }
 135 }
 136
 137
 138 CoreNetwork *CoreSession::network(NetworkId id) const
 139 {
 140     if (_networks.contains(id)) return _networks[id];
 141     return 0;
 142 }
 143
 144
 145 CoreIdentity *CoreSession::identity(IdentityId id) const
 146 {
 147     if (_identities.contains(id)) return _identities[id];
 148     return 0;
 149 }
 150
 151
 152 void CoreSession::loadSettings()
 153 {
 154     CoreUserSettings s(user());
 155
 156     // migrate to db
 157     QList<IdentityId> ids = s.identityIds();
 158     QList<NetworkInfo> networkInfos = Core::networks(user());
 159     foreach(IdentityId id, ids) {
 160         CoreIdentity identity(s.identity(id));
 161         IdentityId newId = Core::createIdentity(user(), identity);
 162         QList<NetworkInfo>::iterator networkIter = networkInfos.begin();
 163         while (networkIter != networkInfos.end()) {
 164             if (networkIter->identity == id) {
 165                 networkIter->identity = newId;
 166                 Core::updateNetwork(user(), *networkIter);
 167                 networkIter = networkInfos.erase(networkIter);
 168             }
 169             else {
 170                 networkIter++;
 171             }
 172         }
 173         s.removeIdentity(id);
 174     }
 175     // end of migration
 176
 177     foreach(CoreIdentity identity, Core::identities(user())) {
 178         createIdentity(identity);
 179     }
 180
 181     foreach(NetworkInfo info, Core::networks(user())) {
 182         createNetwork(info);
 183     }
 184 }
 185
 186
 187 void CoreSession::saveSessionState() const
 188 {
 189     _bufferSyncer->storeDirtyIds();
 190     _bufferViewManager->saveBufferViews();
 191     _networkConfig->save();
 192 }
 193
 194
 195 void CoreSession::restoreSessionState()
 196 {
 197     QList<NetworkId> nets = Core::connectedNetworks(user());
 198     CoreNetwork *net = 0;
 199     foreach(NetworkId id, nets) {
 200         net = network(id);
 201         Q_ASSERT(net);
 202         net->connectToIrc();
 203     }
 204 }
 205
 206
 207 void CoreSession::addClient(QIODevice *device)
 208 {
 209     if (!device) {
 210         qCritical() << "Invoking CoreSession::addClient with a QObject that is not a QIODevice!";
 211     }
 212     else {
 213         // if the socket is an orphan, the signalProxy adopts it.
 214         // -> we don't need to care about it anymore
 215         device->setParent(0);
 216         signalProxy()->addPeer(device);
 217         QVariantMap reply;
 218         reply["MsgType"] = "SessionInit";
 219         reply["SessionState"] = sessionState();
 220         SignalProxy::writeDataToDevice(device, reply);
 221     }
 222 }
 223
 224
 225 void CoreSession::addClient(SignalProxy *proxy)
 226 {
 227     signalProxy()->addPeer(proxy);
 228     emit sessionState(sessionState());
 229 }
 230
 231
 232 void CoreSession::removeClient(QIODevice *iodev)
 233 {
 234     QTcpSocket *socket = qobject_cast<QTcpSocket *>(iodev);
 235     if (socket)
 236         quInfo() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("disconnected (UserId: %1).").arg(user().toInt()));
 237 }
 238
 239
 240 QHash<QString, QString> CoreSession::persistentChannels(NetworkId id) const
 241 {
 242     return Core::persistentChannels(user(), id);
 243 }
 244
 245
 246 // FIXME switch to BufferId
 247 void CoreSession::msgFromClient(BufferInfo bufinfo, QString msg)
 248 {
 249     CoreNetwork *net = network(bufinfo.networkId());
 250     if (net) {
 251         net->userInput(bufinfo, msg);
 252     }
 253     else {
 254         qWarning() << "Trying to send to unconnected network:" << msg;
 255     }
 256 }
 257
 258
 259 // ALL messages coming pass through these functions before going to the GUI.
 260 // So this is the perfect place for storing the backlog and log stuff.
 261 void CoreSession::recvMessageFromServer(NetworkId networkId, Message::Type type, BufferInfo::Type bufferType,
 262     const QString &target, const QString &text_, const QString &sender, Message::Flags flags)
 263 {
 264     // U+FDD0 and U+FDD1 are special characters for Qt's text engine, specifically they mark the boundaries of
 265     // text frames in a QTextDocument. This might lead to problems in widgets displaying QTextDocuments (such as
 266     // KDE's notifications), hence we remove those just to be safe.
 267     QString text = text_;
 268     text.remove(QChar(0xfdd0)).remove(QChar(0xfdd1));
 269     RawMessage rawMsg(networkId, type, bufferType, target, text, sender, flags);
 270
 271     // check for HardStrictness ignore
 272     CoreNetwork *currentNetwork = network(networkId);
 273     QString networkName = currentNetwork ? currentNetwork->networkName() : QString("");
 274     if (_ignoreListManager.match(rawMsg, networkName) == IgnoreListManager::HardStrictness)
 275         return;
 276
 277     _messageQueue << rawMsg;
 278     if (!_processMessages) {
 279         _processMessages = true;
 280         QCoreApplication::postEvent(this, new ProcessMessagesEvent());
 281     }
 282 }
 283
 284
 285 void CoreSession::recvStatusMsgFromServer(QString msg)
 286 {
 287     CoreNetwork *net = qobject_cast<CoreNetwork *>(sender());
 288     Q_ASSERT(net);
 289     emit displayStatusMsg(net->networkName(), msg);
 290 }
 291
 292
 293 void CoreSession::processMessageEvent(MessageEvent *event)
 294 {
 295     recvMessageFromServer(event->networkId(), event->msgType(), event->bufferType(),
 296         event->target().isNull() ? "" : event->target(),
 297         event->text().isNull() ? "" : event->text(),
 298         event->sender().isNull() ? "" : event->sender(),
 299         event->msgFlags());
 300 }
 301
 302
 303 QList<BufferInfo> CoreSession::buffers() const
 304 {
 305     return Core::requestBuffers(user());
 306 }
 307
 308
 309 void CoreSession::customEvent(QEvent *event)
 310 {
 311     if (event->type() != QEvent::User)
 312         return;
 313
 314     processMessages();
 315     event->accept();
 316 }
 317
 318
 319 void CoreSession::processMessages()
 320 {
 321     if (_messageQueue.count() == 1) {
 322         const RawMessage &rawMsg = _messageQueue.first();
 323         bool createBuffer = !(rawMsg.flags & Message::Redirected);
 324         BufferInfo bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
 325         if (!bufferInfo.isValid()) {
 326             Q_ASSERT(!createBuffer);
 327             bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
 328         }
 329         Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
 330         Core::storeMessage(msg);
 331         emit displayMsg(msg);
 332     }
 333     else {
 334         QHash<NetworkId, QHash<QString, BufferInfo> > bufferInfoCache;
 335         MessageList messages;
 336         QList<RawMessage> redirectedMessages; // list of Messages which don't enforce a buffer creation
 337         BufferInfo bufferInfo;
 338         for (int i = 0; i < _messageQueue.count(); i++) {
 339             const RawMessage &rawMsg = _messageQueue.at(i);
 340             if (bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
 341                 bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
 342             }
 343             else {
 344                 bool createBuffer = !(rawMsg.flags & Message::Redirected);
 345                 bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
 346                 if (!bufferInfo.isValid()) {
 347                     Q_ASSERT(!createBuffer);
 348                     redirectedMessages << rawMsg;
 349                     continue;
 350                 }
 351                 bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
 352             }
 353             Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
 354             messages << msg;
 355         }
 356
 357         // recheck if there exists a buffer to store a redirected message in
 358         for (int i = 0; i < redirectedMessages.count(); i++) {
 359             const RawMessage &rawMsg = _messageQueue.at(i);
 360             if (bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
 361                 bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
 362             }
 363             else {
 364                 // no luck -> we store them in the StatusBuffer
 365                 bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
 366                 // add the StatusBuffer to the Cache in case there are more Messages for the original target
 367                 bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
 368             }
 369             Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
 370             messages << msg;
 371         }
 372
 373         Core::storeMessages(messages);
 374         // FIXME: extend protocol to a displayMessages(MessageList)
 375         for (int i = 0; i < messages.count(); i++) {
 376             emit displayMsg(messages[i]);
 377         }
 378     }
 379     _processMessages = false;
 380     _messageQueue.clear();
 381 }
 382
 383
 384 QVariant CoreSession::sessionState()
 385 {
 386     QVariantMap v;
 387
 388     v["CoreFeatures"] = (int)Quassel::features();
 389
 390     QVariantList bufs;
 391     foreach(BufferInfo id, buffers()) bufs << qVariantFromValue(id);
 392     v["BufferInfos"] = bufs;
 393     QVariantList networkids;
 394     foreach(NetworkId id, _networks.keys()) networkids << qVariantFromValue(id);
 395     v["NetworkIds"] = networkids;
 396
 397     quint32 ircusercount = 0;
 398     quint32 ircchannelcount = 0;
 399     foreach(Network *net, _networks.values()) {
 400         ircusercount += net->ircUserCount();
 401         ircchannelcount += net->ircChannelCount();
 402     }
 403     v["IrcUserCount"] = ircusercount;
 404     v["IrcChannelCount"] = ircchannelcount;
 405
 406     QList<QVariant> idlist;
 407     foreach(Identity *i, _identities.values()) idlist << qVariantFromValue(*i);
 408     v["Identities"] = idlist;
 409
 410     //v["Payload"] = QByteArray(100000000, 'a');  // for testing purposes
 411     return v;
 412 }
 413
 414
 415 void CoreSession::initScriptEngine()
 416 {
 417     signalProxy()->attachSlot(SIGNAL(scriptRequest(QString)), this, SLOT(scriptRequest(QString)));
 418     signalProxy()->attachSignal(this, SIGNAL(scriptResult(QString)));
 419
 420     // FIXME
 421     //QScriptValue storage_ = scriptEngine->newQObject(storage);
 422     //scriptEngine->globalObject().setProperty("storage", storage_);
 423 }
 424
 425
 426 void CoreSession::scriptRequest(QString script)
 427 {
 428     emit scriptResult(scriptEngine->evaluate(script).toString());
 429 }
 430
 431
 432 /*** Identity Handling ***/
 433 void CoreSession::createIdentity(const Identity &identity, const QVariantMap &additional)
 434 {
 435 #ifndef HAVE_SSL
 436     Q_UNUSED(additional)
 437 #endif
 438
 439     CoreIdentity coreIdentity(identity);
 440 #ifdef HAVE_SSL
 441     if (additional.contains("KeyPem"))
 442         coreIdentity.setSslKey(additional["KeyPem"].toByteArray());
 443     if (additional.contains("CertPem"))
 444         coreIdentity.setSslCert(additional["CertPem"].toByteArray());
 445 #endif
 446     qDebug() << Q_FUNC_INFO;
 447     IdentityId id = Core::createIdentity(user(), coreIdentity);
 448     if (!id.isValid())
 449         return;
 450     else
 451         createIdentity(coreIdentity);
 452 }
 453
 454
 455 void CoreSession::createIdentity(const CoreIdentity &identity)
 456 {
 457     CoreIdentity *coreIdentity = new CoreIdentity(identity, this);
 458     _identities[identity.id()] = coreIdentity;
 459     // CoreIdentity has its own synchronize method since its "private" sslManager needs to be synced as well
 460     coreIdentity->synchronize(signalProxy());
 461     connect(coreIdentity, SIGNAL(updated()), this, SLOT(updateIdentityBySender()));
 462     emit identityCreated(*coreIdentity);
 463 }
 464
 465
 466 void CoreSession::updateIdentityBySender()
 467 {
 468     CoreIdentity *identity = qobject_cast<CoreIdentity *>(sender());
 469     if (!identity)
 470         return;
 471     Core::updateIdentity(user(), *identity);
 472 }
 473
 474
 475 void CoreSession::removeIdentity(IdentityId id)
 476 {
 477     CoreIdentity *identity = _identities.take(id);
 478     if (identity) {
 479         emit identityRemoved(id);
 480         Core::removeIdentity(user(), id);
 481         identity->deleteLater();
 482     }
 483 }
 484
 485
 486 /*** Network Handling ***/
 487
 488 void CoreSession::createNetwork(const NetworkInfo &info_, const QStringList &persistentChans)
 489 {
 490     NetworkInfo info = info_;
 491     int id;
 492
 493     if (!info.networkId.isValid())
 494         Core::createNetwork(user(), info);
 495
 496     if (!info.networkId.isValid()) {
 497         qWarning() << qPrintable(tr("CoreSession::createNetwork(): Got invalid networkId from Core when trying to create network %1!").arg(info.networkName));
 498         return;
 499     }
 500
 501     id = info.networkId.toInt();
 502     if (!_networks.contains(id)) {
 503         // create persistent chans
 504         QRegExp rx("\\s*(\\S+)(?:\\s*(\\S+))?\\s*");
 505         foreach(QString channel, persistentChans) {
 506             if (!rx.exactMatch(channel)) {
 507                 qWarning() << QString("Invalid persistent channel declaration: %1").arg(channel);
 508                 continue;
 509             }
 510             Core::bufferInfo(user(), info.networkId, BufferInfo::ChannelBuffer, rx.cap(1), true);
 511             Core::setChannelPersistent(user(), info.networkId, rx.cap(1), true);
 512             if (!rx.cap(2).isEmpty())
 513                 Core::setPersistentChannelKey(user(), info.networkId, rx.cap(1), rx.cap(2));
 514         }
 515
 516         CoreNetwork *net = new CoreNetwork(id, this);
 517         connect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)),
 518             SLOT(recvMessageFromServer(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)));
 519         connect(net, SIGNAL(displayStatusMsg(QString)), SLOT(recvStatusMsgFromServer(QString)));
 520         connect(net, SIGNAL(disconnected(NetworkId)), SIGNAL(networkDisconnected(NetworkId)));
 521
 522         net->setNetworkInfo(info);
 523         net->setProxy(signalProxy());
 524         _networks[id] = net;
 525         signalProxy()->synchronize(net);
 526         emit networkCreated(id);
 527     }
 528     else {
 529         qWarning() << qPrintable(tr("CoreSession::createNetwork(): Trying to create a network that already exists, updating instead!"));
 530         _networks[info.networkId]->requestSetNetworkInfo(info);
 531     }
 532 }
 533
 534
 535 void CoreSession::removeNetwork(NetworkId id)
 536 {
 537     // Make sure the network is disconnected!
 538     CoreNetwork *net = network(id);
 539     if (!net)
 540         return;
 541
 542     if (net->connectionState() != Network::Disconnected) {
 543         // make sure we no longer receive data from the tcp buffer
 544         disconnect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)), this, 0);
 545         disconnect(net, SIGNAL(displayStatusMsg(QString)), this, 0);
 546         connect(net, SIGNAL(disconnected(NetworkId)), this, SLOT(destroyNetwork(NetworkId)));
 547         net->disconnectFromIrc();
 548     }
 549     else {
 550         destroyNetwork(id);
 551     }
 552 }
 553
 554
 555 void CoreSession::destroyNetwork(NetworkId id)
 556 {
 557     QList<BufferId> removedBuffers = Core::requestBufferIdsForNetwork(user(), id);
 558     Network *net = _networks.take(id);
 559     if (net && Core::removeNetwork(user(), id)) {
 560         // make sure that all unprocessed RawMessages from this network are removed
 561         QList<RawMessage>::iterator messageIter = _messageQueue.begin();
 562         while (messageIter != _messageQueue.end()) {
 563             if (messageIter->networkId == id) {
 564                 messageIter = _messageQueue.erase(messageIter);
 565             }
 566             else {
 567                 messageIter++;
 568             }
 569         }
 570         // remove buffers from syncer
 571         foreach(BufferId bufferId, removedBuffers) {
 572             _bufferSyncer->removeBuffer(bufferId);
 573         }
 574         emit networkRemoved(id);
 575         net->deleteLater();
 576     }
 577 }
 578
 579
 580 void CoreSession::renameBuffer(const NetworkId &networkId, const QString &newName, const QString &oldName)
 581 {
 582     BufferInfo bufferInfo = Core::bufferInfo(user(), networkId, BufferInfo::QueryBuffer, oldName, false);
 583     if (bufferInfo.isValid()) {
 584         _bufferSyncer->renameBuffer(bufferInfo.bufferId(), newName);
 585     }
 586 }
 587
 588
 589 void CoreSession::clientsConnected()
 590 {
 591     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
 592     Identity *identity = 0;
 593     CoreNetwork *net = 0;
 594     IrcUser *me = 0;
 595     while (netIter != _networks.end()) {
 596         net = *netIter;
 597         netIter++;
 598
 599         if (!net->isConnected())
 600             continue;
 601         identity = net->identityPtr();
 602         if (!identity)
 603             continue;
 604         me = net->me();
 605         if (!me)
 606             continue;
 607
 608         if (identity->detachAwayEnabled() && me->isAway()) {
 609             net->userInputHandler()->handleAway(BufferInfo(), QString());
 610         }
 611     }
 612 }
 613
 614
 615 void CoreSession::clientsDisconnected()
 616 {
 617     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
 618     Identity *identity = 0;
 619     CoreNetwork *net = 0;
 620     IrcUser *me = 0;
 621     QString awayReason;
 622     while (netIter != _networks.end()) {
 623         net = *netIter;
 624         netIter++;
 625
 626         if (!net->isConnected())
 627             continue;
 628
 629         identity = net->identityPtr();
 630         if (!identity)
 631             continue;
 632         me = net->me();
 633         if (!me)
 634             continue;
 635
 636         if (identity->detachAwayEnabled() && !me->isAway()) {
 637             if (!identity->detachAwayReason().isEmpty())
 638                 awayReason = identity->detachAwayReason();
 639             net->setAutoAwayActive(true);
 640             net->userInputHandler()->handleAway(BufferInfo(), awayReason);
 641         }
 642     }
 643 }
 644
 645
 646 void CoreSession::globalAway(const QString &msg)
 647 {
 648     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
 649     CoreNetwork *net = 0;
 650     while (netIter != _networks.end()) {
 651         net = *netIter;
 652         netIter++;
 653
 654         if (!net->isConnected())
 655             continue;
 656
 657         net->userInputHandler()->issueAway(msg, false /* no force away */);
 658     }
 659 }