src/core/core.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 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  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <QCoreApplication>
  22
  23 #include "core.h"
  24 #include "coresession.h"
  25 #include "coresettings.h"
  26 #include "postgresqlstorage.h"
  27 #include "quassel.h"
  28 #include "signalproxy.h"
  29 #include "sqlitestorage.h"
  30 #include "network.h"
  31 #include "logger.h"
  32
  33 #include "util.h"
  34
  35 // migration related
  36 #include <QFile>
  37 #ifdef Q_OS_WIN32
  38 #  include <windows.h>
  39 #else
  40 #  include <unistd.h>
  41 #  include <termios.h>
  42 #endif /* Q_OS_WIN32 */
  43
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46
  47 // ==============================
  48 //  Custom Events
  49 // ==============================
  50 const int Core::AddClientEventId = QEvent::registerEventType();
  51
  52 class AddClientEvent : public QEvent {
  53 public:
  54   AddClientEvent(QTcpSocket *socket, UserId uid) : QEvent(QEvent::Type(Core::AddClientEventId)), socket(socket), userId(uid) {}
  55   QTcpSocket *socket;
  56   UserId userId;
  57 };
  58
  59
  60 // ==============================
  61 //  Core
  62 // ==============================
  63 Core *Core::instanceptr = 0;
  64
  65 Core *Core::instance() {
  66   if(instanceptr) return instanceptr;
  67   instanceptr = new Core();
  68   instanceptr->init();
  69   return instanceptr;
  70 }
  71
  72 void Core::destroy() {
  73   delete instanceptr;
  74   instanceptr = 0;
  75 }
  76
  77 Core::Core()
  78   : _storage(0)
  79 {
  80   umask(S_IRWXG | S_IRWXO);
  81   _startTime = QDateTime::currentDateTime().toUTC();  // for uptime :)
  82
  83   Quassel::loadTranslation(QLocale::system());
  84
  85   // FIXME: MIGRATION 0.3 -> 0.4: Move database and core config to new location
  86   // Move settings, note this does not delete the old files
  87 #ifdef Q_WS_MAC
  88     QSettings newSettings("quassel-irc.org", "quasselcore");
  89 #else
  90
  91 # ifdef Q_WS_WIN
  92     QSettings::Format format = QSettings::IniFormat;
  93 # else
  94     QSettings::Format format = QSettings::NativeFormat;
  95 # endif
  96     QString newFilePath = Quassel::configDirPath() + "quasselcore"
  97     + ((format == QSettings::NativeFormat) ? QLatin1String(".conf") : QLatin1String(".ini"));
  98     QSettings newSettings(newFilePath, format);
  99 #endif /* Q_WS_MAC */
 100
 101   if(newSettings.value("Config/Version").toUInt() == 0) {
 102 #   ifdef Q_WS_MAC
 103     QString org = "quassel-irc.org";
 104 #   else
 105     QString org = "Quassel Project";
 106 #   endif
 107     QSettings oldSettings(org, "Quassel Core");
 108     if(oldSettings.allKeys().count()) {
 109       qWarning() << "\n\n*** IMPORTANT: Config and data file locations have changed. Attempting to auto-migrate your core settings...";
 110       foreach(QString key, oldSettings.allKeys())
 111         newSettings.setValue(key, oldSettings.value(key));
 112       newSettings.setValue("Config/Version", 1);
 113       qWarning() << "*   Your core settings have been migrated to" << newSettings.fileName();
 114
 115 #ifndef Q_WS_MAC /* we don't need to move the db and cert for mac */
 116 #ifdef Q_OS_WIN32
 117       QString quasselDir = qgetenv("APPDATA") + "/quassel/";
 118 #elif defined Q_WS_MAC
 119       QString quasselDir = QDir::homePath() + "/Library/Application Support/Quassel/";
 120 #else
 121       QString quasselDir = QDir::homePath() + "/.quassel/";
 122 #endif
 123
 124       QFileInfo info(Quassel::configDirPath() + "quassel-storage.sqlite");
 125       if(!info.exists()) {
 126       // move database, if we found it
 127         QFile oldDb(quasselDir + "quassel-storage.sqlite");
 128         if(oldDb.exists()) {
 129           bool success = oldDb.rename(Quassel::configDirPath() + "quassel-storage.sqlite");
 130           if(success)
 131             qWarning() << "*   Your database has been moved to" << Quassel::configDirPath() + "quassel-storage.sqlite";
 132           else
 133             qWarning() << "!!! Moving your database has failed. Please move it manually into" << Quassel::configDirPath();
 134         }
 135       }
 136       // move certificate
 137       QFileInfo certInfo(quasselDir + "quasselCert.pem");
 138       if(certInfo.exists()) {
 139         QFile cert(quasselDir + "quasselCert.pem");
 140         bool success = cert.rename(Quassel::configDirPath() + "quasselCert.pem");
 141         if(success)
 142           qWarning() << "*   Your certificate has been moved to" << Quassel::configDirPath() + "quasselCert.pem";
 143         else
 144           qWarning() << "!!! Moving your certificate has failed. Please move it manually into" << Quassel::configDirPath();
 145       }
 146 #endif /* !Q_WS_MAC */
 147       qWarning() << "*** Migration completed.\n\n";
 148     }
 149   }
 150   // MIGRATION end
 151
 152   // check settings version
 153   // so far, we only have 1
 154   CoreSettings s;
 155   if(s.version() != 1) {
 156     qCritical() << "Invalid core settings version, terminating!";
 157     exit(EXIT_FAILURE);
 158   }
 159
 160   registerStorageBackends();
 161
 162   connect(&_storageSyncTimer, SIGNAL(timeout()), this, SLOT(syncStorage()));
 163   _storageSyncTimer.start(10 * 60 * 1000); // 10 minutes
 164 }
 165
 166 void Core::init() {
 167   CoreSettings cs;
 168   _configured = initStorage(cs.storageSettings().toMap());
 169
 170   if(Quassel::isOptionSet("select-backend")) {
 171     selectBackend(Quassel::optionValue("select-backend"));
 172     exit(0);
 173   }
 174
 175   if(!_configured) {
 176     if(!_storageBackends.count()) {
 177       qWarning() << qPrintable(tr("Could not initialize any storage backend! Exiting..."));
 178       qWarning() << qPrintable(tr("Currently, Quassel supports SQLite3 and PostgreSQL. You need to build your\n"
 179                                   "Qt library with the sqlite or postgres plugin enabled in order for quasselcore\n"
 180                                   "to work."));
 181       exit(1); // TODO make this less brutal (especially for mono client -> popup)
 182     }
 183     qWarning() << "Core is currently not configured! Please connect with a Quassel Client for basic setup.";
 184   }
 185
 186   if(Quassel::isOptionSet("add-user")) {
 187     createUser();
 188     exit(0);
 189   }
 190
 191   if(Quassel::isOptionSet("change-userpass")) {
 192     changeUserPass(Quassel::optionValue("change-userpass"));
 193     exit(0);
 194   }
 195
 196   connect(&_server, SIGNAL(newConnection()), this, SLOT(incomingConnection()));
 197   connect(&_v6server, SIGNAL(newConnection()), this, SLOT(incomingConnection()));
 198   if(!startListening()) exit(1); // TODO make this less brutal
 199 }
 200
 201 Core::~Core() {
 202   foreach(QTcpSocket *socket, blocksizes.keys()) {
 203     socket->disconnectFromHost();  // disconnect non authed clients
 204   }
 205   qDeleteAll(sessions);
 206   qDeleteAll(_storageBackends);
 207 }
 208
 209 /*** Session Restore ***/
 210
 211 void Core::saveState() {
 212   CoreSettings s;
 213   QVariantMap state;
 214   QVariantList activeSessions;
 215   foreach(UserId user, instance()->sessions.keys()) activeSessions << QVariant::fromValue<UserId>(user);
 216   state["CoreStateVersion"] = 1;
 217   state["ActiveSessions"] = activeSessions;
 218   s.setCoreState(state);
 219 }
 220
 221 void Core::restoreState() {
 222   if(!instance()->_configured) {
 223     // qWarning() << qPrintable(tr("Cannot restore a state for an unconfigured core!"));
 224     return;
 225   }
 226   if(instance()->sessions.count()) {
 227     qWarning() << qPrintable(tr("Calling restoreState() even though active sessions exist!"));
 228     return;
 229   }
 230   CoreSettings s;
 231   /* We don't check, since we are at the first version since switching to Git
 232   uint statever = s.coreState().toMap()["CoreStateVersion"].toUInt();
 233   if(statever < 1) {
 234     qWarning() << qPrintable(tr("Core state too old, ignoring..."));
 235     return;
 236   }
 237   */
 238   QVariantList activeSessions = s.coreState().toMap()["ActiveSessions"].toList();
 239   if(activeSessions.count() > 0) {
 240     quInfo() << "Restoring previous core state...";
 241     foreach(QVariant v, activeSessions) {
 242       UserId user = v.value<UserId>();
 243       instance()->createSession(user, true);
 244     }
 245   }
 246 }
 247
 248 /*** Core Setup ***/
 249 QString Core::setupCoreForInternalUsage() {
 250   Q_ASSERT(!_storageBackends.isEmpty());
 251   QVariantMap setupData;
 252   qsrand(QDateTime::currentDateTime().toTime_t());
 253   int pass = 0;
 254   for(int i = 0; i < 10; i++) {
 255     pass *= 10;
 256     pass += qrand() % 10;
 257   }
 258   setupData["AdminUser"] = "AdminUser";
 259   setupData["AdminPasswd"] = QString::number(pass);
 260   setupData["Backend"] = _storageBackends[_storageBackends.keys().first()]->displayName();
 261   return setupCore(setupData);
 262 }
 263
 264 QString Core::setupCore(QVariantMap setupData) {
 265   QString user = setupData.take("AdminUser").toString();
 266   QString password = setupData.take("AdminPasswd").toString();
 267   if(user.isEmpty() || password.isEmpty()) {
 268     return tr("Admin user or password not set.");
 269   }
 270   _configured = initStorage(setupData, true);
 271   if(!_configured) {
 272     return tr("Could not setup storage!");
 273   }
 274   CoreSettings s;
 275   s.setStorageSettings(setupData);
 276   quInfo() << qPrintable(tr("Creating admin user..."));
 277   _storage->addUser(user, password);
 278   startListening();  // TODO check when we need this
 279   return QString();
 280 }
 281
 282 /*** Storage Handling ***/
 283 void Core::registerStorageBackends() {
 284   // Register storage backends here!
 285   registerStorageBackend(new SqliteStorage(this));
 286   registerStorageBackend(new PostgreSqlStorage(this));
 287 }
 288
 289 bool Core::registerStorageBackend(Storage *backend) {
 290   if(backend->isAvailable()) {
 291     _storageBackends[backend->displayName()] = backend;
 292     return true;
 293   } else {
 294     backend->deleteLater();
 295     return false;
 296   }
 297 }
 298
 299 void Core::unregisterStorageBackends() {
 300   foreach(Storage *s, _storageBackends.values()) {
 301     s->deleteLater();
 302   }
 303   _storageBackends.clear();
 304 }
 305
 306 void Core::unregisterStorageBackend(Storage *backend) {
 307   _storageBackends.remove(backend->displayName());
 308   backend->deleteLater();
 309 }
 310
 311 // old db settings:
 312 // "Type" => "sqlite"
 313 bool Core::initStorage(const QString &backend, QVariantMap settings, bool setup) {
 314   _storage = 0;
 315
 316   if(backend.isEmpty()) {
 317     return false;
 318   }
 319
 320   Storage *storage = 0;
 321   if(_storageBackends.contains(backend)) {
 322     storage = _storageBackends[backend];
 323   } else {
 324     qCritical() << "Selected storage backend is not available:" << backend;
 325     return false;
 326   }
 327
 328   Storage::State storageState = storage->init(settings);
 329   switch(storageState) {
 330   case Storage::NeedsSetup:
 331     if(!setup)
 332       return false; // trigger setup process
 333     if(storage->setup(settings))
 334       return initStorage(backend, settings, false);
 335     // if setup wasn't successfull we mark the backend as unavailable
 336   case Storage::NotAvailable:
 337     qCritical() << "Selected storage backend is not available:" << backend;
 338     storage->deleteLater();
 339     _storageBackends.remove(backend);
 340     storage = 0;
 341     return false;
 342   case Storage::IsReady:
 343     // delete all other backends
 344     _storageBackends.remove(backend);
 345     unregisterStorageBackends();
 346     connect(storage, SIGNAL(bufferInfoUpdated(UserId, const BufferInfo &)), this, SIGNAL(bufferInfoUpdated(UserId, const BufferInfo &)));
 347   }
 348   _storage = storage;
 349   return true;
 350 }
 351
 352 bool Core::initStorage(QVariantMap dbSettings, bool setup) {
 353   return initStorage(dbSettings["Backend"].toString(), dbSettings["ConnectionProperties"].toMap(), setup);
 354 }
 355
 356
 357 void Core::syncStorage() {
 358   if(_storage)
 359     _storage->sync();
 360 }
 361
 362 /*** Storage Access ***/
 363 bool Core::createNetwork(UserId user, NetworkInfo &info) {
 364   NetworkId networkId = instance()->_storage->createNetwork(user, info);
 365   if(!networkId.isValid())
 366     return false;
 367
 368   info.networkId = networkId;
 369   return true;
 370 }
 371
 372 /*** Network Management ***/
 373
 374 bool Core::startListening() {
 375   // in mono mode we only start a local port if a port is specified in the cli call
 376   if(Quassel::runMode() == Quassel::Monolithic && !Quassel::isOptionSet("port"))
 377     return true;
 378
 379   bool success = false;
 380   uint port = Quassel::optionValue("port").toUInt();
 381
 382   const QString listen = Quassel::optionValue("listen");
 383   const QStringList listen_list = listen.split(",", QString::SkipEmptyParts);
 384   if(listen_list.size() > 0) {
 385     foreach (const QString listen_term, listen_list) {  // TODO: handle multiple interfaces for same TCP version gracefully
 386       QHostAddress addr;
 387       if(!addr.setAddress(listen_term)) {
 388         qCritical() << qPrintable(
 389           tr("Invalid listen address %1")
 390             .arg(listen_term)
 391         );
 392       } else {
 393         switch(addr.protocol()) {
 394           case QAbstractSocket::IPv4Protocol:
 395             if(_server.listen(addr, port)) {
 396               quInfo() << qPrintable(
 397                 tr("Listening for GUI clients on IPv4 %1 port %2 using protocol version %3")
 398                   .arg(addr.toString())
 399                   .arg(_server.serverPort())
 400                   .arg(Quassel::buildInfo().protocolVersion)
 401               );
 402               success = true;
 403             } else
 404               quWarning() << qPrintable(
 405                 tr("Could not open IPv4 interface %1:%2: %3")
 406                   .arg(addr.toString())
 407                   .arg(port)
 408                   .arg(_server.errorString()));
 409             break;
 410           case QAbstractSocket::IPv6Protocol:
 411             if(_v6server.listen(addr, port)) {
 412               quInfo() << qPrintable(
 413                 tr("Listening for GUI clients on IPv6 %1 port %2 using protocol version %3")
 414                   .arg(addr.toString())
 415                   .arg(_v6server.serverPort())
 416                   .arg(Quassel::buildInfo().protocolVersion)
 417               );
 418               success = true;
 419             } else {
 420               // if v4 succeeded on Any, the port will be already in use - don't display the error then
 421               // FIXME: handle this more sanely, make sure we can listen to both v4 and v6 by default!
 422               if(!success || _v6server.serverError() != QAbstractSocket::AddressInUseError)
 423                 quWarning() << qPrintable(
 424                   tr("Could not open IPv6 interface %1:%2: %3")
 425                   .arg(addr.toString())
 426                   .arg(port)
 427                   .arg(_v6server.errorString()));
 428             }
 429             break;
 430           default:
 431             qCritical() << qPrintable(
 432               tr("Invalid listen address %1, unknown network protocol")
 433                   .arg(listen_term)
 434             );
 435             break;
 436         }
 437       }
 438     }
 439   }
 440   if(!success)
 441     quError() << qPrintable(tr("Could not open any network interfaces to listen on!"));
 442
 443   return success;
 444 }
 445
 446 void Core::stopListening(const QString &reason) {
 447   bool wasListening = false;
 448   if(_server.isListening()) {
 449     wasListening = true;
 450     _server.close();
 451   }
 452   if(_v6server.isListening()) {
 453     wasListening = true;
 454     _v6server.close();
 455   }
 456   if(wasListening) {
 457     if(reason.isEmpty())
 458       quInfo() << "No longer listening for GUI clients.";
 459     else
 460       quInfo() << qPrintable(reason);
 461   }
 462 }
 463
 464 void Core::incomingConnection() {
 465   QTcpServer *server = qobject_cast<QTcpServer *>(sender());
 466   Q_ASSERT(server);
 467   while(server->hasPendingConnections()) {
 468     QTcpSocket *socket = server->nextPendingConnection();
 469     connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
 470     connect(socket, SIGNAL(readyRead()), this, SLOT(clientHasData()));
 471     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
 472
 473     QVariantMap clientInfo;
 474     blocksizes.insert(socket, (quint32)0);
 475     quInfo() << qPrintable(tr("Client connected from"))  << qPrintable(socket->peerAddress().toString());
 476
 477     if(!_configured) {
 478       stopListening(tr("Closing server for basic setup."));
 479     }
 480   }
 481 }
 482
 483 void Core::clientHasData() {
 484   QTcpSocket *socket = dynamic_cast<QTcpSocket*>(sender());
 485   Q_ASSERT(socket && blocksizes.contains(socket));
 486   QVariant item;
 487   while(SignalProxy::readDataFromDevice(socket, blocksizes[socket], item)) {
 488     QVariantMap msg = item.toMap();
 489     processClientMessage(socket, msg);
 490     if(!blocksizes.contains(socket)) break;  // this socket is no longer ours to handle!
 491   }
 492 }
 493
 494 void Core::processClientMessage(QTcpSocket *socket, const QVariantMap &msg) {
 495   if(!msg.contains("MsgType")) {
 496     // Client is way too old, does not even use the current init format
 497     qWarning() << qPrintable(tr("Antique client trying to connect... refusing."));
 498     socket->close();
 499     return;
 500   }
 501   // OK, so we have at least an init message format we can understand
 502   if(msg["MsgType"] == "ClientInit") {
 503     QVariantMap reply;
 504
 505     // Just version information -- check it!
 506     uint ver = msg["ProtocolVersion"].toUInt();
 507     if(ver < Quassel::buildInfo().coreNeedsProtocol) {
 508       reply["MsgType"] = "ClientInitReject";
 509       reply["Error"] = tr("<b>Your Quassel Client is too old!</b><br>"
 510       "This core needs at least client/core protocol version %1.<br>"
 511       "Please consider upgrading your client.").arg(Quassel::buildInfo().coreNeedsProtocol);
 512       SignalProxy::writeDataToDevice(socket, reply);
 513       qWarning() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("too old, rejecting."));
 514       socket->close(); return;
 515     }
 516
 517     reply["ProtocolVersion"] = Quassel::buildInfo().protocolVersion;
 518     reply["CoreVersion"] = Quassel::buildInfo().fancyVersionString;
 519     reply["CoreDate"] = Quassel::buildInfo().buildDate;
 520     reply["CoreStartTime"] = startTime(); // v10 clients don't necessarily parse this, see below
 521
 522     // FIXME: newer clients no longer use the hardcoded CoreInfo (for now), since it gets the
 523     //        time zone wrong. With the next protocol bump (10 -> 11), we should remove this
 524     //        or make it properly configurable.
 525
 526     int uptime = startTime().secsTo(QDateTime::currentDateTime().toUTC());
 527     int updays = uptime / 86400; uptime %= 86400;
 528     int uphours = uptime / 3600; uptime %= 3600;
 529     int upmins = uptime / 60;
 530     reply["CoreInfo"] = tr("<b>Quassel Core Version %1</b><br>"
 531                            "Built: %2<br>"
 532                            "Up %3d%4h%5m (since %6)").arg(Quassel::buildInfo().fancyVersionString)
 533                                                      .arg(Quassel::buildInfo().buildDate)
 534       .arg(updays).arg(uphours,2,10,QChar('0')).arg(upmins,2,10,QChar('0')).arg(startTime().toString(Qt::TextDate));
 535
 536 #ifdef HAVE_SSL
 537     SslServer *sslServer = qobject_cast<SslServer *>(&_server);
 538     QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
 539     bool supportSsl = (bool)sslServer && (bool)sslSocket && sslServer->isCertValid();
 540 #else
 541     bool supportSsl = false;
 542 #endif
 543
 544 #ifndef QT_NO_COMPRESS
 545     bool supportsCompression = true;
 546 #else
 547     bool supportsCompression = false;
 548 #endif
 549
 550     reply["SupportSsl"] = supportSsl;
 551     reply["SupportsCompression"] = supportsCompression;
 552     // switch to ssl/compression after client has been informed about our capabilities (see below)
 553
 554     reply["LoginEnabled"] = true;
 555
 556     // check if we are configured, start wizard otherwise
 557     if(!_configured) {
 558       reply["Configured"] = false;
 559       QList<QVariant> backends;
 560       foreach(Storage *backend, _storageBackends.values()) {
 561         QVariantMap v;
 562         v["DisplayName"] = backend->displayName();
 563         v["Description"] = backend->description();
 564         v["SetupKeys"] = backend->setupKeys();
 565         v["SetupDefaults"] = backend->setupDefaults();
 566         backends.append(v);
 567       }
 568       reply["StorageBackends"] = backends;
 569       reply["LoginEnabled"] = false;
 570     } else {
 571       reply["Configured"] = true;
 572     }
 573     clientInfo[socket] = msg; // store for future reference
 574     reply["MsgType"] = "ClientInitAck";
 575     SignalProxy::writeDataToDevice(socket, reply);
 576     socket->flush(); // ensure that the write cache is flushed before we switch to ssl
 577
 578 #ifdef HAVE_SSL
 579     // after we told the client that we are ssl capable we switch to ssl mode
 580     if(supportSsl && msg["UseSsl"].toBool()) {
 581       qDebug() << qPrintable(tr("Starting TLS for Client:"))  << qPrintable(socket->peerAddress().toString());
 582       connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
 583       sslSocket->startServerEncryption();
 584     }
 585 #endif
 586
 587 #ifndef QT_NO_COMPRESS
 588     if(supportsCompression && msg["UseCompression"].toBool()) {
 589       socket->setProperty("UseCompression", true);
 590       qDebug() << "Using compression for Client:" << qPrintable(socket->peerAddress().toString());
 591     }
 592 #endif
 593
 594   } else {
 595     // for the rest, we need an initialized connection
 596     if(!clientInfo.contains(socket)) {
 597       QVariantMap reply;
 598       reply["MsgType"] = "ClientLoginReject";
 599       reply["Error"] = tr("<b>Client not initialized!</b><br>You need to send an init message before trying to login.");
 600       SignalProxy::writeDataToDevice(socket, reply);
 601       qWarning() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("did not send an init message before trying to login, rejecting."));
 602       socket->close(); return;
 603     }
 604     if(msg["MsgType"] == "CoreSetupData") {
 605       QVariantMap reply;
 606       QString result = setupCore(msg["SetupData"].toMap());
 607       if(!result.isEmpty()) {
 608         reply["MsgType"] = "CoreSetupReject";
 609         reply["Error"] = result;
 610       } else {
 611         reply["MsgType"] = "CoreSetupAck";
 612       }
 613       SignalProxy::writeDataToDevice(socket, reply);
 614     } else if(msg["MsgType"] == "ClientLogin") {
 615       QVariantMap reply;
 616       UserId uid = _storage->validateUser(msg["User"].toString(), msg["Password"].toString());
 617       if(uid == 0) {
 618         reply["MsgType"] = "ClientLoginReject";
 619         reply["Error"] = tr("<b>Invalid username or password!</b><br>The username/password combination you supplied could not be found in the database.");
 620         SignalProxy::writeDataToDevice(socket, reply);
 621         return;
 622       }
 623       reply["MsgType"] = "ClientLoginAck";
 624       SignalProxy::writeDataToDevice(socket, reply);
 625       quInfo() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("initialized and authenticated successfully as \"%1\" (UserId: %2).").arg(msg["User"].toString()).arg(uid.toInt()));
 626       setupClientSession(socket, uid);
 627     }
 628   }
 629 }
 630
 631 // Potentially called during the initialization phase (before handing the connection off to the session)
 632 void Core::clientDisconnected() {
 633   QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
 634   if(socket) {
 635     // here it's safe to call methods on socket!
 636     quInfo() << qPrintable(tr("Non-authed client disconnected.")) << qPrintable(socket->peerAddress().toString());
 637     blocksizes.remove(socket);
 638     clientInfo.remove(socket);
 639     socket->deleteLater();
 640   } else {
 641     // we have to crawl through the hashes and see if we find a victim to remove
 642     qDebug() << qPrintable(tr("Non-authed client disconnected. (socket allready destroyed)"));
 643
 644     // DO NOT CALL ANY METHODS ON socket!!
 645     socket = static_cast<QTcpSocket *>(sender());
 646
 647     QHash<QTcpSocket *, quint32>::iterator blockSizeIter = blocksizes.begin();
 648     while(blockSizeIter != blocksizes.end()) {
 649       if(blockSizeIter.key() == socket) {
 650         blockSizeIter = blocksizes.erase(blockSizeIter);
 651       } else {
 652         blockSizeIter++;
 653       }
 654     }
 655
 656     QHash<QTcpSocket *, QVariantMap>::iterator clientInfoIter = clientInfo.begin();
 657     while(clientInfoIter != clientInfo.end()) {
 658       if(clientInfoIter.key() == socket) {
 659         clientInfoIter = clientInfo.erase(clientInfoIter);
 660       } else {
 661         clientInfoIter++;
 662       }
 663     }
 664   }
 665
 666
 667   // make server listen again if still not configured
 668   if (!_configured) {
 669     startListening();
 670   }
 671
 672   // TODO remove unneeded sessions - if necessary/possible...
 673   // Suggestion: kill sessions if they are not connected to any network and client.
 674 }
 675
 676 void Core::setupClientSession(QTcpSocket *socket, UserId uid) {
 677   // From now on everything is handled by the client session
 678   disconnect(socket, 0, this, 0);
 679   socket->flush();
 680   blocksizes.remove(socket);
 681   clientInfo.remove(socket);
 682
 683   // Find or create session for validated user
 684   SessionThread *session;
 685   if(sessions.contains(uid)) {
 686     session = sessions[uid];
 687   } else {
 688     session = createSession(uid);
 689     if(!session) {
 690       qWarning() << qPrintable(tr("Could not initialize session for client:")) << qPrintable(socket->peerAddress().toString());
 691       socket->close();
 692       return;
 693     }
 694   }
 695
 696   // as we are currently handling an event triggered by incoming data on this socket
 697   // it is unsafe to directly move the socket to the client thread.
 698   QCoreApplication::postEvent(this, new AddClientEvent(socket, uid));
 699 }
 700
 701 void Core::customEvent(QEvent *event) {
 702   if(event->type() == AddClientEventId) {
 703     AddClientEvent *addClientEvent = static_cast<AddClientEvent *>(event);
 704     addClientHelper(addClientEvent->socket, addClientEvent->userId);
 705     return;
 706   }
 707 }
 708
 709 void Core::addClientHelper(QTcpSocket *socket, UserId uid) {
 710   // Find or create session for validated user
 711   if(!sessions.contains(uid)) {
 712     qWarning() << qPrintable(tr("Could not find a session for client:")) << qPrintable(socket->peerAddress().toString());
 713     socket->close();
 714     return;
 715   }
 716
 717   SessionThread *session = sessions[uid];
 718   session->addClient(socket);
 719 }
 720
 721 void Core::setupInternalClientSession(SignalProxy *proxy) {
 722   if(!_configured) {
 723     stopListening();
 724     setupCoreForInternalUsage();
 725   }
 726
 727   UserId uid;
 728   if(_storage) {
 729     uid = _storage->internalUser();
 730   } else {
 731     qWarning() << "Core::setupInternalClientSession(): You're trying to run monolithic Quassel with an unusable Backend! Go fix it!";
 732     return;
 733   }
 734
 735   // Find or create session for validated user
 736   SessionThread *sess;
 737   if(sessions.contains(uid))
 738     sess = sessions[uid];
 739   else
 740     sess = createSession(uid);
 741   sess->addClient(proxy);
 742 }
 743
 744 SessionThread *Core::createSession(UserId uid, bool restore) {
 745   if(sessions.contains(uid)) {
 746     qWarning() << "Calling createSession() when a session for the user already exists!";
 747     return 0;
 748   }
 749   SessionThread *sess = new SessionThread(uid, restore, this);
 750   sessions[uid] = sess;
 751   sess->start();
 752   return sess;
 753 }
 754
 755 #ifdef HAVE_SSL
 756 void Core::sslErrors(const QList<QSslError> &errors) {
 757   Q_UNUSED(errors);
 758   QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
 759   if(socket)
 760     socket->ignoreSslErrors();
 761 }
 762 #endif
 763
 764 void Core::socketError(QAbstractSocket::SocketError err) {
 765   QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(sender());
 766   if(socket && err != QAbstractSocket::RemoteHostClosedError)
 767     qWarning() << "Core::socketError()" << socket << err << socket->errorString();
 768 }
 769
 770 // migration / backend selection
 771 bool Core::selectBackend(const QString &backend) {
 772   // reregister all storage backends
 773   registerStorageBackends();
 774   if(!_storageBackends.contains(backend)) {
 775     qWarning() << qPrintable(QString("Core::selectBackend(): unsupported backend: %1").arg(backend));
 776     qWarning() << "    supported backends are:" << qPrintable(QStringList(_storageBackends.keys()).join(", "));
 777     return false;
 778   }
 779
 780   Storage *storage = _storageBackends[backend];
 781   QVariantMap settings = promptForSettings(storage);
 782
 783   Storage::State storageState = storage->init(settings);
 784   switch(storageState) {
 785   case Storage::IsReady:
 786     saveBackendSettings(backend, settings);
 787     qWarning() << "Switched backend to:" << qPrintable(backend);
 788     qWarning() << "Backend already initialized. Skipping Migration";
 789     return true;
 790   case Storage::NotAvailable:
 791     qCritical() << "Backend is not available:" << qPrintable(backend);
 792     return false;
 793   case Storage::NeedsSetup:
 794     if(!storage->setup(settings)) {
 795       qWarning() << qPrintable(QString("Core::selectBackend(): unable to setup backend: %1").arg(backend));
 796       return false;
 797     }
 798
 799     if(storage->init(settings) != Storage::IsReady) {
 800       qWarning() << qPrintable(QString("Core::migrateBackend(): unable to initialize backend: %1").arg(backend));
 801       return false;
 802     }
 803
 804     saveBackendSettings(backend, settings);
 805     qWarning() << "Switched backend to:" << qPrintable(backend);
 806     break;
 807   }
 808
 809   // let's see if we have a current storage object we can migrate from
 810   AbstractSqlMigrationReader *reader = getMigrationReader(_storage);
 811   AbstractSqlMigrationWriter *writer = getMigrationWriter(storage);
 812   if(reader && writer) {
 813     qDebug() << qPrintable(QString("Migrating Storage backend %1 to %2...").arg(_storage->displayName(), storage->displayName()));
 814     delete _storage;
 815     _storage = 0;
 816     delete storage;
 817     storage = 0;
 818     if(reader->migrateTo(writer)) {
 819       qDebug() << "Migration finished!";
 820       saveBackendSettings(backend, settings);
 821       return true;
 822     }
 823     return false;
 824     qWarning() << qPrintable(QString("Core::migrateDb(): unable to migrate storage backend! (No migration writer for %1)").arg(backend));
 825   }
 826
 827   // inform the user why we cannot merge
 828   if(!_storage) {
 829     qWarning() << "No currently active backend. Skipping migration.";
 830   } else if(!reader) {
 831     qWarning() << "Currently active backend does not support migration:" << qPrintable(_storage->displayName());
 832   }
 833   if(writer) {
 834     qWarning() << "New backend does not support migration:" << qPrintable(backend);
 835   }
 836
 837   // so we were unable to merge, but let's create a user \o/
 838   _storage = storage;
 839   createUser();
 840   return true;
 841 }
 842
 843 void Core::createUser() {
 844   QTextStream out(stdout);
 845   QTextStream in(stdin);
 846   out << "Add a new user:" << endl;
 847   out << "Username: ";
 848   out.flush();
 849   QString username = in.readLine().trimmed();
 850
 851   disableStdInEcho();
 852   out << "Password: ";
 853   out.flush();
 854   QString password = in.readLine().trimmed();
 855   out << endl;
 856   out << "Repeat Password: ";
 857   out.flush();
 858   QString password2 = in.readLine().trimmed();
 859   out << endl;
 860   enableStdInEcho();
 861
 862   if(password != password2) {
 863     qWarning() << "Passwords don't match!";
 864     return;
 865   }
 866   if(password.isEmpty()) {
 867     qWarning() << "Password is empty!";
 868     return;
 869   }
 870
 871   if(_storage->addUser(username, password).isValid()) {
 872     out << "Added user " << username << " successfully!" << endl;
 873   } else {
 874     qWarning() << "Unable to add user:" << qPrintable(username);
 875   }
 876 }
 877
 878 void Core::changeUserPass(const QString &username) {
 879   QTextStream out(stdout);
 880   QTextStream in(stdin);
 881   UserId userId = _storage->getUserId(username);
 882   if(!userId.isValid()) {
 883     out << "User " << username << " does not exist." << endl;
 884     return;
 885   }
 886
 887   out << "Change password for user: " << username << endl;
 888
 889   disableStdInEcho();
 890   out << "New Password: ";
 891   out.flush();
 892   QString password = in.readLine().trimmed();
 893   out << endl;
 894   out << "Repeat Password: ";
 895   out.flush();
 896   QString password2 = in.readLine().trimmed();
 897   out << endl;
 898   enableStdInEcho();
 899
 900   if(password != password2) {
 901     qWarning() << "Passwords don't match!";
 902     return;
 903   }
 904   if(password.isEmpty()) {
 905     qWarning() << "Password is empty!";
 906     return;
 907   }
 908
 909   if(_storage->updateUser(userId, password)) {
 910     out << "Password changed successfuly!" << endl;
 911   } else {
 912     qWarning() << "Failed to change password!";
 913   }
 914 }
 915
 916 AbstractSqlMigrationReader *Core::getMigrationReader(Storage *storage) {
 917   if(!storage)
 918     return 0;
 919
 920   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
 921   if(!sqlStorage) {
 922     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
 923     return 0;
 924   }
 925
 926   return sqlStorage->createMigrationReader();
 927 }
 928
 929 AbstractSqlMigrationWriter *Core::getMigrationWriter(Storage *storage) {
 930   if(!storage)
 931     return 0;
 932
 933   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
 934   if(!sqlStorage) {
 935     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
 936     return 0;
 937   }
 938
 939   return sqlStorage->createMigrationWriter();
 940 }
 941
 942 void Core::saveBackendSettings(const QString &backend, const QVariantMap &settings) {
 943   QVariantMap dbsettings;
 944   dbsettings["Backend"] = backend;
 945   dbsettings["ConnectionProperties"] = settings;
 946   CoreSettings().setStorageSettings(dbsettings);
 947 }
 948
 949 QVariantMap Core::promptForSettings(const Storage *storage) {
 950   QVariantMap settings;
 951
 952   QStringList keys = storage->setupKeys();
 953   if(keys.isEmpty())
 954     return settings;
 955
 956   QTextStream out(stdout);
 957   QTextStream in(stdin);
 958   out << "Default values are in brackets" << endl;
 959
 960   QVariantMap defaults = storage->setupDefaults();
 961   QString value;
 962   foreach(QString key, keys) {
 963     QVariant val;
 964     if(defaults.contains(key)) {
 965       val = defaults[key];
 966     }
 967     out << key;
 968     if(!val.toString().isEmpty()) {
 969       out << " (" << val.toString() << ")";
 970     }
 971     out << ": ";
 972     out.flush();
 973
 974     bool noEcho = QString("password").toLower().startsWith(key.toLower());
 975     if(noEcho) {
 976       disableStdInEcho();
 977     }
 978     value = in.readLine().trimmed();
 979     if(noEcho) {
 980       out << endl;
 981       enableStdInEcho();
 982     }
 983
 984     if(!value.isEmpty()) {
 985       switch(defaults[key].type()) {
 986       case QVariant::Int:
 987         val = QVariant(value.toInt());
 988         break;
 989       default:
 990         val = QVariant(value);
 991       }
 992     }
 993     settings[key] = val;
 994   }
 995   return settings;
 996 }
 997
 998
 999 #ifdef Q_OS_WIN32
1000 void Core::stdInEcho(bool on) {
1001   HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
1002   DWORD mode = 0;
1003   GetConsoleMode(hStdin, &mode);
1004   if(on)
1005     mode |= ENABLE_ECHO_INPUT;
1006   else
1007     mode &= ~ENABLE_ECHO_INPUT;
1008   SetConsoleMode(hStdin, mode);
1009 }
1010 #else
1011 void Core::stdInEcho(bool on) {
1012   termios t;
1013   tcgetattr(STDIN_FILENO, &t);
1014   if(on)
1015     t.c_lflag |= ECHO;
1016   else
1017     t.c_lflag &= ~ECHO;
1018   tcsetattr(STDIN_FILENO, TCSANOW, &t);
1019 }
1020 #endif /* Q_OS_WIN32 */