src/client/client.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2016 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 "client.h"
  22
  23 #include "abstractmessageprocessor.h"
  24 #include "abstractui.h"
  25 #include "bufferinfo.h"
  26 #include "buffermodel.h"
  27 #include "buffersettings.h"
  28 #include "buffersyncer.h"
  29 #include "bufferviewconfig.h"
  30 #include "bufferviewoverlay.h"
  31 #include "clientaliasmanager.h"
  32 #include "clientbacklogmanager.h"
  33 #include "clientbufferviewmanager.h"
  34 #include "clientirclisthelper.h"
  35 #include "clientidentity.h"
  36 #include "clientignorelistmanager.h"
  37 #include "clienttransfermanager.h"
  38 #include "clientuserinputhandler.h"
  39 #include "coreaccountmodel.h"
  40 #include "coreconnection.h"
  41 #include "ircchannel.h"
  42 #include "ircuser.h"
  43 #include "message.h"
  44 #include "messagemodel.h"
  45 #include "network.h"
  46 #include "networkconfig.h"
  47 #include "networkmodel.h"
  48 #include "quassel.h"
  49 #include "signalproxy.h"
  50 #include "transfermodel.h"
  51 #include "util.h"
  52 #include "clientauthhandler.h"
  53
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56
  57 QPointer<Client> Client::instanceptr = 0;
  58 Quassel::Features Client::_coreFeatures = 0;
  59
  60 /*** Initialization/destruction ***/
  61
  62 bool Client::instanceExists()
  63 {
  64     return instanceptr;
  65 }
  66
  67
  68 Client *Client::instance()
  69 {
  70     if (!instanceptr)
  71         instanceptr = new Client();
  72     return instanceptr;
  73 }
  74
  75
  76 void Client::destroy()
  77 {
  78     if (instanceptr) {
  79         delete instanceptr->mainUi();
  80         instanceptr->deleteLater();
  81         instanceptr = 0;
  82     }
  83 }
  84
  85
  86 void Client::init(AbstractUi *ui)
  87 {
  88     instance()->_mainUi = ui;
  89     instance()->init();
  90 }
  91
  92
  93 Client::Client(QObject *parent)
  94     : QObject(parent),
  95     _signalProxy(new SignalProxy(SignalProxy::Client, this)),
  96     _mainUi(0),
  97     _networkModel(0),
  98     _bufferModel(0),
  99     _bufferSyncer(0),
 100     _aliasManager(0),
 101     _backlogManager(new ClientBacklogManager(this)),
 102     _bufferViewManager(0),
 103     _bufferViewOverlay(new BufferViewOverlay(this)),
 104     _ircListHelper(new ClientIrcListHelper(this)),
 105     _inputHandler(0),
 106     _networkConfig(0),
 107     _ignoreListManager(0),
 108     _transferManager(0),
 109     _transferModel(new TransferModel(this)),
 110     _messageModel(0),
 111     _messageProcessor(0),
 112     _coreAccountModel(new CoreAccountModel(this)),
 113     _coreConnection(new CoreConnection(this)),
 114     _connected(false),
 115     _debugLog(&_debugLogBuffer)
 116 {
 117     _signalProxy->synchronize(_ircListHelper);
 118 }
 119
 120
 121 Client::~Client()
 122 {
 123     disconnectFromCore();
 124 }
 125
 126
 127 void Client::init()
 128 {
 129     _networkModel = new NetworkModel(this);
 130
 131     connect(this, SIGNAL(networkRemoved(NetworkId)),
 132         _networkModel, SLOT(networkRemoved(NetworkId)));
 133
 134     _bufferModel = new BufferModel(_networkModel);
 135     _messageModel = mainUi()->createMessageModel(this);
 136     _messageProcessor = mainUi()->createMessageProcessor(this);
 137     _inputHandler = new ClientUserInputHandler(this);
 138
 139     SignalProxy *p = signalProxy();
 140
 141     p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &)));
 142     p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString)));
 143
 144     p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo)));
 145     p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString)));
 146     p->attachSignal(this, SIGNAL(requestNetworkStates()));
 147
 148     p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &, const QVariantMap &)), SIGNAL(createIdentity(const Identity &, const QVariantMap &)));
 149     p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId)));
 150     p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &)));
 151     p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId)));
 152
 153     p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &, const QStringList &)), SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)));
 154     p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId)));
 155     p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
 156     p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
 157
 158     p->attachSignal(this, SIGNAL(requestPasswordChange(PeerPtr,QString,QString,QString)), SIGNAL(changePassword(PeerPtr,QString,QString,QString)));
 159     p->attachSlot(SIGNAL(passwordChanged(PeerPtr,bool)), this, SLOT(corePasswordChanged(PeerPtr,bool)));
 160
 161     //connect(mainUi(), SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
 162     connect(mainUi(), SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
 163     connect(this, SIGNAL(connected()), mainUi(), SLOT(connectedToCore()));
 164     connect(this, SIGNAL(disconnected()), mainUi(), SLOT(disconnectedFromCore()));
 165
 166     // attach backlog manager
 167     p->synchronize(backlogManager());
 168     connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
 169
 170     coreAccountModel()->load();
 171
 172     connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
 173     coreConnection()->init();
 174 }
 175
 176
 177 /*** public static methods ***/
 178
 179 AbstractUi *Client::mainUi()
 180 {
 181     return instance()->_mainUi;
 182 }
 183
 184
 185 void Client::setCoreFeatures(Quassel::Features features)
 186 {
 187     _coreFeatures = features;
 188 }
 189
 190
 191 bool Client::isConnected()
 192 {
 193     return instance()->_connected;
 194 }
 195
 196
 197 bool Client::internalCore()
 198 {
 199     return currentCoreAccount().isInternal();
 200 }
 201
 202
 203 /*** Network handling ***/
 204
 205 QList<NetworkId> Client::networkIds()
 206 {
 207     return instance()->_networks.keys();
 208 }
 209
 210
 211 const Network *Client::network(NetworkId networkid)
 212 {
 213     if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
 214     else return 0;
 215 }
 216
 217
 218 void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels)
 219 {
 220     emit instance()->requestCreateNetwork(info, persistentChannels);
 221 }
 222
 223
 224 void Client::removeNetwork(NetworkId id)
 225 {
 226     emit instance()->requestRemoveNetwork(id);
 227 }
 228
 229
 230 void Client::updateNetwork(const NetworkInfo &info)
 231 {
 232     Network *netptr = instance()->_networks.value(info.networkId, 0);
 233     if (!netptr) {
 234         qWarning() << "Update for unknown network requested:" << info;
 235         return;
 236     }
 237     netptr->requestSetNetworkInfo(info);
 238 }
 239
 240
 241 void Client::addNetwork(Network *net)
 242 {
 243     net->setProxy(signalProxy());
 244     signalProxy()->synchronize(net);
 245     networkModel()->attachNetwork(net);
 246     connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
 247     instance()->_networks[net->networkId()] = net;
 248     emit instance()->networkCreated(net->networkId());
 249 }
 250
 251
 252 void Client::coreNetworkCreated(NetworkId id)
 253 {
 254     if (_networks.contains(id)) {
 255         qWarning() << "Creation of already existing network requested!";
 256         return;
 257     }
 258     Network *net = new Network(id, this);
 259     addNetwork(net);
 260 }
 261
 262
 263 void Client::coreNetworkRemoved(NetworkId id)
 264 {
 265     if (!_networks.contains(id))
 266         return;
 267     Network *net = _networks.take(id);
 268     emit networkRemoved(net->networkId());
 269     net->deleteLater();
 270 }
 271
 272
 273 /*** Identity handling ***/
 274
 275 QList<IdentityId> Client::identityIds()
 276 {
 277     return instance()->_identities.keys();
 278 }
 279
 280
 281 const Identity *Client::identity(IdentityId id)
 282 {
 283     if (instance()->_identities.contains(id)) return instance()->_identities[id];
 284     else return 0;
 285 }
 286
 287
 288 void Client::createIdentity(const CertIdentity &id)
 289 {
 290     QVariantMap additional;
 291 #ifdef HAVE_SSL
 292     additional["KeyPem"] = id.sslKey().toPem();
 293     additional["CertPem"] = id.sslCert().toPem();
 294 #endif
 295     emit instance()->requestCreateIdentity(id, additional);
 296 }
 297
 298
 299 void Client::updateIdentity(IdentityId id, const QVariantMap &ser)
 300 {
 301     Identity *idptr = instance()->_identities.value(id, 0);
 302     if (!idptr) {
 303         qWarning() << "Update for unknown identity requested:" << id;
 304         return;
 305     }
 306     idptr->requestUpdate(ser);
 307 }
 308
 309
 310 void Client::removeIdentity(IdentityId id)
 311 {
 312     emit instance()->requestRemoveIdentity(id);
 313 }
 314
 315
 316 void Client::coreIdentityCreated(const Identity &other)
 317 {
 318     if (!_identities.contains(other.id())) {
 319         Identity *identity = new Identity(other, this);
 320         _identities[other.id()] = identity;
 321         identity->setInitialized();
 322         signalProxy()->synchronize(identity);
 323         emit identityCreated(other.id());
 324     }
 325     else {
 326         qWarning() << tr("Identity already exists in client!");
 327     }
 328 }
 329
 330
 331 void Client::coreIdentityRemoved(IdentityId id)
 332 {
 333     if (_identities.contains(id)) {
 334         emit identityRemoved(id);
 335         Identity *i = _identities.take(id);
 336         i->deleteLater();
 337     }
 338 }
 339
 340
 341 /*** User input handling ***/
 342
 343 void Client::userInput(const BufferInfo &bufferInfo, const QString &message)
 344 {
 345     // we need to make sure that AliasManager is ready before processing input
 346     if (aliasManager() && aliasManager()->isInitialized())
 347         inputHandler()->handleUserInput(bufferInfo, message);
 348     else
 349         instance()->_userInputBuffer.append(qMakePair(bufferInfo, message));
 350 }
 351
 352
 353 void Client::sendBufferedUserInput()
 354 {
 355     for (int i = 0; i < _userInputBuffer.count(); i++)
 356         userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second);
 357
 358     _userInputBuffer.clear();
 359 }
 360
 361
 362 /*** core connection stuff ***/
 363
 364 void Client::connectionStateChanged(CoreConnection::ConnectionState state)
 365 {
 366     switch (state) {
 367     case CoreConnection::Disconnected:
 368         setDisconnectedFromCore();
 369         break;
 370     case CoreConnection::Synchronized:
 371         setSyncedToCore();
 372         break;
 373     default:
 374         break;
 375     }
 376 }
 377
 378
 379 void Client::setSyncedToCore()
 380 {
 381     // create buffersyncer
 382     Q_ASSERT(!_bufferSyncer);
 383     _bufferSyncer = new BufferSyncer(this);
 384     connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(BufferId, MsgId)));
 385     connect(bufferSyncer(), SIGNAL(markerLineSet(BufferId, MsgId)), _networkModel, SLOT(setMarkerLineMsgId(BufferId, MsgId)));
 386     connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
 387     connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
 388     connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), this, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
 389     connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), _messageModel, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
 390     connect(bufferSyncer(), SIGNAL(bufferMarkedAsRead(BufferId)), SIGNAL(bufferMarkedAsRead(BufferId)));
 391     connect(networkModel(), SIGNAL(requestSetLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &)));
 392
 393     SignalProxy *p = signalProxy();
 394     p->synchronize(bufferSyncer());
 395
 396     // create a new BufferViewManager
 397     Q_ASSERT(!_bufferViewManager);
 398     _bufferViewManager = new ClientBufferViewManager(p, this);
 399     connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
 400
 401     // create AliasManager
 402     Q_ASSERT(!_aliasManager);
 403     _aliasManager = new ClientAliasManager(this);
 404     connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
 405     p->synchronize(aliasManager());
 406
 407     // create NetworkConfig
 408     Q_ASSERT(!_networkConfig);
 409     _networkConfig = new NetworkConfig("GlobalNetworkConfig", this);
 410     p->synchronize(networkConfig());
 411
 412     // create IgnoreListManager
 413     Q_ASSERT(!_ignoreListManager);
 414     _ignoreListManager = new ClientIgnoreListManager(this);
 415     p->synchronize(ignoreListManager());
 416
 417     // create TransferManager if core supports it
 418     Q_ASSERT(!_transferManager);
 419     if (coreFeatures() & Quassel::DccFileTransfer) {
 420         _transferManager = new ClientTransferManager(this);
 421         _transferModel->setManager(_transferManager);
 422         p->synchronize(transferManager());
 423     }
 424
 425     // trigger backlog request once all active bufferviews are initialized
 426     connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
 427
 428     _connected = true;
 429     emit connected();
 430     emit coreConnectionStateChanged(true);
 431 }
 432
 433
 434 void Client::requestInitialBacklog()
 435 {
 436     // usually it _should_ take longer until the bufferViews are initialized, so that's what
 437     // triggers this slot. But we have to make sure that we know all buffers yet.
 438     // so we check the BufferSyncer and in case it wasn't initialized we wait for that instead
 439     if (!bufferSyncer()->isInitialized()) {
 440         disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
 441         connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
 442         return;
 443     }
 444     disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
 445     disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
 446
 447     _backlogManager->requestInitialBacklog();
 448 }
 449
 450
 451 void Client::disconnectFromCore()
 452 {
 453     if (!coreConnection()->isConnected())
 454         return;
 455
 456     coreConnection()->disconnectFromCore();
 457 }
 458
 459
 460 void Client::setDisconnectedFromCore()
 461 {
 462     _connected = false;
 463     _coreFeatures = 0;
 464
 465     emit disconnected();
 466     emit coreConnectionStateChanged(false);
 467
 468     backlogManager()->reset();
 469     messageProcessor()->reset();
 470
 471     // Clear internal data. Hopefully nothing relies on it at this point.
 472
 473     if (_bufferSyncer) {
 474         _bufferSyncer->deleteLater();
 475         _bufferSyncer = 0;
 476     }
 477
 478     if (_bufferViewManager) {
 479         _bufferViewManager->deleteLater();
 480         _bufferViewManager = 0;
 481     }
 482
 483     _bufferViewOverlay->reset();
 484
 485     if (_aliasManager) {
 486         _aliasManager->deleteLater();
 487         _aliasManager = 0;
 488     }
 489
 490     if (_ignoreListManager) {
 491         _ignoreListManager->deleteLater();
 492         _ignoreListManager = 0;
 493     }
 494
 495     if (_transferManager) {
 496         _transferModel->setManager(nullptr);
 497         _transferManager->deleteLater();
 498         _transferManager = nullptr;
 499     }
 500
 501     // we probably don't want to save pending input for reconnect
 502     _userInputBuffer.clear();
 503
 504     _messageModel->clear();
 505     _networkModel->clear();
 506
 507     QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
 508     while (netIter != _networks.end()) {
 509         Network *net = netIter.value();
 510         emit networkRemoved(net->networkId());
 511         disconnect(net, SIGNAL(destroyed()), this, 0);
 512         netIter = _networks.erase(netIter);
 513         net->deleteLater();
 514     }
 515     Q_ASSERT(_networks.isEmpty());
 516
 517     QHash<IdentityId, Identity *>::iterator idIter = _identities.begin();
 518     while (idIter != _identities.end()) {
 519         emit identityRemoved(idIter.key());
 520         Identity *id = idIter.value();
 521         idIter = _identities.erase(idIter);
 522         id->deleteLater();
 523     }
 524     Q_ASSERT(_identities.isEmpty());
 525
 526     if (_networkConfig) {
 527         _networkConfig->deleteLater();
 528         _networkConfig = 0;
 529     }
 530 }
 531
 532
 533 /*** ***/
 534
 535 void Client::networkDestroyed()
 536 {
 537     Network *net = static_cast<Network *>(sender());
 538     QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
 539     while (netIter != _networks.end()) {
 540         if (*netIter == net) {
 541             netIter = _networks.erase(netIter);
 542             break;
 543         }
 544         else {
 545             ++netIter;
 546         }
 547     }
 548 }
 549
 550
 551 // Hmm... we never used this...
 552 void Client::recvStatusMsg(QString /*net*/, QString /*msg*/)
 553 {
 554     //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 555 }
 556
 557
 558 void Client::recvMessage(const Message &msg)
 559 {
 560     Message msg_ = msg;
 561     messageProcessor()->process(msg_);
 562 }
 563
 564
 565 void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId)
 566 {
 567     if (bufferSyncer())
 568         bufferSyncer()->requestSetLastSeenMsg(id, msgId);
 569 }
 570
 571
 572 void Client::setMarkerLine(BufferId id, const MsgId &msgId)
 573 {
 574     if (bufferSyncer())
 575         bufferSyncer()->requestSetMarkerLine(id, msgId);
 576 }
 577
 578
 579 MsgId Client::markerLine(BufferId id)
 580 {
 581     if (id.isValid() && networkModel())
 582         return networkModel()->markerLineMsgId(id);
 583     return MsgId();
 584 }
 585
 586
 587 void Client::removeBuffer(BufferId id)
 588 {
 589     if (!bufferSyncer()) return;
 590     bufferSyncer()->requestRemoveBuffer(id);
 591 }
 592
 593
 594 void Client::renameBuffer(BufferId bufferId, const QString &newName)
 595 {
 596     if (!bufferSyncer())
 597         return;
 598     bufferSyncer()->requestRenameBuffer(bufferId, newName);
 599 }
 600
 601
 602 void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2)
 603 {
 604     if (!bufferSyncer())
 605         return;
 606     bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2);
 607 }
 608
 609
 610 void Client::purgeKnownBufferIds()
 611 {
 612     if (!bufferSyncer())
 613         return;
 614     bufferSyncer()->requestPurgeBufferIds();
 615 }
 616
 617
 618 void Client::bufferRemoved(BufferId bufferId)
 619 {
 620     // select a sane buffer (status buffer)
 621     /* we have to manually select a buffer because otherwise inconsitent changes
 622      * to the model might occur:
 623      * the result of a buffer removal triggers a change in the selection model.
 624      * the newly selected buffer might be a channel that hasn't been selected yet
 625      * and a new nickview would be created (which never heard of the "rowsAboutToBeRemoved").
 626      * this new view (and/or) its sort filter will then only receive a "rowsRemoved" signal.
 627      */
 628     QModelIndex current = bufferModel()->currentIndex();
 629     if (current.data(NetworkModel::BufferIdRole).value<BufferId>() == bufferId) {
 630         bufferModel()->setCurrentIndex(current.sibling(0, 0));
 631     }
 632
 633     // and remove it from the model
 634     networkModel()->removeBuffer(bufferId);
 635 }
 636
 637
 638 void Client::bufferRenamed(BufferId bufferId, const QString &newName)
 639 {
 640     QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
 641     if (bufferIndex.isValid()) {
 642         networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
 643     }
 644 }
 645
 646
 647 void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2)
 648 {
 649     QModelIndex idx = networkModel()->bufferIndex(bufferId1);
 650     bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx));
 651     networkModel()->removeBuffer(bufferId2);
 652 }
 653
 654
 655 void Client::markBufferAsRead(BufferId id)
 656 {
 657     if (bufferSyncer() && id.isValid())
 658         bufferSyncer()->requestMarkBufferAsRead(id);
 659 }
 660
 661
 662 void Client::changePassword(const QString &oldPassword, const QString &newPassword) {
 663     CoreAccount account = currentCoreAccount();
 664     account.setPassword(newPassword);
 665     coreAccountModel()->createOrUpdateAccount(account);
 666     emit instance()->requestPasswordChange(nullptr, account.user(), oldPassword, newPassword);
 667 }
 668
 669
 670 void Client::corePasswordChanged(PeerPtr, bool success)
 671 {
 672     if (success)
 673         coreAccountModel()->save();
 674     emit passwordChanged(success);
 675 }
 676
 677
 678 #if QT_VERSION < 0x050000
 679 void Client::logMessage(QtMsgType type, const char *msg)
 680 {
 681     fprintf(stderr, "%s\n", msg);
 682     fflush(stderr);
 683     if (type == QtFatalMsg) {
 684         Quassel::logFatalMessage(msg);
 685     }
 686     else {
 687         QString msgString = QString("%1\n").arg(msg);
 688
 689         //Check to see if there is an instance around, else we risk recursions
 690         //when calling instance() and creating new ones.
 691         if (!instanceExists())
 692             return;
 693
 694         instance()->_debugLog << msgString;
 695         emit instance()->logUpdated(msgString);
 696     }
 697 }
 698 #else
 699 void Client::logMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 700 {
 701     Q_UNUSED(context);
 702
 703     fprintf(stderr, "%s\n", msg.toLocal8Bit().constData());
 704     fflush(stderr);
 705     if (type == QtFatalMsg) {
 706         Quassel::logFatalMessage(msg.toLocal8Bit().constData());
 707     }
 708     else {
 709         QString msgString = QString("%1\n").arg(msg);
 710
 711         //Check to see if there is an instance around, else we risk recursions
 712         //when calling instance() and creating new ones.
 713         if (!instanceExists())
 714             return;
 715
 716         instance()->_debugLog << msgString;
 717         emit instance()->logUpdated(msgString);
 718     }
 719 }
 720 #endif