src/core/coresession.cpp

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